diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -259,3 +259,13 @@
 * Define experimental methods: `<*+>`, `<**+>`, `<***+>`
 * Rename Bindable method `>>=$` to `<>>=`
 * Move `Comprehension` wrapper from `Construction` to `Structure.Ability` module
+
+# 0.3.1
+* Define `Set` interface for data structures with `member` method
+* Move `zoom` function to `Inventory` module
+* Move `Adjoint` instance for `(:*:)` and `(->)` to `Paradigm.Primary.Functor` module
+* Remove `Schematic` module and move `Schematic` type family to `Interpreted` module
+* Change arity of `Schematic` type family
+* Remove `lay` method of `Monadic` type class, use `lift` instead
+* Remove `flick` method of `Comonadic` type class, use `lower` instead
+* Change `lift` constraint: from `Covariant` to `Traversable`
diff --git a/Pandora/Paradigm.hs b/Pandora/Paradigm.hs
--- a/Pandora/Paradigm.hs
+++ b/Pandora/Paradigm.hs
@@ -4,3 +4,4 @@
 import Pandora.Paradigm.Inventory as Exports
 import Pandora.Paradigm.Controlflow as Exports
 import Pandora.Paradigm.Primary as Exports
+import Pandora.Paradigm.Schemes as Exports
diff --git a/Pandora/Paradigm/Controlflow/Effect.hs b/Pandora/Paradigm/Controlflow/Effect.hs
--- a/Pandora/Paradigm/Controlflow/Effect.hs
+++ b/Pandora/Paradigm/Controlflow/Effect.hs
@@ -1,7 +1,5 @@
 module Pandora.Paradigm.Controlflow.Effect (module Exports) where
 
-import Pandora.Paradigm.Schemes as Exports
-import Pandora.Paradigm.Controlflow.Effect.Schematic as Exports
 import Pandora.Paradigm.Controlflow.Effect.Transformer as Exports
 import Pandora.Paradigm.Controlflow.Effect.Interpreted as Exports
 import Pandora.Paradigm.Controlflow.Effect.Adaptable as Exports
diff --git a/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs b/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
@@ -7,313 +7,360 @@
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Pointable (Pointable)
 import Pandora.Pattern.Functor.Extractable (Extractable)
