diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -222,7 +222,7 @@
 * Define `Delta` datatype
 * Define `Wedge` datatype
 * Rename `Variation` to `These`
-* Define two experimental methods in `Bindable` class - `$>>=` and `>>=$`
+* Define experimental methods in `Bindable` class - `$>>=` and `>>=$`
 * Define `here` and `there` methods from `Wedge` to `Maybe`
 * Move `Boolean` definition to its own module
 * Move `Ordering` definition to its own module
@@ -230,3 +230,18 @@
 * Define `Focusable` typeclass for getting root and creating singleton
 * Replace `top` method of `Stack` structure with `Focusable` instance
 * Add `Covariant` constraint on `natural transformation` in `Hoistable` typeclass
+
+# 0.2.9
+* Define `Zipper` type family to walk datastructures with context
+* Define `Tap` datatype for context dependent values
+* Define type synonyms for `TU`, `UT`, `TUT` and `UTU` joint schemes
+* Move `Schemes` module to `Paradigm` submodule
+* Move `$` definition from `Divariant` to `Category`
+* Define generalized point free combinators in `Covariant` module
+* Rename `Joint` module To `Effect`
+* Define left and right `zig`, `zig-zig` and `zig-zag` `Splay` rotations for `Binary` tree
+* Define experimental methods in `Extendable` class - `$=>>` and `<<=$`
+* Define `Rotatable` typeclass to rotate trees
+* 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
diff --git a/Pandora/Paradigm/Controlflow.hs b/Pandora/Paradigm/Controlflow.hs
--- a/Pandora/Paradigm/Controlflow.hs
+++ b/Pandora/Paradigm/Controlflow.hs
@@ -2,4 +2,4 @@
 
 import Pandora.Paradigm.Controlflow.Pipeline as Exports
 import Pandora.Paradigm.Controlflow.Observable as Exports
