diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -245,3 +245,17 @@
 * Rename `sub` method of `Substructure` typeclass to `substructure`
 * Define `sub` method which doesn't involve `Tagged`
 * Change `Focusable` typeclass - now it's possible to point not only top/root
+
+# 0.3.0
+* Rename `Root` datatype to `Location` with `Head` (stack) and `Root` (tree) constructors
+* Define `represent` as lens in `Representable` containers
+* Define `Equivalence` datatype and define `Contravariant` instance for it
+* Define `swop` for `Wye` (useful if you want to invert binary tree with `hoist swap`)
+* Add experimental `Monotonic` typeclass
+* Implement delete method for Stack
+* Define `Comprehension` wrapper for data structures that can behave like list comprehensions
+* Define experimental `Insertable` typeclass
+* Define `Day convolution` datatype in `Transformer` module
+* Define experimental methods: `<*+>`, `<**+>`, `<***+>`
+* Rename Bindable method `>>=$` to `<>>=`
+* Move `Comprehension` wrapper from `Construction` to `Structure.Ability` module
diff --git a/Pandora/Paradigm/Inventory/Optics.hs b/Pandora/Paradigm/Inventory/Optics.hs
--- a/Pandora/Paradigm/Inventory/Optics.hs
+++ b/Pandora/Paradigm/Inventory/Optics.hs
@@ -1,13 +1,16 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, zoom, (^.), (.~), (%~)) where
+module Pandora.Paradigm.Inventory.Optics where
 
 import Pandora.Core.Functor (type (|->))
 import Pandora.Pattern.Category (identity, (.), ($))
 import Pandora.Pattern.Functor.Covariant ((<$))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
 import Pandora.Pattern.Functor.Bivariant ((<->))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
+import Pandora.Paradigm.Primary.Object.Boolean ((?))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)
 import Pandora.Paradigm.Inventory.State (State (State), Stateful)
 import Pandora.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)
@@ -47,3 +50,6 @@
 
 zoom :: Stateful bg t => Lens bg ls -> State ls a -> t a
 zoom lens (State f) = adapt . State $ (\(Store (p :*: g)) -> (g <-> identity) . f $ p) . lens
+
+represent :: (Representable t, Setoid (Representation t)) => Representation t -> t a :-. a
+represent r x = Store $ (r <#> x) :*: \new -> tabulate (\r' -> r' == r ? new $ r' <#> x)
diff --git a/Pandora/Paradigm/Inventory/State.hs b/Pandora/Paradigm/Inventory/State.hs
--- a/Pandora/Paradigm/Inventory/State.hs
+++ b/Pandora/Paradigm/Inventory/State.hs
@@ -5,6 +5,7 @@
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Morphism ((%))
 import Pandora.Pattern.Category (identity, (.), ($))
+import Pandora.Pattern.Functor ((<*+>))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
@@ -21,7 +22,7 @@
 import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
 import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))
 import Pandora.Paradigm.Primary.Object.Boolean (bool)
-import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (predicate))
+import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), delta)
 
 newtype State s a = State ((->) s :. (:*:) s := a)
@@ -47,7 +48,7 @@
 	$ struct ->> modify . op *> current
 
 find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a
-find p = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x)
+find (Predicate p) = fold empty (\x s -> (<+>) s . bool empty (point x) . p $ x)
 
 instance Interpreted (State s) where
 	type Primary (State s) a = (->) s :. (:*:) s := a
@@ -74,6 +75,12 @@
 	TUT x >>= f = TUT $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y
 
 instance Monad u => Monad ((->) s <:<.>:> (:*:) s := u) where
+
+instance Alternative u => Alternative ((->) s <:<.>:> (:*:) s := u) where
+	TUT x <+> TUT y = TUT (x <*+> y)
+
+instance Avoidable u => Avoidable ((->) s <:<.>:> (:*:) s := u) where
+	empty = TUT $ \_ -> empty
 
 current :: Stateful s t => t s
 current = adapt $ State delta
diff --git a/Pandora/Paradigm/Primary/Functor.hs b/Pandora/Paradigm/Primary/Functor.hs
--- a/Pandora/Paradigm/Primary/Functor.hs
+++ b/Pandora/Paradigm/Primary/Functor.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Primary.Functor (module Exports, note, hush, left, right, this, that, here, there) where
 
 import Pandora.Paradigm.Primary.Functor.Fix as Exports
+import Pandora.Paradigm.Primary.Functor.Equivalence as Exports
 import Pandora.Paradigm.Primary.Functor.Predicate as Exports
 import Pandora.Paradigm.Primary.Functor.These as Exports
 import Pandora.Paradigm.Primary.Functor.Validation as Exports
diff --git a/Pandora/Paradigm/Primary/Functor/Conclusion.hs b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
--- a/Pandora/Paradigm/Primary/Functor/Conclusion.hs
+++ b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
@@ -1,11 +1,11 @@
-module Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where
+module Pandora.Paradigm.Primary.Functor.Conclusion where
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -92,7 +92,7 @@
 	f <$> UT x = UT $ f <$$> x
 
 instance Applicative u => Applicative (UT Covariant Covariant (Conclusion e) u) where
-	UT f <*> UT x = UT $ apply <$> f <*> x
+	UT f <*> UT x = UT $ (<*>) <$> f <*> x
 
 instance Pointable u => Pointable (UT Covariant Covariant (Conclusion e) u) where
 	point = UT . point . point