+import Pandora.Pattern.Functor.Traversable (Traversable)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Effect.Transformer (Transformer, lay, wrap, flick, bring, (:>), (:<))
+import Pandora.Pattern.Transformer (Liftable (lift), Lowerable (lower), Hoistable (hoist))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Transformer (Transformer, wrap, bring, (:>), (:<))
 
 class Adaptable t u where
 	{-# MINIMAL adapt #-}
 	adapt :: t ~> u
 
-type Layable t u = (Transformer Monad t, Covariant u)
+type Lifting t u = (Transformer Monad t, Liftable (Schematic Monad t), Traversable u)
+type Lowering t u = (Transformer Comonad t, Lowerable (Schematic Comonad t), Covariant u)
 type Wrappable t u = (Transformer Monad t, Pointable u)
-type Flickable t u = (Transformer Comonad t, Covariant u)
 type Bringable t u = (Transformer Comonad t, Extractable u)
 
 instance Covariant t => Adaptable t t where
 	adapt = identity
 
-instance (Covariant (t :> u), Layable t u) => Adaptable u (t :> u) where
-	adapt = lay
+instance (Covariant (t :> u), Lifting t u) => Adaptable u (t :> u) where
+	adapt = lift
 
 instance (Covariant (t :> u), Wrappable t u) => Adaptable t (t :> u) where
 	adapt = wrap
 
-instance (Covariant (t :> u), Flickable t u) => Adaptable (t :< u) u where
-	adapt = flick
+instance (Covariant (t :> u), Lowering t u) => Adaptable (t :< u) u where
+	adapt = lower
 
 instance (Covariant (t :< u), Bringable t u) => Adaptable (t :< u) t where
 	adapt = bring
 
 instance
 	( Covariant (t :> u :> v)
-	, Layable t (Schematic Monad u v)
+	, Liftable (Schematic Monad t)
+	, Traversable (Schematic Monad u v)
 	, Wrappable u v
 	) => Adaptable u (t :> u :> v) where
-	adapt = lay . wrap
+	adapt = lift . wrap
 
 instance
 	( Covariant (t :> u :> v)
-	, Layable t (Schematic Monad u v)
-	, Layable u v
+	, Lifting t (Schematic Monad u v)
+	, Lifting u v
 	) => Adaptable v (t :> u :> v) where
-	adapt = lay . lay
+	adapt = lift . lift
 
 instance
 	( Covariant (t :< u :< v)
-	, Flickable t (Schematic Comonad u v)
+	, Lowering t (Schematic Comonad u v)
 	, Bringable u v
 	) => Adaptable (t :< u :< v) u where
-	adapt = bring . flick
+	adapt = bring . lower
 
 instance
 	( Covariant (t :< u :< v)
-	, Flickable t (Schematic Comonad u v)
-	, Flickable u v
+	, Lowering t (Schematic Comonad u v)
+	, Lowering u v
 	) => Adaptable (t :< u :< v) v where
-	adapt = flick . flick
+	adapt = lower . lower
 
 instance
 	( Covariant (t :> u :> v :> w)
-	, Layable t (Schematic Monad u (v :> w))
-	, Layable u (Schematic Monad v w)
+	, Liftable (Schematic Monad t)
+	, Lifting t (Schematic Monad u (v :> w))
+	, Lifting u (Schematic Monad v w)
 	, Wrappable v w
 	) => Adaptable v (t :> u :> v :> w) where
-	adapt = lay . lay . wrap
+	adapt = lift . lift . wrap
 
 instance
 	( Covariant (t :> u :> v :> w)
-	, Layable t (Schematic Monad u v)
-	, Layable t (Schematic Monad u (v :> w))
-	, Layable u (Schematic Monad v w)
-	, Layable v w
+	, Lifting t (Schematic Monad u v)
+	, Lifting t (Schematic Monad u (v :> w))
+	, Lifting u (Schematic Monad v w)
+	, Lifting v w
 	) => Adaptable w (t :> u :> v :> w) where
-	adapt = lay . lay . lay
+	adapt = lift . lift . lift
 
 instance
 	( Covariant (t :< u :< v :< w)
-	, Flickable t (Schematic Comonad u (v :< w))
-	, Flickable u (Schematic Comonad v w)
+	, Lowering t (Schematic Comonad u (v :< w))
+	, Lowering u (Schematic Comonad v w)
 	, Bringable v w
 	) => Adaptable (t :< u :< v :< w) v where
-	adapt = bring . flick . flick
+	adapt = bring . lower . lower
 
 instance
 	( Covariant (t :< u :< v :< w)
-	, Flickable t (Schematic Comonad u v)
-	, Flickable t (Schematic Comonad u (v :< w))
-	, Flickable u (Schematic Comonad v w)
-	, Flickable v w
+	, Lowering t (Schematic Comonad u v)
+	, Lowering t (Schematic Comonad u (v :< w))
+	, Lowering u (Schematic Comonad v w)
+	, Lowering v w
 	) => Adaptable (t :< u :< v :< w) w where
-	adapt = flick . flick . flick
+	adapt = lower . lower . lower
 
 instance
 	( Covariant (t :> u :> v :> w :> x)
-	, Layable t (Schematic Monad u (v :> w :> x))
-	, Layable u (Schematic Monad v (w :> x))
-	, Layable v (Schematic Monad w x)
-	, Layable w x
+	, Lifting t (Schematic Monad u (v :> w :> x))
+	, Lifting u (Schematic Monad v (w :> x))
+	, Lifting v (Schematic Monad w x)
+	, Lifting w x
 	) => Adaptable x (t :> u :> v :> w :> x) where
-	adapt = lay . lay . lay . lay
+	adapt = lift . lift . lift . lift
 
 instance
 	( Covariant (t :> u :> v :> w :> x)
-	, Layable t (Schematic Monad u (v :> w :> x))
-	, Layable u (Schematic Monad v (w :> x))
-	, Layable v (Schematic Monad w x)
+	, Lifting t (Schematic Monad u (v :> w :> x))
+	, Lifting u (Schematic Monad v (w :> x))
+	, Lifting v (Schematic Monad w x)
 	, Wrappable w x
 	) => Adaptable w (t :> u :> v :> w :> x) where
-	adapt = lay . lay . lay . wrap
+	adapt = lift . lift . lift . wrap
 
 instance
 	( Covariant (t :< u :< v :< w :< x)
-	, Flickable t (Schematic Comonad u (v :< w :< x))
-	, Flickable u (Schematic Comonad v (w :< x))
-	, Flickable v (Schematic Comonad w x)
-	, Flickable w x
+	, Lowering t (Schematic Comonad u (v :< w :< x))
+	, Lowering u (Schematic Comonad v (w :< x))
+	, Lowering v (Schematic Comonad w x)
+	, Lowering w x
 	) => Adaptable (t :< u :< v :< w :< x) x where
-	adapt = flick . flick . flick . flick
+	adapt = lower . lower . lower . lower
 
 instance
 	( Covariant (t :< u :< v :< w :< x)
-	, Flickable t (Schematic Comonad u (v :< w :< x))
-	, Flickable u (Schematic Comonad v (w :< x))
-	, Flickable v (Schematic Comonad w x)
+	, Lowering t (Schematic Comonad u (v :< w :< x))
+	, Lowering u (Schematic Comonad v (w :< x))
+	, Lowering v (Schematic Comonad w x)
 	, Bringable w x
 	) => Adaptable (t :< u :< v :< w :< x) w where
-	adapt = bring . flick . flick . flick
+	adapt = bring . lower . lower . lower
 
 instance
 	( Covariant (t :> u :> v :> w :> x :> y)
-	, Layable t (Schematic Monad u (v :> w :> x :> y))
-	, Layable u (Schematic Monad v (w :> x :> y))
-	, Layable v (Schematic Monad w (x :> y))
-	, Layable w (Schematic Monad x y)
-	, Layable x y
+	, Lifting t (Schematic Monad u (v :> w :> x :> y))
+	, Lifting u (Schematic Monad v (w :> x :> y))
+	, Lifting v (Schematic Monad w (x :> y))
+	, Lifting w (Schematic Monad x y)
+	, Lifting x y
 	) => Adaptable y (t :> u :> v :> w :> x :> y) where
-	adapt = lay . lay . lay . lay . lay
+	adapt = lift . lift . lift . lift . lift
 
 instance
 	( Covariant (t :> u :> v :> w :> x :> y)
-	, Layable t (Schematic Monad u (v :> w :> x :> y))
-	, Layable u (Schematic Monad v (w :> x :> y))
-	, Layable v (Schematic Monad w (x :> y))
-	, Layable w (Schematic Monad x y)
+	, Lifting t (Schematic Monad u (v :> w :> x :> y))
+	, Lifting u (Schematic Monad v (w :> x :> y))
+	, Lifting v (Schematic Monad w (x :> y))
+	, Lifting w (Schematic Monad x y)
 	, Wrappable x y
 	) => Adaptable x (t :> u :> v :> w :> x :> y) where
-	adapt = lay . lay . lay . lay . wrap
+	adapt = lift . lift . lift . lift . wrap
 
 instance
 	( Covariant (t :< u :< v :< w :< x :< y)
-	, Flickable t (Schematic Comonad u (v :< w :< x :< y))
-	, Flickable u (Schematic Comonad v (w :< x :< y))
-	, Flickable v (Schematic Comonad w (x :< y))
-	, Flickable w (Schematic Comonad x y)
-	, Flickable x y
+	, Lowering t (Schematic Comonad u (v :< w :< x :< y))
+	, Lowering u (Schematic Comonad v (w :< x :< y))
+	, Lowering v (Schematic Comonad w (x :< y))
+	, Lowering w (Schematic Comonad x y)
+	, Lowering x y
 	) => Adaptable (t :< u :< v :< w :< x :< y) y where
-	adapt = flick . flick . flick . flick . flick
+	adapt = lower . lower . lower . lower . lower
 
 instance
 	( Covariant (t :< u :< v :< w :< x :< y)
-	, Flickable t (Schematic Comonad u (v :< w :< x :< y))
-	, Flickable u (Schematic Comonad v (w :< x :< y))
-	, Flickable v (Schematic Comonad w (x :< y))
-	, Flickable w (Schematic Comonad x y)
+	, Lowering t (Schematic Comonad u (v :< w :< x :< y))
+	, Lowering u (Schematic Comonad v (w :< x :< y))
+	, Lowering v (Schematic Comonad w (x :< y))
+	, Lowering w (Schematic Comonad x y)
 	, Bringable x y
 	) => Adaptable (t :< u :< v :< w :< x :< y) x where
-	adapt = bring . flick . flick . flick . flick
+	adapt = bring . lower . lower . lower . lower
 
 instance
 	( Covariant (t :> u :> v :> w :> x :> y :> z)
-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))
-	, Layable u (Schematic Monad v (w :> x :> y :> z))
-	, Layable v (Schematic Monad w (x :> y :> z))
-	, Layable w (Schematic Monad x (y :> z))
-	, Layable x (Schematic Monad y z)
-	, Layable y z
+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z))
+	, Lifting u (Schematic Monad v (w :> x :> y :> z))
+	, Lifting v (Schematic Monad w (x :> y :> z))
+	, Lifting w (Schematic Monad x (y :> z))
+	, Lifting x (Schematic Monad y z)
+	, Lifting y z
 	) => Adaptable z (t :> u :> v :> w :> x :> y :> z) where