-import Pandora.Paradigm.Controlflow.Joint as Exports
+import Pandora.Paradigm.Controlflow.Effect as Exports
diff --git a/Pandora/Paradigm/Controlflow/Effect.hs b/Pandora/Paradigm/Controlflow/Effect.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Effect.hs
@@ -0,0 +1,7 @@
+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
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
@@ -0,0 +1,319 @@
+{-# LANGUAGE UndecidableInstances #-}
+
+module Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (..)) where
+
+import Pandora.Core.Functor (type (~>))
+import Pandora.Pattern.Category (identity, (.))
+import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Pointable (Pointable)
+import Pandora.Pattern.Functor.Extractable (Extractable)
+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, (:>), (:<))
+
+class Adaptable t u where
+	{-# MINIMAL adapt #-}
+	adapt :: t ~> u
+
+type Layable t u = (Transformer Monad 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), 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), Bringable t u) => Adaptable (t :< u) t where
+	adapt = bring
+
+instance
+	( Covariant (t :> u :> v)
+	, Layable t (Schematic Monad u v)
+	, Wrappable u v
+	) => Adaptable u (t :> u :> v) where
+	adapt = lay . wrap
+
+instance
+	( Covariant (t :> u :> v)
+	, Layable t (Schematic Monad u v)
+	, Layable u v
+	) => Adaptable v (t :> u :> v) where
+	adapt = lay . lay
+
+instance
+	( Covariant (t :< u :< v)
+	, Flickable t (Schematic Comonad u v)
+	, Bringable u v
+	) => Adaptable (t :< u :< v) u where
+	adapt = bring . flick
+
+instance
+	( Covariant (t :< u :< v)
+	, Flickable t (Schematic Comonad u v)
+	, Flickable u v
+	) => Adaptable (t :< u :< v) v where
+	adapt = flick . flick
+
+instance
+	( Covariant (t :> u :> v :> w)
+	, Layable t (Schematic Monad u (v :> w))
+	, Layable u (Schematic Monad v w)
+	, Wrappable v w
+	) => Adaptable v (t :> u :> v :> w) where
+	adapt = lay . lay . 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
+	) => Adaptable w (t :> u :> v :> w) where
+	adapt = lay . lay . lay
+
+instance
+	( Covariant (t :< u :< v :< w)
+	, Flickable t (Schematic Comonad u (v :< w))
+	, Flickable u (Schematic Comonad v w)
+	, Bringable v w
+	) => Adaptable (t :< u :< v :< w) v where
+	adapt = bring . flick . flick
+
+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
+	) => Adaptable (t :< u :< v :< w) w where
+	adapt = flick . flick . flick
+
+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
+	) => Adaptable x (t :> u :> v :> w :> x) where
+	adapt = lay . lay . lay . lay
+
+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)
+	, Wrappable w x
+	) => Adaptable w (t :> u :> v :> w :> x) where
+	adapt = lay . lay . lay . 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
+	) => Adaptable (t :< u :< v :< w :< x) x where
+	adapt = flick . flick . flick . flick
+
+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)
+	, Bringable w x
+	) => Adaptable (t :< u :< v :< w :< x) w where
+	adapt = bring . flick . flick . flick
+
+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
+	) => Adaptable y (t :> u :> v :> w :> x :> y) where
+	adapt = lay . lay . lay . lay . lay
+
+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)
+	, Wrappable x y
+	) => Adaptable x (t :> u :> v :> w :> x :> y) where
+	adapt = lay . lay . lay . lay . 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
+	) => Adaptable (t :< u :< v :< w :< x :< y) y where
+	adapt = flick . flick . flick . flick . flick
+
+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)
+	, Bringable x y
+	) => Adaptable (t :< u :< v :< w :< x :< y) x where
+	adapt = bring . flick . flick . flick . flick
+
+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
+	) => Adaptable z (t :> u :> v :> w :> x :> y :> z) where
+	adapt = lay . lay . lay . lay . lay . lay
+
+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)
+	, Wrappable y z
+	) => Adaptable y (t :> u :> v :> w :> x :> y :> z) where
+	adapt = lay . lay . lay . lay . lay . 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
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z) z where
+	adapt = flick . flick . flick . flick . flick . flick
+
+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)
+	, Bringable y z
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z) y where
+	adapt = bring . flick . flick . flick . flick . flick
+
+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
+	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f) where
+	adapt = lay . lay . lay . lay . lay . lay . lay
+
+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)
+	, Wrappable z f
+	) => Adaptable z (t :> u :> v :> w :> x :> y :> z :> f) where
+	adapt = lay . lay . lay . lay . lay . lay . 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
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) f where
+	adapt = flick . flick . flick . flick . flick . flick . flick
+
+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)
+	, Bringable z f
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) z where
+	adapt = bring . flick . flick . flick . flick . flick . flick
+
+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
+	) => Adaptable h (t :> u :> v :> w :> x :> y :> z :> f :> h) where
+	adapt = lay . lay . lay . lay . lay . lay . lay . lay
+
+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)
+	, Wrappable f h
+	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where
+	adapt = lay . lay . lay . lay . lay . lay . lay . 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
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) h where
+	adapt = flick . flick . flick . flick . flick . flick . flick . flick
+
+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)
+	, Bringable f h
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where
+	adapt = bring . flick . flick . flick . flick . flick . flick . flick
diff --git a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
@@ -0,0 +1,6 @@
+module Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (..)) where
+
+class Interpreted t where
+	{-# MINIMAL run #-}
+	type Primary t a :: *
+	run :: t a -> Primary t a
diff --git a/Pandora/Paradigm/Controlflow/Effect/Schematic.hs b/Pandora/Paradigm/Controlflow/Effect/Schematic.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Effect/Schematic.hs
@@ -0,0 +1,3 @@
+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.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer.hs
@@ -0,0 +1,10 @@
+module Pandora.Paradigm.Controlflow.Effect.Transformer (module Exports, Transformer) where
+
+import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic as Exports
+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic as Exports
+
+import Pandora.Pattern.Functor (Monad, Comonad)
+
+type family Transformer c t where
+	Transformer Monad t = Monadic t
+	Transformer Comonad t = Comonadic t
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
@@ -0,0 +1,59 @@
+{-# LANGUAGE UndecidableInstances #-}
+
+module Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (..), (:<) (..)) 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.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+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)
+
+class Interpreted t => Comonadic t where
+	{-# MINIMAL flick, bring #-}
+	flick :: Covariant u => t :< u ~> u
+	bring :: Extractable u => t :< u ~> t
+
+infixr 3 :<
+newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }
+
+instance Covariant (Schematic Comonad t u) => Covariant (t :< u) where
+	f <$> TC x = TC $ f <$> x
+
+instance Pointable (Schematic Comonad t u) => Pointable (t :< u) where
+	point = TC . point
+
+instance Extractable (Schematic Comonad t u) => Extractable (t :< u) where
+	extract = extract . tc
+
+instance Applicative (Schematic Comonad t u) => Applicative (t :< u) where
+	TC f <*> TC x = TC $ f <*> x
+
+instance Alternative (Schematic Comonad t u) => Alternative (t :< u) where
+	TC x <+> TC y = TC $ x <+> y
+
+instance Traversable (Schematic Comonad t u) => Traversable (t :< u) where
+	TC x ->> f = TC <$> x ->> f
+
+instance Distributive (Schematic Comonad t u) => Distributive (t :< u) where
+	x >>- f = TC $ x >>- tc . f
+
+instance Bindable (Schematic Comonad t u) => Bindable (t :< u) where
+	TC x >>= f = TC $ x >>= tc . f
+
+instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where
+	TC x =>> f = TC $ x =>> f . TC
+
+instance (Extractable (t :< u), Extendable (t :< u)) => Comonad (t :< u) where
+
+instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where
+	type Primary (t :< u) a = Primary (Schematic Comonad t u) a
+	run (TC x) = run x
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
@@ -0,0 +1,59 @@
+{-# LANGUAGE UndecidableInstances #-}
+
+module Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (..), (:>) (..)) 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.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+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)
+
+class Interpreted t => Monadic t where
+	{-# MINIMAL lay, wrap #-}
+	lay :: Covariant u => u ~> t :> u
+	wrap :: Pointable u => t ~> t :> u
+
+infixr 3 :>
+newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
+
+instance Covariant (Schematic Monad t u) => Covariant (t :> u) where
+	f <$> TM x = TM $ f <$> x
+
+instance Pointable (Schematic Monad t u) => Pointable (t :> u) where
+	point = TM . point
+
+instance Extractable (Schematic Monad t u) => Extractable (t :> u) where
+	extract = extract . tm
+
+instance Applicative (Schematic Monad t u) => Applicative (t :> u) where
+	TM f <*> TM x = TM $ f <*> x
+
+instance Alternative (Schematic Monad t u) => Alternative (t :> u) where
+	TM x <+> TM y = TM $ x <+> y
+
+instance Traversable (Schematic Monad t u) => Traversable (t :> u) where
+	TM x ->> f = TM <$> x ->> f
+
+instance Distributive (Schematic Monad t u) => Distributive (t :> u) where
+	x >>- f = TM $ x >>- tm . f
+
+instance Bindable (Schematic Monad t u) => Bindable (t :> u) where
+	TM x >>= f = TM $ x >>= tm . f
+
+instance Extendable (Schematic Monad t u) => Extendable (t :> u) where
+	TM x =>> f = TM $ x =>> f . TM
+
+instance (Pointable (t :> u), Bindable (t :> u)) => Monad (t :> u) where
+
+instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where
+	type Primary (t :> u) a = Primary (Schematic Monad t u) a
+	run (TM x) = run x
diff --git a/Pandora/Paradigm/Controlflow/Joint.hs b/Pandora/Paradigm/Controlflow/Joint.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint.hs
+++ /dev/null
@@ -1,7 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint (module Exports) where
-
-import Pandora.Paradigm.Controlflow.Joint.Schemes as Exports
-import Pandora.Paradigm.Controlflow.Joint.Schematic as Exports
-import Pandora.Paradigm.Controlflow.Joint.Transformer as Exports
-import Pandora.Paradigm.Controlflow.Joint.Interpreted as Exports
-import Pandora.Paradigm.Controlflow.Joint.Adaptable as Exports
diff --git a/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs b/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
+++ /dev/null
@@ -1,320 +0,0 @@
-{-# LANGUAGE UndecidableInstances #-}
-
-module Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (..)) where
-
-import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category (identity, (.))
-import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Pointable (Pointable)
-import Pandora.Pattern.Functor.Extractable (Extractable)
-import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>))
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<))
-
-class Adaptable t u where
-	{-# MINIMAL adapt #-}
-	adapt :: t ~> u
-
-type Layable t u = (Monadic t, Covariant u)
-type Wrappable t u = (Monadic t, Pointable u)
-type Flickable t u = (Comonadic t, Covariant u)
-type Bringable t u = (Comonadic 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), 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), Bringable t u) => Adaptable (t :< u) t where
-	adapt = bring
-
-instance
-	( Covariant (t :> u :> v)
-	, Layable t (Schematic Monad u v)
-	, Wrappable u v
-	) => Adaptable u (t :> u :> v) where
-	adapt = lay . wrap
-
-instance
-	( Covariant (t :> u :> v)
-	, Layable t (Schematic Monad u v)
-	, Layable u v
-	) => Adaptable v (t :> u :> v) where
-	adapt = lay . lay
-
-instance
-	( Covariant (t :< u :< v)
-	, Flickable t (Schematic Comonad u v)
-	, Bringable u v
-	) => Adaptable (t :< u :< v) u where
-	adapt = bring . flick
-
-instance
-	( Covariant (t :< u :< v)
-	, Flickable t (Schematic Comonad u v)
-	, Flickable u v
-	) => Adaptable (t :< u :< v) v where
-	adapt = flick . flick
-
-instance
-	( Covariant (t :> u :> v :> w)
-	, Layable t (Schematic Monad u (v :> w))
-	, Layable u (Schematic Monad v w)
-	, Wrappable v w
-	) => Adaptable v (t :> u :> v :> w) where
-	adapt = lay . lay . 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
-	) => Adaptable w (t :> u :> v :> w) where
-	adapt = lay . lay . lay
-
-instance
-	( Covariant (t :< u :< v :< w)
-	, Flickable t (Schematic Comonad u (v :< w))
-	, Flickable u (Schematic Comonad v w)
-	, Bringable v w
-	) => Adaptable (t :< u :< v :< w) v where
-	adapt = bring . flick . flick
-
-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
-	) => Adaptable (t :< u :< v :< w) w where
-	adapt = flick . flick . flick
-
-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
-	) => Adaptable x (t :> u :> v :> w :> x) where
-	adapt = lay . lay . lay . lay
-
-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)
-	, Wrappable w x
-	) => Adaptable w (t :> u :> v :> w :> x) where
-	adapt = lay . lay . lay . 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
-	) => Adaptable (t :< u :< v :< w :< x) x where
-	adapt = flick . flick . flick . flick
-
-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)
-	, Bringable w x
-	) => Adaptable (t :< u :< v :< w :< x) w where
-	adapt = bring . flick . flick . flick
-
-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
-	) => Adaptable y (t :> u :> v :> w :> x :> y) where
-	adapt = lay . lay . lay . lay . lay
-
-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)
-	, Wrappable x y
-	) => Adaptable x (t :> u :> v :> w :> x :> y) where
-	adapt = lay . lay . lay . lay . 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
-	) => Adaptable (t :< u :< v :< w :< x :< y) y where
-	adapt = flick . flick . flick . flick . flick
-
-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)
-	, Bringable x y
-	) => Adaptable (t :< u :< v :< w :< x :< y) x where
-	adapt = bring . flick . flick . flick . flick
-
-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
-	) => Adaptable z (t :> u :> v :> w :> x :> y :> z) where
-	adapt = lay . lay . lay . lay . lay . lay
-
-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)
-	, Wrappable y z
-	) => Adaptable y (t :> u :> v :> w :> x :> y :> z) where
-	adapt = lay . lay . lay . lay . lay . 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
-	) => Adaptable (t :< u :< v :< w :< x :< y :< z) z where
-	adapt = flick . flick . flick . flick . flick . flick
-
-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)
-	, Bringable y z
-	) => Adaptable (t :< u :< v :< w :< x :< y :< z) y where
-	adapt = bring . flick . flick . flick . flick . flick
-
-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
-	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f) where
-	adapt = lay . lay . lay . lay . lay . lay . lay
-
-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)
-	, Wrappable z f
-	) => Adaptable z (t :> u :> v :> w :> x :> y :> z :> f) where
-	adapt = lay . lay . lay . lay . lay . lay . 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
-	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) f where
-	adapt = flick . flick . flick . flick . flick . flick . flick
-
-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)
-	, Bringable z f
-	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) z where
-	adapt = bring . flick . flick . flick . flick . flick . flick
-
-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
-	) => Adaptable h (t :> u :> v :> w :> x :> y :> z :> f :> h) where
-	adapt = lay . lay . lay . lay . lay . lay . lay . lay
-
-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)
-	, Wrappable f h
-	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where
-	adapt = lay . lay . lay . lay . lay . lay . lay . 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
-	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) h where
-	adapt = flick . flick . flick . flick . flick . flick . flick . flick
-
-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)
-	, Bringable f h
-	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where
-	adapt = bring . flick . flick . flick . flick . flick . flick . flick
diff --git a/Pandora/Paradigm/Controlflow/Joint/Interpreted.hs b/Pandora/Paradigm/Controlflow/Joint/Interpreted.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Interpreted.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (..)) where
-
-class Interpreted t where
-	{-# MINIMAL run #-}
-	type Primary t a :: *
-	run :: t a -> Primary t a
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schematic.hs b/Pandora/Paradigm/Controlflow/Joint/Schematic.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Schematic.hs
+++ /dev/null
@@ -1,3 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) where
-
-type family Schematic (c :: (* -> *) -> k) (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> t u
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes.hs
+++ /dev/null
@@ -1,41 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Pandora.Paradigm.Controlflow.Joint.Schemes (module Exports) where
-
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UTU as Exports
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT as Exports
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW as Exports
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUT as Exports
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU as Exports
-
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
-
-instance (Covariant (TU Covariant Covariant v t), Covariant (TU Covariant Covariant u w), Adjoint t u, Adjoint v w)
-	=> Adjoint (TU Covariant Covariant v t) (TU Covariant Covariant u w) where
-		TU y |- g = y |- (|- run . g)
-		x -| f = TU $ x -| (-| f . TU)
-
-instance (Covariant (TU Covariant Covariant v t), Covariant (UT Covariant Covariant w u), Adjoint t u, Adjoint v w)
-	=> Adjoint (TU Covariant Covariant v t) (UT Covariant Covariant w u) where
-		TU t |- g = t |- (|- run . g)
-		x -| f = UT $ x -| (-| f . TU)
-
-instance (Covariant (UT Covariant Covariant t v), Covariant (UT Covariant Covariant w u), Adjoint t u, Adjoint v w)
-	=> Adjoint (UT Covariant Covariant t v) (UT Covariant Covariant w u) where
-		UT t |- g = t |- (|- run . g)
-		x -| f = UT $ x -| (-| f . UT)
-
-instance (Covariant (UT Covariant Covariant t v), Covariant (TU Covariant Covariant w u) , Adjoint v u, Adjoint t w)
-	=> Adjoint (UT Covariant Covariant t v) (TU Covariant Covariant w u) where
-		UT t |- g = t |- (|- run . g)
-		x -| f = TU $ x -| (-| f . UT)
-
-instance (Covariant (TUT Covariant Covariant Covariant t u t'), Covariant (TUT Covariant Covariant Covariant v w v')
-	, Adjoint t w, Adjoint t' v', Adjoint t v, Adjoint u v, Adjoint v' t')
-	=> Adjoint (TUT Covariant Covariant Covariant t u t') (TUT Covariant Covariant Covariant v w v') where
-		TUT t |- g = t |- (|- (|- run . g))
-		x -| f = TUT $ x -| (-| (-| f . TUT))
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs
+++ /dev/null
@@ -1,27 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (..)) where
-
-import Pandora.Core.Functor (type (:.), type (:=))
-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.Divariant (($))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-
-newtype TU ct cu t u a = TU (t :. u := a)
-
-instance Interpreted (TU ct cu t u) where
-	type Primary (TU ct cu t u) a = t :. u := a
-	run (TU x) = x
-
-instance Pointable t => Liftable (TU Covariant Covariant t) where
-	lift = TU . point
-
-instance Extractable t => Lowerable (TU Covariant Covariant t) where
-	lower (TU x) = extract x
-
-instance Covariant t => Hoistable (TU Covariant Covariant t) where
-	hoist f (TU x) = TU $ f <$> x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
+++ /dev/null
@@ -1,28 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint.Schemes.TUT (TUT (..)) where
-
-import Pandora.Pattern.Category (identity)
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant)
-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.Functor.Divariant (($))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-
-newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a)
-
-instance Interpreted (TUT ct ct' cu t t' u) where
-	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 (TUT Covariant Covariant Covariant t t') where
-		lift x = TUT $ x ->> (-| identity)
-
-instance (Adjoint t t', Distributive t')
-	=> Lowerable (TUT Covariant Covariant Covariant t t') where
-		lower (TUT x) = x |- (>>- identity)
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUVW.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUVW.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUVW.hs
+++ /dev/null
@@ -1,10 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW (TUVW (..)) where
-
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-
-newtype TUVW ct cu cv cw t u v w a = TUVW (t :. u :. v :. w := a)
-
-instance Interpreted (TUVW ct cu cv cw t u v w) where
-	type Primary (TUVW ct cu cv cw t u v w) a = t :. u :. v :. w := a
-	run (TUVW x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs
+++ /dev/null
@@ -1,22 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (..)) where
-
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-
-newtype UT ct cu t u a = UT (u :. t := a)
-
-instance Interpreted (UT ct cu t u) where
-	type Primary (UT ct cu t u) a = u :. t := a
-	run (UT x) = x
-
-instance Pointable t => Liftable (UT Covariant Covariant t) where
-	lift x = UT $ point <$> x
-
-instance Extractable t => Lowerable (UT Covariant Covariant t) where
-	lower (UT x) = extract <$> x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs
+++ /dev/null
@@ -1,10 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint.Schemes.UTU (UTU (..)) where
-
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-
-newtype UTU ct cu t u u' a = UTU (u :. t :. u' := a)
-
-instance Interpreted (UTU ct cu t u u') where
-	type Primary (UTU ct cu t u u') a = u :. t :. u' := a
-	run (UTU x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer.hs
+++ /dev/null
@@ -1,10 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint.Transformer (module Exports, Transformer) where
-
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic as Exports
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic as Exports
-
-import Pandora.Pattern.Functor (Monad, Comonad)
-
-type family Transformer c t where
-	Transformer Monad t = Monadic t
-	Transformer Comonad t = Comonadic t
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
+++ /dev/null
@@ -1,60 +0,0 @@
-{-# LANGUAGE UndecidableInstances #-}
-
-module Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (..), (:<) (..)) 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.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-
-class Interpreted t => Comonadic t where
-	{-# MINIMAL flick, bring #-}
-	flick :: Covariant u => t :< u ~> u
-	bring :: Extractable u => t :< u ~> t
-
-infixr 3 :<
-newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }
-
-instance Covariant (Schematic Comonad t u) => Covariant (t :< u) where
-	f <$> TC x = TC $ f <$> x
-
-instance Pointable (Schematic Comonad t u) => Pointable (t :< u) where
-	point = TC . point
-
-instance Extractable (Schematic Comonad t u) => Extractable (t :< u) where
-	extract = extract . tc
-
-instance Applicative (Schematic Comonad t u) => Applicative (t :< u) where
-	TC f <*> TC x = TC $ f <*> x
-
-instance Alternative (Schematic Comonad t u) => Alternative (t :< u) where
-	TC x <+> TC y = TC $ x <+> y
-
-instance Traversable (Schematic Comonad t u) => Traversable (t :< u) where
-	TC x ->> f = TC <$> x ->> f
-
-instance Distributive (Schematic Comonad t u) => Distributive (t :< u) where
-	x >>- f = TC $ x >>- tc . f
-
-instance Bindable (Schematic Comonad t u) => Bindable (t :< u) where
-	TC x >>= f = TC $ x >>= tc . f
-
-instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where
-	TC x =>> f = TC $ x =>> f . TC
-
-instance (Extractable (t :< u), Extendable (t :< u)) => Comonad (t :< u) where
-
-instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where
-	type Primary (t :< u) a = Primary (Schematic Comonad t u) a
-	run (TC x) = run x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
+++ /dev/null
@@ -1,60 +0,0 @@
-{-# LANGUAGE UndecidableInstances #-}
-
-module Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (..), (:>) (..)) 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.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-
-class Interpreted t => Monadic t where
-	{-# MINIMAL lay, wrap #-}
-	lay :: Covariant u => u ~> t :> u
-	wrap :: Pointable u => t ~> t :> u
-
-infixr 3 :>
-newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
-
-instance Covariant (Schematic Monad t u) => Covariant (t :> u) where
-	f <$> TM x = TM $ f <$> x
-
-instance Pointable (Schematic Monad t u) => Pointable (t :> u) where
-	point = TM . point
-
-instance Extractable (Schematic Monad t u) => Extractable (t :> u) where
-	extract = extract . tm
-
-instance Applicative (Schematic Monad t u) => Applicative (t :> u) where
-	TM f <*> TM x = TM $ f <*> x
-
-instance Alternative (Schematic Monad t u) => Alternative (t :> u) where
-	TM x <+> TM y = TM $ x <+> y
-
-instance Traversable (Schematic Monad t u) => Traversable (t :> u) where
-	TM x ->> f = TM <$> x ->> f
-
-instance Distributive (Schematic Monad t u) => Distributive (t :> u) where
-	x >>- f = TM $ x >>- tm . f
-
-instance Bindable (Schematic Monad t u) => Bindable (t :> u) where
-	TM x >>= f = TM $ x >>= tm . f
-
-instance Extendable (Schematic Monad t u) => Extendable (t :> u) where
-	TM x =>> f = TM $ x =>> f . TM
-
-instance (Pointable (t :> u), Bindable (t :> u)) => Monad (t :> u) where
-
-instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where
-	type Primary (t :> u) a = Primary (Schematic Monad t u) a
-	run (TM x) = run x
diff --git a/Pandora/Paradigm/Controlflow/Observable.hs b/Pandora/Paradigm/Controlflow/Observable.hs
--- a/Pandora/Paradigm/Controlflow/Observable.hs
+++ b/Pandora/Paradigm/Controlflow/Observable.hs
@@ -1,9 +1,8 @@
 module Pandora.Paradigm.Controlflow.Observable (Observable, observe,
 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where
 
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Applicative (Applicative (forever))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation, continue))
 
 newtype Capture r t a = Capture { captured :: t r }
diff --git a/Pandora/Paradigm/Controlflow/Pipeline.hs b/Pandora/Paradigm/Controlflow/Pipeline.hs
--- a/Pandora/Paradigm/Controlflow/Pipeline.hs
+++ b/Pandora/Paradigm/Controlflow/Pipeline.hs
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Controlflow.Pipeline (Pipeline, await, yield, finish, impact, (=*=), pipeline) where
 
+import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation, continue))
 
 newtype Producer i t r = Producer { produce :: Consumer i t r -> t r }
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -11,12 +11,11 @@
 import Pandora.Paradigm.Inventory.Accumulator as Exports
 
 import Pandora.Core.Morphism ((!), (%))
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 
 instance Adjoint (Store s) (State s) where
 	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !)
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
@@ -2,21 +2,20 @@
 
 module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where
 
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
-import Pandora.Pattern.Category ((.))
+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.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Functor.Monad (Monad)
 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.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
 
 newtype Accumulator e a = Accumulator (e :*: a)
 
@@ -34,7 +33,7 @@
 	Accumulator (e :*: x) >>= f = let (e' :*: b) = run $ f x in
 		Accumulator $ e + e':*: b
 
-type instance Schematic Monad (Accumulator e) u = UT Covariant Covariant ((:*:) e) u
+type instance Schematic Monad (Accumulator e) u = (:*:) e <.:> u
 
 instance Interpreted (Accumulator e) where
 	type Primary (Accumulator e) a = e :*: a
@@ -46,17 +45,17 @@
 
 type Accumulated e t = Adaptable (Accumulator e) t
 
-instance Covariant u => Covariant (UT Covariant Covariant ((:*:) e) u) where
+instance Covariant u => Covariant ((:*:) e <.:> u) where
 	f <$> UT x = UT $ f <$$> x
 
-instance (Semigroup e, Applicative u) => Applicative (UT Covariant Covariant ((:*:) e) u) where
+instance (Semigroup e, Applicative u) => Applicative ((:*:) e <.:> u) where
 	UT f <*> UT x = UT $ k <$> f <*> x where
 		k ~(u :*: g) ~(v :*: y) = u + v :*: g y
 
-instance (Pointable u, Monoid e) => Pointable (UT Covariant Covariant ((:*:) e) u) where
+instance (Pointable u, Monoid e) => Pointable ((:*:) e <.:> u) where
 	point = UT . point . (zero :*:)
 
-instance (Semigroup e, Pointable u, Bindable u) => Bindable (UT Covariant Covariant ((:*:) e) u) where
+instance (Semigroup e, Pointable u, Bindable u) => Bindable ((:*:) e <.:> u) where
 	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> run (f v)
 
 gather :: Accumulated e t => 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
@@ -2,20 +2,19 @@
 
 module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where
 
-import Pandora.Core.Morphism ((!), (%))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
-import Pandora.Pattern.Category (identity, (.))
+import Pandora.Pattern.Category (identity, (.), ($))
 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.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Divariant (($))
+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.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 
 newtype Environment e a = Environment (e -> a)
 
@@ -40,7 +39,7 @@
 	type Primary (Environment e) a = (->) e a
 	run (Environment x) = x
 
-type instance Schematic Monad (Environment e) u = TU Covariant Covariant ((->) e) u
+type instance Schematic Monad (Environment e) u = (->) e <:.> u
 
 instance Monadic (Environment e) where
 	lay = TM . TU . (!)
@@ -48,16 +47,16 @@
 
 type Configured e = Adaptable (Environment e)
 
-instance Covariant u => Covariant (TU Covariant Covariant ((->) e) u) where
+instance Covariant u => Covariant ((->) e <:.> u) where
 	f <$> TU x = TU $ f <$$> x
 
-instance (Covariant u, Pointable u) => Pointable (TU Covariant Covariant ((->) e) u) where
+instance (Covariant u, Pointable u) => Pointable ((->) e <:.> u) where
 	point = TU . point . point
 
-instance Applicative u => Applicative (TU Covariant Covariant ((->) e) u) where
+instance Applicative u => Applicative ((->) e <:.> u) where
 	TU f <*> TU x = TU $ f <**> x
 
-instance Bindable u => Bindable (TU Covariant Covariant ((->) e) u) where
+instance Bindable u => Bindable ((->) e <:.> u) where
 	TU x >>= f = TU $ \e -> x e >>= ($ e) . run . f
 
 env :: Configured e t => t 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
@@ -2,18 +2,17 @@
 
 module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where
 
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 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.Divariant (($))
+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.Schemes.TU (TU (TU), type (<:.>))
 
 newtype Equipment e a = Equipment (e :*: a)
 
@@ -30,7 +29,7 @@
 	type Primary (Equipment e) a = e :*: a
 	run (Equipment x) = x
 
-type instance Schematic Comonad (Equipment e) u = TU Covariant Covariant ((:*:) e) u
+type instance Schematic Comonad (Equipment e) u = (:*:) e <:.> u
 
 instance Comonadic (Equipment e) where
 	flick (TC (TU x)) = extract x
@@ -38,13 +37,13 @@
 
 type Equipped e t = Adaptable t (Equipment e)
 
-instance Covariant u => Covariant (TU Covariant Covariant ((:*:) e) u) where
+instance Covariant u => Covariant ((:*:) e <:.> u) where
 	f <$> TU x = TU $ f <$$> x
 
-instance Extractable u => Extractable (TU Covariant Covariant ((:*:) e) u) where
+instance Extractable u => Extractable ((:*:) e <:.> u) where
 	extract (TU x) = extract . extract $ x
 
-instance Extendable u => Extendable (TU Covariant Covariant ((:*:) e) u) where
+instance Extendable u => Extendable ((:*:) e <:.> u) where
 	TU (e :*: x) =>> f = TU . (:*:) e $ x =>> f . TU . (:*:) e
 
 instance Comonad (Equipment e) where
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
@@ -2,21 +2,20 @@
 
 module Pandora.Paradigm.Inventory.Imprint (Imprint (..), Traceable) where
 
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Divariant (($))
 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.Adaptable (Adaptable)
+import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
 
 newtype Imprint e a = Imprint (e -> a)
 
@@ -36,22 +35,22 @@
 	type Primary (Imprint e) a = (->) e a
 	run (Imprint x) = x
 
-type instance Schematic Comonad (Imprint e) u = UT Covariant Covariant ((->) e) u
+type instance Schematic Comonad (Imprint e) u = (->) e <.:> u
 
 instance Monoid e => Comonadic (Imprint e) where
 	flick (TC (UT x)) = extract <$> x
 	bring (TC (UT x)) = Imprint . extract $ x
 
-instance Covariant u => Covariant (UT Covariant Covariant ((->) e) u) where
+instance Covariant u => Covariant ((->) e <.:> u) where
 	f <$> UT x = UT $ f <$$> x
 
-instance Applicative u => Applicative (UT Covariant Covariant ((->) e) u) where
+instance Applicative u => Applicative ((->) e <.:> u) where
 	UT f <*> UT x = UT $ f <**> x
 
-instance (Monoid e, Extractable u) => Extractable (UT Covariant Covariant ((->) e) u) where
+instance (Monoid e, Extractable u) => Extractable ((->) e <.:> u) where
 	extract (UT x) = extract . extract $ x
 
-instance (Semigroup e, Extendable u) => Extendable (UT Covariant Covariant ((->) e) u) where
+instance (Semigroup e, Extendable u) => Extendable ((->) e <.:> u) where
 	UT x =>> f = UT $ x =>> (\x' e -> f . UT . (<$>) (. (e +)) $ x')
 
 type Traceable e t = Adaptable t (Imprint e)
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,15 +3,14 @@
 module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, zoom, (^.), (.~), (%~)) 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.Bivariant ((<->))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (adapt)
+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)
-import Pandora.Pattern.Category (identity, (.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Functor.Bivariant ((<->))
 
 infixr 0 :-.
 type (:-.) src tgt = Lens src tgt
@@ -19,7 +18,7 @@
 type Lens src tgt = src |-> Store tgt
 
 -- | Lens composition infix operator
-(|>) :: Lens src btw -> Lens btw tgt -> Lens src tgt
+(|>) :: Lens src old -> Lens old new -> Lens src new
 from |> to = \x -> ((<$) x . to) . position . from $ x
 
 -- | Get the target of a lens
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
@@ -4,8 +4,8 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Morphism ((%))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>)))
+import Pandora.Pattern.Category (identity, (.), ($))
+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))
@@ -14,13 +14,12 @@
 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.Pattern.Functor.Divariant (($))
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUT (TUT (TUT))
+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.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)
@@ -35,7 +34,7 @@
 		let (new :*: g) = f old in g <$> x new
 
 instance Pointable (State s) where