diff --git a/Pandora/Paradigm/Primary/Functor/Constant.hs b/Pandora/Paradigm/Primary/Functor/Constant.hs
--- a/Pandora/Paradigm/Primary/Functor/Constant.hs
+++ b/Pandora/Paradigm/Primary/Functor/Constant.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Constant (Constant (..)) where
+module Pandora.Paradigm.Primary.Functor.Constant where
 
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
diff --git a/Pandora/Paradigm/Primary/Functor/Delta.hs b/Pandora/Paradigm/Primary/Functor/Delta.hs
--- a/Pandora/Paradigm/Primary/Functor/Delta.hs
+++ b/Pandora/Paradigm/Primary/Functor/Delta.hs
@@ -1,30 +1,47 @@
-module Pandora.Paradigm.Primary.Functor.Delta (Delta (..), type (:^:)) where
+module Pandora.Paradigm.Primary.Functor.Delta where
 
+import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 
-data Delta a = a :^: a
+infixr 1 :^:
 
-type (:^:) = Delta
+data Delta a = a :^: a
 
 instance Covariant Delta where
-	f <$> x :^: y = f x :^: f y
+	f <$> (x :^: y) = f x :^: f y
 
 instance Pointable Delta where
 	point x = x :^: x
 
 instance Applicative Delta where
-	f :^: g <*> x :^: y = f x :^: g y
+	(f :^: g) <*> (x :^: y) = f x :^: g y
 
+instance Distributive Delta where
+	t >>- f = (True <#>) . f <$> t :^: (False <#>) . f <$> t
+
 instance Traversable Delta where
-	x :^: y ->> f = (:^:) <$> f x <*> f y
+	(x :^: y) ->> f = (:^:) <$> f x <*> f y
 
 instance Representable Delta where
 	type Representation Delta = Boolean
 	True <#> (x :^: _) = x
 	False <#> (_ :^: y) = y
 	tabulate f = f True :^: f False
+
+instance Setoid a => Setoid (Delta a) where
+	(x :^: y) == (x' :^: y') = (x == x') * (y == y')
+
+instance Semigroup a => Semigroup (Delta a) where
+	(x :^: y) + (x' :^: y') = (x + x') :^: (y + y')
+
+instance Ringoid a => Ringoid (Delta a) where
+	(x :^: y) * (x' :^: y') = (x * x') :^: (y * y')
diff --git a/Pandora/Paradigm/Primary/Functor/Edges.hs b/Pandora/Paradigm/Primary/Functor/Edges.hs
--- a/Pandora/Paradigm/Primary/Functor/Edges.hs
+++ b/Pandora/Paradigm/Primary/Functor/Edges.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Edges (Edges (..), edges) where
+module Pandora.Paradigm.Primary.Functor.Edges where
 
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
diff --git a/Pandora/Paradigm/Primary/Functor/Endo.hs b/Pandora/Paradigm/Primary/Functor/Endo.hs
--- a/Pandora/Paradigm/Primary/Functor/Endo.hs
+++ b/Pandora/Paradigm/Primary/Functor/Endo.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Endo (Endo (..)) where
+module Pandora.Paradigm.Primary.Functor.Endo where
 
 import Pandora.Pattern.Category (identity, (.))
 import Pandora.Pattern.Functor.Invariant (Invariant (invmap))
diff --git a/Pandora/Paradigm/Primary/Functor/Equivalence.hs b/Pandora/Paradigm/Primary/Functor/Equivalence.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Equivalence.hs
@@ -0,0 +1,10 @@
+module Pandora.Paradigm.Primary.Functor.Equivalence where
+
+import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Paradigm.Primary.Object.Boolean (Boolean)
+
+data Equivalence a = Equivalence (a -> a -> Boolean)
+
+instance Contravariant Equivalence where
+	f >$< Equivalence g = Equivalence $ \x y -> g (f x) (f y)
diff --git a/Pandora/Paradigm/Primary/Functor/Fix.hs b/Pandora/Paradigm/Primary/Functor/Fix.hs
--- a/Pandora/Paradigm/Primary/Functor/Fix.hs
+++ b/Pandora/Paradigm/Primary/Functor/Fix.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Fix (Fix (..), cata, ana, hylo) where
+module Pandora.Paradigm.Primary.Functor.Fix where
 
 import Pandora.Core.Functor (type (<-|), type (|->))
 import Pandora.Pattern.Category ((.))
diff --git a/Pandora/Paradigm/Primary/Functor/Identity.hs b/Pandora/Paradigm/Primary/Functor/Identity.hs
--- a/Pandora/Paradigm/Primary/Functor/Identity.hs
+++ b/Pandora/Paradigm/Primary/Functor/Identity.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Identity (Identity (..)) where
+module Pandora.Paradigm.Primary.Functor.Identity where
 
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
diff --git a/Pandora/Paradigm/Primary/Functor/Maybe.hs b/Pandora/Paradigm/Primary/Functor/Maybe.hs
--- a/Pandora/Paradigm/Primary/Functor/Maybe.hs
+++ b/Pandora/Paradigm/Primary/Functor/Maybe.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Maybe (Maybe (..), Optional, maybe, nothing) where
+module Pandora.Paradigm.Primary.Functor.Maybe where
 
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
diff --git a/Pandora/Paradigm/Primary/Functor/Predicate.hs b/Pandora/Paradigm/Primary/Functor/Predicate.hs
--- a/Pandora/Paradigm/Primary/Functor/Predicate.hs
+++ b/Pandora/Paradigm/Primary/Functor/Predicate.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Predicate (Predicate (..)) where
+module Pandora.Paradigm.Primary.Functor.Predicate where
 
 import Pandora.Core.Morphism ((!))
 import Pandora.Pattern.Category ((.), ($))
@@ -6,10 +6,10 @@
 import Pandora.Pattern.Functor.Determinable (Determinable (determine))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True))
 
-newtype Predicate a = Predicate { predicate :: a -> Boolean }
+newtype Predicate a = Predicate (a -> Boolean)
 
 instance Contravariant Predicate where
-	f >$< g = Predicate $ predicate g . f
+	f >$< Predicate g = Predicate $ g . f
 
 instance Determinable Predicate where
 	determine = Predicate (True !)