-	adapt = lay . lay . lay . lay . lay . lay
+	adapt = lift . lift . lift . lift . lift . lift
 
 instance
 	( Covariant (t :> u :> v :> w :> x :> y :> z)
-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))
-	, Layable u (Schematic Monad v (w :> x :> y :> z))
-	, Layable v (Schematic Monad w (x :> y :> z))
-	, Layable w (Schematic Monad x (y :> z))
-	, Layable x (Schematic Monad y z)
+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z))
+	, Lifting u (Schematic Monad v (w :> x :> y :> z))
+	, Lifting v (Schematic Monad w (x :> y :> z))
+	, Lifting w (Schematic Monad x (y :> z))
+	, Lifting x (Schematic Monad y z)
 	, Wrappable y z
 	) => Adaptable y (t :> u :> v :> w :> x :> y :> z) where
-	adapt = lay . lay . lay . lay . lay . wrap
+	adapt = lift . lift . lift . lift . lift . wrap
 
 instance
 	( Covariant (t :< u :< v :< w :< x :< y :< z)
-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))
-	, Flickable u (Schematic Comonad v (w :< x :< y :< z))
-	, Flickable v (Schematic Comonad w (x :< y :< z))
-	, Flickable w (Schematic Comonad x (y :< z))
-	, Flickable x (Schematic Comonad y z)
-	, Flickable y z
+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z))
+	, Lowering u (Schematic Comonad v (w :< x :< y :< z))
+	, Lowering v (Schematic Comonad w (x :< y :< z))
+	, Lowering w (Schematic Comonad x (y :< z))
+	, Lowering x (Schematic Comonad y z)
+	, Lowering y z
 	) => Adaptable (t :< u :< v :< w :< x :< y :< z) z where
-	adapt = flick . flick . flick . flick . flick . flick
+	adapt = lower . lower . lower . lower . lower . lower
 
 instance
 	( Covariant (t :< u :< v :< w :< x :< y :< z)
-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))
-	, Flickable u (Schematic Comonad v (w :< x :< y :< z))
-	, Flickable v (Schematic Comonad w (x :< y :< z))
-	, Flickable w (Schematic Comonad x (y :< z))
-	, Flickable x (Schematic Comonad y z)
+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z))
+	, Lowering u (Schematic Comonad v (w :< x :< y :< z))
+	, Lowering v (Schematic Comonad w (x :< y :< z))
+	, Lowering w (Schematic Comonad x (y :< z))
+	, Lowering x (Schematic Comonad y z)
 	, Bringable y z
 	) => Adaptable (t :< u :< v :< w :< x :< y :< z) y where
-	adapt = bring . flick . flick . flick . flick . flick
+	adapt = bring . lower . lower . lower . lower . lower
 
 instance
 	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)
-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))
-	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))
-	, Layable v (Schematic Monad w (x :> y :> z :> f))
-	, Layable w (Schematic Monad x (y :> z :> f))
-	, Layable x (Schematic Monad y (z :> f))
-	, Layable y (Schematic Monad z f)
-	, Layable z f
+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f))
+	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f))
+	, Lifting v (Schematic Monad w (x :> y :> z :> f))
+	, Lifting w (Schematic Monad x (y :> z :> f))
+	, Lifting x (Schematic Monad y (z :> f))
+	, Lifting y (Schematic Monad z f)
+	, Lifting z f
 	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f) where
-	adapt = lay . lay . lay . lay . lay . lay . lay
+	adapt = lift . lift . lift . lift . lift . lift . lift
 
 instance
 	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)
-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))
-	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))
-	, Layable v (Schematic Monad w (x :> y :> z :> f))
-	, Layable w (Schematic Monad x (y :> z :> f))
-	, Layable x (Schematic Monad y (z :> f))
-	, Layable y (Schematic Monad z f)
+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f))
+	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f))
+	, Lifting v (Schematic Monad w (x :> y :> z :> f))
+	, Lifting w (Schematic Monad x (y :> z :> f))
+	, Lifting x (Schematic Monad y (z :> f))
+	, Lifting y (Schematic Monad z f)
 	, Wrappable z f
 	) => Adaptable z (t :> u :> v :> w :> x :> y :> z :> f) where
-	adapt = lay . lay . lay . lay . lay . lay . wrap
+	adapt = lift . lift . lift . lift . lift . lift . wrap
 
 instance
 	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)
-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
-	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))
-	, Flickable v (Schematic Comonad w (x :< y :< z :< f))
-	, Flickable w (Schematic Comonad x (y :< z :< f))
-	, Flickable x (Schematic Comonad y (z :< f))
-	, Flickable y (Schematic Comonad z f)
-	, Flickable z f
+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
+	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f))
+	, Lowering v (Schematic Comonad w (x :< y :< z :< f))
+	, Lowering w (Schematic Comonad x (y :< z :< f))
+	, Lowering x (Schematic Comonad y (z :< f))
+	, Lowering y (Schematic Comonad z f)
+	, Lowering z f
 	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) f where
-	adapt = flick . flick . flick . flick . flick . flick . flick
+	adapt = lower . lower . lower . lower . lower . lower . lower
 
 instance
 	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)
-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
-	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))
-	, Flickable v (Schematic Comonad w (x :< y :< z :< f))
-	, Flickable w (Schematic Comonad x (y :< z :< f))
-	, Flickable x (Schematic Comonad y (z :< f))
-	, Flickable y (Schematic Comonad z f)
+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
+	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f))
+	, Lowering v (Schematic Comonad w (x :< y :< z :< f))
+	, Lowering w (Schematic Comonad x (y :< z :< f))
+	, Lowering x (Schematic Comonad y (z :< f))
+	, Lowering y (Schematic Comonad z f)
 	, Bringable z f
 	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) z where