-	point x = State $ \s -> s :*: x
+	point = State . (-| identity)
 
 instance Bindable (State s) where
 	State x >>= f = State $ \old ->
@@ -44,18 +43,17 @@
 instance Monad (State s) where
 
 fold :: Traversable t => s -> (a -> s -> s) -> t a -> s
-fold start op struct = extract . run @(State _) % start $
-	struct ->> modify . op $> () *> current
+fold start op struct = extract . run @(State _) % start
+	$ struct ->> modify . op *> current
 
 find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a
-find p struct = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x) struct
+find p = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x)
 
 instance Interpreted (State s) where
 	type Primary (State s) a = (->) s :. (:*:) s := a
 	run (State x) = x
 
-type instance Schematic Monad (State s) u =
-	TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u
+type instance Schematic Monad (State s) u = (->) s <:<.>:> (:*:) s := u
 
 instance Monadic (State s) where
 	lay x = TM . TUT $ \s -> (s :*:) <$> x
@@ -63,25 +61,25 @@
 
 type Stateful s = Adaptable (State s)
 
-instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
+instance Covariant u => Covariant ((->) s <:<.>:> (:*:) s := u) where
 	f <$> TUT x = TUT $ \old -> f <$$> x old
 
-instance Bindable u => Applicative (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
+instance Bindable u => Applicative ((->) s <:<.>:> (:*:) s := u) where
 	TUT f <*> TUT x = TUT $ \old -> f old >>= \(new :*: g) -> g <$$> x new
 
-instance Pointable u => Pointable (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
-	point x = TUT $ \s -> point $ s :*: x
+instance Pointable u => Pointable ((->) s <:<.>:> (:*:) s := u) where
+	point = TUT . (-| point)
 
-instance Bindable u => Bindable (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
+instance Bindable u => Bindable ((->) s <:<.>:> (:*:) s := u) where
 	TUT x >>= f = TUT $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y
 
-instance Monad u => Monad (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
+instance Monad u => Monad ((->) s <:<.>:> (:*:) s := u) where
 
 current :: Stateful s t => t s
 current = adapt $ State delta
 
 modify :: Stateful s t => (s -> s) -> t ()
-modify f = adapt $ State $ \s -> f s :*: ()
+modify f = adapt . State $ (:*: ()) . f
 
 replace :: Stateful s t => s -> t ()
-replace s = adapt $ State $ \_ -> s :*: ()
+replace s = adapt . State $ \_ -> s :*: ()
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
@@ -4,30 +4,29 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (<-|), type (~>))
 import Pandora.Core.Morphism ((%))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+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.Extendable (Extendable ((=>>), (<<=$)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUT (TUT (TUT))
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
+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.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
-	f <$> Store (p :*: x) = Store . (:*:) p $ f <$> x
+	f <$> Store x = Store $ f <$$> x
 
 instance Extractable (Store p) where
-	extract (Store (p :*: f)) = f p
+	extract = (|- ($)) . run
 
 instance Extendable (Store p) where
-	Store (old :*: x) =>> f = Store . (:*:) old
-		$ \new -> f <$> Store $ new :*: x
+	Store x =>> f = Store $ f <$$> (Store .|.. (-| identity)) <$> x
 
 instance Comonad (Store p) where
 
@@ -35,8 +34,7 @@
 	type Primary (Store p) a = (:*:) p :. (->) p := a
 	run (Store x) = x
 
-type instance Schematic Comonad (Store p) u =
-	TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u
+type instance Schematic Comonad (Store p) u = (:*:) p <:<.>:> (->) p := u
 
 instance Comonadic (Store p) where
 	flick (TC (TUT (p :*: f))) = ($ p) <$> f
@@ -44,14 +42,14 @@
 
 type Storable s x = Adaptable x (Store s)
 
-instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where
-	f <$> TUT (p :*: x) = TUT . (:*:) p $ f <$$> x
+instance Covariant u => Covariant ((:*:) p <:<.>:> (->) p := u) where
+	f <$> TUT x = TUT $ f <$$$> x
 
-instance Extractable u => Extractable (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where
-	extract (TUT (p :*: x)) = extract x p
+instance Extractable u => Extractable ((:*:) p <:<.>:> (->) p := u) where
+	extract = (|- extract) . run
 
-instance Extendable u => Extendable (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where
-	TUT (old :*: x) =>> f = TUT . (:*:) old $ x =>> (\x' new -> f . TUT . (:*:) new $ x')
+instance Extendable u => Extendable ((:*:) p <:<.>:> (->) p := u) where
+	TUT x =>> f = TUT $ x <<=$ (\x' -> f . TUT . (x' -| identity))
 
 position :: Storable s t => t a -> s
 position = attached . run @(Store _) . adapt
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,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
@@ -10,17 +10,16 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 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.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+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.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Schemes.UT (UT (UT))
 
 data Conclusion e a = Failure e | Success a
 
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,12 +1,12 @@
 module Pandora.Paradigm.Primary.Functor.Constant (Constant (..)) where
 
+import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Invariant (Invariant (invmap))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
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,9 +1,10 @@
 module Pandora.Paradigm.Primary.Functor.Edges (Edges (..), edges) where
 
+import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Divariant (($))
+
 
 data Edges a = Empty | Leap a | Connect a | Overlay a
 
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,6 +1,6 @@
 module Pandora.Paradigm.Primary.Functor.Identity (Identity (..)) where
 
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -13,7 +13,6 @@
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
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,6 +1,6 @@
 module Pandora.Paradigm.Primary.Functor.Maybe (Maybe (..), Optional, maybe, nothing) where
 
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -9,7 +9,6 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
@@ -18,11 +17,11 @@
 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.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+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.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Schemes.UT (UT (UT))
 
 data Maybe a = Nothing | Just a
 
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,10 +1,9 @@
 module Pandora.Paradigm.Primary.Functor.Predicate (Predicate (..)) where
 
 import Pandora.Core.Morphism ((!))
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Determinable (Determinable (determine))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True))
 
 newtype Predicate a = Predicate { predicate :: a -> Boolean }
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,6 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Product (Product (..), type (:*:)
 	, delta, swap, attached, curry, uncurry) where
 
+import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
@@ -8,7 +9,6 @@
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
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,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Tagged (Tagged (..), retag, tagself, type (:#)) where
 
 import Pandora.Core.Functor (type (|->), type (~>))
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -13,7 +13,6 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
@@ -89,7 +88,7 @@
 instance Group a => Group (Tagged tag a) where
 	invert (Tag x) = Tag $ invert x
 
-retag :: Tagged old ~> Tagged new
+retag :: forall new old . Tagged old ~> Tagged new
 retag (Tag x) = Tag x
 
 tagself :: a |-> Tagged a
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,9 +1,9 @@
 module Pandora.Paradigm.Primary.Functor.These (These (..), these) where
 
+import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Divariant (($))
 
 data These e a = This a | That e | These e a
 
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,13 +1,12 @@
 module Pandora.Paradigm.Primary.Functor.Validation (Validation (..)) where
 
-import Pandora.Pattern.Category ((.))
+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.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
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,9 +1,9 @@
 module Pandora.Paradigm.Primary.Functor.Wedge (Wedge (..), wedge) where
 
+import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Divariant (($))
 
 data Wedge e a = Nowhere | Here e | There a
 
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,10 +1,10 @@
 module Pandora.Paradigm.Primary.Functor.Wye (Wye (..), wye) 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.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Divariant (($))
 
 data Wye a = End | Left a | Right a | Both a a
 
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
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Primary.Transformer (module Exports) where
 
 import Pandora.Paradigm.Primary.Transformer.Yoneda as Exports
+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.Jet 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,7 +1,7 @@
 module Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (..)) where
 
 import Pandora.Core.Morphism ((&))
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
@@ -9,11 +9,10 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
 
 newtype Backwards t a = Backwards (t a)
 
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,7 +1,7 @@
 module Pandora.Paradigm.Primary.Transformer.Construction (Construction (..), deconstruct, coiterate, section) where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (|->), type (~>))
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -15,12 +15,11 @@
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid ((*))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
+import Pandora.Paradigm.Schemes.TU (TU (TU))
 
 data Construction t a = Construct a (t :. Construction t := a)
 
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
@@ -2,14 +2,13 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
 import Pandora.Core.Morphism ((!), (%))
-import Pandora.Pattern.Category ((.))
+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.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Functor.Divariant (($))
 
 newtype Continuation r t a = Continuation { continue :: (->) ::|:. a :. t := r }
 
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,6 +1,7 @@
 module Pandora.Paradigm.Primary.Transformer.Instruction (Instruction (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -9,7 +10,6 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Functor.Divariant (($))
 
 data Instruction t a = Enter a | Instruct (t :. Instruction t := a)
 
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,6 +1,6 @@
 module Pandora.Paradigm.Primary.Transformer.Jack (Jack (..), jack) where
 
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), comap)
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
@@ -10,7 +10,6 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), traverse))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
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,10 +1,9 @@
 module Pandora.Paradigm.Primary.Transformer.Kan (Kan (..)) where
 
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 
 data family Kan (v :: * -> k) (t :: * -> *) (u :: * -> *) b a
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,15 +1,14 @@
 module Pandora.Paradigm.Primary.Transformer.Outline (Outline (..)) where
 
 import Pandora.Core.Morphism ((%))
-import Pandora.Pattern.Category (identity, (.))
+import Pandora.Pattern.Category (identity, (.), ($))
 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.Divariant (($))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
 
 data Outline t a where
 	Line :: a -> Outline t a
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,6 +1,6 @@
 module Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (..)) where
 
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
@@ -8,12 +8,11 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
 import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
 
 newtype Reverse t a = Reverse (t a)
 