diff --git a/Pandora/Paradigm/Primary/Functor/Product.hs b/Pandora/Paradigm/Primary/Functor/Product.hs
--- a/Pandora/Paradigm/Primary/Functor/Product.hs
+++ b/Pandora/Paradigm/Primary/Functor/Product.hs
@@ -1,5 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Product (Product (..), type (:*:)
-	, delta, swap, attached, curry, uncurry) where
+module Pandora.Paradigm.Primary.Functor.Product where
 
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
@@ -17,6 +16,7 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
+import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (iterate))
 
 infixr 1 :*:
 
@@ -70,6 +70,9 @@
 
 instance (Group a, Group b) => Group (Product a b) where
 	invert (x :*: y) = invert x :*: invert y
+
+instance Monotonic e a => Monotonic (Product a e) a where
+	iterate f r (x :*: e) = iterate f (f x r) e
 
 delta :: a -> a :*: a
 delta x = x :*: x
diff --git a/Pandora/Paradigm/Primary/Functor/Tagged.hs b/Pandora/Paradigm/Primary/Functor/Tagged.hs
--- a/Pandora/Paradigm/Primary/Functor/Tagged.hs
+++ b/Pandora/Paradigm/Primary/Functor/Tagged.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Tagged (Tagged (..), retag, tagself, type (:#)) where
+module Pandora.Paradigm.Primary.Functor.Tagged where
 
 import Pandora.Core.Functor (type (|->), type (~>))
 import Pandora.Pattern.Category ((.), ($))
diff --git a/Pandora/Paradigm/Primary/Functor/These.hs b/Pandora/Paradigm/Primary/Functor/These.hs
--- a/Pandora/Paradigm/Primary/Functor/These.hs
+++ b/Pandora/Paradigm/Primary/Functor/These.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.These (These (..), these) where
+module Pandora.Paradigm.Primary.Functor.These where
 
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
diff --git a/Pandora/Paradigm/Primary/Functor/Validation.hs b/Pandora/Paradigm/Primary/Functor/Validation.hs
--- a/Pandora/Paradigm/Primary/Functor/Validation.hs
+++ b/Pandora/Paradigm/Primary/Functor/Validation.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Validation (Validation (..)) where
+module Pandora.Paradigm.Primary.Functor.Validation where
 
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
diff --git a/Pandora/Paradigm/Primary/Functor/Wedge.hs b/Pandora/Paradigm/Primary/Functor/Wedge.hs
--- a/Pandora/Paradigm/Primary/Functor/Wedge.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wedge.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Functor.Wedge (Wedge (..), wedge) where
+module Pandora.Paradigm.Primary.Functor.Wedge where
 
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
diff --git a/Pandora/Paradigm/Primary/Functor/Wye.hs b/Pandora/Paradigm/Primary/Functor/Wye.hs
--- a/Pandora/Paradigm/Primary/Functor/Wye.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wye.hs
@@ -1,5 +1,6 @@
-module Pandora.Paradigm.Primary.Functor.Wye (Wye (..), wye) where
+module Pandora.Paradigm.Primary.Functor.Wye where
 
+import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -25,3 +26,9 @@
 wye _ f _ _ (Left x) = f x
 wye _ _ g _ (Right y) = g y
 wye _ _ _ h (Both x y) = h x y
+
+swop :: Wye ~> Wye
+swop End = End
+swop (Both l r) = Both r l
+swop (Left l) = Right l
+swop (Right r) = Left r
diff --git a/Pandora/Paradigm/Primary/Object.hs b/Pandora/Paradigm/Primary/Object.hs
--- a/Pandora/Paradigm/Primary/Object.hs
+++ b/Pandora/Paradigm/Primary/Object.hs
@@ -1,4 +1,37 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
 module Pandora.Paradigm.Primary.Object (module Exports) where
 
 import Pandora.Paradigm.Primary.Object.Ordering as Exports
 import Pandora.Paradigm.Primary.Object.Boolean as Exports
+
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)))
+
+instance Setoid Boolean where
+	True == True = True
+	False == False = True
+	_ == _ = False
+
+instance Chain Boolean where
+	True <=> True = Equal
+	True <=> False = Greater
+	False <=> True = Less
+	False <=> False = Equal
+
+instance Setoid Ordering where
+	Less == Less = True
+	Equal == Equal = True
+	Greater == Greater = True
+	_ == _ = False
+
+instance Chain Ordering where
+	Less <=> Less = Equal
+	Less <=> Equal = Less
+	Less <=> Greater = Less
+	Equal <=> Less = Greater
+	Equal <=> Equal = Equal
+	Equal <=> Greater = Equal
+	Greater <=> Less = Greater
+	Greater <=> Equal = Greater
+	Greater <=> Greater = Equal
diff --git a/Pandora/Paradigm/Primary/Object/Boolean.hs b/Pandora/Paradigm/Primary/Object/Boolean.hs
--- a/Pandora/Paradigm/Primary/Object/Boolean.hs
+++ b/Pandora/Paradigm/Primary/Object/Boolean.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Object.Boolean (Boolean (..), bool, (?)) where
+module Pandora.Paradigm.Primary.Object.Boolean where
 
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
diff --git a/Pandora/Paradigm/Primary/Object/Ordering.hs b/Pandora/Paradigm/Primary/Object/Ordering.hs
--- a/Pandora/Paradigm/Primary/Object/Ordering.hs
+++ b/Pandora/Paradigm/Primary/Object/Ordering.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Object.Ordering (Ordering (..), order) where
+module Pandora.Paradigm.Primary.Object.Ordering where
 
 data Ordering = Less | Equal | Greater
 
diff --git a/Pandora/Paradigm/Primary/Transformer.hs b/Pandora/Paradigm/Primary/Transformer.hs
--- a/Pandora/Paradigm/Primary/Transformer.hs
+++ b/Pandora/Paradigm/Primary/Transformer.hs
@@ -4,6 +4,7 @@
 import Pandora.Paradigm.Primary.Transformer.Tap as Exports
 import Pandora.Paradigm.Primary.Transformer.Continuation as Exports
 import Pandora.Paradigm.Primary.Transformer.Kan as Exports