-	adapt = bring . flick . flick . flick . flick . flick . flick
+	adapt = bring . lower . lower . lower . lower . lower . lower
 
 instance
 	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)
-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
-	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))
-	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))
-	, Layable w (Schematic Monad x (y :> z :> f :> h))
-	, Layable x (Schematic Monad y (z :> f :> h))
-	, Layable y (Schematic Monad z (f :> h))
-	, Layable z (Schematic Monad f h)
-	, Layable f h
+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
+	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f :> h))
+	, Lifting v (Schematic Monad w (x :> y :> z :> f :> h))
+	, Lifting w (Schematic Monad x (y :> z :> f :> h))
+	, Lifting x (Schematic Monad y (z :> f :> h))
+	, Lifting y (Schematic Monad z (f :> h))
+	, Lifting z (Schematic Monad f h)
+	, Lifting f h
 	) => Adaptable h (t :> u :> v :> w :> x :> y :> z :> f :> h) where
-	adapt = lay . lay . lay . lay . lay . lay . lay . lay
+	adapt = lift . lift . lift . lift . lift . lift . lift . lift
 
 instance
 	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)
-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
-	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))
-	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))
-	, Layable w (Schematic Monad x (y :> z :> f :> h))
-	, Layable x (Schematic Monad y (z :> f :> h))
-	, Layable y (Schematic Monad z (f :> h))
-	, Layable z (Schematic Monad f h)
+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
+	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f :> h))
+	, Lifting v (Schematic Monad w (x :> y :> z :> f :> h))
+	, Lifting w (Schematic Monad x (y :> z :> f :> h))
+	, Lifting x (Schematic Monad y (z :> f :> h))
+	, Lifting y (Schematic Monad z (f :> h))
+	, Lifting z (Schematic Monad f h)
 	, Wrappable f h
 	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where
-	adapt = lay . lay . lay . lay . lay . lay . lay . wrap
+	adapt = lift . lift . lift . lift . lift . lift . lift . wrap
 
 instance
 	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)
-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
-	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))
-	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))
-	, Flickable w (Schematic Comonad x (y :< z :< f :< h))
-	, Flickable x (Schematic Comonad y (z :< f :< h))
-	, Flickable y (Schematic Comonad z (f :< h))
-	, Flickable z (Schematic Comonad f h)
-	, Flickable f h
+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
+	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f :< h))
+	, Lowering v (Schematic Comonad w (x :< y :< z :< f :< h))
+	, Lowering w (Schematic Comonad x (y :< z :< f :< h))
+	, Lowering x (Schematic Comonad y (z :< f :< h))
+	, Lowering y (Schematic Comonad z (f :< h))
+	, Lowering z (Schematic Comonad f h)
+	, Lowering f h
 	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) h where
-	adapt = flick . flick . flick . flick . flick . flick . flick . flick
+	adapt = lower . lower . lower . lower . lower . lower . lower . lower
 
 instance
 	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)
-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
-	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))
-	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))
-	, Flickable w (Schematic Comonad x (y :< z :< f :< h))
-	, Flickable x (Schematic Comonad y (z :< f :< h))
-	, Flickable y (Schematic Comonad z (f :< h))
-	, Flickable z (Schematic Comonad f h)
+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
+	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f :< h))
+	, Lowering v (Schematic Comonad w (x :< y :< z :< f :< h))
+	, Lowering w (Schematic Comonad x (y :< z :< f :< h))
+	, Lowering x (Schematic Comonad y (z :< f :< h))
+	, Lowering y (Schematic Comonad z (f :< h))
+	, Lowering z (Schematic Comonad f h)
 	, Bringable f h
 	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where