diff --git a/Pandora/Paradigm/Primary/Transformer/Tap.hs b/Pandora/Paradigm/Primary/Transformer/Tap.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Tap.hs
@@ -0,0 +1,44 @@
+module Pandora.Paradigm.Primary.Transformer.Tap (Tap (..)) where
+
+import Pandora.Core.Morphism ((%))
+import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
+
+data Tap t a = Tap a (t a)
+
+instance Covariant t => Covariant (Tap t) where
+	f <$> Tap x xs = Tap (f x) $ f <$> xs
+
+instance Avoidable t => Pointable (Tap t) where
+	point = Tap % empty
+
+instance Covariant t => Extractable (Tap t) where
+	extract (Tap x _) = x
+
+instance Applicative t => Applicative (Tap t) where
+	Tap f fs <*> Tap x xs = Tap (f x) $ fs <*> xs
+
+instance Traversable t => Traversable (Tap t) where
+	Tap x xs ->> f = Tap <$> f x <*> xs ->> f
+
+instance (Extractable t, Alternative t, Bindable t) => Bindable (Tap t) where
+	Tap x xs >>= f = case f x of Tap y ys -> Tap y $ ys <+> (xs >>= lower . f)
+
+instance (Extractable t, Extendable t) => Extendable (Tap t) where
+	x =>> f = Tap (f x) $ lower x =>> f . Tap (extract x)
+
+instance Lowerable Tap where
+	lower (Tap _ xs) = xs
+
+instance Hoistable Tap where
+	hoist f (Tap x xs) = Tap x $ f xs
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,7 @@
 module Pandora.Paradigm.Primary.Transformer.Yoneda (Yoneda (..)) where
 
 import Pandora.Core.Morphism ((!))