+import Pandora.Paradigm.Primary.Transformer.Day as Exports
 import Pandora.Paradigm.Primary.Transformer.Jet as Exports
 import Pandora.Paradigm.Primary.Transformer.Jack as Exports
 import Pandora.Paradigm.Primary.Transformer.Outline as Exports
diff --git a/Pandora/Paradigm/Primary/Transformer/Backwards.hs b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
--- a/Pandora/Paradigm/Primary/Transformer/Backwards.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (..)) where
+module Pandora.Paradigm.Primary.Transformer.Backwards where
 
 import Pandora.Core.Morphism ((&))
 import Pandora.Pattern.Category ((.), ($))
diff --git a/Pandora/Paradigm/Primary/Transformer/Construction.hs b/Pandora/Paradigm/Primary/Transformer/Construction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Construction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Construction.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Construction (Construction (..), deconstruct, coiterate, section) where
+module Pandora.Paradigm.Primary.Transformer.Construction where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (|->), type (~>))
 import Pandora.Pattern.Category ((.), ($))
@@ -19,7 +19,7 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid ((*))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Schemes.TU (TU (TU))
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 
 data Construction t a = Construct a (t :. Construction t := a)
 
@@ -39,7 +39,8 @@
 	Construct x xs ->> f = Construct <$> f x <*> xs ->>> f
 
 instance Alternative t => Bindable (Construction t) where
-	Construct x xs >>= f = case f x of Construct y ys -> Construct y $ ys <+> (>>= f) <$> xs
+	Construct x xs >>= f = case f x of
+		Construct y ys -> Construct y $ ys <+> (>>= f) <$> xs
 
 instance Covariant t => Extendable (Construction t) where
 	x =>> f = Construct (f x) $ extend f <$> deconstruct x
@@ -72,20 +73,20 @@
 section :: Comonad t => t ~> Construction t
 section as = Construct (extract as) $ extend section as
 
-instance (Covariant t, Covariant u) => Covariant (TU Covariant Covariant u (Construction t)) where
+instance (Covariant t, Covariant u) => Covariant (u <:.> Construction t) where
 	f <$> TU g = TU $ f <$$> g
 
-instance (Avoidable t, Pointable u) => Pointable (TU Covariant Covariant u (Construction t)) where
+instance (Avoidable t, Pointable u) => Pointable (u <:.> Construction t) where
 	point x = TU . point . Construct x $ empty
 
-instance (Applicative t, Applicative u) => Applicative (TU Covariant Covariant u (Construction t)) where
+instance (Applicative t, Applicative u) => Applicative (u <:.> Construction t) where
 	TU f <*> TU x = TU $ f <**> x
 
-instance (Covariant t, Alternative u) => Alternative (TU Covariant Covariant u (Construction t)) where
+instance (Covariant t, Alternative u) => Alternative (u <:.> Construction t) where
 	TU x <+> TU y = TU $ x <+> y
 
-instance (Covariant t, Avoidable u) => Avoidable (TU Covariant Covariant u (Construction t)) where
+instance (Covariant t, Avoidable u) => Avoidable (u <:.> Construction t) where
 	empty = TU empty
 
-instance (Traversable t, Traversable u) => Traversable (TU Covariant Covariant u (Construction t)) where
+instance (Traversable t, Traversable u) => Traversable (u <:.> Construction t) where
 	TU g ->> f = TU <$> g ->>> f
diff --git a/Pandora/Paradigm/Primary/Transformer/Continuation.hs b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
--- a/Pandora/Paradigm/Primary/Transformer/Continuation.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (..), cwcc, reset, shift) where
+module Pandora.Paradigm.Primary.Transformer.Continuation where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
 import Pandora.Core.Morphism ((!), (%))
diff --git a/Pandora/Paradigm/Primary/Transformer/Day.hs b/Pandora/Paradigm/Primary/Transformer/Day.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Day.hs
@@ -0,0 +1,35 @@
+module Pandora.Paradigm.Primary.Transformer.Day where
+
+import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (.|..))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
+
+data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a)
+
+instance Covariant (Day t u) where
+	f <$> Day tb uc g = Day tb uc (f .|.. g)
+
+instance (Pointable t, Pointable u) => Pointable (Day t u) where
+	point x = Day (point ()) (point ()) $ \_ _ -> x
+
+instance (Applicative t, Applicative u) => Applicative (Day t u) where
+	Day tb uc bcad <*> Day vb wc bca = Day ((:*:) <$> tb <*> vb) ((:*:) <$> uc <*> wc)
+		$ \(b :*: b') (c :*: c') -> bcad b c $ bca b' c'
+
+instance (Extractable t, Extractable u) => Extractable (Day t u) where
+	extract (Day tb uc bcad) = bcad (extract tb) (extract uc)
+
+instance (Extendable t, Extendable u) => Extendable (Day t u) where
+	day@(Day tb uc _) =>> f = Day tb uc (\_ _ -> f day)
+
+instance Extractable t => Lowerable (Day t) where
+	lower (Day tb uc bca) = bca (extract tb) <$> uc
+
+instance Hoistable (Day t) where
+	hoist g (Day tb uc bca) = Day tb (g uc) bca
diff --git a/Pandora/Paradigm/Primary/Transformer/Instruction.hs b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Instruction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Instruction (Instruction (..)) where
+module Pandora.Paradigm.Primary.Transformer.Instruction where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (($))
diff --git a/Pandora/Paradigm/Primary/Transformer/Jack.hs b/Pandora/Paradigm/Primary/Transformer/Jack.hs
--- a/Pandora/Paradigm/Primary/Transformer/Jack.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Jack.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Jack (Jack (..), jack) where
+module Pandora.Paradigm.Primary.Transformer.Jack where
 
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), comap)
diff --git a/Pandora/Paradigm/Primary/Transformer/Jet.hs b/Pandora/Paradigm/Primary/Transformer/Jet.hs
--- a/Pandora/Paradigm/Primary/Transformer/Jet.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Jet.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Jet (Jet (..)) where
+module Pandora.Paradigm.Primary.Transformer.Jet where
 
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
diff --git a/Pandora/Paradigm/Primary/Transformer/Kan.hs b/Pandora/Paradigm/Primary/Transformer/Kan.hs
--- a/Pandora/Paradigm/Primary/Transformer/Kan.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Kan.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Kan (Kan (..)) where
+module Pandora.Paradigm.Primary.Transformer.Kan where
 
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
diff --git a/Pandora/Paradigm/Primary/Transformer/Outline.hs b/Pandora/Paradigm/Primary/Transformer/Outline.hs
--- a/Pandora/Paradigm/Primary/Transformer/Outline.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Outline.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Outline (Outline (..)) where
+module Pandora.Paradigm.Primary.Transformer.Outline where
 
 import Pandora.Core.Morphism ((%))
 import Pandora.Pattern.Category (identity, (.), ($))