-	adapt = bring . flick . flick . flick . flick . flick . flick . flick
+	adapt = bring . lower . lower . lower . lower . lower . lower . lower
+
+instance (Covariant u, Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where
+	adapt = hoist adapt
+
+instance
+	( Covariant u
+	, Covariant v
+	, Traversable (Schematic Monad u v)
+	, Hoistable ((:>) (t :> u))
+	, Hoistable (Schematic Monad t)
+	, Hoistable (Schematic Monad u)
+	, Adaptable v v'
+	) => Adaptable (t :> u :> v) (t :> u :> v') where
+	adapt = hoist (hoist adapt)
+
+instance
+	( Covariant u, Covariant v, Covariant w
+	, Traversable (Schematic Monad u v)
+	, Traversable (Schematic Monad u (v :> w))
+	, Traversable (Schematic Monad v w)
+	, Hoistable ((:>) (t :> u :> v))
+	, Hoistable (Schematic Monad t)
+	, Hoistable (Schematic Monad u)
+	, Hoistable (Schematic Monad v)
+	, Adaptable w w'
+	) => Adaptable (t :> u :> v :> w) (t :> u :> v :> w') where
+	adapt = hoist (hoist (hoist adapt))
+
+instance
+	( Covariant u, Covariant v, Covariant w, Covariant x
+	, Traversable (Schematic Monad u v)
+	, Traversable (Schematic Monad u (v :> w))
+	, Traversable (Schematic Monad v (w :> x))
+	, Traversable (Schematic Monad u (v :> (w :> x)))
+	, Traversable (Schematic Monad w x)
+	, Hoistable ((:>) (t :> u :> v))
+	, Hoistable (Schematic Monad t)
+	, Hoistable (Schematic Monad u)
+	, Hoistable (Schematic Monad v)
+	, Hoistable (Schematic Monad w)
+	, Adaptable x x'
+	) => Adaptable (t :> u :> v :> w :> x) (t :> u :> v :> w :> x') where
+	adapt = hoist (hoist (hoist (hoist adapt)))
diff --git a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
@@ -1,4 +1,6 @@
-module Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (..)) where
+module Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (..)) where
+
+type family Schematic (c :: (* -> *) -> k) (t :: * -> *) = (r :: (* -> *) -> * -> *) | r -> t
 
 class Interpreted t where
 	{-# MINIMAL run #-}
diff --git a/Pandora/Paradigm/Controlflow/Effect/Schematic.hs b/Pandora/Paradigm/Controlflow/Effect/Schematic.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Effect/Schematic.hs
+++ /dev/null
@@ -1,3 +0,0 @@
-module Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic) where
-
-type family Schematic (c :: (* -> *) -> k) (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> t u
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
@@ -14,12 +14,12 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))
 
 class Interpreted t => Comonadic t where
-	{-# MINIMAL flick, bring #-}
-	flick :: Covariant u => t :< u ~> u
+	{-# MINIMAL bring #-}
 	bring :: Extractable u => t :< u ~> t
 
 infixr 3 :<
@@ -53,6 +53,12 @@
 	TC x =>> f = TC $ x =>> f . TC
 
 instance (Extractable (t :< u), Extendable (t :< u)) => Comonad (t :< u) where
+
+instance Lowerable (Schematic Comonad t) => Lowerable ((:<) t) where
+	lower (TC x) = lower x
+
+instance Hoistable (Schematic Comonad t) => Hoistable ((:<) t) where
+	hoist f (TC x) = TC $ hoist f x
 
 instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where
 	type Primary (t :< u) a = Primary (Schematic Comonad t u) a
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
@@ -14,12 +14,12 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))
 
 class Interpreted t => Monadic t where
-	{-# MINIMAL lay, wrap #-}
-	lay :: Covariant u => u ~> t :> u
+	{-# MINIMAL wrap #-}
 	wrap :: Pointable u => t ~> t :> u
 
 infixr 3 :>
@@ -53,6 +53,12 @@
 	TM x =>> f = TM $ x =>> f . TM
 
 instance (Pointable (t :> u), Bindable (t :> u)) => Monad (t :> u) where
+
+instance Liftable (Schematic Monad t) => Liftable ((:>) t) where
+	lift = TM . lift
+
+instance Hoistable (Schematic Monad t) => Hoistable ((:>) t) where
+	hoist f (TM x) = TM $ hoist f x
 
 instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where
 	type Primary (t :> u) a = Primary (Schematic Monad t u) a
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -1,6 +1,6 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Inventory (module Exports) where
+module Pandora.Paradigm.Inventory (module Exports, zoom) where
 
 import Pandora.Paradigm.Inventory.Optics as Exports
 import Pandora.Paradigm.Inventory.Store as Exports
@@ -11,14 +11,16 @@
 import Pandora.Paradigm.Inventory.Accumulator as Exports
 
 import Pandora.Core.Morphism ((!), (%))
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Pattern.Category ((.), ($), identity)
+import Pandora.Pattern.Functor (Adjoint ((-|), (|-)), extract, (<->))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)
 
 instance Adjoint (Store s) (State s) where
+	(-|) :: a -> (Store s a -> b) -> State s b
 	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !)
+	(|-) :: Store s a -> (a -> State s b) -> b
 	Store (s :*: f) |- g = extract . run % s . g $ f s
 
 instance Adjoint (Accumulator e) (Imprint e) where
@@ -28,3 +30,6 @@
 instance Adjoint (Equipment e) (Environment e) where
 	x -| f = Environment $ x -| f . Equipment
 	x |- g = run x |- run . g
+
+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
diff --git a/Pandora/Paradigm/Inventory/Accumulator.hs b/Pandora/Paradigm/Inventory/Accumulator.hs
--- a/Pandora/Paradigm/Inventory/Accumulator.hs
+++ b/Pandora/Paradigm/Inventory/Accumulator.hs
@@ -11,9 +11,8 @@
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
 
@@ -33,14 +32,13 @@
 	Accumulator (e :*: x) >>= f = let (e' :*: b) = run $ f x in
 		Accumulator $ e + e':*: b
 
-type instance Schematic Monad (Accumulator e) u = (:*:) e <.:> u
+type instance Schematic Monad (Accumulator e) = (<.:>) ((:*:) e)
 
 instance Interpreted (Accumulator e) where
 	type Primary (Accumulator e) a = e :*: a
 	run (Accumulator x) = x
 
 instance Monoid e => Monadic (Accumulator e) where
-	lay x = TM . UT $ (zero :*:) <$> x
 	wrap = TM . UT . point . run
 
 type Accumulated e t = Adaptable (Accumulator e) t
diff --git a/Pandora/Paradigm/Inventory/Environment.hs b/Pandora/Paradigm/Inventory/Environment.hs
--- a/Pandora/Paradigm/Inventory/Environment.hs
+++ b/Pandora/Paradigm/Inventory/Environment.hs
@@ -10,9 +10,8 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Core.Morphism ((!), (%))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 
@@ -39,10 +38,9 @@
 	type Primary (Environment e) a = (->) e a
 	run (Environment x) = x
 
-type instance Schematic Monad (Environment e) u = (->) e <:.> u
+type instance Schematic Monad (Environment e) = (<:.>) ((->) e)
 
 instance Monadic (Environment e) where
-	lay = TM . TU . (!)
 	wrap x = TM . TU $ point <$> run x
 
 type Configured e = Adaptable (Environment e)
diff --git a/Pandora/Paradigm/Inventory/Equipment.hs b/Pandora/Paradigm/Inventory/Equipment.hs
--- a/Pandora/Paradigm/Inventory/Equipment.hs
+++ b/Pandora/Paradigm/Inventory/Equipment.hs
@@ -9,9 +9,8 @@
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))
 import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 
 newtype Equipment e a = Equipment (e :*: a)
@@ -29,10 +28,9 @@
 	type Primary (Equipment e) a = e :*: a
 	run (Equipment x) = x
 
-type instance Schematic Comonad (Equipment e) u = (:*:) e <:.> u
+type instance Schematic Comonad (Equipment e) = (<:.>) ((:*:) e)
 
 instance Comonadic (Equipment e) where
-	flick (TC (TU x)) = extract x
 	bring (TC (TU x)) = Equipment $ extract <$> x
 
 type Equipped e t = Adaptable t (Equipment e)
diff --git a/Pandora/Paradigm/Inventory/Imprint.hs b/Pandora/Paradigm/Inventory/Imprint.hs
--- a/Pandora/Paradigm/Inventory/Imprint.hs
+++ b/Pandora/Paradigm/Inventory/Imprint.hs
@@ -11,9 +11,8 @@
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable)
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
 
@@ -35,10 +34,9 @@
 	type Primary (Imprint e) a = (->) e a
 	run (Imprint x) = x
 
-type instance Schematic Comonad (Imprint e) u = (->) e <.:> u
+type instance Schematic Comonad (Imprint e) = (<.:>) ((->) e)
 
 instance Monoid e => Comonadic (Imprint e) where