-import Pandora.Pattern.Category (identity, (.))
+import Pandora.Pattern.Category (identity, (.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
@@ -10,7 +10,6 @@
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Functor.Divariant (($))
 
 newtype Yoneda t a = Yoneda
 	{ yoneda :: forall b . (a -> b) -> t b }
@@ -34,7 +33,7 @@
 	extract (Yoneda f) = extract $ f identity
 
 instance Liftable Yoneda where
-	lift x = Yoneda (\f -> f <$> x)
+	lift x = Yoneda (<$> x)
 
 instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where
 	x -| f = point . f . point $ x
diff --git a/Pandora/Paradigm/Schemes.hs b/Pandora/Paradigm/Schemes.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Schemes.hs
@@ -0,0 +1,40 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Schemes (module Exports) where
+
+import Pandora.Paradigm.Schemes.UTU as Exports
+import Pandora.Paradigm.Schemes.UT as Exports
+import Pandora.Paradigm.Schemes.TUVW as Exports
+import Pandora.Paradigm.Schemes.TUT as Exports
+import Pandora.Paradigm.Schemes.TU as Exports
+
+import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+
+instance (Covariant (v <:.> t), Covariant (u <:.> w), Adjoint t u, Adjoint v w)
+	=> Adjoint (v <:.> t) (u <:.> w) where
+		TU y |- g = y |- (|- run . g)
+		x -| f = TU $ x -| (-| f . TU)
+
+instance (Covariant (v <:.> t), Covariant (w <.:> u), Adjoint t u, Adjoint v w)
+	=> Adjoint (v <:.> t) (w <.:> u) where
+		TU t |- g = t |- (|- run . g)
+		x -| f = UT $ x -| (-| f . TU)
+
+instance (Covariant (t <.:> v), Covariant (w <.:> u), Adjoint t u, Adjoint v w)
+	=> Adjoint (t <.:> v) (w <.:> u) where
+		UT t |- g = t |- (|- run . g)
+		x -| f = UT $ x -| (-| f . UT)
+
+instance (Covariant (t <.:> v), Covariant (w <:.> u) , Adjoint v u, Adjoint t w)
+	=> Adjoint (t <.:> v) (w <:.> u) where
+		UT t |- g = t |- (|- run . g)
+		x -| f = TU $ x -| (-| f . UT)
+
+instance (Covariant ((t <:<.>:> u) t'), Covariant ((v <:<.>:> w) v')
+	, Adjoint t w, Adjoint t' v', Adjoint t v, Adjoint u v, Adjoint v' t')
+	=> Adjoint ((t <:<.>:> u) t') ((v <:<.>:> w) v') where
+		TUT t |- g = t |- (|- (|- run . g))
+		x -| f = TUT $ x -| (-| (-| f . TUT))
diff --git a/Pandora/Paradigm/Schemes/TU.hs b/Pandora/Paradigm/Schemes/TU.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Schemes/TU.hs
@@ -0,0 +1,32 @@
+module Pandora.Paradigm.Schemes.TU where
+
+import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant)
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
+
+newtype TU ct cu t u a = TU (t :. u := a)
+
+type (<:.>) = TU Covariant Covariant
+type (>:.>) = TU Contravariant Covariant
+type (<:.<) = TU Covariant Contravariant
+type (>:.<) = TU Contravariant Contravariant
+
+instance Interpreted (TU ct cu t u) where
+	type Primary (TU ct cu t u) a = t :. u := a
+	run (TU x) = x
+
+instance Pointable t => Liftable (TU Covariant Covariant t) where
+	lift = TU . point
+
+instance Extractable t => Lowerable (TU Covariant Covariant t) where
+	lower (TU x) = extract x
+
+instance Covariant t => Hoistable (TU Covariant Covariant t) where
+	hoist f (TU x) = TU $ f <$> x
diff --git a/Pandora/Paradigm/Schemes/TUT.hs b/Pandora/Paradigm/Schemes/TUT.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Schemes/TUT.hs
@@ -0,0 +1,35 @@
+module Pandora.Paradigm.Schemes.TUT where
+
+import Pandora.Core.Functor (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))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
+
+newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a)
+
+type (<:<.>:>) = TUT Covariant Covariant Covariant
+type (>:<.>:>) = TUT Contravariant Covariant Covariant
+type (<:<.>:<) = TUT Covariant Covariant Contravariant
+type (>:<.>:<) = TUT Contravariant Covariant Contravariant
+type (<:>.<:>) = TUT Covariant Contravariant Covariant
+type (>:>.<:>) = TUT Contravariant Contravariant Covariant
+type (<:>.<:<) = TUT Covariant Contravariant Contravariant
+type (>:>.<:<) = TUT Contravariant Contravariant Contravariant
+
+instance Interpreted (TUT ct ct' cu t t' u) where
+	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') => Lowerable (t <:<.>:> t') where
+	lower (TUT x) = x |- (>>- identity)
diff --git a/Pandora/Paradigm/Schemes/TUVW.hs b/Pandora/Paradigm/Schemes/TUVW.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Schemes/TUVW.hs
@@ -0,0 +1,10 @@
+module Pandora.Paradigm.Schemes.TUVW (TUVW (..)) where
+
+import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
+
+newtype TUVW ct cu cv cw t u v w a = TUVW (t :. u :. v :. w := a)
+
+instance Interpreted (TUVW ct cu cv cw t u v w) where
+	type Primary (TUVW ct cu cv cw t u v w) a = t :. u :. v :. w := a
+	run (TUVW x) = x
diff --git a/Pandora/Paradigm/Schemes/UT.hs b/Pandora/Paradigm/Schemes/UT.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Schemes/UT.hs
@@ -0,0 +1,28 @@
+module Pandora.Paradigm.Schemes.UT where
+
+import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant)
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
+
+newtype UT ct cu t u a = UT (u :. t := a)
+
+type (<.:>) = UT Covariant Covariant
+type (>.:>) = UT Contravariant Covariant
+type (<.:<) = UT Covariant Contravariant
+type (>.:<) = UT Contravariant Contravariant
+
+instance Interpreted (UT ct cu t u) where
+	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
+	lift x = UT $ point <$> x
+
+instance Extractable t => Lowerable (UT Covariant Covariant t) where
+	lower (UT x) = extract <$> x
diff --git a/Pandora/Paradigm/Schemes/UTU.hs b/Pandora/Paradigm/Schemes/UTU.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Schemes/UTU.hs
@@ -0,0 +1,21 @@
+module Pandora.Paradigm.Schemes.UTU where
+
+import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Contravariant (Contravariant)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))
+
+newtype UTU ct cu t u u' a = UTU (u :. t :. u' := a)
+
+type (<.<:>.>) = UTU Covariant Covariant Covariant
+type (>.<:>.>) = UTU Contravariant Covariant Covariant
+type (<.<:>.<) = UTU Covariant Covariant Contravariant
+type (>.<:>.<) = UTU Contravariant Covariant Contravariant
+type (<.>:<.>) = UTU Covariant Contravariant Covariant
+type (>.>:<.>) = UTU Contravariant Contravariant Covariant
+type (<.>:<.<) = UTU Covariant Contravariant Contravariant
+type (>.>:<.<) = UTU Contravariant Contravariant Contravariant
+
+instance Interpreted (UTU ct cu t u u') where
+	type Primary (UTU ct cu t u u') a = u :. t :. u' := a
+	run (UTU x) = x
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,5 +1,7 @@
 module Pandora.Paradigm.Structure.Ability (module Exports) where
 
+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.Focusable as Exports
 import Pandora.Paradigm.Structure.Ability.Nonempty as Exports
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
@@ -1,9 +1,18 @@
-module Pandora.Paradigm.Structure.Ability.Focusable (Focusable (..)) where
+{-# LANGUAGE AllowAmbiguousTypes #-}
 
-import Pandora.Core.Functor (type (|->))
+module Pandora.Paradigm.Structure.Ability.Focusable where
+
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (comap)
+import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Paradigm.Inventory.Optics (type (:-.))
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 
-class Focusable t where
-	type Focus (t :: * -> *) a
-	top :: t a :-. Focus t a
-	singleton :: a |-> t
+class Focusable f t where
+	type Focusing (f :: * -> k) (t :: * -> *) a
+	focusing :: Tagged f (t a) :-. Focusing f t a
+
+focus :: forall f t a . Focusable f t => t a :-. Focusing f t a
+focus = comap extract . focusing . Tag @f
+
+data Root a
diff --git a/Pandora/Paradigm/Structure/Ability/Nonempty.hs b/Pandora/Paradigm/Structure/Ability/Nonempty.hs
--- a/Pandora/Paradigm/Structure/Ability/Nonempty.hs
+++ b/Pandora/Paradigm/Structure/Ability/Nonempty.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty) where
+module Pandora.Paradigm.Structure.Ability.Nonempty where
 
 -- | Type synonymous for at least one element data structure
 type family Nonempty (s :: * -> *) = (r :: * -> *) | r -> s
diff --git a/Pandora/Paradigm/Structure/Ability/Rotatable.hs b/Pandora/Paradigm/Structure/Ability/Rotatable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Ability/Rotatable.hs
@@ -0,0 +1,13 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+
+module Pandora.Paradigm.Structure.Ability.Rotatable where
+
+import Pandora.Pattern.Category ((.))
+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
+
+class Rotatable (f :: k) t where
+	rotation :: (Tagged f) (t a) -> Maybe (t a)
+
+rotate :: forall f t a . Rotatable f t => t a -> Maybe (t a)
+rotate = rotation . Tag @f
diff --git a/Pandora/Paradigm/Structure/Ability/Substructure.hs b/Pandora/Paradigm/Structure/Ability/Substructure.hs
--- a/Pandora/Paradigm/Structure/Ability/Substructure.hs
+++ b/Pandora/Paradigm/Structure/Ability/Substructure.hs
@@ -1,8 +1,16 @@
-module Pandora.Paradigm.Structure.Ability.Substructure (Substructure (..)) where
+{-# LANGUAGE AllowAmbiguousTypes #-}
 
+module Pandora.Paradigm.Structure.Ability.Substructure where
+
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (comap)
+import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Paradigm.Inventory.Optics (type (:-.))
-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 
 class Substructure f t where
 	type Substructural (f :: * -> k) (t :: * -> *) a
-	sub :: t a :-. Tagged f (Substructural f t a)
+	substructure :: Tagged f (t a) :-. Substructural f t a
+
+sub :: forall f t a . Substructure f t => t a :-. Substructural f t a
+sub = comap extract . substructure . Tag @f
diff --git a/Pandora/Paradigm/Structure/Ability/Zipper.hs b/Pandora/Paradigm/Structure/Ability/Zipper.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Ability/Zipper.hs
@@ -0,0 +1,3 @@
+module Pandora.Paradigm.Structure.Ability.Zipper where
+
+type family Zipper (s :: * -> *) = (r :: * -> *) | r -> s
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
@@ -1,35 +1,38 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# LANGUAGE UndecidableInstances #-}
 
-module Pandora.Paradigm.Structure.Binary (Binary, insert) where
+module Pandora.Paradigm.Structure.Binary where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Morphism ((&), (%), (!))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
 import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Pattern.Functor.Divariant (($))
+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))
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
-import Pandora.Paradigm.Inventory.Optics ((%~))
+import Pandora.Paradigm.Inventory.Optics (type (:-.), (|>), (%~))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focus, top, singleton))
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, sub))
+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root)
+import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (rotation), rotate)
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), sub)
 