diff --git a/Pandora/Paradigm/Primary/Transformer/Reverse.hs b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
--- a/Pandora/Paradigm/Primary/Transformer/Reverse.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (..)) where
+module Pandora.Paradigm.Primary.Transformer.Reverse where
 
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
diff --git a/Pandora/Paradigm/Primary/Transformer/Tap.hs b/Pandora/Paradigm/Primary/Transformer/Tap.hs
--- a/Pandora/Paradigm/Primary/Transformer/Tap.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Tap.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Primary.Transformer.Tap (Tap (..)) where
+module Pandora.Paradigm.Primary.Transformer.Tap where
 
 import Pandora.Core.Morphism ((%))
 import Pandora.Pattern.Category ((.), ($))
diff --git a/Pandora/Paradigm/Primary/Transformer/Yoneda.hs b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
--- a/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
@@ -1,7 +1,8 @@
-module Pandora.Paradigm.Primary.Transformer.Yoneda (Yoneda (..)) where
+module Pandora.Paradigm.Primary.Transformer.Yoneda where
 
 import Pandora.Core.Morphism ((!))
 import Pandora.Pattern.Category (identity, (.), ($))
+import Pandora.Pattern.Functor ((<*+>))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
@@ -18,7 +19,7 @@
 	f <$> x = Yoneda (\k -> yoneda x (k . f))
 
 instance Alternative t => Alternative (Yoneda t) where
-	Yoneda f <+> Yoneda g = Yoneda (\k -> f k <+> g k)
+	Yoneda f <+> Yoneda g = Yoneda (f <*+> g)
 
 instance Applicative t => Applicative (Yoneda t) where
 	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Structure (module Exports) where
 
-import Pandora.Paradigm.Structure.Ability.Substructure as Exports
-import Pandora.Paradigm.Structure.Ability.Nonempty as Exports
+import Pandora.Paradigm.Structure.Ability as Exports
 import Pandora.Paradigm.Structure.Rose as Exports
+import Pandora.Paradigm.Structure.Splay as Exports
 import Pandora.Paradigm.Structure.Binary as Exports
 import Pandora.Paradigm.Structure.Stack as Exports
diff --git a/Pandora/Paradigm/Structure/Ability.hs b/Pandora/Paradigm/Structure/Ability.hs
--- a/Pandora/Paradigm/Structure/Ability.hs
+++ b/Pandora/Paradigm/Structure/Ability.hs
@@ -1,7 +1,10 @@
 module Pandora.Paradigm.Structure.Ability (module Exports) where
 
+import Pandora.Paradigm.Structure.Ability.Monotonic as Exports
 import Pandora.Paradigm.Structure.Ability.Zipper as Exports
 import Pandora.Paradigm.Structure.Ability.Substructure as Exports
 import Pandora.Paradigm.Structure.Ability.Rotatable as Exports
+import Pandora.Paradigm.Structure.Ability.Insertable as Exports
 import Pandora.Paradigm.Structure.Ability.Focusable as Exports
 import Pandora.Paradigm.Structure.Ability.Nonempty as Exports
+import Pandora.Paradigm.Structure.Ability.Comprehension as Exports
diff --git a/Pandora/Paradigm/Structure/Ability/Comprehension.hs b/Pandora/Paradigm/Structure/Ability/Comprehension.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Ability/Comprehension.hs
@@ -0,0 +1,24 @@
+{-# LANGUAGE UndecidableInstances #-}
+
+module Pandora.Paradigm.Structure.Ability.Comprehension where
+
+import Pandora.Core.Functor (type (:=))
+import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
+
+newtype Comprehension t a = Comprehension (t <:.> Construction t := a)
+
+instance Interpreted (Comprehension t) where
+	type Primary (Comprehension t) a = t <:.> Construction t := a
+	run (Comprehension x) = x
+
+instance Covariant (t <:.> Construction t) => Covariant (Comprehension t) where
+	f <$> Comprehension x = Comprehension $ f <$> x
+
+instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t) => Bindable (Comprehension t) where
+	Comprehension (TU t) >>= f = Comprehension . TU $ t >>= \(Construct x xs) -> run $ run (f x) + run (Comprehension (TU xs) >>= f)
diff --git a/Pandora/Paradigm/Structure/Ability/Focusable.hs b/Pandora/Paradigm/Structure/Ability/Focusable.hs
--- a/Pandora/Paradigm/Structure/Ability/Focusable.hs
+++ b/Pandora/Paradigm/Structure/Ability/Focusable.hs
@@ -15,4 +15,4 @@
 focus :: forall f t a . Focusable f t => t a :-. Focusing f t a
 focus = comap extract . focusing . Tag @f
 
