diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -184,7 +184,7 @@
 * Rename `Group`'s method from `inverse` to `invert`
 * Remove `not` method of `Boolean`, (use `invert` instead)
 * Remove `Injective` and `Has` type families
-* Change superclasseses for `Liftable` and `Lowerable` classes to provide a law
+* Change superclasses for `Liftable` and `Lowerable` classes to provide a law
 
 # 0.2.6
 * Change order of arguments for `TUT` joint schema
@@ -200,3 +200,19 @@
 * Remove `left_sub_tree` and `right_sub_tree` lenses of `Binary` tree
 * Define `this` and `that` methods from `Variation` to `Maybe`
 * Define `Backwards` type to run `Applicative` actions in reverse order
+
+# 0.2.7
+* Replace `Lan` and `Ran` with `Kan` data family
+* Rename `Free` to `Instruction` and its constructors: `Pure` to `Enter` and `Impure` to `Instruct`
+* Define `Ring` typeclass with `Group` superclass
+* Define `Weighted` type family and define instance for `Graph`
+* Add `Leap` to `Edges` to indicate a connection with only the first vertex
+* Remove `Graph` structure and `Weighted` type family
+* Define `Reverse` type to run `Traversable` in reverse order with `Backwards`
+* Rename `Twister` to `Construction` (in contrast of `Instruction`)
+* Split `Basis` on `Functor` and `Transformer` modules in `Primary`
+* Rename `untwist` to `deconstruct` in `Construction`
+* Define `Rose` tree structure
+* Replace `UT` joint scheme with `TU` in data structures
+* Change `sub` method of `Substructure` - it always returns `Tagged` value
+* Rename `Construction` constructor of `Construction` to `Construct`
diff --git a/Pandora/Paradigm.hs b/Pandora/Paradigm.hs
--- a/Pandora/Paradigm.hs
+++ b/Pandora/Paradigm.hs
@@ -3,4 +3,4 @@
 import Pandora.Paradigm.Structure as Exports
 import Pandora.Paradigm.Inventory as Exports
 import Pandora.Paradigm.Controlflow as Exports