-	flick (TC (UT x)) = extract <$> x
 	bring (TC (UT x)) = Imprint . extract $ x
 
 instance Covariant u => Covariant ((->) e <.:> u) where
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
@@ -3,16 +3,13 @@
 module Pandora.Paradigm.Inventory.Optics where
 
 import Pandora.Core.Functor (type (|->))
-import Pandora.Pattern.Category (identity, (.), ($))
+import Pandora.Pattern.Category ((.), ($))
 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)
 
 infixr 0 :-.
@@ -47,9 +44,6 @@
 -- | Infix version of `over`
 (%~) :: Lens src tgt -> (tgt -> tgt) -> src -> src
 lens %~ f = over lens f
-
-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
@@ -1,29 +1,15 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Inventory.State (State (..), Stateful, current, modify, replace, fold, find) where
+module Pandora.Paradigm.Inventory.State where
 
 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))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
-import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Pattern.Functor (Covariant ((<$>), (<$$>)), Avoidable (empty), Pointable (point), Applicative ((<*>), (*>)), Alternative ((<+>)), Traversable ((->>)), Bindable ((>>=), (>=>)), Monad, extract, (-|), (|-), (<*+>))
+import Pandora.Paradigm.Controlflow (Adaptable (adapt), Interpreted (Primary, run), Monadic (wrap), (:>) (TM), 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.Product (Product ((:*:)), type (:*:), delta)
+import Pandora.Paradigm.Primary.Functor (Predicate (Predicate), Product ((:*:)), type (:*:), delta)
+import Pandora.Paradigm.Primary.Object (bool)
 
 newtype State s a = State ((->) s :. (:*:) s := a)
 
@@ -54,25 +40,24 @@
 	type Primary (State s) a = (->) s :. (:*:) s := a
 	run (State x) = x
 
-type instance Schematic Monad (State s) u = (->) s <:<.>:> (:*:) s := u
+type instance Schematic Monad (State s) = (->) s <:<.>:> (:*:) s
 
 instance Monadic (State s) where
-	lay x = TM . TUT $ \s -> (s :*:) <$> x
 	wrap x = TM . TUT $ point <$> run x
 
 type Stateful s = Adaptable (State s)
 
 instance Covariant u => Covariant ((->) s <:<.>:> (:*:) s := u) where
-	f <$> TUT x = TUT $ \old -> f <$$> x old
+	f <$> TUT x = TUT $ (<$$>) f . x
 
 instance Bindable u => Applicative ((->) s <:<.>:> (:*:) s := u) where
-	TUT f <*> TUT x = TUT $ \old -> f old >>= \(new :*: g) -> g <$$> x new
+	TUT f <*> TUT x = TUT $ f >=> \(new :*: g) -> g <$$> x new
 
 instance Pointable u => Pointable ((->) s <:<.>:> (:*:) s := u) where
 	point = TUT . (-| point)
 
 instance Bindable u => Bindable ((->) s <:<.>:> (:*:) s := u) where
-	TUT x >>= f = TUT $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y
+	TUT x >>= f = TUT $ x >=> \(new :*: y) -> ($ new) . run . f $ y
 
 instance Monad u => Monad ((->) s <:<.>:> (:*:) s := u) where
 
diff --git a/Pandora/Paradigm/Inventory/Store.hs b/Pandora/Paradigm/Inventory/Store.hs
--- a/Pandora/Paradigm/Inventory/Store.hs
+++ b/Pandora/Paradigm/Inventory/Store.hs
@@ -1,22 +1,15 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Inventory.Store (Store (..), Storable, position, access, retrofit) where
+module Pandora.Paradigm.Inventory.Store where
 
-import Pandora.Core.Functor (type (:.), type (:=), type (<-|), type (~>))
-import Pandora.Core.Morphism ((%))
+import Pandora.Core (type (:.), type (:=), type (<-|), type (~>), (%))
 import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>)), (.|..))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), (<<=$)))
-import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
-import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Pattern.Functor (Covariant ((<$>), (<$$>), (<$$$>)), Extractable (extract), Extendable ((=>>), (<<=$)), Comonad, (.|..), (-|), (|-))
+import Pandora.Paradigm.Primary.Functor (Product ((:*:)), type (:*:), attached)
+import Pandora.Paradigm.Controlflow (Adaptable (adapt), Interpreted (Primary, run), Schematic, Comonadic (bring), (:<) (TC))
 import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))
-import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
 
+
 newtype Store p a = Store ((:*:) p :. (->) p := a)
 
 instance Covariant (Store p) where
@@ -34,10 +27,9 @@
 	type Primary (Store p) a = (:*:) p :. (->) p := a
 	run (Store x) = x
 
-type instance Schematic Comonad (Store p) u = (:*:) p <:<.>:> (->) p := u
+type instance Schematic Comonad (Store p) = (:*:) p <:<.>:> (->) p
 
 instance Comonadic (Store p) where
-	flick (TC (TUT (p :*: f))) = ($ p) <$> f
 	bring (TC (TUT (p :*: f))) = Store $ p :*: extract f
 
 type Storable s x = Adaptable x (Store s)
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,3 +1,5 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
 module Pandora.Paradigm.Primary.Functor (module Exports, note, hush, left, right, this, that, here, there) where
 
 import Pandora.Paradigm.Primary.Functor.Fix as Exports
@@ -20,6 +22,14 @@
 
 import Pandora.Core.Morphism ((!))
 import Pandora.Core.Functor (type (~>))
+import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+
+instance Adjoint (Product s) ((->) s) where
+	(-|) :: a -> ((s :*: a) -> b) -> (s -> b)
+	x -| f = \s -> f $ s :*: x
+	(|-) :: (s :*: a) -> (a -> s -> b) -> b
+	(s :*: x) |- f = f x s
 
 note :: e -> Maybe ~> Conclusion e
 note x = maybe (Failure x) Success
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
@@ -15,9 +15,8 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT))
 
@@ -80,10 +79,9 @@
 	type Primary (Conclusion e) a = Conclusion e a
 	run x = x
 
-type instance Schematic Monad (Conclusion e) u = UT Covariant Covariant (Conclusion e) u
+type instance Schematic Monad (Conclusion e) = UT Covariant Covariant (Conclusion e)
 
 instance Monadic (Conclusion e) where