-data Root a
+data Location a = Root a | Head a
diff --git a/Pandora/Paradigm/Structure/Ability/Insertable.hs b/Pandora/Paradigm/Structure/Ability/Insertable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Ability/Insertable.hs
@@ -0,0 +1,4 @@
+module Pandora.Paradigm.Structure.Ability.Insertable where
+
+class Insertable t where
+	insert :: a -> t a -> t a
diff --git a/Pandora/Paradigm/Structure/Ability/Monotonic.hs b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
@@ -0,0 +1,7 @@
+module Pandora.Paradigm.Structure.Ability.Monotonic where
+
+class Monotonic e a where
+	iterate :: (a -> r -> r) -> r -> e -> r
+
+instance Monotonic a a where
+	iterate f r x = f x r
diff --git a/Pandora/Paradigm/Structure/Binary.hs b/Pandora/Paradigm/Structure/Binary.hs
--- a/Pandora/Paradigm/Structure/Binary.hs
+++ b/Pandora/Paradigm/Structure/Binary.hs
@@ -8,11 +8,9 @@
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
 import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Paradigm.Primary.Object.Ordering (order)
-import Pandora.Paradigm.Primary.Functor (left, right)
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing), maybe)
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both))
@@ -23,23 +21,23 @@
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Optics (type (:-.), (|>), (%~))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root)
-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (rotation), rotate)
+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Root))
+import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert))
 import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), sub)
 
 type Binary = Maybe <:.> Construction Wye
 
-insert :: Chain a => a -> Binary a -> Binary a
-insert x (run -> Nothing) = lift . Construct x $ End
-insert x tree@(run -> Just nonempty) = x <=> extract nonempty & order
-	(sub @Left %~ insert x $ tree) tree (sub @Right %~ insert x $ tree)
-
 rebalance :: Chain a => (Wye :. Construction Wye := a) -> Nonempty Binary a
 rebalance (Both x y) = extract x <=> extract y & order
 	(Construct (extract y) $ Both x (rebalance $ deconstruct y))
 	(Construct (extract x) $ Both (rebalance $ deconstruct x) (rebalance $ deconstruct y))
 	(Construct (extract x) $ Both (rebalance $ deconstruct x) y)
 
+instance (forall a . Chain a) => Insertable Binary where
+	insert x (run -> Nothing) = lift . Construct x $ End
+	insert x tree@(run -> Just nonempty) = x <=> extract nonempty & order
+		(sub @Left %~ insert x $ tree) tree (sub @Right %~ insert x $ tree)
+
 instance (forall a . Chain a) => Focusable Root Binary where
 	type Focusing Root Binary a = Maybe a
 	focusing (run . extract -> Nothing) = Store $ Nothing :*: Tag . TU . comap (Construct % End)
@@ -64,6 +62,10 @@
 	type Focusing Root (Construction Wye) a = a
 	focusing (extract -> Construct x xs) = Store $ x :*: Tag . Construct % xs
 
+instance (forall a . Chain a) => Insertable (Construction Wye) where
+	insert x nonempty = let change = Just . maybe (Construct x End) (insert x) in
+		x <=> extract nonempty & order (sub @Left %~ change $ nonempty) nonempty (sub @Right %~ change $ nonempty)
+
 instance Substructure Left (Construction Wye) where
 	type Substructural Left (Construction Wye) a = Maybe :. Construction Wye := a
 	substructure empty_tree@(extract -> Construct _ End) = Store $ Nothing :*: (!) empty_tree
@@ -77,43 +79,3 @@
 	substructure (extract -> Construct x (Left lst)) = Store $ Nothing :*: Tag . Construct x . maybe (Left lst) (Both lst)
 	substructure (extract -> Construct x (Right rst)) = Store $ Just rst :*: Tag . Construct x . maybe End Right
 	substructure (extract -> Construct x (Both lst rst)) = Store $ Just rst :*: Tag . Construct x . maybe (Left lst) (Both lst)
-
-data Splay a = Zig a | Zag a
-
-instance Rotatable (Left Zig) (Construction Wye) where
-	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where
-
-		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c
-		found = extract <$> left st
-		a = deconstruct <$> left st >>= left
-		b = deconstruct <$> left st >>= right
-		c = right st
-
-instance Rotatable (Right Zig) (Construction Wye) where
-	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where
-
-		found = extract <$> right st
-		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c
-		a = left st
-		b = deconstruct <$> right st >>= left
-		c = deconstruct <$> right st >>= right
-
-instance Rotatable (Left (Zig Zig)) (Construction Wye) where
-	rotation (Tag tree) = rotate @(Left Zig) tree >>= rotate @(Left Zig)
-
-instance Rotatable (Right (Zig Zig)) (Construction Wye) where
-	rotation (Tag tree) = rotate @(Right Zig) tree >>= rotate @(Right Zig)
-
-instance Rotatable (Left (Zig Zag)) (Construction Wye) where
-	rotation (Tag tree) = rotate @(Left Zig)
-		$ sub @Left %~ (>>= rotate @(Right Zig)) $ tree
-
-instance Rotatable (Right (Zig Zag)) (Construction Wye) where
-	rotation (Tag tree) = rotate @(Right Zig)
-		$ sub @Right %~ (>>= rotate @(Left Zig)) $ tree
-
-maybe_subtree :: Maybe a -> Maybe a -> Wye a
-maybe_subtree (Just x) (Just y) = Both x y
-maybe_subtree Nothing (Just y) = Right y
-maybe_subtree (Just x) Nothing = Left x
-maybe_subtree Nothing Nothing = End
diff --git a/Pandora/Paradigm/Structure/Rose.hs b/Pandora/Paradigm/Structure/Rose.hs
--- a/Pandora/Paradigm/Structure/Rose.hs
+++ b/Pandora/Paradigm/Structure/Rose.hs
@@ -17,7 +17,7 @@
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root)
+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Root))
 import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure))
 import Pandora.Paradigm.Structure.Stack (Stack)
 