-type Binary = TU Covariant Covariant Maybe (Construction Wye)
+type Binary = Maybe <:.> Construction Wye
 
 insert :: Chain a => a -> Binary a -> Binary a
-insert x (TU Nothing) = TU . Just . Construct x $ End
-insert x tree@(TU (Just (Construct y _))) = x <=> y & order
-	(sub @Left %~ (insert x <$>) $ tree) tree
-	(sub @Right %~ (insert x <$>) $ tree)
+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
@@ -37,61 +40,80 @@
 	(Construct (extract x) $ Both (rebalance $ deconstruct x) (rebalance $ deconstruct y))
 	(Construct (extract x) $ Both (rebalance $ deconstruct x) y)
 
-instance (forall a . Chain a) => Focusable Binary where
-	type Focus Binary a = Maybe a
-	top (TU Nothing) = Store . (:*:) Nothing $ TU . (<$>) (Construct % End)
-	top (TU (Just x)) = Store . (:*:) (Just $ extract x) $ maybe
-		(TU . Just . rebalance $ deconstruct x)
-		(TU . Just . Construct % deconstruct x)
-	singleton = TU . Just . Construct % End
+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)
+	focusing (run . extract -> Just x) = Store $ Just (extract x) :*: Tag . lift . maybe (rebalance $ deconstruct x) (Construct % deconstruct x)
 
 instance Substructure Left Binary where
 	type Substructural Left Binary a = Binary a
-	sub (TU Nothing) = Store $ (:*:) (Tag $ TU Nothing) $ (TU Nothing !)
-	sub t@(TU (Just (Construct x End))) = Store $ (:*:) (Tag $ TU Nothing) $
-		maybe t (TU . Just . Construct x . Left) . run . extract
-	sub (TU (Just (Construct x (Left lst)))) = Store $ (:*:) (Tag . TU . Just $ lst) $
-		maybe (TU . Just . Construct x $ End) (TU . Just . Construct x . Left) . run . extract
-	sub t@(TU (Just (Construct x (Right rst)))) = Store $ (:*:) (Tag $ TU Nothing) $
-		maybe t (TU . Just . Construct x . Both % rst) . run . extract
-	sub (TU (Just (Construct x (Both lst rst)))) = Store $ (:*:) (Tag . TU . Just $ lst) $
-		maybe (TU (Just (Construct x (Right rst)))) (TU . Just . Construct x . Both % rst) . run . extract
+	substructure empty_tree@(run . extract -> Nothing) = Store $ extract empty_tree :*: (!) empty_tree
+	substructure (run . extract -> Just tree) = Tag . lift <$> (sub @Left |> can_be_empty) tree
 
 instance Substructure Right Binary where
 	type Substructural Right Binary a = Binary a
-	sub (TU Nothing) = Store $ Tag (TU Nothing) :*: (TU Nothing !)
-	sub t@(TU (Just (Construct x End))) = Store $ Tag (TU Nothing)
-		:*: maybe t (TU . Just . Construct x . Right) . run . extract
-	sub t@(TU (Just (Construct x (Left lst)))) = Store $ Tag (TU Nothing)
-		:*: maybe t (TU . Just . Construct x . Both lst) . run . extract
-	sub (TU (Just (Construct x (Right rst)))) = Store $ (Tag . TU . Just $ rst)
-		:*: maybe (TU . Just . Construct x $ End) (TU . Just . Construct x . Right) . run . extract
-	sub (TU (Just (Construct x (Both lst rst)))) = Store $ (Tag . TU . Just $ rst)
-		:*: maybe (TU . Just . Construct x $ Left lst) (TU . Just . Construct x . Both lst) . run . extract
+	substructure empty_tree@(run . extract -> Nothing) = Store $ extract empty_tree :*: (!) empty_tree
+	substructure (run . extract -> Just tree) = Tag . lift <$> (sub @Right |> can_be_empty) tree
 
+can_be_empty :: Maybe (Construction Wye a) :-. Binary a
+can_be_empty maybe_tree = Store $ TU maybe_tree :*: run
+
 type instance Nonempty Binary = Construction Wye
 
-instance Focusable (Construction Wye) where
-	type Focus (Construction Wye) a = a
-	top (Construct x xs) = Store $ x :*: Construct % xs
-	singleton = Construct % End
+instance Focusable Root (Construction Wye) where
+	type Focusing Root (Construction Wye) a = a
+	focusing (extract -> Construct x xs) = Store $ x :*: Tag . Construct % xs
 
 instance Substructure Left (Construction Wye) where
 	type Substructural Left (Construction Wye) a = Maybe :. Construction Wye := a