-import Pandora.Paradigm.Basis as Exports
+import Pandora.Paradigm.Primary as Exports
diff --git a/Pandora/Paradigm/Basis.hs b/Pandora/Paradigm/Basis.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis.hs
+++ /dev/null
@@ -1,55 +0,0 @@
-module Pandora.Paradigm.Basis (module Exports, note, hush, left, right, this, that) where
-
-import Pandora.Paradigm.Basis.Twister as Exports
-import Pandora.Paradigm.Basis.Free as Exports
-import Pandora.Paradigm.Basis.Fix as Exports
-import Pandora.Paradigm.Basis.Yoneda as Exports
-import Pandora.Paradigm.Basis.Continuation as Exports
-import Pandora.Paradigm.Basis.Predicate as Exports
-import Pandora.Paradigm.Basis.Variation as Exports
-import Pandora.Paradigm.Basis.Validation as Exports
-import Pandora.Paradigm.Basis.Wye as Exports
-import Pandora.Paradigm.Basis.Edges as Exports
-import Pandora.Paradigm.Basis.Conclusion as Exports
-import Pandora.Paradigm.Basis.Maybe as Exports
-import Pandora.Paradigm.Basis.Endo as Exports
-import Pandora.Paradigm.Basis.Kan as Exports
-import Pandora.Paradigm.Basis.Jet as Exports
-import Pandora.Paradigm.Basis.Jack as Exports
-import Pandora.Paradigm.Basis.Proxy as Exports
-import Pandora.Paradigm.Basis.Tagged as Exports
-import Pandora.Paradigm.Basis.Product as Exports
-import Pandora.Paradigm.Basis.Constant as Exports
-import Pandora.Paradigm.Basis.Backwards as Exports
-import Pandora.Paradigm.Basis.Identity as Exports
-
-import Pandora.Core.Morphism ((!))
-import Pandora.Core.Functor (type (~>))
-
-note :: e -> Maybe ~> Conclusion e
-note x = maybe (Failure x) Success
-
-hush :: Conclusion e ~> Maybe
-hush = conclusion (Nothing !) Just
-
-left :: Wye ~> Maybe
-left (Both ls _) = Just ls
-left (Left ls) = Just ls
-left (Right _) = Nothing
-left End = Nothing
-
-right :: Wye ~> Maybe
-right (Both _ rs) = Just rs
-right (Left _) = Nothing
-right (Right rs) = Just rs
-right End = Nothing
-
-this :: Variation e ~> Maybe
-this (This x) = Just x
-this (That _) = Nothing
-this (These _ x) = Just x
-
-that :: Variation e a -> Maybe e
-that (This _) = Nothing
-that (That x) = Just x
-that (These y _) = Just y
diff --git a/Pandora/Paradigm/Basis/Backwards.hs b/Pandora/Paradigm/Basis/Backwards.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Backwards.hs
+++ /dev/null
@@ -1,40 +0,0 @@
-module Pandora.Paradigm.Basis.Backwards (Backwards (..)) where
-
-import Pandora.Core.Morphism ((&))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-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.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-
-newtype Backwards t a = Backwards (t a)
-
-instance Covariant t => Covariant (Backwards t) where
-	f <$> Backwards x = Backwards $ f <$> x
-
-instance Pointable t => Pointable (Backwards t) where
-	point = Backwards . point
-
-instance Extractable t => Extractable (Backwards t) where
-	extract (Backwards x) = extract x
-
-instance Applicative t => Applicative (Backwards t) where
-	Backwards f <*> Backwards x = Backwards ((&) <$> x <*> f)
-
-instance Traversable t => Traversable (Backwards t) where
-	Backwards x ->> f = Backwards <$> x ->> f
-
-instance Distributive t => Distributive (Backwards t) where
-	x >>- f = Backwards $ x >>- run . f
-
-instance Contravariant t => Contravariant (Backwards t) where
-	f >$< Backwards x = Backwards $ f >$< x
-
-instance Interpreted (Backwards t) where
-	type Primary (Backwards t) a = t a
-	run (Backwards x) = x
diff --git a/Pandora/Paradigm/Basis/Conclusion.hs b/Pandora/Paradigm/Basis/Conclusion.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Conclusion.hs
+++ /dev/null
@@ -1,105 +0,0 @@
-module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where
-
-import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category ((.))
-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.Functor.Covariant (Covariant ((<$>), (<$$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-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 ((==)), Boolean (False))
-import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-
-data Conclusion e a = Failure e | Success a
-
-instance Covariant (Conclusion e) where
-	f <$> Success x = Success $ f x
-	_ <$> Failure y = Failure y
-
-instance Pointable (Conclusion e) where
-	point = Success
-
-instance Applicative (Conclusion e) where
-	Success f <*> x = f <$> x
-	Failure y <*> _ = Failure y
-
-instance Alternative (Conclusion e) where
-	Failure _ <+> x = x
-	Success x <+> _ = Success x
-
-instance Traversable (Conclusion e) where
-	Failure y ->> _ = point $ Failure y
-	Success x ->> f = Success <$> f x
-
-instance Bindable (Conclusion e) where
-	Success x >>= f = f x
-	Failure y >>= _ = Failure y
-
-instance Monad (Conclusion e) where
-
-instance Bivariant Conclusion where
-    f <-> g = conclusion (Failure . f) (Success . g)
-
-instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where
-	Success x == Success y = x == y
-	Failure x == Failure y = x == y
-	_ == _ = False
-
-instance (Chain e, Chain a) => Chain (Conclusion e a) where
-	Success x <=> Success y = x <=> y
-	Failure x <=> Failure y = x <=> y
-	Failure _ <=> Success _ = Less
-	Success _ <=> Failure _ = Greater
-
-instance (Semigroup e, Semigroup a) => Semigroup (Conclusion e a) where
-	Success x + Success y = Success $ x + y
-	Failure x + Failure y = Failure $ x + y
-	Failure _ + Success y = Success y
-	Success x + Failure _ = Success x
-
-conclusion :: (e -> r) -> (a -> r) -> Conclusion e a -> r
-conclusion f _ (Failure x) = f x
-conclusion _ s (Success x) = s x
-
-fail :: (e -> r) -> Conclusion e ~> Conclusion r
-fail f (Failure x) = Failure $ f x
-fail _ (Success y) = Success y
-
-instance Interpreted (Conclusion e) where
-	type Primary (Conclusion e) a = Conclusion e a
-	run x = x
-
-type instance Schematic Monad (Conclusion e) u = UT Covariant Covariant (Conclusion e) u
-
-instance Monadic (Conclusion e) where
-	lay x = TM . UT $ Success <$> x
-	wrap x = TM . UT . point $ x
-
-type Failable e = Adaptable (Conclusion e)
-
-instance Covariant u => Covariant (UT Covariant Covariant (Conclusion e) u) where
-	f <$> UT x = UT $ f <$$> x
-
-instance Applicative u => Applicative (UT Covariant Covariant (Conclusion e) u) where
-	UT f <*> UT x = UT $ apply <$> f <*> x
-
-instance Pointable u => Pointable (UT Covariant Covariant (Conclusion e) u) where
-	point = UT . point . point
-
-instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant (Conclusion e) u) where
-	UT x >>= f = UT $ x >>= conclusion (point . Failure) (run . f)
-
-instance Monad u => Monad (UT Covariant Covariant (Conclusion e) u) where
-
-failure :: Failable e t => e -> t a
-failure = adapt . Failure
diff --git a/Pandora/Paradigm/Basis/Constant.hs b/Pandora/Paradigm/Basis/Constant.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Constant.hs
+++ /dev/null
@@ -1,64 +0,0 @@
-module Pandora.Paradigm.Basis.Constant (Constant (..)) where
-
-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 ((+)))
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Pattern.Object.Quasiring (Quasiring (one))
-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
-import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (invert))
-
-newtype Constant a b = Constant a
-
-instance Covariant (Constant a) where
-	_ <$> Constant x = Constant x
-
-instance Contravariant (Constant a) where
-	_ >$< Constant x = Constant x
-
-instance Invariant (Constant a) where
-	invmap _ _ (Constant x) = Constant x
-
-instance Traversable (Constant a) where
-	Constant x ->> _ = point (Constant x)
-
-instance Bivariant Constant where
-	f <-> _ = \(Constant x) -> Constant $ f x
-
-instance Setoid a => Setoid (Constant a b) where
-	Constant x == Constant y = x == y
-
-instance Chain a => Chain (Constant a b) where
-	Constant x <=> Constant y = x <=> y
-
-instance Semigroup a => Semigroup (Constant a b) where
-	Constant x + Constant y = Constant $ x + y
-
-instance Monoid a => Monoid (Constant a b) where
-	 zero = Constant zero
-
-instance Ringoid a => Ringoid (Constant a b) where
-	Constant x * Constant y = Constant $ x * y
-
-instance Quasiring a => Quasiring (Constant a b) where
-	 one = Constant one
-
-instance Infimum a => Infimum (Constant a b) where
-	Constant x /\ Constant y = Constant $ x /\ y
-
-instance Supremum a => Supremum (Constant a b) where
-	Constant x \/ Constant y = Constant $ x \/ y
-
-instance Lattice a => Lattice (Constant a b) where
-
-instance Group a => Group (Constant a b) where
-	invert (Constant x) = Constant $ invert x
diff --git a/Pandora/Paradigm/Basis/Continuation.hs b/Pandora/Paradigm/Basis/Continuation.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Continuation.hs
+++ /dev/null
@@ -1,43 +0,0 @@
-module Pandora.Paradigm.Basis.Continuation (Continuation (..), cwcc, reset, shift) where
-
-import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
-import Pandora.Core.Morphism ((!), (%))
-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 }
-
-instance Covariant t => Covariant (Continuation r t) where
-	f <$> Continuation continuation = Continuation $ continuation . (. f)
-
-instance Covariant t => Pointable (Continuation r t) where
-	point x = Continuation ($ x)
-
-instance Covariant t => Applicative (Continuation r t) where
-	f <*> x = Continuation $ \h -> continue f $ \g -> continue x (h . g)
-
-instance Covariant t => Bindable (Continuation r t) where
-	x >>= f = Continuation $ \g -> continue x $ \y -> continue (f y) g
-
-instance Monad t => Monad (Continuation r t) where
-
-instance (forall u . Bindable u) => Liftable (Continuation r) where
-	lift = Continuation . (>>=)
-
--- | Call with current continuation
-cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a
-cwcc f = Continuation $ \g -> continue % g . f $ Continuation . (!) . g
-
--- | Delimit the continuation of any 'shift'
-reset :: (forall u . Bindable u, Bindable t, Pointable t) => Continuation r t r -> Continuation s t r
-reset = lift . continue % point
-
--- | Capture the continuation up to the nearest enclosing 'reset' and pass it
-shift :: Pointable t => ((a -> t r) -> Continuation r t r) -> Continuation r t a
-shift f = Continuation $ continue % point . f
diff --git a/Pandora/Paradigm/Basis/Edges.hs b/Pandora/Paradigm/Basis/Edges.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Edges.hs
+++ /dev/null
@@ -1,23 +0,0 @@
-module Pandora.Paradigm.Basis.Edges (Edges (..), edges) where
-
-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 | Connect a | Overlay a
-
-instance Covariant Edges where
-	_ <$> Empty = Empty
-	f <$> Connect x = Connect $ f x
-	f <$> Overlay x = Overlay $ f x
-
-instance Traversable Edges where
-	Empty ->> _ = point Empty
-	Connect x ->> f = Connect <$> f x
-	Overlay x ->> f = Overlay <$> f x
-
-edges :: r -> (a -> r) -> (a -> r) -> Edges a -> r
-edges r _ _ Empty = r
-edges _ f _ (Connect x) = f x
-edges _ _ g (Overlay y) = g y
diff --git a/Pandora/Paradigm/Basis/Endo.hs b/Pandora/Paradigm/Basis/Endo.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Endo.hs
+++ /dev/null
@@ -1,17 +0,0 @@
-module Pandora.Paradigm.Basis.Endo (Endo (..)) where
-
-import Pandora.Pattern.Category (identity, (.))
-import Pandora.Pattern.Functor.Invariant (Invariant (invmap))
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
-
-newtype Endo a = Endo { endo :: a -> a }
-
-instance Invariant Endo where
-	invmap f g (Endo x) = Endo (f . x . g)
-
-instance Semigroup (Endo a) where
-	Endo f + Endo g = Endo (g . f)
-
-instance Monoid (Endo a) where
-	zero = Endo identity
diff --git a/Pandora/Paradigm/Basis/Fix.hs b/Pandora/Paradigm/Basis/Fix.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Fix.hs
+++ /dev/null
@@ -1,16 +0,0 @@
-module Pandora.Paradigm.Basis.Fix (Fix (..), cata, ana, hylo) where
-
-import Pandora.Core.Functor (type (<-|), type (|->))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant (comap))
-
-newtype Fix t = Fix { unfix :: t (Fix t) }
-
-cata :: Covariant t => (a <-| t) -> Fix t -> a
-cata f = f . comap (cata f) . unfix
-
-ana :: Covariant t => (a |-> t) -> a -> Fix t
-ana f = Fix . comap (ana f) . f
-
-hylo :: Covariant t => (b <-| t) -> (a |-> t) -> (a -> b)
-hylo phi psi = cata phi . ana psi
diff --git a/Pandora/Paradigm/Basis/Free.hs b/Pandora/Paradigm/Basis/Free.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Free.hs
+++ /dev/null
@@ -1,45 +0,0 @@
-module Pandora.Paradigm.Basis.Free (Free (..)) where
-
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-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 Free t a = Pure a | Impure (t :. Free t := a)
-
-instance Covariant t => Covariant (Free t) where
-	f <$> Pure x = Pure $ f x
-	f <$> Impure xs = Impure $ f <$$> xs
-
-instance Covariant t => Pointable (Free t) where
-	point = Pure
-
-instance Alternative t => Alternative (Free t) where
-	Pure x <+> _ = Pure x
-	_ <+> Pure y = Pure y
-	Impure xs <+> Impure ys = Impure $ xs <+> ys
-
-instance Avoidable t => Avoidable (Free t) where
-	empty = Impure empty
-
-instance Covariant t => Applicative (Free t) where
-	Pure f <*> Pure y = Pure $ f y
-	Pure f <*> Impure y = Impure $ f <$$> y
-	Impure f <*> y = Impure $ (<*> y) <$> f
-
-instance Covariant t => Bindable (Free t) where
-	Pure x >>= f = f x
-	Impure xs >>= f = Impure $ (>>= f) <$> xs
-
-instance Traversable t => Traversable (Free t) where
-	Pure x ->> f = Pure <$> f x
-	Impure xs ->> f = Impure <$> xs ->>> f
-
-instance Liftable Free where
-	lift x = Impure $ Pure <$> x
diff --git a/Pandora/Paradigm/Basis/Identity.hs b/Pandora/Paradigm/Basis/Identity.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Identity.hs
+++ /dev/null
@@ -1,87 +0,0 @@
-module Pandora.Paradigm.Basis.Identity (Identity (..)) where
-
-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))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Comonad (Comonad)
-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 ((+)))
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Pattern.Object.Quasiring (Quasiring (one))
-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
-import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (invert))
-
-newtype Identity a = Identity a
-
-instance Covariant Identity where
-	f <$> Identity x = Identity $ f x
-
-instance Pointable Identity where
-	point = Identity
-
-instance Extractable Identity where
-	extract (Identity x) = x
-
-instance Applicative Identity where
-	Identity f <*> Identity x = Identity $ f x
-
-instance Traversable Identity where
-	Identity x ->> f = Identity <$> f x
-
-instance Distributive Identity where
-	x >>- f = Identity $ extract . f <$> x
-
-instance Bindable Identity where
-	Identity x >>= f = f x
-
-instance Monad Identity
-
-instance Extendable Identity where
-	x =>> f = Identity . f $ x
-
-instance Comonad Identity
-
-instance Adjoint Identity Identity where
-	x -| f = Identity . f . Identity $ x
-	x |- g = extract . extract . comap g $ x
-
-instance Setoid a => Setoid (Identity a) where
-	Identity x == Identity y = x == y
-
-instance Chain a => Chain (Identity a) where
-	Identity x <=> Identity y = x <=> y
-
-instance Semigroup a => Semigroup (Identity a) where
-	Identity x + Identity y = Identity $ x + y
-
-instance Monoid a => Monoid (Identity a) where
-	 zero = Identity zero
-
-instance Ringoid a => Ringoid (Identity a) where
-	Identity x * Identity y = Identity $ x * y
-
-instance Quasiring a => Quasiring (Identity a) where
-	 one = Identity one
-
-instance Infimum a => Infimum (Identity a) where
-	Identity x /\ Identity y = Identity $ x /\ y
-
-instance Supremum a => Supremum (Identity a) where
-	Identity x \/ Identity y = Identity $ x \/ y
-
-instance Lattice a => Lattice (Identity a) where
-
-instance Group a => Group (Identity a) where
-	invert (Identity x) = Identity $ invert x
diff --git a/Pandora/Paradigm/Basis/Jack.hs b/Pandora/Paradigm/Basis/Jack.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Jack.hs
+++ /dev/null
@@ -1,67 +0,0 @@
-module Pandora.Paradigm.Basis.Jack (Jack (..), jack) where
-
-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))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-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 ((==)), Boolean (False))
-import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
-
-data Jack t a = It a | Other (t a)
-
-instance Covariant t => Covariant (Jack t) where
-	f <$> It x = It $ f x
-	f <$> Other y = Other $ f <$> y
-
-instance Covariant t => Pointable (Jack t) where
-	point = It
-
-instance Alternative t => Alternative (Jack t) where
-	It x <+> _ = It x
-	Other _ <+> It y = It y
-	Other x <+> Other y = Other (x <+> y)
-
-instance Avoidable t => Avoidable (Jack t) where
-	empty = Other empty
-
-instance Extractable t => Extractable (Jack t) where
-	extract (It x) = x
-	extract (Other y) = extract y
-
-instance Applicative t => Applicative (Jack t) where
-	It f <*> It x = It $ f x
-	It f <*> Other y = Other $ f <$> y
-	Other f <*> It x = Other $ ($ x) <$> f
-	Other f <*> Other y = Other $ f <*> y
-
-instance Traversable t => Traversable (Jack t) where
-	It x ->> f = It <$> f x
-	Other y ->> f = comap Other . traverse f $ y
-
-instance Distributive t => Distributive (Jack t) where
-	x >>- f = distribute $ f <$> x
-
-instance Liftable Jack where
-	lift = Other
-
-instance (Setoid a, Setoid (t a)) => Setoid (Jack t a) where
-	It x == It y = x == y
-	Other x == Other y = x == y
-	_ == _ = False
-
-instance (Chain a, Chain (t a)) => Chain (Jack t a) where
-	It _ <=> Other _ = Less
-	Other _ <=> It _ = Greater
-	It x <=> It y = x <=> y
-	Other x <=> Other y = x <=> y
-
-jack :: (a -> r) -> (t a -> r) -> Jack t a -> r
-jack f _ (It x) = f x
-jack _ g (Other y) = g y
diff --git a/Pandora/Paradigm/Basis/Jet.hs b/Pandora/Paradigm/Basis/Jet.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Jet.hs
+++ /dev/null
@@ -1,22 +0,0 @@
-module Pandora.Paradigm.Basis.Jet (Jet (..)) where
-
-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.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-
-data Jet t a = Jet a (Jet t (t a))
-
-instance Covariant t => Covariant (Jet t) where
-	f <$> Jet a as = Jet (f a) (f <$$> as)
-
-instance Traversable t => Traversable (Jet t) where
-	Jet a as ->> f = Jet <$> f a <*> as ->>> f
-
-instance (forall u . Avoidable u) => Pointable (Jet t) where
-	point x = Jet x empty
-
-instance Covariant t => Extractable (Jet t) where
-	extract (Jet x _) = x
diff --git a/Pandora/Paradigm/Basis/Kan.hs b/Pandora/Paradigm/Basis/Kan.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Kan.hs
+++ /dev/null
@@ -1,25 +0,0 @@
-module Pandora.Paradigm.Basis.Kan (Lan (..), Ran (..)) where
-
-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))
-
-newtype Lan t u b a = Lan ((t b -> a) -> u b)
-
-instance Contravariant (Lan t u b) where
-	f >$< Lan x = Lan $ x . (f .)
-
-instance Interpreted (Lan t u b) where
-	type Primary (Lan t u b) a = (t b -> a) -> u b
-	run (Lan x) = x
-
-newtype Ran t u b a = Ran ((a -> t b) -> u b)
-
-instance Covariant (Ran t u b) where
-	f <$> Ran x = Ran $ x . (. f)
-
-instance Interpreted (Ran t u b) where
-	type Primary (Ran t u b) a = (a -> t b) -> u b
-	run (Ran x) = x
diff --git a/Pandora/Paradigm/Basis/Maybe.hs b/Pandora/Paradigm/Basis/Maybe.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Maybe.hs
+++ /dev/null
@@ -1,117 +0,0 @@
-module Pandora.Paradigm.Basis.Maybe (Maybe (..), Optional, maybe, nothing) where
-
-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.Functor.Covariant (Covariant ((<$>), (<$$>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
-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 ((==)), Boolean (True, False))
-import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Equal, Greater))
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
-import Pandora.Pattern.Object.Lattice (Lattice)
-
-data Maybe a = Nothing | Just a
-
-instance Covariant Maybe where
-	f <$> Just x = Just $ f x
-	_ <$> Nothing = Nothing
-
-instance Pointable Maybe where
-	point = Just
-
-instance Avoidable Maybe where
-	empty = Nothing
-
-instance Applicative Maybe where
-	Just f <*> x = f <$> x
-	Nothing <*> _ = Nothing
-
-instance Alternative Maybe where
-	Nothing <+> y = y
-	Just x <+> _ = Just x
-
-instance Traversable Maybe where
-	Nothing ->> _ = point Nothing
-	Just x ->> f = Just <$> f x
-
-instance Bindable Maybe where
-	Just x >>= f = f x
-	Nothing >>= _ = Nothing
-
-instance Monad Maybe where
-
-instance Setoid a => Setoid (Maybe a) where
-	Just x == Just y = x == y
-	Nothing == Nothing = True
-	_ == _ = False
-
-instance Chain a => Chain (Maybe a) where
-	Just x <=> Just y = x <=> y
-	Nothing <=> Nothing = Equal
-	Nothing <=> Just _ = Less
-	Just _ <=> Nothing = Greater
-
-instance Semigroup a => Semigroup (Maybe a) where
-	Just x + Just y = Just $ x + y
-	Nothing + x = x
-	x + Nothing = x
-
-instance Semigroup a => Monoid (Maybe a) where
-	zero = Nothing
-
-instance Infimum a => Infimum (Maybe a) where
-	Just x /\ Just y = Just $ x /\ y
-	_ /\ Nothing = Nothing
-	Nothing /\ _ = Nothing
-
-instance Supremum a => Supremum (Maybe a) where
-	Just x \/ Just y = Just $ x \/ y
-	x \/ Nothing = x
-	Nothing \/ x = x
-
-instance Lattice a => Lattice (Maybe a) where
-
-maybe :: b -> (a -> b) -> Maybe a -> b
-maybe x _ Nothing = x
-maybe _ f (Just y) = f y
-
-type instance Schematic Monad Maybe u = UT Covariant Covariant Maybe u
-
-instance Interpreted Maybe where
-	type Primary Maybe a = Maybe a
-	run x = x
-
-instance Monadic Maybe where
-	lay x = TM . UT $ Just <$> x
-	wrap x = TM . UT . point $ x
-
-type Optional = Adaptable Maybe
-
-instance Covariant u => Covariant (UT Covariant Covariant Maybe u) where
-	f <$> UT x = UT $ f <$$> x
-
-instance Applicative u => Applicative (UT Covariant Covariant Maybe u) where
-	UT f <*> UT x = UT $ apply <$> f <*> x
-
-instance Pointable u => Pointable (UT Covariant Covariant Maybe u) where
-	point = UT . point . point
-
-instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant Maybe u) where
-	UT x >>= f = UT $ x >>= maybe (point Nothing) (run . f)
-
-instance Monad u => Monad (UT Covariant Covariant Maybe u) where
-
-nothing :: Optional t => t a
-nothing = adapt Nothing
diff --git a/Pandora/Paradigm/Basis/Predicate.hs b/Pandora/Paradigm/Basis/Predicate.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Predicate.hs
+++ /dev/null
@@ -1,16 +0,0 @@
-module Pandora.Paradigm.Basis.Predicate (Predicate (..)) where
-
-import Pandora.Core.Morphism ((!))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Determinable (Determinable (determine))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Object.Setoid (Boolean (True))
-
-newtype Predicate a = Predicate { predicate :: a -> Boolean }
-
-instance Contravariant Predicate where
-	f >$< g = Predicate $ predicate g . f
-
-instance Determinable Predicate where
-	determine = Predicate (True !)
diff --git a/Pandora/Paradigm/Basis/Product.hs b/Pandora/Paradigm/Basis/Product.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Product.hs
+++ /dev/null
@@ -1,87 +0,0 @@
-module Pandora.Paradigm.Basis.Product (Product (..), type (:*:)
-	, delta, swap, attached, curry, uncurry) where
-
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Object.Setoid (Setoid ((==)))
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Pattern.Object.Quasiring (Quasiring (one))
-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
-import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (invert))
-
-infixr 1 :*:
-
-data Product a b = a :*: b
-
-type (:*:) = Product
-
-instance Covariant (Product a) where
-	f <$> (x :*: y) = x :*: f y
-
-instance Extractable (Product a) where
-	extract (_ :*: y) = y
-
-instance Traversable (Product a) where
-	(x :*: y) ->> f = (:*:) x <$> f y
-
-instance Extendable (Product a) where
-	(x :*: y) =>> f = (:*:) x $ f (x :*: y)
-
-instance Comonad (Product a) where
-
-instance Adjoint (Product a) ((->) a) where
-	x -| f = \y -> f $ y :*: x
-	(y :*: x) |- f = f x y
-
-instance Bivariant Product where
-	f <-> g = \(x :*: y) -> f x :*: g y
-
-instance (Setoid a, Setoid b) => Setoid (Product a b) where
-	(x :*: y) == (x' :*: y') = (x == x') * (y == y')
-
-instance (Semigroup a, Semigroup b) => Semigroup (Product a b) where
-	(x :*: y) + (x' :*: y') = x + x' :*: y + y'
-
-instance (Monoid a, Monoid b) => Monoid (Product a b) where
-	zero = zero :*: zero
-
-instance (Ringoid a, Ringoid b) => Ringoid (Product a b) where
-	(x :*: y) * (x' :*: y') = x * x' :*: y * y'
-
-instance (Quasiring a, Quasiring b) => Quasiring (Product a b) where
-	one = one :*: one
-
-instance (Infimum a, Infimum b) => Infimum (Product a b) where
-	(x :*: y) /\ (x' :*: y') = x /\ x' :*: y /\ y'
-
-instance (Supremum a, Supremum b) => Supremum (Product a b) where
-	(x :*: y) \/ (x' :*: y') = x \/ x' :*: y \/ y'
-
-instance (Lattice a, Lattice b) => Lattice (Product a b) where
-
-instance (Group a, Group b) => Group (Product a b) where
-	invert (x :*: y) = invert x :*: invert y
-
-delta :: a -> a :*: a
-delta x = x :*: x
-
-swap :: a :*: b -> b :*: a
-swap (x :*: y) = y :*: x
-
-attached :: a :*: b -> a
-attached (x :*: _) = x
-
-curry :: (a :*: b -> c) -> a -> b -> c
-curry f x y = f $ x :*: y
-
-uncurry :: (a -> b -> c) -> (a :*: b -> c)
-uncurry f (x :*: y) = f x y
diff --git a/Pandora/Paradigm/Basis/Proxy.hs b/Pandora/Paradigm/Basis/Proxy.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Proxy.hs
+++ /dev/null
@@ -1,39 +0,0 @@
-module Pandora.Paradigm.Basis.Proxy where
-
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Monad (Monad)
-
-data Proxy a = Proxy
-
-instance Covariant Proxy where
-	_ <$> Proxy = Proxy
-
-instance Contravariant Proxy where
-	_ >$< _ = Proxy
-
-instance Pointable Proxy where
-	point _ = Proxy
-
-instance Applicative Proxy where
-	_ <*> _ = Proxy
-
-instance Alternative Proxy where
-	_ <+> _ = Proxy
-
-instance Distributive Proxy where
-	_ >>- _ = Proxy
-
-instance Bindable Proxy where
-	_ >>= _ = Proxy
-
-instance Monad Proxy
-
-instance Extendable Proxy where
-	_ =>> _ = Proxy
diff --git a/Pandora/Paradigm/Basis/Tagged.hs b/Pandora/Paradigm/Basis/Tagged.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Tagged.hs
+++ /dev/null
@@ -1,96 +0,0 @@
-module Pandora.Paradigm.Basis.Tagged (Tagged (..), retag, tagself, type (:#)) where
-
-import Pandora.Core.Functor (type (|->), type (~>))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-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 ((+)))
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Pattern.Object.Quasiring (Quasiring (one))
-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
-import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (invert))
-
-newtype Tagged tag a = Tag a
-
-infixr 0 :#
-type (:#) tag = Tagged tag
-
-instance Covariant (Tagged tag) where
-	f <$> Tag x = Tag $ f x
-
-instance Pointable (Tagged tag) where
-	point = Tag
-
-instance Extractable (Tagged tag) where
-	extract (Tag x) = x
-
-instance Applicative (Tagged tag) where
-	Tag f <*> Tag x = Tag $ f x
-
-instance Traversable (Tagged tag) where
-	Tag x ->> f = Tag <$> f x
-
-instance Distributive (Tagged tag) where
-	x >>- f = Tag $ extract . f <$> x
-
-instance Bindable (Tagged tag) where
-	Tag x >>= f = f x
-
-instance Monad (Tagged tag)
-
-instance Extendable (Tagged tag) where
-	x =>> f = Tag . f $ x
-
-instance Comonad (Tagged tag)
-
-instance Bivariant Tagged where
-	_ <-> g = \(Tag x) -> Tag $ g x
-
-instance Setoid a => Setoid (Tagged tag a) where
-	Tag x == Tag y = x == y
-
-instance Chain a => Chain (Tagged tag a) where
-	Tag x <=> Tag y = x <=> y
-
-instance Semigroup a => Semigroup (Tagged tag a) where
-	Tag x + Tag y = Tag $ x + y
-
-instance Monoid a => Monoid (Tagged tag a) where
-	 zero = Tag zero
-
-instance Ringoid a => Ringoid (Tagged tag a) where
-	Tag x * Tag y = Tag $ x * y
-
-instance Quasiring a => Quasiring (Tagged tag a) where
-	one = Tag one
-
-instance Infimum a => Infimum (Tagged tag a) where
-	Tag x /\ Tag y = Tag $ x /\ y
-
-instance Supremum a => Supremum (Tagged tag a) where
-	Tag x \/ Tag y = Tag $ x \/ y
-
-instance Lattice a => Lattice (Tagged tag a) where
-
-instance Group a => Group (Tagged tag a) where
-	invert (Tag x) = Tag $ invert x
-
-retag :: Tagged old ~> Tagged new
-retag (Tag x) = Tag x
-
-tagself :: a |-> Tagged a
-tagself = Tag
diff --git a/Pandora/Paradigm/Basis/Twister.hs b/Pandora/Paradigm/Basis/Twister.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Twister.hs
+++ /dev/null
@@ -1,68 +0,0 @@
-module Pandora.Paradigm.Basis.Twister (Twister (..), untwist, coiterate, section) where
-
-import Pandora.Core.Functor (type (:.), type (:=), type (|->), type (~>))
-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.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend))
-import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-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))
-
-data Twister t a = Twister a (t :. Twister t := a)
-
-instance Covariant t => Covariant (Twister t) where
-	f <$> Twister x xs = Twister (f x) $ f <$$> xs
-
-instance Avoidable t => Pointable (Twister t) where
-	point x = Twister x empty
-
-instance Covariant t => Extractable (Twister t) where
-	extract (Twister x _) = x
-
-instance Applicative t => Applicative (Twister t) where
-	Twister f fs <*> Twister x xs = Twister (f x) $ fs <**> xs
-
-instance Traversable t => Traversable (Twister t) where
-	Twister x xs ->> f = Twister <$> f x <*> xs ->>> f
-
-instance Alternative t => Bindable (Twister t) where
-	Twister x xs >>= f = case f x of Twister y ys -> Twister y $ ys <+> (>>= f) <$> xs
-
-instance Covariant t => Extendable (Twister t) where
-	x =>> f = Twister (f x) $ extend f <$> untwist x
-
-instance (Avoidable t, Alternative t) => Monad (Twister t) where
-
-instance Covariant t => Comonad (Twister t) where
-
-instance Lowerable Twister where
-	lower (Twister _ xs) = extract <$> xs
-
-instance (Setoid a, forall b . Setoid b => Setoid (t b)) => Setoid (Twister t a) where
-	Twister x xs == Twister y ys = (x == y) * (xs == ys)
-
-instance (Semigroup a, forall b . Semigroup b => Semigroup (t b)) => Semigroup (Twister t a) where
-	Twister x xs + Twister y ys = Twister (x + y) $ xs + ys
-
-instance (Monoid a, forall b . Semigroup b => Monoid (t b)) => Monoid (Twister t a) where
-	zero = Twister zero zero
-
-untwist :: Twister t a -> (t :. Twister t) a
-untwist (Twister _ xs) = xs
-
-coiterate :: Covariant t => a |-> t -> a |-> Twister t
-coiterate coalgebra x = Twister x $ coiterate coalgebra <$> coalgebra x
-
-section :: Comonad t => t ~> Twister t
-section as = Twister (extract as) $ extend section as
diff --git a/Pandora/Paradigm/Basis/Validation.hs b/Pandora/Paradigm/Basis/Validation.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Validation.hs
+++ /dev/null
@@ -1,60 +0,0 @@
-module Pandora.Paradigm.Basis.Validation (Validation (..)) 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.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 ((==)), Boolean (False))
-import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-
-data Validation e a = Flaws e | Validated a
-
-instance Covariant (Validation e) where
-	_ <$> Flaws e = Flaws e
-	f <$> Validated x = Validated $ f x
-
-instance Pointable (Validation e) where
-	point = Validated
-
-instance Semigroup e => Applicative (Validation e) where
-	Flaws e <*> Flaws e' = Flaws $ e + e'
-	Flaws e <*> Validated _ = Flaws e
-	Validated _ <*> Flaws e' = Flaws e'
-	Validated f <*> Validated x = Validated $ f x
-
-instance Alternative (Validation e) where
-	Flaws _ <+> x = x
-	Validated x <+> _ = Validated x
-
-instance Traversable (Validation e) where
-	Validated x ->> f = Validated <$> f x
-	Flaws e ->> _ = point $ Flaws e
-
-instance Bivariant Validation where
-    f <-> g = validation (Flaws . f) (Validated . g)
-
-instance (Setoid e, Setoid a) => Setoid (Validation e a) where
-	Validated x == Validated y = x == y
-	Flaws x == Flaws y = x == y
-	_ == _ = False
-
-instance (Chain e, Chain a) => Chain (Validation e a) where
-	Validated x <=> Validated y = x <=> y
-	Flaws x <=> Flaws y = x <=> y
-	Flaws _ <=> Validated _ = Less
-	Validated _ <=> Flaws _ = Greater
-
-instance (Semigroup e, Semigroup a) => Semigroup (Validation e a) where
-	Validated x + Validated y = Validated $ x + y
-	Flaws x + Flaws y = Flaws $ x + y
-	Flaws _ + Validated y = Validated y
-	Validated x + Flaws _ = Validated x
-
-validation :: (e -> r) -> (a -> r) -> Validation e a -> r
-validation f _ (Flaws x) = f x
-validation _ s (Validated x) = s x
diff --git a/Pandora/Paradigm/Basis/Variation.hs b/Pandora/Paradigm/Basis/Variation.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Variation.hs
+++ /dev/null
@@ -1,26 +0,0 @@
-module Pandora.Paradigm.Basis.Variation (Variation (..), variation) where
-
-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 Variation e a = This a | That e | These e a
-
-instance Covariant (Variation e) where
-	f <$> This x = This $ f x
-	_ <$> That y = That y
-	f <$> These y x = These y (f x)
-
-instance Pointable (Variation e) where
-	point = This
-
-instance Traversable (Variation e) where
-	This x ->> f = This <$> f x
-	That y ->> _ = point $ That y
-	These y x ->> f = These y <$> f x
-
-variation :: (a -> r) -> (e -> r) -> (e -> a -> r) -> Variation e a -> r
-variation f _ _ (This x) = f x
-variation _ g _ (That y) = g y
-variation _ _ h (These y x) = h y x
diff --git a/Pandora/Paradigm/Basis/Wye.hs b/Pandora/Paradigm/Basis/Wye.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Wye.hs
+++ /dev/null
@@ -1,27 +0,0 @@
-module Pandora.Paradigm.Basis.Wye (Wye (..), wye) where
-
-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
-
-instance Covariant Wye where
-	_ <$> End = End
-	f <$> Left x = Left $ f x
-	f <$> Right y = Right $ f y
-	f <$> Both x y = Both (f x) (f y)
-
-instance Traversable Wye where
-	End ->> _ = point End
-	Left x ->> f = Left <$> f x
-	Right y ->> f = Right <$> f y
-	Both x y ->> f = Both <$> f x <*> f y
-
-wye :: r -> (a -> r) -> (a -> r) -> (a -> a -> r) -> Wye a -> r
-wye r _ _ _ End = r
-wye _ f _ _ (Left x) = f x
-wye _ _ g _ (Right y) = g y
-wye _ _ _ h (Both x y) = h x y
diff --git a/Pandora/Paradigm/Basis/Yoneda.hs b/Pandora/Paradigm/Basis/Yoneda.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Yoneda.hs
+++ /dev/null
@@ -1,41 +0,0 @@
-module Pandora.Paradigm.Basis.Yoneda (Yoneda (..)) where
-
-import Pandora.Core.Morphism ((!))
-import Pandora.Pattern.Category (identity, (.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-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.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 }
-
-instance Covariant (Yoneda t) where
-	f <$> x = Yoneda (\k -> yoneda x (k . f))
-
-instance Alternative t => Alternative (Yoneda t) where
-	Yoneda f <+> Yoneda g = Yoneda (\k -> f k <+> g k)
-
-instance Applicative t => Applicative (Yoneda t) where
-	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)
-
-instance Avoidable t => Avoidable (Yoneda t) where
-	empty = Yoneda (empty !)
-
-instance Pointable t => Pointable (Yoneda t) where
-	point x = Yoneda (\f -> point $ f x)
-
-instance Extractable t => Extractable (Yoneda t) where
-	extract (Yoneda f) = extract $ f identity
-
-instance Liftable Yoneda where
-	lift x = Yoneda (\f -> f <$> x)
-
-instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where
-	x -| f = point . f . point $ x
-	x |- g = extract . extract $ g <$> x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes.hs
@@ -1,3 +1,5 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
 module Pandora.Paradigm.Controlflow.Joint.Schemes (module Exports) where
 
 import Pandora.Paradigm.Controlflow.Joint.Schemes.UTU as Exports