diff --git a/Pandora/Paradigm/Structure/Splay.hs b/Pandora/Paradigm/Structure/Splay.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Splay.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE UndecidableInstances #-}
+
+module Pandora.Paradigm.Structure.Splay where
+
+import Pandora.Core.Morphism ((%))
+import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Extractable (extract)
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Paradigm.Primary.Functor (left, right)
+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
+import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both))
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
+import Pandora.Paradigm.Inventory.Optics ((%~))
+import Pandora.Paradigm.Structure.Binary ()
+import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (rotation), rotate)
+import Pandora.Paradigm.Structure.Ability.Substructure (sub)
+
+data Splay a = Zig a | Zag a
+
+instance Rotatable (Left Zig) (Construction Wye) where
+	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where
+
+		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c
+		found = extract <$> left st
+		a = deconstruct <$> left st >>= left
+		b = deconstruct <$> left st >>= right
+		c = right st
+
+instance Rotatable (Right Zig) (Construction Wye) where
+	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where
+
+		found = extract <$> right st
+		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c
+		a = left st
+		b = deconstruct <$> right st >>= left
+		c = deconstruct <$> right st >>= right
+
+instance Rotatable (Left (Zig Zig)) (Construction Wye) where
+	rotation (Tag tree) = rotate @(Left Zig) tree >>= rotate @(Left Zig)
+
+instance Rotatable (Right (Zig Zig)) (Construction Wye) where
+	rotation (Tag tree) = rotate @(Right Zig) tree >>= rotate @(Right Zig)
+
+instance Rotatable (Left (Zig Zag)) (Construction Wye) where
+	rotation (Tag tree) = rotate @(Left Zig)
+		$ sub @Left %~ (>>= rotate @(Right Zig)) $ tree
+
+instance Rotatable (Right (Zig Zag)) (Construction Wye) where
+	rotation (Tag tree) = rotate @(Right Zig)
+		$ sub @Right %~ (>>= rotate @(Left Zig)) $ tree
+
+maybe_subtree :: Maybe a -> Maybe a -> Wye a
+maybe_subtree (Just x) (Just y) = Both x y
+maybe_subtree Nothing (Just y) = Right y
+maybe_subtree (Just x) Nothing = Left x
+maybe_subtree Nothing Nothing = End
diff --git a/Pandora/Paradigm/Structure/Stack.hs b/Pandora/Paradigm/Structure/Stack.hs
--- a/Pandora/Paradigm/Structure/Stack.hs
+++ b/Pandora/Paradigm/Structure/Stack.hs
@@ -31,7 +31,8 @@
 import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)
-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root, focus)
+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Head), focus)
+import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert))
 
 -- | Linear data structure that serves as a collection of elements
 type Stack = Maybe <:.> Construction Maybe
@@ -47,18 +48,23 @@
 instance Monoid (Stack a) where
 	zero = TU Nothing
 
-instance Focusable Root Stack where
-	type Focusing Root Stack a = Maybe a
+instance Focusable Head Stack where
+	type Focusing Head Stack a = Maybe a
 	focusing (Tag stack) = Store $ extract <$> run stack :*: \case
-		Just x -> stack & pop & push x & Tag
+		Just x -> stack & pop & insert x & Tag
 		Nothing -> Tag $ pop stack
 
-push :: a -> Stack a -> Stack a
-push x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x
+instance Insertable Stack where
+	insert x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x
 
 pop :: Stack ~> Stack
 pop (TU stack) = TU $ stack >>= deconstruct
 
+delete :: Setoid a => a -> Stack a -> Stack a
+delete _ (TU Nothing) = TU Nothing
+delete x (TU (Just (Construct y ys))) = x == y ? TU ys
+	$ lift . Construct y . run . delete x $ TU ys
+
 filter :: Predicate a -> Stack a -> Stack a
 filter (Predicate p) = TU . fold empty
 	(\now new -> p now ? Just (Construct now new) $ new)
@@ -69,12 +75,18 @@
 
 type instance Nonempty Stack = Construction Maybe
 
-instance Focusable Root (Construction Maybe) where
-	type Focusing Root (Construction Maybe) a = a
+instance Focusable Head (Construction Maybe) where
+	type Focusing Head (Construction Maybe) a = a
 	focusing (Tag stack) = Store $ extract stack :*: Tag . Construct % deconstruct stack
 
+instance Insertable (Construction Maybe) where
+	insert x = Construct x . Just
+
 type instance Zipper Stack = Tap (Delta <:.> Stack)
 
+instance Covariant (Delta <:.> Stack) where
+	f <$> (TU (bs :^: fs)) = TU $ f <$> bs :^: f <$> fs
+
 forward, backward :: Zipper Stack a -> Maybe (Zipper Stack a)
-forward (Tap x (TU (bs :^: fs))) = Tap % (TU $ push x bs :^: pop fs) <$> focus @Root ^. fs
-backward (Tap x (TU (bs :^: fs))) = Tap % (TU $ pop bs :^: push x fs) <$> focus @Root ^. bs
+forward (Tap x (TU (bs :^: fs))) = Tap % (TU $ insert x bs :^: pop fs) <$> focus @Head ^. fs
+backward (Tap x (TU (bs :^: fs))) = Tap % (TU $ pop bs :^: insert x fs) <$> focus @Head ^. bs
diff --git a/Pandora/Pattern.hs b/Pandora/Pattern.hs
--- a/Pandora/Pattern.hs
+++ b/Pandora/Pattern.hs
@@ -1,5 +1,6 @@
 module Pandora.Pattern (module Exports) where
 
 import Pandora.Pattern.Object as Exports