-	lay x = TM . UT $ Success <$> x
 	wrap x = TM . UT . point $ x
 
 type Failable e = Adaptable (Conclusion e)
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
@@ -17,9 +17,8 @@
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT))
 
@@ -88,14 +87,14 @@
 maybe x _ Nothing = x
 maybe _ f (Just y) = f y
 
-type instance Schematic Monad Maybe u = UT Covariant Covariant Maybe u
+-- type instance Schematic Monad Maybe u = UT Covariant Covariant Maybe u
+type instance Schematic Monad Maybe = UT Covariant Covariant Maybe
 
 instance Interpreted Maybe where
 	type Primary Maybe a = Maybe a
 	run x = x
 
 instance Monadic Maybe where
-	lay x = TM . UT $ Just <$> x
 	wrap x = TM . UT . point $ x
 
 type Optional = Adaptable Maybe
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
@@ -6,7 +6,6 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
@@ -20,56 +19,52 @@
 
 infixr 1 :*:
 
-data Product a b = a :*: b
+data Product s a = s :*: a
 
 type (:*:) = Product
 
-instance Covariant (Product a) where
-	f <$> (x :*: y) = x :*: f y
+instance Covariant (Product s) where
+	f <$> (s :*: x) = s :*: f x
 
 instance Extractable (Product a) where
 	extract (_ :*: y) = y
 
-instance Traversable (Product a) where
-	(x :*: y) ->> f = (:*:) x <$> f y
-
-instance Extendable (Product a) where
-	(x :*: y) =>> f = (:*:) x $ f (x :*: y)
+instance Traversable (Product s) where
+	(s :*: x) ->> f = (s :*:) <$> f x
 
-instance Comonad (Product a) where
+instance Extendable (Product s) where
+	(s :*: x) =>> f = s :*: f (s :*: x)
 
-instance Adjoint (Product a) ((->) a) where
-	x -| f = \y -> f $ y :*: x
-	(y :*: x) |- f = f x y
+instance Comonad (Product s) where
 
 instance Bivariant Product where
-	f <-> g = \(x :*: y) -> f x :*: g y
+	f <-> g = \(s :*: x) -> f s :*: g x
 
-instance (Setoid a, Setoid b) => Setoid (Product a b) where
-	(x :*: y) == (x' :*: y') = (x == x') * (y == y')
+instance (Setoid s, Setoid a) => Setoid (Product s a) where
+	(s :*: x) == (s' :*: x') = (s == s') * (x == x')
 
-instance (Semigroup a, Semigroup b) => Semigroup (Product a b) where
-	(x :*: y) + (x' :*: y') = x + x' :*: y + y'
+instance (Semigroup s, Semigroup a) => Semigroup (Product s a) where
+	(s :*: x) + (s' :*: x') = s + s' :*: x + x'
 
-instance (Monoid a, Monoid b) => Monoid (Product a b) where
+instance (Monoid s, Monoid a) => Monoid (Product s a) where
 	zero = zero :*: zero
 
-instance (Ringoid a, Ringoid b) => Ringoid (Product a b) where
-	(x :*: y) * (x' :*: y') = x * x' :*: y * y'
+instance (Ringoid s, Ringoid a) => Ringoid (Product s a) where
+	(s :*: x) * (s' :*: x') = s * s' :*: x * x'
 
-instance (Quasiring a, Quasiring b) => Quasiring (Product a b) where
+instance (Quasiring s, Quasiring a) => Quasiring (Product s a) where
 	one = one :*: one
 
-instance (Infimum a, Infimum b) => Infimum (Product a b) where
-	(x :*: y) /\ (x' :*: y') = x /\ x' :*: y /\ y'
+instance (Infimum s, Infimum a) => Infimum (Product s a) where
+	(s :*: x) /\ (s' :*: x') = s /\ s' :*: x /\ x'
 
-instance (Supremum a, Supremum b) => Supremum (Product a b) where
-	(x :*: y) \/ (x' :*: y') = x \/ x' :*: y \/ y'
+instance (Supremum s, Supremum a) => Supremum (Product s a) where
+	(s :*: x) \/ (s' :*: x') = s \/ s' :*: x \/ x'
 
-instance (Lattice a, Lattice b) => Lattice (Product a b) where
+instance (Lattice s, Lattice a) => Lattice (Product s a) where
 
-instance (Group a, Group b) => Group (Product a b) where
-	invert (x :*: y) = invert x :*: invert y
+instance (Group s, Group a) => Group (Product s a) where
+	invert (s :*: x) = invert s :*: invert x
 
 instance Monotonic e a => Monotonic (Product a e) a where
 	iterate f r (x :*: e) = iterate f (f x r) e
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
@@ -6,6 +6,7 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Traversable (Traversable)
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
@@ -34,7 +35,7 @@
 cwcc f = Continuation $ \g -> continue % g . f $ Continuation . (!) . g
 
 -- | Delimit the continuation of any 'shift'
-reset :: (forall u . Bindable u, Bindable t, Pointable t) => Continuation r t r -> Continuation s t r
+reset :: (forall u . Bindable u, Monad t, Traversable t) => Continuation r t r -> Continuation s t r
 reset = lift . continue % point
 
 -- | Capture the continuation up to the nearest enclosing 'reset' and pass it
diff --git a/Pandora/Paradigm/Schemes/TU.hs b/Pandora/Paradigm/Schemes/TU.hs
--- a/Pandora/Paradigm/Schemes/TU.hs
+++ b/Pandora/Paradigm/Schemes/TU.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Schemes.TU where
 
-import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
@@ -23,10 +23,13 @@
 	run (TU x) = x
 
 instance Pointable t => Liftable (TU Covariant Covariant t) where
+	lift :: Covariant u => u ~> t <:.> u
 	lift = TU . point
 
 instance Extractable t => Lowerable (TU Covariant Covariant t) where
+	lower :: t <:.> u ~> u
 	lower (TU x) = extract x
 
 instance Covariant t => Hoistable (TU Covariant Covariant t) where
+	hoist :: u ~> v -> (t <:.> u ~> t <:.> v)
 	hoist f (TU x) = TU $ f <$> x
diff --git a/Pandora/Paradigm/Schemes/TUT.hs b/Pandora/Paradigm/Schemes/TUT.hs
--- a/Pandora/Paradigm/Schemes/TUT.hs
+++ b/Pandora/Paradigm/Schemes/TUT.hs
@@ -1,12 +1,9 @@
 module Pandora.Paradigm.Schemes.TUT where
 