-	sub (Construct x End) = Store $ Tag Nothing :*: (Construct x End !)
-	sub (Construct x (Left lst)) = Store $ Tag (Just lst)
-		:*: maybe (Construct x End) (Construct x . Left) . extract
-	sub tree@(Construct x (Right rst)) = Store $ Tag Nothing
-		:*: maybe tree (Construct x . Both % rst) . extract
-	sub (Construct x (Both lst rst)) = Store $ Tag (Just lst)
-		:*: maybe (Construct x $ Right rst) (Construct x . Both % rst) . extract
+	substructure empty_tree@(extract -> Construct _ End) = Store $ Nothing :*: (!) empty_tree
+	substructure (extract -> Construct x (Left lst)) = Store $ Just lst :*: Tag . Construct x . maybe End Left
+	substructure (extract -> Construct x (Right rst)) = Store $ Nothing :*: Tag . Construct x . maybe (Right rst) (Both % rst)
+	substructure (extract -> Construct x (Both lst rst)) = Store $ Just lst :*: Tag . Construct x . maybe (Right rst) (Both % rst)
 
 instance Substructure Right (Construction Wye) where
 	type Substructural Right (Construction Wye) a = Maybe :. Construction Wye := a
-	sub (Construct x End) = Store $ Tag Nothing :*: (Construct x End !)
-	sub tree@(Construct x (Left lst)) = Store $ Tag Nothing
-		:*: maybe tree (Construct x . Both lst) . extract
-	sub (Construct x (Right rst)) = Store $ Tag (Just rst)
-		:*: maybe (Construct x End) (Construct x . Right) . extract
-	sub (Construct x (Both lst rst)) = Store $ Tag (Just rst)
-		:*: maybe (Construct x $ Left lst) (Construct x . Both lst) . extract
+	substructure emtpy_tree@(extract -> Construct _ End) = Store $ Nothing :*: (!) emtpy_tree
+	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
@@ -1,47 +1,45 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Structure.Rose (Rose) where
+module Pandora.Paradigm.Structure.Rose where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Morphism ((!), (%))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant (comap))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing), maybe)
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
-import Pandora.Paradigm.Structure.Stack (Stack)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focus, top, singleton))
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, sub))
+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root)
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure))
+import Pandora.Paradigm.Structure.Stack (Stack)
 
-type Rose = TU Covariant Covariant Maybe (Construction Stack)
+type Rose = Maybe <:.> Construction Stack
 
-instance Focusable Rose where
-	type Focus Rose a = Maybe a
-	top (TU Nothing) = Store $ Nothing :*: TU . (<$>) (Construct % empty)
-	top (TU (Just x)) = Store $ Just (extract x) :*: maybe
-		(TU $ Just x) -- TODO: Nothing at top's lens - should it remove something?
-		(TU . Just . Construct % deconstruct x)
-	singleton = TU . Just . Construct % empty
+instance Focusable Root Rose where
+	type Focusing Root Rose a = Maybe a
+	focusing (run . extract -> Nothing) = Store $ Nothing :*: Tag . TU . comap (Construct % empty)
+	focusing (run . extract -> Just rose) = Store $ Just (extract rose)
+		:*: Tag . maybe (TU Nothing) (lift . Construct % deconstruct rose)
 
 instance Substructure Just Rose where
 	type Substructural Just Rose a = Stack :. Construction Stack := a
-	sub (TU Nothing) = Store $ Tag (TU Nothing) :*: (TU Nothing !)
-	sub (TU (Just (Construct x xs))) = Store $ Tag xs :*: TU . Just . Construct x . extract
+	substructure (run . extract -> Nothing) = Store $ TU Nothing :*: (Tag (TU Nothing) !)
+	substructure (run . extract -> Just (Construct x xs)) = Store $ xs :*: Tag . lift . Construct x
 
 type instance Nonempty Rose = Construction Stack
 
+instance Focusable Root (Construction Stack) where
+	type Focusing Root (Construction Stack) a = a
+	focusing (Tag rose) = Store $ extract rose :*: Tag . Construct % deconstruct rose
+
 instance Substructure Just (Construction Stack) where
 	type Substructural Just (Construction Stack) a = Stack :. Construction Stack := a
-	sub (Construct x xs) = Store $ Tag xs :*: Construct x . extract
-
-instance Focusable (Construction Stack) where
-	type Focus (Construction Stack) a = a
-	top rose = Store $ extract rose :*: Construct % deconstruct rose
-	singleton = Construct % empty
+	substructure (Tag (Construct x xs)) = Store $ xs :*: Tag . Construct x
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
@@ -1,60 +1,57 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Structure.Stack (Stack, push, pop, filter, linearize) where
+module Pandora.Paradigm.Structure.Stack where
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Core.Morphism ((&), (%))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (.|..))
 import Pandora.Pattern.Functor.Alternative ((<+>))
 import Pandora.Pattern.Functor.Avoidable (empty)
 import Pandora.Pattern.Functor.Pointable (point)
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Traversable (Traversable)
 import Pandora.Pattern.Functor.Bindable ((>>=))
-import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 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.Predicate (Predicate (Predicate))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 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.Store (Store (Store))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
+import Pandora.Paradigm.Inventory.Optics ((^.))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focus, top, singleton))
+import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)
+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root, focus)
 
 -- | Linear data structure that serves as a collection of elements
-type Stack = TU Covariant Covariant Maybe (Construction Maybe)
+type Stack = Maybe <:.> Construction Maybe
 
 instance Setoid a => Setoid (Stack a) where
 	TU ls == TU rs = ls == rs
 
 instance Semigroup (Stack a) where
 	TU Nothing + TU ys = TU ys
-	TU (Just (Construct x xs)) + TU ys = TU . Just . Construct x . run
+	TU (Just (Construct x xs)) + TU ys = lift . Construct x . run
 		$ TU @Covariant @Covariant xs + TU @Covariant @Covariant ys
 
 instance Monoid (Stack a) where
 	zero = TU Nothing
 
-instance Focusable Stack where
-	type Focus Stack a = Maybe a
-	top stack = Store $ (:*:) (extract <$> run stack) $ \case
-		Just x -> stack & pop & push x
-		Nothing -> pop stack
-	singleton = TU . Just . Construct % Nothing
-
-type instance Nonempty Stack = Construction Maybe
-
-instance Focusable (Construction Maybe) where
-	type Focus (Construction Maybe) a = a
-	top stack = Store $ extract stack :*: Construct % deconstruct stack
-	singleton = Construct % Nothing
+instance Focusable Root Stack where
+	type Focusing Root Stack a = Maybe a
+	focusing (Tag stack) = Store $ extract <$> run stack :*: \case
+		Just x -> stack & pop & push x & Tag
+		Nothing -> Tag $ pop stack
 
 push :: a -> Stack a -> Stack a
 push x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x
@@ -68,4 +65,16 @@
 
 -- | Transform any traversable structure into a stack
 linearize :: Traversable t => t ~> Stack
-linearize = TU . fold Nothing (\x -> Just . Construct x)
+linearize = TU . fold Nothing (Just .|.. Construct)
+
+type instance Nonempty Stack = Construction Maybe
+
+instance Focusable Root (Construction Maybe) where
+	type Focusing Root (Construction Maybe) a = a
+	focusing (Tag stack) = Store $ extract stack :*: Tag . Construct % deconstruct stack
+
+type instance Zipper Stack = Tap (Delta <:.> Stack)
+
+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
diff --git a/Pandora/Paradigm/Structure/Stream.hs b/Pandora/Paradigm/Structure/Stream.hs
--- a/Pandora/Paradigm/Structure/Stream.hs
+++ b/Pandora/Paradigm/Structure/Stream.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Structure.Stream (Stream) where
+module Pandora.Paradigm.Structure.Stream where
 
 import Pandora.Paradigm.Primary.Functor.Identity (Identity)
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction)
diff --git a/Pandora/Pattern/Category.hs b/Pandora/Pattern/Category.hs
--- a/Pandora/Pattern/Category.hs
+++ b/Pandora/Pattern/Category.hs
@@ -1,10 +1,14 @@
 module Pandora.Pattern.Category (Category (..)) where
 
 infixr 8 .
+infixr 0 $
 
 class Category (m :: * -> * -> *) where
 	identity :: m a a
 	(.) :: m b c -> m a b -> m a c
+
+	($) :: m a b -> m a b
+	($) f = identity . f
 
 instance Category (->) where
 	identity x = x
diff --git a/Pandora/Pattern/Functor/Adjoint.hs b/Pandora/Pattern/Functor/Adjoint.hs
--- a/Pandora/Pattern/Functor/Adjoint.hs
+++ b/Pandora/Pattern/Functor/Adjoint.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Adjoint (Adjoint (..), type (-|)) where
+module Pandora.Pattern.Functor.Adjoint where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (identity)
diff --git a/Pandora/Pattern/Functor/Alternative.hs b/Pandora/Pattern/Functor/Alternative.hs
--- a/Pandora/Pattern/Functor/Alternative.hs
+++ b/Pandora/Pattern/Functor/Alternative.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Alternative (Alternative (..)) where
+module Pandora.Pattern.Functor.Alternative where
 
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
diff --git a/Pandora/Pattern/Functor/Applicative.hs b/Pandora/Pattern/Functor/Applicative.hs
--- a/Pandora/Pattern/Functor/Applicative.hs
+++ b/Pandora/Pattern/Functor/Applicative.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Applicative (Applicative (..)) where
+module Pandora.Pattern.Functor.Applicative where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (identity)
diff --git a/Pandora/Pattern/Functor/Avoidable.hs b/Pandora/Pattern/Functor/Avoidable.hs
--- a/Pandora/Pattern/Functor/Avoidable.hs
+++ b/Pandora/Pattern/Functor/Avoidable.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Avoidable (Avoidable (..)) where
+module Pandora.Pattern.Functor.Avoidable where
 
 import Pandora.Pattern.Functor.Alternative (Alternative)
 
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
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Bindable (Bindable (..)) where
+module Pandora.Pattern.Functor.Bindable where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Morphism ((%))
diff --git a/Pandora/Pattern/Functor/Bivariant.hs b/Pandora/Pattern/Functor/Bivariant.hs
--- a/Pandora/Pattern/Functor/Bivariant.hs
+++ b/Pandora/Pattern/Functor/Bivariant.hs
@@ -1,6 +1,6 @@
-module Pandora.Pattern.Functor.Bivariant (Bivariant (..)) where
+module Pandora.Pattern.Functor.Bivariant where
 
-import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Category (($))
 
 infixl 4 <->
 
diff --git a/Pandora/Pattern/Functor/Comonad.hs b/Pandora/Pattern/Functor/Comonad.hs
--- a/Pandora/Pattern/Functor/Comonad.hs
+++ b/Pandora/Pattern/Functor/Comonad.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Comonad (Comonad) where
+module Pandora.Pattern.Functor.Comonad where
 
 import Pandora.Pattern.Functor.Extractable (Extractable)
 import Pandora.Pattern.Functor.Extendable (Extendable)