+import Pandora.Pattern.Transformer as Exports
 import Pandora.Pattern.Functor as Exports
 import Pandora.Pattern.Category as Exports
diff --git a/Pandora/Pattern/Functor.hs b/Pandora/Pattern/Functor.hs
--- a/Pandora/Pattern/Functor.hs
+++ b/Pandora/Pattern/Functor.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor (module Exports) where
+module Pandora.Pattern.Functor (module Exports, (<*+>), (<**+>), (<***+>)) where
 
 import Pandora.Pattern.Functor.Bivariant as Exports
 import Pandora.Pattern.Functor.Divariant as Exports
@@ -19,3 +19,16 @@
 import Pandora.Pattern.Functor.Invariant as Exports
 import Pandora.Pattern.Functor.Contravariant as Exports
 import Pandora.Pattern.Functor.Covariant as Exports
+
+import Pandora.Core.Functor (type (:.), type (:=))
+
+(<*+>) :: (Applicative t, Alternative u) => t :. u := a -> t :. u := a -> t :. u := a
+x <*+> y = (<+>) <$> x <*> y
+
+(<**+>) :: (Applicative t, Applicative u, Alternative v)
+	=> t :. u :. v := a -> t :. u :. v := a -> t :. u :. v := a
+x <**+> y = (<+>) <$$> x <**> y
+
+(<***+>) :: (Applicative t, Applicative u, Applicative v, Alternative w)
+	=> t :. u :. v :. w := a -> t :. u :. v :. w := a -> t :. u :. v :. w := a
+x <***+> y = (<+>) <$$$> x <***> y
diff --git a/Pandora/Pattern/Functor/Bindable.hs b/Pandora/Pattern/Functor/Bindable.hs
--- a/Pandora/Pattern/Functor/Bindable.hs
+++ b/Pandora/Pattern/Functor/Bindable.hs
@@ -37,8 +37,9 @@
 	-- | Experimental methods
 	($>>=) :: Covariant u => (a -> t b) -> u :. t := a -> u :. t := b
 	f $>>= x = (>>= f) <$> x
-	(>>=$) :: (t b -> c) -> (a -> t b) -> t a -> c
-	f >>=$ g = f <$> (>>= g)
+
+	(<>>=) :: (t b -> c) -> (a -> t b) -> t a -> c
+	f <>>= g = f <$> (>>= g)
 
 instance Bindable ((->) e) where
 	f >>= g = \x -> g (f x) x
diff --git a/Pandora/Pattern/Functor/Representable.hs b/Pandora/Pattern/Functor/Representable.hs
--- a/Pandora/Pattern/Functor/Representable.hs
+++ b/Pandora/Pattern/Functor/Representable.hs
@@ -22,7 +22,7 @@
 	tabulate :: (Representation t -> a) -> t a
 	-- | Prefix and flipped version of '<#>'
 	index :: t a -> Representation t -> a
-	index x f = f <#> x
+	index x r = r <#> x
 
 instance Representable ((->) e) where
 	type Representation ((->) e) = e
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.2.9
+version:             0.3.0
 synopsis:            A box of patterns and paradigms
 description:         Humble attempt to define a library for problem solving based on math abstractions.
 homepage:            https://github.com/iokasimov/pandora
@@ -26,7 +26,6 @@
 
     Pandora.Paradigm
     -- Basic constructions
-
     Pandora.Paradigm.Primary
     Pandora.Paradigm.Primary.Object
     Pandora.Paradigm.Primary.Object.Boolean
@@ -40,7 +39,6 @@
     Pandora.Paradigm.Primary.Functor.Fix
     Pandora.Paradigm.Primary.Functor.Identity
     Pandora.Paradigm.Primary.Functor.Maybe
-    Pandora.Paradigm.Primary.Functor.Predicate
     Pandora.Paradigm.Primary.Functor.Product
     Pandora.Paradigm.Primary.Functor.Proxy
     Pandora.Paradigm.Primary.Functor.Tagged
@@ -48,6 +46,8 @@
     Pandora.Paradigm.Primary.Functor.Validation
     Pandora.Paradigm.Primary.Functor.Wye
     Pandora.Paradigm.Primary.Functor.Wedge
+    Pandora.Paradigm.Primary.Functor.Predicate
+    Pandora.Paradigm.Primary.Functor.Equivalence
     Pandora.Paradigm.Primary.Transformer
     Pandora.Paradigm.Primary.Transformer.Backwards
     Pandora.Paradigm.Primary.Transformer.Reverse
@@ -59,6 +59,7 @@
     Pandora.Paradigm.Primary.Transformer.Jack
     Pandora.Paradigm.Primary.Transformer.Jet
     Pandora.Paradigm.Primary.Transformer.Kan
+    Pandora.Paradigm.Primary.Transformer.Day
     Pandora.Paradigm.Primary.Transformer.Yoneda
     -- Schemes of functor compositions
     Pandora.Paradigm.Schemes
@@ -93,13 +94,17 @@
     Pandora.Paradigm.Structure.Stream
     Pandora.Paradigm.Structure.Stack
     Pandora.Paradigm.Structure.Binary
+    Pandora.Paradigm.Structure.Splay
     Pandora.Paradigm.Structure.Rose
     Pandora.Paradigm.Structure.Ability
+    Pandora.Paradigm.Structure.Ability.Comprehension
     Pandora.Paradigm.Structure.Ability.Focusable
+    Pandora.Paradigm.Structure.Ability.Insertable
     Pandora.Paradigm.Structure.Ability.Rotatable
     Pandora.Paradigm.Structure.Ability.Substructure
     Pandora.Paradigm.Structure.Ability.Nonempty
     Pandora.Paradigm.Structure.Ability.Zipper
+    Pandora.Paradigm.Structure.Ability.Monotonic
 
     Pandora.Pattern
     -- Category typeclass