@@ -5,3 +7,35 @@
 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/TUT.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
@@ -1,6 +1,16 @@
 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)
@@ -8,3 +18,11 @@
 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/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
@@ -3,8 +3,6 @@
 module Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (..), (:<) (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -17,6 +15,8 @@
 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 #-}
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
@@ -3,8 +3,6 @@
 module Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (..), (:>) (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -17,6 +15,8 @@
 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 #-}
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
@@ -2,9 +2,9 @@
 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where
 
 import Pandora.Pattern.Category ((.))
-import Pandora.Paradigm.Basis.Continuation (Continuation (Continuation, continue))
 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,11 +1,11 @@
 module Pandora.Paradigm.Controlflow.Pipeline (Pipeline, await, yield, finish, impact, (=*=), pipeline) where
 
-import Pandora.Paradigm.Basis.Continuation (Continuation (Continuation, continue))
 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
@@ -1,3 +1,5 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
 module Pandora.Paradigm.Inventory (module Exports) where
 
 import Pandora.Paradigm.Inventory.Optics as Exports
@@ -7,3 +9,23 @@
 import Pandora.Paradigm.Inventory.Equipment as Exports
 import Pandora.Paradigm.Inventory.Environment as Exports
 import Pandora.Paradigm.Inventory.Accumulator as Exports
+
+import Pandora.Core.Morphism ((!), (%))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Extractable (extract)
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
+
+instance Adjoint (Store s) (State s) where
+	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !)
+	Store (s :*: f) |- g = extract . run % s . g $ f s
+
+instance Adjoint (Accumulator e) (Imprint e) where
+	x -| f = Imprint $ x -| f . Accumulator
+	x |- g = run x |- run . g
+
+instance Adjoint (Equipment e) (Environment e) where
+	x -| f = Environment $ x -| f . Equipment
+	x |- g = run x |- run . g
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,7 +2,7 @@
 
 module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where
 
-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))
+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)
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,7 +2,7 @@
 
 module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where
 
-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached)
+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))
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,22 +3,15 @@
 module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, zoom, (^.), (.~), (%~)) where
 
 import Pandora.Core.Functor (type (|->))
-import Pandora.Core.Morphism ((!), (%))
-import Pandora.Paradigm.Basis.Product (Product ((:*:)))
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (adapt)
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (run))
 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.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Functor.Bivariant ((<->))
-
-instance Adjoint (Store s) (State s) where
-	v -| f = State $ \s -> (:*:) s . f . Store $ s :*: (v !)
-	Store (s :*: f) |- g = extract . run % s . g $ f s
 
 infixr 0 :-.
 type (:-.) src tgt = Lens src tgt
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
@@ -6,7 +6,7 @@
 import Pandora.Core.Morphism ((%))
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))
@@ -14,6 +14,7 @@
 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.Pattern.Object.Setoid (bool)
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
@@ -21,8 +22,8 @@
 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.Paradigm.Basis.Predicate (Predicate (predicate))
-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)
+import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (predicate))
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), delta)
 
 newtype State s a = State ((->) s :. (:*:) s := a)
 
@@ -31,15 +32,14 @@
 
 instance Applicative (State s) where
 	State f <*> State x = State $ \old ->
-		let latest = attached . x $ old in
-			latest :*: (extract (f old) . extract . x $ old)
+		let (new :*: g) = f old in g <$> x new
 
 instance Pointable (State s) where
 	point x = State $ \s -> s :*: x
 
 instance Bindable (State s) where
 	State x >>= f = State $ \old ->
-		uncurry (run %) $ f <$> x old
+		(|- run) $ f <$> x old
 
 instance Monad (State s) where
 
diff --git a/Pandora/Paradigm/Inventory/Store.hs b/Pandora/Paradigm/Inventory/Store.hs
--- a/Pandora/Paradigm/Inventory/Store.hs
+++ b/Pandora/Paradigm/Inventory/Store.hs
@@ -10,7 +10,7 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached)
+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)
diff --git a/Pandora/Paradigm/Primary.hs b/Pandora/Paradigm/Primary.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary.hs
@@ -0,0 +1,4 @@
+module Pandora.Paradigm.Primary (module Exports) where
+
+import Pandora.Paradigm.Primary.Functor as Exports
+import Pandora.Paradigm.Primary.Transformer as Exports
diff --git a/Pandora/Paradigm/Primary/Functor.hs b/Pandora/Paradigm/Primary/Functor.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor.hs
@@ -0,0 +1,47 @@
+module Pandora.Paradigm.Primary.Functor (module Exports, note, hush, left, right, this, that) where
+
+import Pandora.Paradigm.Primary.Functor.Fix as Exports
+import Pandora.Paradigm.Primary.Functor.Predicate as Exports
+import Pandora.Paradigm.Primary.Functor.Variation as Exports
+import Pandora.Paradigm.Primary.Functor.Validation as Exports
+import Pandora.Paradigm.Primary.Functor.Wye as Exports
+import Pandora.Paradigm.Primary.Functor.Edges as Exports
+import Pandora.Paradigm.Primary.Functor.Conclusion as Exports
+import Pandora.Paradigm.Primary.Functor.Maybe as Exports
+import Pandora.Paradigm.Primary.Functor.Endo as Exports
+import Pandora.Paradigm.Primary.Functor.Proxy as Exports
+import Pandora.Paradigm.Primary.Functor.Tagged as Exports
+import Pandora.Paradigm.Primary.Functor.Product as Exports
+import Pandora.Paradigm.Primary.Functor.Constant as Exports
+import Pandora.Paradigm.Primary.Functor.Identity as Exports
+
+import Pandora.Core.Morphism ((!))
+import Pandora.Core.Functor (type (~>))
+
+note :: e -> Maybe ~> Conclusion e
+note x = maybe (Failure x) Success
+
+hush :: Conclusion e ~> Maybe
+hush = conclusion (Nothing !) Just
+
+left :: Wye ~> Maybe
+left (Both ls _) = Just ls
+left (Left ls) = Just ls
+left (Right _) = Nothing
+left End = Nothing
+
+right :: Wye ~> Maybe
+right (Both _ rs) = Just rs
+right (Left _) = Nothing
+right (Right rs) = Just rs
+right End = Nothing
+
+this :: Variation e ~> Maybe
+this (This x) = Just x
+this (That _) = Nothing
+this (These _ x) = Just x
+
+that :: Variation e a -> Maybe e
+that (This _) = Nothing
+that (That x) = Just x
+that (These y _) = Just y
diff --git a/Pandora/Paradigm/Primary/Functor/Conclusion.hs b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
@@ -0,0 +1,105 @@
+module Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where
+
+import Pandora.Core.Functor (type (~>))
+import Pandora.Pattern.Category ((.))
+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.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+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 ((==)), Boolean (False))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+
+data Conclusion e a = Failure e | Success a
+
+instance Covariant (Conclusion e) where
+	f <$> Success x = Success $ f x
+	_ <$> Failure y = Failure y
+
+instance Pointable (Conclusion e) where
+	point = Success
+
+instance Applicative (Conclusion e) where
+	Success f <*> x = f <$> x
+	Failure y <*> _ = Failure y
+
+instance Alternative (Conclusion e) where
+	Failure _ <+> x = x
+	Success x <+> _ = Success x
+
+instance Traversable (Conclusion e) where
+	Failure y ->> _ = point $ Failure y
+	Success x ->> f = Success <$> f x
+
+instance Bindable (Conclusion e) where
+	Success x >>= f = f x
+	Failure y >>= _ = Failure y
+
+instance Monad (Conclusion e) where
+
+instance Bivariant Conclusion where
+    f <-> g = conclusion (Failure . f) (Success . g)
+
+instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where
+	Success x == Success y = x == y
+	Failure x == Failure y = x == y
+	_ == _ = False
+
+instance (Chain e, Chain a) => Chain (Conclusion e a) where
+	Success x <=> Success y = x <=> y
+	Failure x <=> Failure y = x <=> y
+	Failure _ <=> Success _ = Less
+	Success _ <=> Failure _ = Greater
+
+instance (Semigroup e, Semigroup a) => Semigroup (Conclusion e a) where
+	Success x + Success y = Success $ x + y
+	Failure x + Failure y = Failure $ x + y
+	Failure _ + Success y = Success y
+	Success x + Failure _ = Success x
+
+conclusion :: (e -> r) -> (a -> r) -> Conclusion e a -> r
+conclusion f _ (Failure x) = f x
+conclusion _ s (Success x) = s x
+
+fail :: (e -> r) -> Conclusion e ~> Conclusion r
+fail f (Failure x) = Failure $ f x
+fail _ (Success y) = Success y
+
+instance Interpreted (Conclusion e) where
+	type Primary (Conclusion e) a = Conclusion e a
+	run x = x
+
+type instance Schematic Monad (Conclusion e) u = UT Covariant Covariant (Conclusion e) u
+
+instance Monadic (Conclusion e) where
+	lay x = TM . UT $ Success <$> x
+	wrap x = TM . UT . point $ x
+
+type Failable e = Adaptable (Conclusion e)
+
+instance Covariant u => Covariant (UT Covariant Covariant (Conclusion e) u) where
+	f <$> UT x = UT $ f <$$> x
+
+instance Applicative u => Applicative (UT Covariant Covariant (Conclusion e) u) where
+	UT f <*> UT x = UT $ apply <$> f <*> x
+
+instance Pointable u => Pointable (UT Covariant Covariant (Conclusion e) u) where
+	point = UT . point . point
+
+instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant (Conclusion e) u) where
+	UT x >>= f = UT $ x >>= conclusion (point . Failure) (run . f)
+
+instance Monad u => Monad (UT Covariant Covariant (Conclusion e) u) where
+
+failure :: Failable e t => e -> t a
+failure = adapt . Failure
diff --git a/Pandora/Paradigm/Primary/Functor/Constant.hs b/Pandora/Paradigm/Primary/Functor/Constant.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Constant.hs
@@ -0,0 +1,64 @@
+module Pandora.Paradigm.Primary.Functor.Constant (Constant (..)) where
+
+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 ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
+import Pandora.Pattern.Object.Lattice (Lattice)
+import Pandora.Pattern.Object.Group (Group (invert))
+
+newtype Constant a b = Constant a
+
+instance Covariant (Constant a) where
+	_ <$> Constant x = Constant x
+
+instance Contravariant (Constant a) where
+	_ >$< Constant x = Constant x
+
+instance Invariant (Constant a) where
+	invmap _ _ (Constant x) = Constant x
+
+instance Traversable (Constant a) where
+	Constant x ->> _ = point (Constant x)
+
+instance Bivariant Constant where
+	f <-> _ = \(Constant x) -> Constant $ f x
+
+instance Setoid a => Setoid (Constant a b) where
+	Constant x == Constant y = x == y
+
+instance Chain a => Chain (Constant a b) where
+	Constant x <=> Constant y = x <=> y
+
+instance Semigroup a => Semigroup (Constant a b) where
+	Constant x + Constant y = Constant $ x + y
+
+instance Monoid a => Monoid (Constant a b) where
+	 zero = Constant zero
+
+instance Ringoid a => Ringoid (Constant a b) where
+	Constant x * Constant y = Constant $ x * y
+
+instance Quasiring a => Quasiring (Constant a b) where
+	 one = Constant one
+
+instance Infimum a => Infimum (Constant a b) where
+	Constant x /\ Constant y = Constant $ x /\ y
+
+instance Supremum a => Supremum (Constant a b) where
+	Constant x \/ Constant y = Constant $ x \/ y
+
+instance Lattice a => Lattice (Constant a b) where
+
+instance Group a => Group (Constant a b) where
+	invert (Constant x) = Constant $ invert x
diff --git a/Pandora/Paradigm/Primary/Functor/Edges.hs b/Pandora/Paradigm/Primary/Functor/Edges.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Edges.hs
@@ -0,0 +1,26 @@
+module Pandora.Paradigm.Primary.Functor.Edges (Edges (..), edges) where
+
+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
+
+instance Covariant Edges where
+	_ <$> Empty = Empty
+	f <$> Connect x = Connect $ f x
+	f <$> Overlay x = Overlay $ f x
+	f <$> Leap x = Leap $ f x
+
+instance Traversable Edges where
+	Empty ->> _ = point Empty
+	Connect x ->> f = Connect <$> f x
+	Overlay x ->> f = Overlay <$> f x
+	Leap x ->> f = Leap <$> f x
+
+edges :: r -> (a -> r) -> (a -> r) -> (a -> r) -> Edges a -> r
+edges r _ _ _ Empty = r
+edges _ f _ _ (Connect x) = f x
+edges _ _ g _ (Overlay y) = g y
+edges _ _ _ h (Leap z) = h z
diff --git a/Pandora/Paradigm/Primary/Functor/Endo.hs b/Pandora/Paradigm/Primary/Functor/Endo.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Endo.hs
@@ -0,0 +1,17 @@
+module Pandora.Paradigm.Primary.Functor.Endo (Endo (..)) where
+
+import Pandora.Pattern.Category (identity, (.))
+import Pandora.Pattern.Functor.Invariant (Invariant (invmap))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+
+newtype Endo a = Endo { endo :: a -> a }
+
+instance Invariant Endo where
+	invmap f g (Endo x) = Endo (f . x . g)
+
+instance Semigroup (Endo a) where
+	Endo f + Endo g = Endo (g . f)
+
+instance Monoid (Endo a) where
+	zero = Endo identity
diff --git a/Pandora/Paradigm/Primary/Functor/Fix.hs b/Pandora/Paradigm/Primary/Functor/Fix.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Fix.hs
@@ -0,0 +1,16 @@
+module Pandora.Paradigm.Primary.Functor.Fix (Fix (..), cata, ana, hylo) where
+
+import Pandora.Core.Functor (type (<-|), type (|->))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant (comap))
+
+newtype Fix t = Fix { unfix :: t (Fix t) }
+
+cata :: Covariant t => (a <-| t) -> Fix t -> a
+cata f = f . comap (cata f) . unfix
+
+ana :: Covariant t => (a |-> t) -> a -> Fix t
+ana f = Fix . comap (ana f) . f
+
+hylo :: Covariant t => (b <-| t) -> (a |-> t) -> (a -> b)
+hylo phi psi = cata phi . ana psi
diff --git a/Pandora/Paradigm/Primary/Functor/Identity.hs b/Pandora/Paradigm/Primary/Functor/Identity.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Identity.hs
@@ -0,0 +1,87 @@
+module Pandora.Paradigm.Primary.Functor.Identity (Identity (..)) where
+
+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))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor.Comonad (Comonad)
+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 ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
+import Pandora.Pattern.Object.Lattice (Lattice)
+import Pandora.Pattern.Object.Group (Group (invert))
+
+newtype Identity a = Identity a
+
+instance Covariant Identity where
+	f <$> Identity x = Identity $ f x
+
+instance Pointable Identity where
+	point = Identity
+
+instance Extractable Identity where
+	extract (Identity x) = x
+
+instance Applicative Identity where
+	Identity f <*> Identity x = Identity $ f x
+
+instance Traversable Identity where
+	Identity x ->> f = Identity <$> f x
+
+instance Distributive Identity where
+	x >>- f = Identity $ extract . f <$> x
+
+instance Bindable Identity where
+	Identity x >>= f = f x
+
+instance Monad Identity
+
+instance Extendable Identity where
+	x =>> f = Identity . f $ x
+
+instance Comonad Identity
+
+instance Adjoint Identity Identity where
+	x -| f = Identity . f . Identity $ x
+	x |- g = extract . extract . comap g $ x
+
+instance Setoid a => Setoid (Identity a) where
+	Identity x == Identity y = x == y
+
+instance Chain a => Chain (Identity a) where
+	Identity x <=> Identity y = x <=> y
+
+instance Semigroup a => Semigroup (Identity a) where
+	Identity x + Identity y = Identity $ x + y
+
+instance Monoid a => Monoid (Identity a) where
+	 zero = Identity zero
+
+instance Ringoid a => Ringoid (Identity a) where
+	Identity x * Identity y = Identity $ x * y
+
+instance Quasiring a => Quasiring (Identity a) where
+	 one = Identity one
+
+instance Infimum a => Infimum (Identity a) where
+	Identity x /\ Identity y = Identity $ x /\ y
+
+instance Supremum a => Supremum (Identity a) where
+	Identity x \/ Identity y = Identity $ x \/ y
+
+instance Lattice a => Lattice (Identity a) where
+
+instance Group a => Group (Identity a) where
+	invert (Identity x) = Identity $ invert x
diff --git a/Pandora/Paradigm/Primary/Functor/Maybe.hs b/Pandora/Paradigm/Primary/Functor/Maybe.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Maybe.hs
@@ -0,0 +1,117 @@
+module Pandora.Paradigm.Primary.Functor.Maybe (Maybe (..), Optional, maybe, nothing) where
+
+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.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
+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 ((==)), Boolean (True, False))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Equal, Greater))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
+import Pandora.Pattern.Object.Lattice (Lattice)
+
+data Maybe a = Nothing | Just a
+
+instance Covariant Maybe where
+	f <$> Just x = Just $ f x
+	_ <$> Nothing = Nothing
+
+instance Pointable Maybe where
+	point = Just
+
+instance Avoidable Maybe where
+	empty = Nothing
+
+instance Applicative Maybe where
+	Just f <*> x = f <$> x
+	Nothing <*> _ = Nothing
+
+instance Alternative Maybe where
+	Nothing <+> y = y
+	Just x <+> _ = Just x
+
+instance Traversable Maybe where
+	Nothing ->> _ = point Nothing
+	Just x ->> f = Just <$> f x
+
+instance Bindable Maybe where
+	Just x >>= f = f x
+	Nothing >>= _ = Nothing
+
+instance Monad Maybe where
+
+instance Setoid a => Setoid (Maybe a) where
+	Just x == Just y = x == y
+	Nothing == Nothing = True
+	_ == _ = False
+
+instance Chain a => Chain (Maybe a) where
+	Just x <=> Just y = x <=> y
+	Nothing <=> Nothing = Equal
+	Nothing <=> Just _ = Less
+	Just _ <=> Nothing = Greater
+
+instance Semigroup a => Semigroup (Maybe a) where
+	Just x + Just y = Just $ x + y
+	Nothing + x = x
+	x + Nothing = x
+
+instance Semigroup a => Monoid (Maybe a) where
+	zero = Nothing
+
+instance Infimum a => Infimum (Maybe a) where
+	Just x /\ Just y = Just $ x /\ y
+	_ /\ Nothing = Nothing
+	Nothing /\ _ = Nothing
+
+instance Supremum a => Supremum (Maybe a) where
+	Just x \/ Just y = Just $ x \/ y
+	x \/ Nothing = x
+	Nothing \/ x = x
+
+instance Lattice a => Lattice (Maybe a) where
+
+maybe :: b -> (a -> b) -> Maybe a -> b
+maybe x _ Nothing = x
+maybe _ f (Just y) = f y
+
+type instance Schematic Monad Maybe u = UT Covariant Covariant Maybe u
+
+instance Interpreted Maybe where
+	type Primary Maybe a = Maybe a
+	run x = x
+
+instance Monadic Maybe where
+	lay x = TM . UT $ Just <$> x
+	wrap x = TM . UT . point $ x
+
+type Optional = Adaptable Maybe
+
+instance Covariant u => Covariant (UT Covariant Covariant Maybe u) where
+	f <$> UT x = UT $ f <$$> x
+
+instance Applicative u => Applicative (UT Covariant Covariant Maybe u) where
+	UT f <*> UT x = UT $ apply <$> f <*> x
+
+instance Pointable u => Pointable (UT Covariant Covariant Maybe u) where
+	point = UT . point . point
+
+instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant Maybe u) where
+	UT x >>= f = UT $ x >>= maybe (point Nothing) (run . f)
+
+instance Monad u => Monad (UT Covariant Covariant Maybe u) where
+
+nothing :: Optional t => t a
+nothing = adapt Nothing
diff --git a/Pandora/Paradigm/Primary/Functor/Predicate.hs b/Pandora/Paradigm/Primary/Functor/Predicate.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Predicate.hs
@@ -0,0 +1,16 @@
+module Pandora.Paradigm.Primary.Functor.Predicate (Predicate (..)) where
+
+import Pandora.Core.Morphism ((!))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Determinable (Determinable (determine))
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Object.Setoid (Boolean (True))
+
+newtype Predicate a = Predicate { predicate :: a -> Boolean }
+
+instance Contravariant Predicate where
+	f >$< g = Predicate $ predicate g . f
+
+instance Determinable Predicate where
+	determine = Predicate (True !)
diff --git a/Pandora/Paradigm/Primary/Functor/Product.hs b/Pandora/Paradigm/Primary/Functor/Product.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Product.hs
@@ -0,0 +1,87 @@
+module Pandora.Paradigm.Primary.Functor.Product (Product (..), type (:*:)
+	, delta, swap, attached, curry, uncurry) where
+
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
+import Pandora.Pattern.Object.Lattice (Lattice)
+import Pandora.Pattern.Object.Group (Group (invert))
+
+infixr 1 :*:
+
+data Product a b = a :*: b
+
+type (:*:) = Product
+
+instance Covariant (Product a) where
+	f <$> (x :*: y) = x :*: f y
+
+instance Extractable (Product a) where
+	extract (_ :*: y) = y
+
+instance Traversable (Product a) where
+	(x :*: y) ->> f = (:*:) x <$> f y
+
+instance Extendable (Product a) where
+	(x :*: y) =>> f = (:*:) x $ f (x :*: y)
+
+instance Comonad (Product a) where
+
+instance Adjoint (Product a) ((->) a) where
+	x -| f = \y -> f $ y :*: x
+	(y :*: x) |- f = f x y
+
+instance Bivariant Product where
+	f <-> g = \(x :*: y) -> f x :*: g y
+
+instance (Setoid a, Setoid b) => Setoid (Product a b) where
+	(x :*: y) == (x' :*: y') = (x == x') * (y == y')
+
+instance (Semigroup a, Semigroup b) => Semigroup (Product a b) where
+	(x :*: y) + (x' :*: y') = x + x' :*: y + y'
+
+instance (Monoid a, Monoid b) => Monoid (Product a b) where
+	zero = zero :*: zero
+
+instance (Ringoid a, Ringoid b) => Ringoid (Product a b) where
+	(x :*: y) * (x' :*: y') = x * x' :*: y * y'
+
+instance (Quasiring a, Quasiring b) => Quasiring (Product a b) where
+	one = one :*: one
+
+instance (Infimum a, Infimum b) => Infimum (Product a b) where
+	(x :*: y) /\ (x' :*: y') = x /\ x' :*: y /\ y'
+
+instance (Supremum a, Supremum b) => Supremum (Product a b) where
+	(x :*: y) \/ (x' :*: y') = x \/ x' :*: y \/ y'
+
+instance (Lattice a, Lattice b) => Lattice (Product a b) where
+
+instance (Group a, Group b) => Group (Product a b) where
+	invert (x :*: y) = invert x :*: invert y
+
+delta :: a -> a :*: a
+delta x = x :*: x
+
+swap :: a :*: b -> b :*: a
+swap (x :*: y) = y :*: x
+
+attached :: a :*: b -> a
+attached (x :*: _) = x
+
+curry :: (a :*: b -> c) -> a -> b -> c
+curry f x y = f $ x :*: y
+
+uncurry :: (a -> b -> c) -> (a :*: b -> c)
+uncurry f (x :*: y) = f x y
diff --git a/Pandora/Paradigm/Primary/Functor/Proxy.hs b/Pandora/Paradigm/Primary/Functor/Proxy.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Proxy.hs
@@ -0,0 +1,39 @@
+module Pandora.Paradigm.Primary.Functor.Proxy where
+
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Monad (Monad)
+
+data Proxy a = Proxy
+
+instance Covariant Proxy where
+	_ <$> Proxy = Proxy
+
+instance Contravariant Proxy where
+	_ >$< _ = Proxy
+
+instance Pointable Proxy where
+	point _ = Proxy
+
+instance Applicative Proxy where
+	_ <*> _ = Proxy
+
+instance Alternative Proxy where
+	_ <+> _ = Proxy
+
+instance Distributive Proxy where
+	_ >>- _ = Proxy
+
+instance Bindable Proxy where
+	_ >>= _ = Proxy
+
+instance Monad Proxy
+
+instance Extendable Proxy where
+	_ =>> _ = Proxy
diff --git a/Pandora/Paradigm/Primary/Functor/Tagged.hs b/Pandora/Paradigm/Primary/Functor/Tagged.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Tagged.hs
@@ -0,0 +1,96 @@
+module Pandora.Paradigm.Primary.Functor.Tagged (Tagged (..), retag, tagself, type (:#)) where
+
+import Pandora.Core.Functor (type (|->), type (~>))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+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 ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
+import Pandora.Pattern.Object.Lattice (Lattice)
+import Pandora.Pattern.Object.Group (Group (invert))
+
+newtype Tagged tag a = Tag a
+
+infixr 0 :#
+type (:#) tag = Tagged tag
+
+instance Covariant (Tagged tag) where
+	f <$> Tag x = Tag $ f x
+
+instance Pointable (Tagged tag) where
+	point = Tag
+
+instance Extractable (Tagged tag) where
+	extract (Tag x) = x
+
+instance Applicative (Tagged tag) where
+	Tag f <*> Tag x = Tag $ f x
+
+instance Traversable (Tagged tag) where
+	Tag x ->> f = Tag <$> f x
+
+instance Distributive (Tagged tag) where
+	x >>- f = Tag $ extract . f <$> x
+
+instance Bindable (Tagged tag) where
+	Tag x >>= f = f x
+
+instance Monad (Tagged tag)
+
+instance Extendable (Tagged tag) where
+	x =>> f = Tag . f $ x
+
+instance Comonad (Tagged tag)
+
+instance Bivariant Tagged where
+	_ <-> g = \(Tag x) -> Tag $ g x
+
+instance Setoid a => Setoid (Tagged tag a) where
+	Tag x == Tag y = x == y
+
+instance Chain a => Chain (Tagged tag a) where
+	Tag x <=> Tag y = x <=> y
+
+instance Semigroup a => Semigroup (Tagged tag a) where
+	Tag x + Tag y = Tag $ x + y
+
+instance Monoid a => Monoid (Tagged tag a) where
+	 zero = Tag zero
+
+instance Ringoid a => Ringoid (Tagged tag a) where
+	Tag x * Tag y = Tag $ x * y
+
+instance Quasiring a => Quasiring (Tagged tag a) where
+	one = Tag one
+
+instance Infimum a => Infimum (Tagged tag a) where
+	Tag x /\ Tag y = Tag $ x /\ y
+
+instance Supremum a => Supremum (Tagged tag a) where
+	Tag x \/ Tag y = Tag $ x \/ y
+
+instance Lattice a => Lattice (Tagged tag a) where
+
+instance Group a => Group (Tagged tag a) where
+	invert (Tag x) = Tag $ invert x
+
+retag :: Tagged old ~> Tagged new
+retag (Tag x) = Tag x
+
+tagself :: a |-> Tagged a
+tagself = Tag
diff --git a/Pandora/Paradigm/Primary/Functor/Validation.hs b/Pandora/Paradigm/Primary/Functor/Validation.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Validation.hs
@@ -0,0 +1,60 @@
+module Pandora.Paradigm.Primary.Functor.Validation (Validation (..)) 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.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 ((==)), Boolean (False))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+
+data Validation e a = Flaws e | Validated a
+
+instance Covariant (Validation e) where
+	_ <$> Flaws e = Flaws e
+	f <$> Validated x = Validated $ f x
+
+instance Pointable (Validation e) where
+	point = Validated
+
+instance Semigroup e => Applicative (Validation e) where
+	Flaws e <*> Flaws e' = Flaws $ e + e'
+	Flaws e <*> Validated _ = Flaws e
+	Validated _ <*> Flaws e' = Flaws e'
+	Validated f <*> Validated x = Validated $ f x
+
+instance Alternative (Validation e) where
+	Flaws _ <+> x = x
+	Validated x <+> _ = Validated x
+
+instance Traversable (Validation e) where
+	Validated x ->> f = Validated <$> f x
+	Flaws e ->> _ = point $ Flaws e
+
+instance Bivariant Validation where
+    f <-> g = validation (Flaws . f) (Validated . g)
+
+instance (Setoid e, Setoid a) => Setoid (Validation e a) where
+	Validated x == Validated y = x == y
+	Flaws x == Flaws y = x == y
+	_ == _ = False
+
+instance (Chain e, Chain a) => Chain (Validation e a) where
+	Validated x <=> Validated y = x <=> y
+	Flaws x <=> Flaws y = x <=> y
+	Flaws _ <=> Validated _ = Less
+	Validated _ <=> Flaws _ = Greater
+
+instance (Semigroup e, Semigroup a) => Semigroup (Validation e a) where
+	Validated x + Validated y = Validated $ x + y
+	Flaws x + Flaws y = Flaws $ x + y
+	Flaws _ + Validated y = Validated y
+	Validated x + Flaws _ = Validated x
+
+validation :: (e -> r) -> (a -> r) -> Validation e a -> r
+validation f _ (Flaws x) = f x
+validation _ s (Validated x) = s x
diff --git a/Pandora/Paradigm/Primary/Functor/Variation.hs b/Pandora/Paradigm/Primary/Functor/Variation.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Variation.hs
@@ -0,0 +1,26 @@
+module Pandora.Paradigm.Primary.Functor.Variation (Variation (..), variation) where
+
+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 Variation e a = This a | That e | These e a
+
+instance Covariant (Variation e) where
+	f <$> This x = This $ f x
+	_ <$> That y = That y
+	f <$> These y x = These y (f x)
+
+instance Pointable (Variation e) where
+	point = This
+
+instance Traversable (Variation e) where
+	This x ->> f = This <$> f x
+	That y ->> _ = point $ That y
+	These y x ->> f = These y <$> f x
+
+variation :: (a -> r) -> (e -> r) -> (e -> a -> r) -> Variation e a -> r
+variation f _ _ (This x) = f x
+variation _ g _ (That y) = g y
+variation _ _ h (These y x) = h y x
diff --git a/Pandora/Paradigm/Primary/Functor/Wye.hs b/Pandora/Paradigm/Primary/Functor/Wye.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Functor/Wye.hs
@@ -0,0 +1,27 @@
+module Pandora.Paradigm.Primary.Functor.Wye (Wye (..), wye) where
+
+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
+
+instance Covariant Wye where
+	_ <$> End = End
+	f <$> Left x = Left $ f x
+	f <$> Right y = Right $ f y
+	f <$> Both x y = Both (f x) (f y)
+
+instance Traversable Wye where
+	End ->> _ = point End
+	Left x ->> f = Left <$> f x
+	Right y ->> f = Right <$> f y
+	Both x y ->> f = Both <$> f x <*> f y
+
+wye :: r -> (a -> r) -> (a -> r) -> (a -> a -> r) -> Wye a -> r
+wye r _ _ _ End = r
+wye _ f _ _ (Left x) = f x
+wye _ _ g _ (Right y) = g y
+wye _ _ _ h (Both x y) = h x y
diff --git a/Pandora/Paradigm/Primary/Transformer.hs b/Pandora/Paradigm/Primary/Transformer.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer.hs
@@ -0,0 +1,11 @@
+module Pandora.Paradigm.Primary.Transformer (module Exports) where
+
+import Pandora.Paradigm.Primary.Transformer.Yoneda 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
+import Pandora.Paradigm.Primary.Transformer.Jack as Exports
+import Pandora.Paradigm.Primary.Transformer.Instruction as Exports
+import Pandora.Paradigm.Primary.Transformer.Construction as Exports
+import Pandora.Paradigm.Primary.Transformer.Reverse as Exports
+import Pandora.Paradigm.Primary.Transformer.Backwards as Exports
diff --git a/Pandora/Paradigm/Primary/Transformer/Backwards.hs b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
@@ -0,0 +1,52 @@
+module Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (..)) where
+
+import Pandora.Core.Morphism ((&))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+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))
+
+newtype Backwards t a = Backwards (t a)
+
+instance Covariant t => Covariant (Backwards t) where
+	f <$> Backwards x = Backwards $ f <$> x
+
+instance Pointable t => Pointable (Backwards t) where
+	point = Backwards . point
+
+instance Extractable t => Extractable (Backwards t) where
+	extract (Backwards x) = extract x
+
+instance Applicative t => Applicative (Backwards t) where
+	Backwards f <*> Backwards x = Backwards ((&) <$> x <*> f)
+
+instance Traversable t => Traversable (Backwards t) where
+	Backwards x ->> f = Backwards <$> x ->> f
+
+instance Distributive t => Distributive (Backwards t) where
+	x >>- f = Backwards $ x >>- run . f
+
+instance Contravariant t => Contravariant (Backwards t) where
+	f >$< Backwards x = Backwards $ f >$< x
+
+instance Interpreted (Backwards t) where
+	type Primary (Backwards t) a = t a
+	run (Backwards x) = x
+
+instance Liftable Backwards where
+	lift = Backwards
+
+instance Lowerable Backwards where
+	lower = run
+
+instance Hoistable Backwards where
+	hoist f (Backwards x) = Backwards $ f x
diff --git a/Pandora/Paradigm/Primary/Transformer/Construction.hs b/Pandora/Paradigm/Primary/Transformer/Construction.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Construction.hs
@@ -0,0 +1,88 @@
+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.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.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend))
+import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+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))
+
+data Construction t a = Construct a (t :. Construction t := a)
+
+instance Covariant t => Covariant (Construction t) where
+	f <$> Construct x xs = Construct (f x) $ f <$$> xs
+
+instance Avoidable t => Pointable (Construction t) where
+	point x = Construct x empty
+
+instance Covariant t => Extractable (Construction t) where
+	extract (Construct x _) = x
+
+instance Applicative t => Applicative (Construction t) where
+	Construct f fs <*> Construct x xs = Construct (f x) $ fs <**> xs
+
+instance Traversable t => Traversable (Construction t) where
+	Construct x xs ->> f = Construct <$> f x <*> xs ->>> f
+
+instance Alternative t => Bindable (Construction t) where
+	Construct x xs >>= f = case f x of Construct y ys -> Construct y $ ys <+> (>>= f) <$> xs
+
+instance Covariant t => Extendable (Construction t) where
+	x =>> f = Construct (f x) $ extend f <$> deconstruct x
+
+instance (Avoidable t, Alternative t) => Monad (Construction t) where
+
+instance Covariant t => Comonad (Construction t) where
+
+instance Lowerable Construction where
+	lower (Construct _ xs) = extract <$> xs
+
+instance (Setoid a, forall b . Setoid b => Setoid (t b)) => Setoid (Construction t a) where
+	Construct x xs == Construct y ys = (x == y) * (xs == ys)
+
+instance (Semigroup a, forall b . Semigroup b => Semigroup (t b)) => Semigroup (Construction t a) where
+	Construct x xs + Construct y ys = Construct (x + y) $ xs + ys
+
+instance (Monoid a, forall b . Semigroup b => Monoid (t b)) => Monoid (Construction t a) where
+	zero = Construct zero zero
+
+deconstruct :: Construction t a -> (t :. Construction t) a
+deconstruct (Construct _ xs) = xs
+
+coiterate :: Covariant t => a |-> t -> a |-> Construction t
+coiterate coalgebra x = Construct x $ coiterate coalgebra <$> coalgebra x
+
+section :: Comonad t => t ~> Construction t
+section as = Construct (extract as) $ extend section as
+
+instance (Covariant t, Covariant u) => Covariant (TU Covariant Covariant u (Construction t)) where
+	f <$> TU g = TU $ f <$$> g
+
+instance (Avoidable t, Pointable u) => Pointable (TU Covariant Covariant u (Construction t)) where
+	point x = TU . point . Construct x $ empty
+
+instance (Applicative t, Applicative u) => Applicative (TU Covariant Covariant u (Construction t)) where
+	TU f <*> TU x = TU $ f <**> x
+
+instance (Covariant t, Alternative u) => Alternative (TU Covariant Covariant u (Construction t)) where
+	TU x <+> TU y = TU $ x <+> y
+
+instance (Covariant t, Avoidable u) => Avoidable (TU Covariant Covariant u (Construction t)) where
+	empty = TU empty
+
+instance (Traversable t, Traversable u) => Traversable (TU Covariant Covariant u (Construction t)) where
+	TU g ->> f = TU <$> g ->>> f
diff --git a/Pandora/Paradigm/Primary/Transformer/Continuation.hs b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
@@ -0,0 +1,43 @@
+module Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (..), cwcc, reset, shift) where
+
+import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
+import Pandora.Core.Morphism ((!), (%))
+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 }
+
+instance Covariant t => Covariant (Continuation r t) where
+	f <$> Continuation continuation = Continuation $ continuation . (. f)
+
+instance Covariant t => Pointable (Continuation r t) where
+	point x = Continuation ($ x)
+
+instance Covariant t => Applicative (Continuation r t) where
+	f <*> x = Continuation $ \h -> continue f $ \g -> continue x (h . g)
+
+instance Covariant t => Bindable (Continuation r t) where
+	x >>= f = Continuation $ \g -> continue x $ \y -> continue (f y) g
+
+instance Monad t => Monad (Continuation r t) where
+
+instance (forall u . Bindable u) => Liftable (Continuation r) where
+	lift = Continuation . (>>=)
+
+-- | Call with current continuation
+cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a
+cwcc f = Continuation $ \g -> continue % g . f $ Continuation . (!) . g
+
+-- | Delimit the continuation of any 'shift'
+reset :: (forall u . Bindable u, Bindable t, Pointable t) => Continuation r t r -> Continuation s t r
+reset = lift . continue % point
+
+-- | Capture the continuation up to the nearest enclosing 'reset' and pass it
+shift :: Pointable t => ((a -> t r) -> Continuation r t r) -> Continuation r t a
+shift f = Continuation $ continue % point . f
diff --git a/Pandora/Paradigm/Primary/Transformer/Instruction.hs b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
@@ -0,0 +1,45 @@
+module Pandora.Paradigm.Primary.Transformer.Instruction (Instruction (..)) where
+
+import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+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)
+
+instance Covariant t => Covariant (Instruction t) where
+	f <$> Enter x = Enter $ f x
+	f <$> Instruct xs = Instruct $ f <$$> xs
+
+instance Covariant t => Pointable (Instruction t) where
+	point = Enter
+
+instance Alternative t => Alternative (Instruction t) where
+	Enter x <+> _ = Enter x
+	_ <+> Enter y = Enter y
+	Instruct xs <+> Instruct ys = Instruct $ xs <+> ys
+
+instance Avoidable t => Avoidable (Instruction t) where
+	empty = Instruct empty
+
+instance Covariant t => Applicative (Instruction t) where
+	Enter f <*> Enter y = Enter $ f y
+	Enter f <*> Instruct y = Instruct $ f <$$> y
+	Instruct f <*> y = Instruct $ (<*> y) <$> f
+
+instance Covariant t => Bindable (Instruction t) where
+	Enter x >>= f = f x
+	Instruct xs >>= f = Instruct $ (>>= f) <$> xs
+
+instance Traversable t => Traversable (Instruction t) where
+	Enter x ->> f = Enter <$> f x
+	Instruct xs ->> f = Instruct <$> xs ->>> f
+
+instance Liftable Instruction where
+	lift x = Instruct $ Enter <$> x
diff --git a/Pandora/Paradigm/Primary/Transformer/Jack.hs b/Pandora/Paradigm/Primary/Transformer/Jack.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Jack.hs
@@ -0,0 +1,67 @@
+module Pandora.Paradigm.Primary.Transformer.Jack (Jack (..), jack) where
+
+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))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+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 ((==)), Boolean (False))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
+
+data Jack t a = It a | Other (t a)
+
+instance Covariant t => Covariant (Jack t) where
+	f <$> It x = It $ f x
+	f <$> Other y = Other $ f <$> y
+
+instance Covariant t => Pointable (Jack t) where
+	point = It
+
+instance Alternative t => Alternative (Jack t) where
+	It x <+> _ = It x
+	Other _ <+> It y = It y
+	Other x <+> Other y = Other (x <+> y)
+
+instance Avoidable t => Avoidable (Jack t) where
+	empty = Other empty
+
+instance Extractable t => Extractable (Jack t) where
+	extract (It x) = x
+	extract (Other y) = extract y
+
+instance Applicative t => Applicative (Jack t) where
+	It f <*> It x = It $ f x
+	It f <*> Other y = Other $ f <$> y
+	Other f <*> It x = Other $ ($ x) <$> f
+	Other f <*> Other y = Other $ f <*> y
+
+instance Traversable t => Traversable (Jack t) where
+	It x ->> f = It <$> f x
+	Other y ->> f = comap Other . traverse f $ y
+
+instance Distributive t => Distributive (Jack t) where
+	x >>- f = distribute $ f <$> x
+
+instance Liftable Jack where
+	lift = Other
+
+instance (Setoid a, Setoid (t a)) => Setoid (Jack t a) where
+	It x == It y = x == y
+	Other x == Other y = x == y
+	_ == _ = False
+
+instance (Chain a, Chain (t a)) => Chain (Jack t a) where
+	It _ <=> Other _ = Less
+	Other _ <=> It _ = Greater
+	It x <=> It y = x <=> y
+	Other x <=> Other y = x <=> y
+
+jack :: (a -> r) -> (t a -> r) -> Jack t a -> r
+jack f _ (It x) = f x
+jack _ g (Other y) = g y
diff --git a/Pandora/Paradigm/Primary/Transformer/Jet.hs b/Pandora/Paradigm/Primary/Transformer/Jet.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Jet.hs
@@ -0,0 +1,22 @@
+module Pandora.Paradigm.Primary.Transformer.Jet (Jet (..)) where
+
+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.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
+
+data Jet t a = Jet a (Jet t (t a))
+
+instance Covariant t => Covariant (Jet t) where
+	f <$> Jet a as = Jet (f a) (f <$$> as)
+
+instance Traversable t => Traversable (Jet t) where
+	Jet a as ->> f = Jet <$> f a <*> as ->>> f
+
+instance (forall u . Avoidable u) => Pointable (Jet t) where
+	point x = Jet x empty
+
+instance Covariant t => Extractable (Jet t) where
+	extract (Jet x _) = x
diff --git a/Pandora/Paradigm/Primary/Transformer/Kan.hs b/Pandora/Paradigm/Primary/Transformer/Kan.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Kan.hs
@@ -0,0 +1,28 @@
+module Pandora.Paradigm.Primary.Transformer.Kan (Kan (..)) where
+
+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.Primary.Functor.Wye (Wye (Left, Right))
+
+data family Kan (v :: * -> k) (t :: * -> *) (u :: * -> *) b a
+
+data instance Kan Left t u b a = Lan ((t b -> a) -> u b)
+
+instance Contravariant (Kan Left t u b) where
+	f >$< Lan x = Lan $ x . (f .)
+
+instance Interpreted (Kan Left t u b) where
+	type Primary (Kan Left t u b) a = (t b -> a) -> u b
+	run (Lan x) = x
+
+data instance Kan Right t u b a = Ran ((a -> t b) -> u b)
+
+instance Covariant (Kan Right t u b) where
+	f <$> Ran x = Ran $ x . (. f)
+
+instance Interpreted (Kan Right t u b) where
+	type Primary (Kan Right t u b) a = (a -> t b) -> u b
+	run (Ran x) = x
diff --git a/Pandora/Paradigm/Primary/Transformer/Reverse.hs b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
@@ -0,0 +1,52 @@
+module Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (..)) where
+
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+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))
+
+newtype Reverse t a = Reverse (t a)
+
+instance Covariant t => Covariant (Reverse t) where
+	f <$> Reverse x = Reverse $ f <$> x
+
+instance Pointable t => Pointable (Reverse t) where
+	point = Reverse . point
+
+instance Extractable t => Extractable (Reverse t) where
+	extract (Reverse x) = extract x
+
+instance Applicative t => Applicative (Reverse t) where
+	Reverse f <*> Reverse x = Reverse (f <*> x)
+
+instance Traversable t => Traversable (Reverse t) where
+	Reverse x ->> f = Reverse <$> run (x ->> Backwards . f)
+
+instance Distributive t => Distributive (Reverse t) where
+	x >>- f = Reverse $ x >>- run . f
+
+instance Contravariant t => Contravariant (Reverse t) where
+	f >$< Reverse x = Reverse $ f >$< x
+
+instance Interpreted (Reverse t) where
+	type Primary (Reverse t) a = t a
+	run (Reverse x) = x
+
+instance Liftable Reverse where
+	lift = Reverse
+
+instance Lowerable Reverse where
+	lower = run
+
+instance Hoistable Reverse where
+	hoist f (Reverse x) = Reverse $ f x
diff --git a/Pandora/Paradigm/Primary/Transformer/Yoneda.hs b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
@@ -0,0 +1,41 @@
+module Pandora.Paradigm.Primary.Transformer.Yoneda (Yoneda (..)) where
+
+import Pandora.Core.Morphism ((!))
+import Pandora.Pattern.Category (identity, (.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+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.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 }
+
+instance Covariant (Yoneda t) where
+	f <$> x = Yoneda (\k -> yoneda x (k . f))
+
+instance Alternative t => Alternative (Yoneda t) where
+	Yoneda f <+> Yoneda g = Yoneda (\k -> f k <+> g k)
+
+instance Applicative t => Applicative (Yoneda t) where
+	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)
+
+instance Avoidable t => Avoidable (Yoneda t) where
+	empty = Yoneda (empty !)
+
+instance Pointable t => Pointable (Yoneda t) where
+	point x = Yoneda (\f -> point $ f x)
+
+instance Extractable t => Extractable (Yoneda t) where
+	extract (Yoneda f) = extract $ f identity
+
+instance Liftable Yoneda where
+	lift x = Yoneda (\f -> f <$> x)
+
+instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where
+	x -| f = point . f . point $ x
+	x |- g = extract . extract $ g <$> x
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -2,6 +2,6 @@
 
 import Pandora.Paradigm.Structure.Variation.Substructure as Exports
 import Pandora.Paradigm.Structure.Variation.Nonempty as Exports
+import Pandora.Paradigm.Structure.Rose as Exports
 import Pandora.Paradigm.Structure.Binary as Exports
-import Pandora.Paradigm.Structure.Graph as Exports
 import Pandora.Paradigm.Structure.Stack as Exports
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
@@ -4,83 +4,72 @@
 
 import Pandora.Core.Morphism ((&), (%), (!))
 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.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)), order)
-import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing), maybe)
-import Pandora.Paradigm.Basis.Product (Product ((:*:)))
-import Pandora.Paradigm.Basis.Wye (Wye (End, Left, Right, Both))
-import Pandora.Paradigm.Basis.Twister (Twister (Twister))
-import Pandora.Paradigm.Basis.Tagged (Tagged (Tag), type (:#))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+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))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Optics ((%~))
 import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Variation.Substructure (Substructure (Output, sub))
 
-type Binary = UT Covariant Covariant (Twister Wye) Maybe
-
-instance Covariant Binary where
-	f <$> UT g = UT $ f <$$> g
-
-instance Pointable Binary where
-	point x = UT . Just . Twister x $ End
-
-instance Traversable Binary where
-	UT g ->> f = UT <$> g ->>> f
+type Binary = TU Covariant Covariant Maybe (Construction Wye)
 
 insert :: Chain a => a -> Binary a -> Binary a
-insert x (UT Nothing) = point x
-insert x tree@(UT (Just (Twister y _))) = x <=> y & order
-	(sub @'Left %~ (insert x <$>) $ tree) tree
-	(sub @'Right %~ (insert x <$>) $ tree)
+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)
 
-instance Substructure 'Left Binary where
-	type Output 'Left Binary a = 'Left :# Binary a
-	sub (UT Nothing) = Store $ (:*:) (Tag $ UT Nothing) $ (UT Nothing !)
-	sub  t@(UT (Just (Twister x End))) = Store $ (:*:) (Tag $ UT Nothing) $
-		maybe t (UT . Just . Twister x . Left) . run . extract
-	sub (UT (Just (Twister x (Left lst)))) = Store $ (:*:) (Tag . UT . Just $ lst) $
-		maybe (point x) (UT . Just . Twister x . Left) . run . extract
-	sub t@(UT (Just (Twister x (Right rst)))) = Store $ (:*:) (Tag $ UT Nothing) $
-		maybe t (UT . Just . Twister x . Both % rst) . run . extract
-	sub  (UT (Just (Twister x (Both lst rst)))) = Store $ (:*:) (Tag . UT . Just $ lst) $
-		maybe (UT (Just (Twister x (Right rst)))) (UT . Just . Twister x . Both % rst) . run . extract
+instance Substructure Left Binary where
+	type Output 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
 
-instance Substructure 'Right Binary where
-	type Output 'Right Binary a = 'Right :# Binary a
-	sub (UT Nothing) = Store $ Tag (UT Nothing) :*: (!) (UT Nothing)
-	sub t@(UT (Just (Twister x End))) = Store $ (:*:) (Tag $ UT Nothing) $
-		maybe t (UT . Just . Twister x . Right) . run . extract
-	sub t@(UT (Just (Twister x (Left lst)))) = Store $ (:*:) (Tag $ UT Nothing) $
-		maybe t (UT . Just . Twister x . Both lst) . run . extract
-	sub (UT (Just (Twister x (Right rst)))) = Store $ (:*:) (Tag . UT . Just $ rst) $
-		maybe (point x) (UT . Just . Twister x . Right) . run . extract
-	sub (UT (Just (Twister x (Both lst rst)))) = Store $ (:*:) (Tag . UT . Just $ rst) $
-		maybe (UT (Just (Twister x (Left lst)))) (UT . Just . Twister x . Both lst) . run . extract
+instance Substructure Right Binary where
+	type Output 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
 
-type instance Nonempty Binary = Twister Wye
+type instance Nonempty Binary = Construction Wye
 
-instance Substructure 'Left (Twister Wye) where
-	type Output 'Left (Twister Wye) a = Maybe ('Left :# Twister Wye a)
-	sub (Twister x End) = Store $ (:*:) Nothing $ (Twister x End !)
-	sub (Twister x (Left lst)) = Store $ (:*:) (Just . Tag $ lst) $
-		maybe (Twister x End) (Twister x . Left . extract)
-	sub tree@(Twister x (Right rst)) = Store $ (:*:) Nothing $
-		maybe tree (Twister x . Both % rst . extract)
-	sub (Twister x (Both lst rst)) = Store $ (:*:) (Just . Tag $ lst) $
-		maybe (Twister x $ Right rst) (Twister x . Both % rst . extract)
+instance Substructure Left (Construction Wye) where
+	type Output 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
 
-instance Substructure 'Right (Twister Wye) where
-	type Output 'Right (Twister Wye) a = Maybe ('Right :# Twister Wye a)
-	sub (Twister x End) = Store $ (:*:) Nothing $ (Twister x End !)
-	sub tree@(Twister x (Left lst)) = Store $ (:*:) Nothing $
-		maybe tree (Twister x . Both lst . extract)
-	sub (Twister x (Right rst)) = Store $ (:*:) (Just . Tag $ rst) $
-		maybe (Twister x End) (Twister x . Right . extract)
-	sub (Twister x (Both lst rst)) = Store $ (:*:) (Just . Tag $ rst) $
-		maybe (Twister x $ Left lst) (Twister x . Both lst . extract)
+instance Substructure Right (Construction Wye) where
+	type Output 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
diff --git a/Pandora/Paradigm/Structure/Graph.hs b/Pandora/Paradigm/Structure/Graph.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Graph.hs
+++ /dev/null
@@ -1,29 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Pandora.Paradigm.Structure.Graph (Graph, loose) where
-
-import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))
-import Pandora.Paradigm.Basis.Twister (Twister (Twister))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
-import Pandora.Paradigm.Inventory.State (fold)
-import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)
-
--- | Directed acyclic graph structure
-type Graph = UT Covariant Covariant (Twister Edges) Edges
-
-type instance Nonempty Graph = Twister Edges
-
-instance Covariant Graph where
-	f <$> UT g = UT $ f <$$> g
-
-instance Traversable Graph where
-	UT g ->> f = UT <$> g ->>> f
-
--- | Transform any traversable structure into all loose edges graph
-loose :: Traversable t => t ~> Graph
-loose = UT . fold Empty (\x -> Overlay . Twister x)
diff --git a/Pandora/Paradigm/Structure/Rose.hs b/Pandora/Paradigm/Structure/Rose.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Rose.hs
@@ -0,0 +1,9 @@
+module Pandora.Paradigm.Structure.Rose (Rose) where
+
+import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction)
+import Pandora.Paradigm.Structure.Stack (Stack)
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU)
+
+type Rose = TU Covariant Covariant Maybe (Construction Stack)
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
@@ -5,62 +5,43 @@
 import Pandora.Core.Functor (type (~>))
 import Pandora.Core.Morphism ((&))
 import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+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.Object.Setoid (Setoid ((==)), (?))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
-import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))
-import Pandora.Paradigm.Basis.Product (Product ((:*:)))
-import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)
+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.Transformer.Construction (Construction (Construct), deconstruct)
 import Pandora.Paradigm.Inventory.State (fold)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Optics (type (:-.))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
 import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)
 
 -- | Linear data structure that serves as a collection of elements
-type Stack = UT Covariant Covariant (Twister Maybe) Maybe
-
-type instance Nonempty Stack = Twister Maybe
-
-instance Covariant Stack where
-	f <$> UT stack = UT $ f <$$> stack
-
-instance Pointable Stack where
-	point = UT . Just . point
-
-instance Alternative Stack where
-	UT x <+> UT y = UT $ x <+> y
-
-instance Avoidable Stack where
-	empty = UT Nothing
-
-instance Applicative Stack where
-	UT f <*> UT x = UT $ f <**> x
+type Stack = TU Covariant Covariant Maybe (Construction Maybe)
 
-instance Traversable Stack where
-	UT stack ->> f = UT <$> stack ->>> f
+type instance Nonempty Stack = Construction Maybe
 
 instance Setoid a => Setoid (Stack a) where
-	UT ls == UT rs = ls == rs
+	TU ls == TU rs = ls == rs
 
 instance Semigroup (Stack a) where
-	UT Nothing + UT ys = UT ys
-	UT (Just (Twister x xs)) + UT ys = UT . Just . Twister x . run
-		$ UT @Covariant @Covariant xs + UT @Covariant @Covariant ys
+	TU Nothing + TU ys = TU ys
+	TU (Just (Construct x xs)) + TU ys = TU . Just . Construct x . run
+		$ TU @Covariant @Covariant xs + TU @Covariant @Covariant ys
 
 instance Monoid (Stack a) where
-	zero = UT Nothing
+	zero = TU Nothing
 
 top :: Stack a :-. Maybe a
 top stack = Store $ (:*:) (extract <$> run stack) $ \case
@@ -68,15 +49,15 @@
     Nothing -> pop stack
 
 push :: a -> Stack a -> Stack a
-push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x
+push x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x
 
 pop :: Stack ~> Stack
-pop (UT stack) = UT $ stack >>= untwist
+pop (TU stack) = TU $ stack >>= deconstruct
 
 filter :: Predicate a -> Stack a -> Stack a
-filter (Predicate p) = UT . fold empty
-	(\now new -> p now ? Just (Twister now new) $ new)
+filter (Predicate p) = TU . fold empty
+	(\now new -> p now ? Just (Construct now new) $ new)
 
 -- | Transform any traversable structure into a stack
 linearize :: Traversable t => t ~> Stack
-linearize = UT . fold Nothing (\x -> Just . Twister x)
+linearize = TU . fold Nothing (\x -> Just . Construct x)
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,6 +1,6 @@
 module Pandora.Paradigm.Structure.Stream (Stream) where
 
-import Pandora.Paradigm.Basis.Identity (Identity)
-import Pandora.Paradigm.Basis.Twister (Twister)
+import Pandora.Paradigm.Primary.Functor.Identity (Identity)
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction)
 
-type Stream = Twister Identity
+type Stream = Construction Identity
diff --git a/Pandora/Paradigm/Structure/Variation/Substructure.hs b/Pandora/Paradigm/Structure/Variation/Substructure.hs
--- a/Pandora/Paradigm/Structure/Variation/Substructure.hs
+++ b/Pandora/Paradigm/Structure/Variation/Substructure.hs
@@ -1,7 +1,8 @@
 module Pandora.Paradigm.Structure.Variation.Substructure (Substructure (..)) where
 
 import Pandora.Paradigm.Inventory.Optics (type (:-.))
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)
 
 class Substructure f t where
-	type Output (f :: * -> k) (t :: * -> *) a = r | r -> f t a
-	sub :: t a :-. Output f t a
+	type Output (f :: * -> k) (t :: * -> *) a
+	sub :: t a :-. Tagged f (Output f t a)
diff --git a/Pandora/Pattern/Object.hs b/Pandora/Pattern/Object.hs
--- a/Pandora/Pattern/Object.hs
+++ b/Pandora/Pattern/Object.hs
@@ -2,6 +2,7 @@
 
 import Pandora.Pattern.Object.Lattice as Exports
 import Pandora.Pattern.Object.Semilattice as Exports
+import Pandora.Pattern.Object.Ring as Exports
 import Pandora.Pattern.Object.Group as Exports
 import Pandora.Pattern.Object.Monoid as Exports
 import Pandora.Pattern.Object.Quasiring as Exports
diff --git a/Pandora/Pattern/Object/Ring.hs b/Pandora/Pattern/Object/Ring.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Object/Ring.hs
@@ -0,0 +1,10 @@
+module Pandora.Pattern.Object.Ring (Ring) where
+
+import Pandora.Pattern.Object.Group (Group)
+
+{- |
+> When providing a new instance, you should ensure it satisfies the one law:
+> * Commutativity of addition: x + y ≡ y + x
+-}
+
+class Group a => Ring a where
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.2.6
+version:             0.2.7
 synopsis:            A box of patterns and paradigms
 description:         Humble attempt to define a library for problem solving based on math abstractions.
 homepage:            https://github.com/iokasimov/pandora
@@ -26,29 +26,32 @@
 
     Pandora.Paradigm
     -- Basic constructions
-    Pandora.Paradigm.Basis
-    Pandora.Paradigm.Basis.Backwards
-    Pandora.Paradigm.Basis.Conclusion
-    Pandora.Paradigm.Basis.Constant
-    Pandora.Paradigm.Basis.Continuation
-    Pandora.Paradigm.Basis.Edges
-    Pandora.Paradigm.Basis.Endo
-    Pandora.Paradigm.Basis.Fix
-    Pandora.Paradigm.Basis.Free
-    Pandora.Paradigm.Basis.Identity
-    Pandora.Paradigm.Basis.Jack
-    Pandora.Paradigm.Basis.Jet
-    Pandora.Paradigm.Basis.Kan
-    Pandora.Paradigm.Basis.Maybe
-    Pandora.Paradigm.Basis.Predicate
-    Pandora.Paradigm.Basis.Product
-    Pandora.Paradigm.Basis.Proxy
-    Pandora.Paradigm.Basis.Tagged
-    Pandora.Paradigm.Basis.Twister
-    Pandora.Paradigm.Basis.Validation
-    Pandora.Paradigm.Basis.Variation
-    Pandora.Paradigm.Basis.Wye
-    Pandora.Paradigm.Basis.Yoneda
+    Pandora.Paradigm.Primary
+    Pandora.Paradigm.Primary.Functor
+    Pandora.Paradigm.Primary.Functor.Conclusion
+    Pandora.Paradigm.Primary.Functor.Constant
+    Pandora.Paradigm.Primary.Functor.Edges
+    Pandora.Paradigm.Primary.Functor.Endo
+    Pandora.Paradigm.Primary.Functor.Fix
+    Pandora.Paradigm.Primary.Functor.Identity
+    Pandora.Paradigm.Primary.Functor.Maybe
+    Pandora.Paradigm.Primary.Functor.Predicate
+    Pandora.Paradigm.Primary.Functor.Product
+    Pandora.Paradigm.Primary.Functor.Proxy
+    Pandora.Paradigm.Primary.Functor.Tagged
+    Pandora.Paradigm.Primary.Functor.Validation
+    Pandora.Paradigm.Primary.Functor.Variation
+    Pandora.Paradigm.Primary.Functor.Wye
+    Pandora.Paradigm.Primary.Transformer
+    Pandora.Paradigm.Primary.Transformer.Backwards
+    Pandora.Paradigm.Primary.Transformer.Reverse
+    Pandora.Paradigm.Primary.Transformer.Continuation
+    Pandora.Paradigm.Primary.Transformer.Construction
+    Pandora.Paradigm.Primary.Transformer.Instruction
+    Pandora.Paradigm.Primary.Transformer.Jack
+    Pandora.Paradigm.Primary.Transformer.Jet
+    Pandora.Paradigm.Primary.Transformer.Kan
+    Pandora.Paradigm.Primary.Transformer.Yoneda
     -- Control flow primitives
     Pandora.Paradigm.Controlflow
     -- Typeclassess about functor junctions
@@ -80,8 +83,8 @@
     Pandora.Paradigm.Structure
     Pandora.Paradigm.Structure.Stream
     Pandora.Paradigm.Structure.Stack
-    Pandora.Paradigm.Structure.Graph
     Pandora.Paradigm.Structure.Binary
+    Pandora.Paradigm.Structure.Rose
     Pandora.Paradigm.Structure.Variation.Nonempty
     Pandora.Paradigm.Structure.Variation.Substructure
 
@@ -116,6 +119,7 @@
     Pandora.Pattern.Object.Lattice
     Pandora.Pattern.Object.Monoid
     Pandora.Pattern.Object.Quasiring
+    Pandora.Pattern.Object.Ring
     Pandora.Pattern.Object.Ringoid
     Pandora.Pattern.Object.Semigroup
     Pandora.Pattern.Object.Semilattice
@@ -133,4 +137,4 @@
     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes
     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators
   default-language: Haskell2010
-  ghc-options: -Wall -fno-warn-tabs
+  ghc-options: -Wall -fno-warn-tabs -fno-warn-unticked-promoted-constructors