diff --git a/Pandora/Pattern/Functor/Contravariant.hs b/Pandora/Pattern/Functor/Contravariant.hs
--- a/Pandora/Pattern/Functor/Contravariant.hs
+++ b/Pandora/Pattern/Functor/Contravariant.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Contravariant (Contravariant (..)) where
+module Pandora.Pattern.Functor.Contravariant where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Morphism ((!), (%))
diff --git a/Pandora/Pattern/Functor/Covariant.hs b/Pandora/Pattern/Functor/Covariant.hs
--- a/Pandora/Pattern/Functor/Covariant.hs
+++ b/Pandora/Pattern/Functor/Covariant.hs
@@ -1,8 +1,8 @@
-module Pandora.Pattern.Functor.Covariant (Covariant (..)) where
+module Pandora.Pattern.Functor.Covariant where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (<-|))
 import Pandora.Core.Morphism (fix, (!), (%))
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category (Category ((.)))
 
 infixl 4 <$>, <$, $>
 
@@ -58,3 +58,15 @@
 
 instance Covariant ((->) a) where
 	(<$>) = (.)
+
+(.|..) :: (Category v, Covariant (v a))
+	=> v c d -> v a :. v b := c -> v a :. v b := d
+f .|.. g = (f .) <$> g
+
+(.|...) :: (Category v, Covariant (v a), Covariant (v b))
+	=> v d e -> v a :. v b :. v c := d -> v a :. v b :. v c := e
+f .|... g = (f .) <$$> g
+
+(.|....) :: (Category v, Covariant (v a), Covariant (v b), Covariant (v c))
+	=> v e f -> v a :. v b :. v c :. v d := e -> v a :. v b :. v c :. v d := f
+f .|.... g = (f .) <$$$> g
diff --git a/Pandora/Pattern/Functor/Determinable.hs b/Pandora/Pattern/Functor/Determinable.hs
--- a/Pandora/Pattern/Functor/Determinable.hs
+++ b/Pandora/Pattern/Functor/Determinable.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Determinable (Determinable (..)) where
+module Pandora.Pattern.Functor.Determinable where
 
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 
diff --git a/Pandora/Pattern/Functor/Distributive.hs b/Pandora/Pattern/Functor/Distributive.hs
--- a/Pandora/Pattern/Functor/Distributive.hs
+++ b/Pandora/Pattern/Functor/Distributive.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Distributive (Distributive (..)) where
+module Pandora.Pattern.Functor.Distributive where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Morphism ((%))
diff --git a/Pandora/Pattern/Functor/Divariant.hs b/Pandora/Pattern/Functor/Divariant.hs
--- a/Pandora/Pattern/Functor/Divariant.hs
+++ b/Pandora/Pattern/Functor/Divariant.hs
@@ -1,9 +1,8 @@
-module Pandora.Pattern.Functor.Divariant (Divariant (..)) where
+module Pandora.Pattern.Functor.Divariant where
 
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category ((.), ($))
 
 infixl 4 >->
-infixr 0 $
 
 {- |
 > When providing a new instance, you should ensure it satisfies the two laws:
@@ -17,9 +16,6 @@
 	-- | Prefix version of '>->'
 	dimap :: v a b -> v c d -> v b c -> v a d
 	dimap f g x = f >-> g $ x
-	-- Generalized function application
-	($) :: v a b -> v a b
-	($) f = f
 
 instance Divariant ((->)) where
 	(>->) ab cd bc = cd . bc . ab
diff --git a/Pandora/Pattern/Functor/Extendable.hs b/Pandora/Pattern/Functor/Extendable.hs
--- a/Pandora/Pattern/Functor/Extendable.hs
+++ b/Pandora/Pattern/Functor/Extendable.hs
@@ -1,9 +1,9 @@
-module Pandora.Pattern.Functor.Extendable (Extendable (..)) where
+module Pandora.Pattern.Functor.Extendable where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Morphism ((%))
 import Pandora.Pattern.Category (identity, (.))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 
 infixl 1 =>>
 infixr 1 <<=, =<=, =>=
@@ -34,3 +34,9 @@
 	-- | Left-to-right Cokleisli composition
 	(=>=) :: (t a -> b) -> (t b -> c) -> t a -> c
 	f =>= g = g . extend f
+
+	-- | Experimental methods
+	($=>>) :: Covariant u => (t a -> b) -> u :. t := a -> u :. t := b
+	f $=>> x = (=>> f) <$> x
+	(<<=$) :: Covariant u => u :. t := a -> (t a -> b) -> u :. t := b
+	x <<=$ f = (=>> f) <$> x
diff --git a/Pandora/Pattern/Functor/Extractable.hs b/Pandora/Pattern/Functor/Extractable.hs
--- a/Pandora/Pattern/Functor/Extractable.hs
+++ b/Pandora/Pattern/Functor/Extractable.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Extractable (Extractable (..)) where
+module Pandora.Pattern.Functor.Extractable where
 
 import Pandora.Core.Functor (type (<-|))
 import Pandora.Pattern.Functor.Covariant (Covariant)
diff --git a/Pandora/Pattern/Functor/Invariant.hs b/Pandora/Pattern/Functor/Invariant.hs
--- a/Pandora/Pattern/Functor/Invariant.hs
+++ b/Pandora/Pattern/Functor/Invariant.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Invariant (Invariant (..)) where
+module Pandora.Pattern.Functor.Invariant where
 
 {- |
 > When providing a new instance, you should ensure it satisfies the two laws:
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
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Monad (Monad) where
+module Pandora.Pattern.Functor.Monad where
 
 import Pandora.Pattern.Functor.Bindable (Bindable)
 import Pandora.Pattern.Functor.Pointable (Pointable)
diff --git a/Pandora/Pattern/Functor/Pointable.hs b/Pandora/Pattern/Functor/Pointable.hs
--- a/Pandora/Pattern/Functor/Pointable.hs
+++ b/Pandora/Pattern/Functor/Pointable.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Pointable (Pointable (..)) where
+module Pandora.Pattern.Functor.Pointable where
 
 import Pandora.Core.Functor (type (|->))
 import Pandora.Core.Morphism ((!))
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
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Representable (Representable (..)) where
+module Pandora.Pattern.Functor.Representable where
 
 import Pandora.Core.Functor (type (<-|))
 import Pandora.Core.Morphism ((%))
diff --git a/Pandora/Pattern/Functor/Traversable.hs b/Pandora/Pattern/Functor/Traversable.hs
--- a/Pandora/Pattern/Functor/Traversable.hs
+++ b/Pandora/Pattern/Functor/Traversable.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor.Traversable (Traversable (..)) where
+module Pandora.Pattern.Functor.Traversable where
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (identity, (.))
diff --git a/Pandora/Pattern/Transformer/Liftable.hs b/Pandora/Pattern/Transformer/Liftable.hs
--- a/Pandora/Pattern/Transformer/Liftable.hs
+++ b/Pandora/Pattern/Transformer/Liftable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Transformer.Liftable (Liftable (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Pointable (Pointable)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
 {- |
 > When providing a new instance, you should ensure it satisfies one law:
@@ -9,4 +9,4 @@
 -}
 
 class Liftable t where
-	lift :: Pointable u => u ~> t u
+	lift :: Covariant u => u ~> t u
diff --git a/Pandora/Pattern/Transformer/Lowerable.hs b/Pandora/Pattern/Transformer/Lowerable.hs
--- a/Pandora/Pattern/Transformer/Lowerable.hs
+++ b/Pandora/Pattern/Transformer/Lowerable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Transformer.Lowerable (Lowerable (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Extractable (Extractable)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
 {- |
 > When providing a new instance, you should ensure it satisfies one law:
@@ -9,4 +9,4 @@
 -}
 
 class Lowerable t where
-	lower :: Extractable u => t u ~> u
+	lower :: Covariant u => t u ~> u
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.2.8
+version:             0.2.9
 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
@@ -54,27 +54,29 @@
     Pandora.Paradigm.Primary.Transformer.Continuation
     Pandora.Paradigm.Primary.Transformer.Construction
     Pandora.Paradigm.Primary.Transformer.Instruction
+    Pandora.Paradigm.Primary.Transformer.Tap
     Pandora.Paradigm.Primary.Transformer.Outline
     Pandora.Paradigm.Primary.Transformer.Jack
     Pandora.Paradigm.Primary.Transformer.Jet
     Pandora.Paradigm.Primary.Transformer.Kan
     Pandora.Paradigm.Primary.Transformer.Yoneda
+    -- Schemes of functor compositions
+    Pandora.Paradigm.Schemes
+    Pandora.Paradigm.Schemes.TU
+    Pandora.Paradigm.Schemes.TUT
+    Pandora.Paradigm.Schemes.TUVW
+    Pandora.Paradigm.Schemes.UT
+    Pandora.Paradigm.Schemes.UTU
     -- Control flow primitives
     Pandora.Paradigm.Controlflow
     -- Typeclassess about functor junctions
-    Pandora.Paradigm.Controlflow.Joint
-    Pandora.Paradigm.Controlflow.Joint.Interpreted
-    Pandora.Paradigm.Controlflow.Joint.Transformer
-    Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic
-    Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic
-    Pandora.Paradigm.Controlflow.Joint.Schematic
-    Pandora.Paradigm.Controlflow.Joint.Adaptable
-    Pandora.Paradigm.Controlflow.Joint.Schemes
-    Pandora.Paradigm.Controlflow.Joint.Schemes.TU
-    Pandora.Paradigm.Controlflow.Joint.Schemes.TUT
-    Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW
-    Pandora.Paradigm.Controlflow.Joint.Schemes.UT
-    Pandora.Paradigm.Controlflow.Joint.Schemes.UTU
+    Pandora.Paradigm.Controlflow.Effect
+    Pandora.Paradigm.Controlflow.Effect.Interpreted
+    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
     -- Tools for datastructures
@@ -94,8 +96,10 @@
     Pandora.Paradigm.Structure.Rose
     Pandora.Paradigm.Structure.Ability
     Pandora.Paradigm.Structure.Ability.Focusable
-    Pandora.Paradigm.Structure.Ability.Nonempty
+    Pandora.Paradigm.Structure.Ability.Rotatable
     Pandora.Paradigm.Structure.Ability.Substructure
+    Pandora.Paradigm.Structure.Ability.Nonempty
+    Pandora.Paradigm.Structure.Ability.Zipper
 
     Pandora.Pattern
     -- Category typeclass
@@ -142,7 +146,7 @@
   default-extensions:
     DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints
     FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase
-    MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes
+    MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes, ViewPatterns
     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators
   default-language: Haskell2010
   ghc-options: -Wall -fno-warn-tabs -fno-warn-unticked-promoted-constructors