-import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Category (identity, ($))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Pointable (Pointable)
-import Pandora.Pattern.Functor.Applicative (Applicative)
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
@@ -28,8 +25,10 @@
 	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' := a
 	run (TUT x) = x
 
-instance (Adjoint t' t, Applicative t, Pointable t, forall u . Traversable u) => Liftable (t <:<.>:> t') where
-	lift x = TUT $ x ->> (-| identity)
+instance (Adjoint t' t, Distributive t) => Liftable (t <:<.>:> t') where
+	lift :: Covariant u => u ~> t <:<.>:> t' := u
+	lift x = TUT $ x >>- (-| identity)
 
 instance (Adjoint t t', Distributive t') => Lowerable (t <:<.>:> t') where
+	lower :: Covariant u => (t <:<.>:> t' := u) ~> u
 	lower (TUT x) = x |- (>>- identity)
diff --git a/Pandora/Paradigm/Schemes/UT.hs b/Pandora/Paradigm/Schemes/UT.hs
--- a/Pandora/Paradigm/Schemes/UT.hs
+++ b/Pandora/Paradigm/Schemes/UT.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Schemes.UT where
 
-import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
@@ -21,8 +21,10 @@
 	type Primary (UT ct cu t u) a = u :. t := a
 	run (UT x) = x
 
-instance (forall u . Covariant u, Pointable t) => Liftable (UT Covariant Covariant t) where
+instance Pointable t => Liftable (UT Covariant Covariant t) where
+	lift :: Covariant u => u ~> t <.:> u
 	lift x = UT $ point <$> x
 
 instance Extractable t => Lowerable (UT Covariant Covariant t) where
+	lower :: Covariant u => t <.:> u ~> u
 	lower (UT x) = extract <$> x
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,22 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
 module Pandora.Paradigm.Structure (module Exports) where
 
 import Pandora.Paradigm.Structure.Ability as Exports
+import Pandora.Paradigm.Structure.Interface 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
+
+import Pandora.Pattern (($), (.), extract)
+import Pandora.Paradigm.Primary (Product ((:*:)), Tagged (Tag), Wye (Left, Right))
+import Pandora.Paradigm.Inventory (Store (Store))
+
+instance Substructure Left (Product s) where
+	type Substructural Left (Product s) a = s
+	substructure (extract -> s :*: x) = Store $ s :*: Tag . (:*: x)
+
+instance Substructure Right (Product s) where
+	type Substructural Right (Product s) a = a
+	substructure (extract -> s :*: x) = Store $ x :*: Tag . (s :*:)
diff --git a/Pandora/Paradigm/Structure/Interface.hs b/Pandora/Paradigm/Structure/Interface.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Interface.hs
@@ -0,0 +1,3 @@
+module Pandora.Paradigm.Structure.Interface (module Exports) where
+
+import Pandora.Paradigm.Structure.Interface.Set as Exports
diff --git a/Pandora/Paradigm/Structure/Interface/Set.hs b/Pandora/Paradigm/Structure/Interface/Set.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Interface/Set.hs
@@ -0,0 +1,7 @@
+module Pandora.Paradigm.Structure.Interface.Set where
+
+import Pandora.Pattern.Object.Setoid (Setoid)
+import Pandora.Paradigm.Primary.Object.Boolean (Boolean)
+
+class Set t where
+	member :: Setoid a => a -> t a -> Boolean
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
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Structure.Stack where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Core.Morphism ((&), (%))
+import Pandora.Core.Morphism ((&), (%), (!))
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (.|..))
 import Pandora.Pattern.Functor.Alternative ((<+>))
@@ -18,13 +18,14 @@
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Paradigm.Primary.Object.Boolean ((?))
 import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))
-import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing), maybe)
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
+import Pandora.Paradigm.Primary.Object (Boolean (True, False))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
 import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap))
-import Pandora.Paradigm.Inventory.State (fold)
+import Pandora.Paradigm.Inventory.State (fold, find)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Optics ((^.))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
@@ -33,6 +34,7 @@
 import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)
 import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Head), focus)
 import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert))
+import Pandora.Paradigm.Structure.Interface.Set (Set (member))
 
 -- | Linear data structure that serves as a collection of elements
 type Stack = Maybe <:.> Construction Maybe
@@ -56,6 +58,9 @@
 
 instance Insertable Stack where
 	insert x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x
+
+instance Set Stack where
+	member x = maybe False (True !) . find (Predicate (== x))
 
 pop :: Stack ~> Stack
 pop (TU stack) = TU $ stack >>= deconstruct
diff --git a/Pandora/Pattern/Functor/Monad.hs b/Pandora/Pattern/Functor/Monad.hs
--- a/Pandora/Pattern/Functor/Monad.hs
+++ b/Pandora/Pattern/Functor/Monad.hs
@@ -11,7 +11,7 @@
 > When providing a new instance, you should ensure it satisfies the three laws:
 > * Left identity: point a >>= f ≡ f a
 > * Right identity: h >>= point ≡ h
-> * Associativity: h >>= (\x -> f x >>= g) ≡ (h >>= f) >>= g
+> * Associativity: h >>= (f >=> g) ≡ (h >>= f) >>= g
 -}
 
 class (Pointable t, Bindable t) => Monad t
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.3.0
+version:             0.3.1
 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
@@ -76,7 +76,6 @@
     Pandora.Paradigm.Controlflow.Effect.Transformer
     Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic
     Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic
-    Pandora.Paradigm.Controlflow.Effect.Schematic
     Pandora.Paradigm.Controlflow.Effect.Adaptable
     Pandora.Paradigm.Controlflow.Observable
     Pandora.Paradigm.Controlflow.Pipeline
@@ -105,6 +104,8 @@
     Pandora.Paradigm.Structure.Ability.Nonempty
     Pandora.Paradigm.Structure.Ability.Zipper
     Pandora.Paradigm.Structure.Ability.Monotonic
+    Pandora.Paradigm.Structure.Interface
+    Pandora.Paradigm.Structure.Interface.Set
 
     Pandora.Pattern
     -- Category typeclass
@@ -149,7 +150,7 @@
     Pandora.Pattern.Transformer.Liftable
     Pandora.Pattern.Transformer.Lowerable
   default-extensions:
-    DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints
+    DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints, InstanceSigs
     FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase
     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes, ViewPatterns
     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators