diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -142,3 +142,15 @@
 * Remove `statefully` in favor of `Interpreted` instance for `State`
 
 # 0.2.3
+* Define `Category` type class with `identity` and `.` methods
+* Change `>->` signature: `a -> b` to `v a d` and `c -> d` to `v c d`
+* Extract `Schema` from `Transformer` type class as `Schematic` type family
+* Rename `Transformer` type class to `Monadic`
+* Define `Comonadic` type class for comonad transformers
+* Define `Transformer` umbrella module and type family
+* Rename `:<` data constructor to `Twister` to not confuse it with comonad transformer type operator
+* Use `UT` joint scheme for `Stack` and `Graph` data structures
+* Remove `Variant` type in favor of `Covariant` and `Contravariant` constraints in joint schemes
+* Add `Covariant` constraint on schema parameter in `Adaptable` type class
+* Rename `Storage` type to `Store`
+* Define `Interpreted`, `Schematic` and `Comonadic` instances for `Store` type
diff --git a/Pandora/Core/Functor.hs b/Pandora/Core/Functor.hs
--- a/Pandora/Core/Functor.hs
+++ b/Pandora/Core/Functor.hs
@@ -4,8 +4,6 @@
 infixr 1 .:, :.
 infixr 2 ::|:., ::|.:, ::|::
 
-data Variant = Co | Contra
-
 -- | Parameter application
 type (:=) t a = t a
 
diff --git a/Pandora/Core/Morphism.hs b/Pandora/Core/Morphism.hs
--- a/Pandora/Core/Morphism.hs
+++ b/Pandora/Core/Morphism.hs
@@ -1,20 +1,11 @@
-module Pandora.Core.Morphism (identity, fix, (.), (&), (!), (%)) where
+module Pandora.Core.Morphism (fix, (&), (!), (%)) where
 
-infixr 8 .
 infixl 1 &
 infixr 2 !
 infixr 9 %
 
-{-# INLINE identity #-}
-identity :: a -> a
-identity x = x
-
 fix :: (a -> a) -> a
 fix f = let x = f x in x
-
-{-# INLINE (.) #-}
-(.) :: (b -> c) -> (a -> b) -> a -> c
-f . g = \x -> f (g x)
 
 {-# INLINE (&) #-}
 (&) :: a -> (a -> b) -> b
diff --git a/Pandora/Paradigm/Basis/Conclusion.hs b/Pandora/Paradigm/Basis/Conclusion.hs
--- a/Pandora/Paradigm/Basis/Conclusion.hs
+++ b/Pandora/Paradigm/Basis/Conclusion.hs
@@ -1,9 +1,10 @@
 module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where
 
-import Pandora.Core.Functor (Variant (Co))
-import Pandora.Core.Morphism ((.))
+import Pandora.Core.Transformation (type (~>))
+import Pandora.Pattern.Category ((.))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>)(T))
+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 ((<$>), (<$$>)))
@@ -66,7 +67,7 @@
 conclusion f _ (Failure x) = f x
 conclusion _ s (Success x) = s x
 
-fail :: (e -> r) -> Conclusion e a -> Conclusion r a
+fail :: (e -> r) -> Conclusion e ~> Conclusion r
 fail f (Failure x) = Failure $ f x
 fail _ (Success y) = Success y
 
@@ -74,26 +75,27 @@
 	type Primary (Conclusion e) a = Conclusion e a
 	unwrap x = x
 
-instance Transformer (Conclusion e) where
-	type Schema (Conclusion e) u = UT 'Co 'Co (Conclusion e) u
-	lay x = T . UT $ Success <$> x
-	wrap x = T . UT . point $ 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 'Co 'Co (Conclusion e) u) where
+instance Covariant u => Covariant (UT Covariant Covariant (Conclusion e) u) where
 	f <$> UT x = UT $ f <$$> x
 
-instance Applicative u => Applicative (UT 'Co 'Co (Conclusion e) u) where
+instance Applicative u => Applicative (UT Covariant Covariant (Conclusion e) u) where
 	UT f <*> UT x = UT $ apply <$> f <*> x
 
-instance Pointable u => Pointable (UT 'Co 'Co (Conclusion e) u) where
+instance Pointable u => Pointable (UT Covariant Covariant (Conclusion e) u) where
 	point = UT . point . point
 
-instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co (Conclusion e) u) where
+instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant (Conclusion e) u) where
 	UT x >>= f = UT $ x >>= conclusion (point . Failure) (unwrap . f)
 
-instance Monad u => Monad (UT 'Co 'Co (Conclusion e) u) where
+instance Monad u => Monad (UT Covariant Covariant (Conclusion e) u) where
 
-failure :: (Covariant t, Failable e t) => e -> t a
+failure :: Failable e t => e -> t a
 failure = adapt . Failure
diff --git a/Pandora/Paradigm/Basis/Continuation.hs b/Pandora/Paradigm/Basis/Continuation.hs
--- a/Pandora/Paradigm/Basis/Continuation.hs
+++ b/Pandora/Paradigm/Basis/Continuation.hs
@@ -1,7 +1,8 @@
 module Pandora.Paradigm.Basis.Continuation (Continuation (..), cwcc, reset, shift) where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
-import Pandora.Core.Morphism ((.), (!), (%))
+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 ((<*>)))
diff --git a/Pandora/Paradigm/Basis/Endo.hs b/Pandora/Paradigm/Basis/Endo.hs
--- a/Pandora/Paradigm/Basis/Endo.hs
+++ b/Pandora/Paradigm/Basis/Endo.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Basis.Endo (Endo (..)) where
 
-import Pandora.Core.Morphism ((.), identity)
+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))
diff --git a/Pandora/Paradigm/Basis/Identity.hs b/Pandora/Paradigm/Basis/Identity.hs
--- a/Pandora/Paradigm/Basis/Identity.hs
+++ b/Pandora/Paradigm/Basis/Identity.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Basis.Identity (Identity (..)) where
 
-import Pandora.Core.Morphism ((.))
+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))
diff --git a/Pandora/Paradigm/Basis/Jack.hs b/Pandora/Paradigm/Basis/Jack.hs
--- a/Pandora/Paradigm/Basis/Jack.hs
+++ b/Pandora/Paradigm/Basis/Jack.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Basis.Jack (Jack (..), jack) where
 
-import Pandora.Core.Morphism ((.))
+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))
diff --git a/Pandora/Paradigm/Basis/Kan.hs b/Pandora/Paradigm/Basis/Kan.hs
--- a/Pandora/Paradigm/Basis/Kan.hs
+++ b/Pandora/Paradigm/Basis/Kan.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Basis.Kan (Lan (..), Ran (..)) where
 
-import Pandora.Core.Morphism ((.))
+import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Divariant (($))
diff --git a/Pandora/Paradigm/Basis/Maybe.hs b/Pandora/Paradigm/Basis/Maybe.hs
--- a/Pandora/Paradigm/Basis/Maybe.hs
+++ b/Pandora/Paradigm/Basis/Maybe.hs
@@ -1,11 +1,11 @@
 module Pandora.Paradigm.Basis.Maybe (Maybe (..), Optional, maybe, nothing) where
 
-import Pandora.Core.Functor (Variant (Co))
-import Pandora.Core.Morphism ((.))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>)(T))
+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))
@@ -87,30 +87,31 @@
 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
 	unwrap x = x
 
-instance Transformer Maybe where
-	type Schema Maybe u = UT 'Co 'Co Maybe u
-	lay x = T . UT $ Just <$> x
-	wrap x = T. UT . point $ 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 'Co 'Co Maybe u) where
+instance Covariant u => Covariant (UT Covariant Covariant Maybe u) where
 	f <$> UT x = UT $ f <$$> x
 
-instance Applicative u => Applicative (UT 'Co 'Co Maybe u) where
+instance Applicative u => Applicative (UT Covariant Covariant Maybe u) where
 	UT f <*> UT x = UT $ apply <$> f <*> x
 
-instance Pointable u => Pointable (UT 'Co 'Co Maybe u) where
+instance Pointable u => Pointable (UT Covariant Covariant Maybe u) where
 	point = UT . point . point
 
-instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co Maybe u) where
+instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant Maybe u) where
 	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f)
 
-instance Monad u => Monad (UT 'Co 'Co Maybe u) where
+instance Monad u => Monad (UT Covariant Covariant Maybe u) where
 
-nothing :: (Covariant t, Optional t) => t a
+nothing :: Optional t => t a
 nothing = adapt Nothing
diff --git a/Pandora/Paradigm/Basis/Predicate.hs b/Pandora/Paradigm/Basis/Predicate.hs
--- a/Pandora/Paradigm/Basis/Predicate.hs
+++ b/Pandora/Paradigm/Basis/Predicate.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Basis.Predicate (Predicate (..)) where
 
-import Pandora.Core.Morphism ((.), (!))
+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 (($))
diff --git a/Pandora/Paradigm/Basis/Tagged.hs b/Pandora/Paradigm/Basis/Tagged.hs
--- a/Pandora/Paradigm/Basis/Tagged.hs
+++ b/Pandora/Paradigm/Basis/Tagged.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Basis.Tagged (Tagged (..), retag, tagself, type (:#)) where
 
-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.Pointable (Pointable (point))
diff --git a/Pandora/Paradigm/Basis/Twister.hs b/Pandora/Paradigm/Basis/Twister.hs
--- a/Pandora/Paradigm/Basis/Twister.hs
+++ b/Pandora/Paradigm/Basis/Twister.hs
@@ -2,65 +2,67 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (|->))
 import Pandora.Core.Transformation (type (~>))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), comap))
+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.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.Functor.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)), (&&))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 
-infixr 5 :<
-
-data Twister t a = a :< (t :. Twister t := a)
+data Twister t a = Twister a (t :. Twister t := a)
 
 instance Covariant t => Covariant (Twister t) where
-	f <$> (x :< xs) = f x :< (f <$$> xs)
+	f <$> Twister x xs = Twister (f x) $ f <$$> xs
 
 instance Avoidable t => Pointable (Twister t) where
-	point x = x :< empty
+	point x = Twister x empty
 
 instance Covariant t => Extractable (Twister t) where
-	extract (x :< _) = x
+	extract (Twister x _) = x
 
 instance Applicative t => Applicative (Twister t) where
-	(f :< fs) <*> (x :< xs) = f x :< ((<*>) <$> fs <*> xs)
+	Twister f fs <*> Twister x xs = Twister (f x) $ fs <**> xs
 
 instance Traversable t => Traversable (Twister t) where
-	(x :< xs) ->> f = (:<) <$> f x <*> xs ->>> f
+	Twister x xs ->> f = Twister <$> f x <*> xs ->>> f
 
 instance Alternative t => Bindable (Twister t) where
-	(x :< xs) >>= f = case f x of
-		y :< ys -> y :< (ys <+> comap (>>= f) xs)
+	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 = f x :< (extend f <$> untwist x)
+	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
-	(x :< xs) == (y :< ys) = x == y && xs == ys
+	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
-	(x :< xs) + (y :< ys) = (x + y) :< (xs + ys)
+	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 = zero :< zero
+	zero = Twister zero zero
 
 untwist :: Twister t a -> (t :. Twister t) a
-untwist (_ :< xs) = xs
+untwist (Twister _ xs) = xs
 
-coiterate :: Covariant t => a |-> t -> a -> Twister t a
-coiterate coalgebra x = x :< (coiterate coalgebra <$> coalgebra x)
+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 = extract as :< extend section as
+section as = Twister (extract as) $ extend section as
diff --git a/Pandora/Paradigm/Basis/Yoneda.hs b/Pandora/Paradigm/Basis/Yoneda.hs
--- a/Pandora/Paradigm/Basis/Yoneda.hs
+++ b/Pandora/Paradigm/Basis/Yoneda.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Basis.Yoneda (Yoneda (..)) where
 
-import Pandora.Core.Morphism ((.), (!), identity)
+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 ((<*>)))
diff --git a/Pandora/Paradigm/Controlflow/Joint.hs b/Pandora/Paradigm/Controlflow/Joint.hs
--- a/Pandora/Paradigm/Controlflow/Joint.hs
+++ b/Pandora/Paradigm/Controlflow/Joint.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Controlflow.Joint (module Exports) where
 
 import Pandora.Paradigm.Controlflow.Joint.Schemes as Exports
+import Pandora.Paradigm.Controlflow.Joint.Schematic as Exports
 import Pandora.Paradigm.Controlflow.Joint.Transformer as Exports
 import Pandora.Paradigm.Controlflow.Joint.Interpreted as Exports
 import Pandora.Paradigm.Controlflow.Joint.Adaptable as Exports
diff --git a/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs b/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
@@ -1,148 +1,168 @@
+{-# LANGUAGE UndecidableInstances #-}
+
 module Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (..)) where
 
-import Pandora.Core.Morphism (identity, (.))
 import Pandora.Core.Transformation (type (~>))
+import Pandora.Pattern.Category (identity, (.))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Pointable (Pointable)
-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>))
+import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>))
 
-class Adaptable eff schema where
+class Covariant u => Adaptable t u where
 	{-# MINIMAL adapt #-}
-	adapt :: eff ~> schema
+	adapt :: t ~> u
 
-type Layable t u = (Transformer t, Covariant u)
-type Wrappable t u = (Transformer t, Pointable u)
+type Layable t u = (Monadic t, Covariant u)
+type Wrappable t u = (Monadic t, Pointable u)
 
-instance Adaptable t t where
+instance Covariant t => Adaptable t t where
 	adapt = identity
 
-instance Layable t u => Adaptable u (t :> u) where
+instance (Covariant (t :> u), Layable t u) => Adaptable u (t :> u) where
 	adapt = lay
 
-instance Wrappable t u => Adaptable t (t :> u) where
+instance (Covariant (t :> u), Wrappable t u) => Adaptable t (t :> u) where
 	adapt = wrap
 
 instance
-	( Layable t (Schema u v)
+	( Covariant (t :> u :> v)
+	, Layable t (Schematic Monad u v)
 	, Wrappable u v
 	) => Adaptable u (t :> u :> v) where
 	adapt = lay . wrap
 
 instance
-	( Layable t (Schema u v)
+	( Covariant (t :> u :> v)
+	, Layable t (Schematic Monad u v)
 	, Layable u v
 	) => Adaptable v (t :> u :> v) where
 	adapt = lay . lay
 
 instance
-	( Layable t (Schema u (v :> w))
-	, Layable u (Schema v w)
+	( Covariant (t :> u :> v :> w)
+	, Layable t (Schematic Monad u (v :> w))
+	, Layable u (Schematic Monad v w)
 	, Wrappable v w
 	) => Adaptable v (t :> u :> v :> w) where
 	adapt = lay . lay . wrap
 
 instance
-	( Layable t (Schema u v)
-	, Layable t (Schema u (v :> w))
-	, Layable u (Schema v w)
+	( Covariant (t :> u :> v :> w)
+	, Layable t (Schematic Monad u v)
+	, Layable t (Schematic Monad u (v :> w))
+	, Layable u (Schematic Monad v w)
 	, Layable v w
 	) => Adaptable w (t :> u :> v :> w) where
 	adapt = lay . lay . lay
 
-instance (Layable t (Schema u (v :> w :> x))
-	, Layable u (Schema v (w :> x))
-	, Layable v (Schema w x)
+instance
+	( Covariant (t :> u :> v :> w :> x)
+	, Layable t (Schematic Monad u (v :> w :> x))
+	, Layable u (Schematic Monad v (w :> x))
+	, Layable v (Schematic Monad w x)
 	, Layable w x
 	) => Adaptable x (t :> u :> v :> w :> x) where
 	adapt = lay . lay . lay . lay
 
-instance (Layable t (Schema u (v :> w :> x))
-	, Layable u (Schema v (w :> x))
-	, Layable v (Schema w x)
+instance
+	( Covariant (t :> u :> v :> w :> x)
+	, Layable t (Schematic Monad u (v :> w :> x))
+	, Layable u (Schematic Monad v (w :> x))
+	, Layable v (Schematic Monad w x)
 	, Wrappable w x
 	) => Adaptable w (t :> u :> v :> w :> x) where
 	adapt = lay . lay . lay . wrap
 
 instance
-	( Layable t (Schema u (v :> w :> x :> y))
-	, Layable u (Schema v (w :> x :> y))
-	, Layable v (Schema w (x :> y))
-	, Layable w (Schema x y)
+	( Covariant (t :> u :> v :> w :> x :> y)
+	, Layable t (Schematic Monad u (v :> w :> x :> y))
+	, Layable u (Schematic Monad v (w :> x :> y))
+	, Layable v (Schematic Monad w (x :> y))
+	, Layable w (Schematic Monad x y)
 	, Layable x y
 	) => Adaptable y (t :> u :> v :> w :> x :> y) where
 	adapt = lay . lay . lay . lay . lay
 
 instance
-	( Layable t (Schema u (v :> w :> x :> y))
-	, Layable u (Schema v (w :> x :> y))
-	, Layable v (Schema w (x :> y))
-	, Layable w (Schema x y)
+	( Covariant (t :> u :> v :> w :> x :> y)
+	, Layable t (Schematic Monad u (v :> w :> x :> y))
+	, Layable u (Schematic Monad v (w :> x :> y))
+	, Layable v (Schematic Monad w (x :> y))
+	, Layable w (Schematic Monad x y)
 	, Wrappable x y
 	) => Adaptable x (t :> u :> v :> w :> x :> y) where
 	adapt = lay . lay . lay . lay . wrap
 
 instance
-	( Layable t (Schema u (v :> w :> x :> y :> z))
-	, Layable u (Schema v (w :> x :> y :> z))
-	, Layable v (Schema w (x :> y :> z))
-	, Layable w (Schema x (y :> z))
-	, Layable x (Schema y z)
+	( Covariant (t :> u :> v :> w :> x :> y :> z)
+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))
+	, Layable u (Schematic Monad v (w :> x :> y :> z))
+	, Layable v (Schematic Monad w (x :> y :> z))
+	, Layable w (Schematic Monad x (y :> z))
+	, Layable x (Schematic Monad y z)
 	, Layable y z
 	) => Adaptable z (t :> u :> v :> w :> x :> y :> z) where
 	adapt = lay . lay . lay . lay . lay . lay
 
 instance
-	( Layable t (Schema u (v :> w :> x :> y :> z))
-	, Layable u (Schema v (w :> x :> y :> z))
-	, Layable v (Schema w (x :> y :> z))
-	, Layable w (Schema x (y :> z))
-	, Layable x (Schema y z)
+	( Covariant (t :> u :> v :> w :> x :> y :> z)
+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))
+	, Layable u (Schematic Monad v (w :> x :> y :> z))
+	, Layable v (Schematic Monad w (x :> y :> z))
+	, Layable w (Schematic Monad x (y :> z))
+	, Layable x (Schematic Monad y z)
 	, Wrappable y z
 	) => Adaptable y (t :> u :> v :> w :> x :> y :> z) where
 	adapt = lay . lay . lay . lay . lay . wrap
 
 instance
-	( Layable t (Schema u (v :> w :> x :> y :> z :> f))
-	, Layable u (Schema v (w :> x :> y :> z :> f))
-	, Layable v (Schema w (x :> y :> z :> f))
-	, Layable w (Schema x (y :> z :> f))
-	, Layable x (Schema y (z :> f))
-	, Layable y (Schema z f)
+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)
+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))
+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))
+	, Layable v (Schematic Monad w (x :> y :> z :> f))
+	, Layable w (Schematic Monad x (y :> z :> f))
+	, Layable x (Schematic Monad y (z :> f))
+	, Layable y (Schematic Monad z f)
 	, Layable z f
 	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f) where
 	adapt = lay . lay . lay . lay . lay . lay . lay
 
 instance
-	( Layable t (Schema u (v :> w :> x :> y :> z :> f))
-	, Layable u (Schema v (w :> x :> y :> z :> f))
-	, Layable v (Schema w (x :> y :> z :> f))
-	, Layable w (Schema x (y :> z :> f))
-	, Layable x (Schema y (z :> f))
-	, Layable y (Schema z f)
+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)
+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))
+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))
+	, Layable v (Schematic Monad w (x :> y :> z :> f))
+	, Layable w (Schematic Monad x (y :> z :> f))
+	, Layable x (Schematic Monad y (z :> f))
+	, Layable y (Schematic Monad z f)
 	, Wrappable z f
 	) => Adaptable z (t :> u :> v :> w :> x :> y :> z :> f) where
 	adapt = lay . lay . lay . lay . lay . lay . wrap
 
 instance
-	( Layable t (Schema u (v :> w :> x :> y :> z :> f :> h))
-	, Layable u (Schema v (w :> x :> y :> z :> f :> h))
-	, Layable v (Schema w (x :> y :> z :> f :> h))
-	, Layable w (Schema x (y :> z :> f :> h))
-	, Layable x (Schema y (z :> f :> h))
-	, Layable y (Schema z (f :> h))
-	, Layable z (Schema f h)
+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)
+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))
+	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))
+	, Layable w (Schematic Monad x (y :> z :> f :> h))
+	, Layable x (Schematic Monad y (z :> f :> h))
+	, Layable y (Schematic Monad z (f :> h))
+	, Layable z (Schematic Monad f h)
 	, Layable f h
 	) => Adaptable h (t :> u :> v :> w :> x :> y :> z :> f :> h) where
 	adapt = lay . lay . lay . lay . lay . lay . lay . lay
 
 instance
-	( Layable t (Schema u (v :> w :> x :> y :> z :> f :> h))
-	, Layable u (Schema v (w :> x :> y :> z :> f :> h))
-	, Layable v (Schema w (x :> y :> z :> f :> h))
-	, Layable w (Schema x (y :> z :> f :> h))
-	, Layable x (Schema y (z :> f :> h))
-	, Layable y (Schema z (f :> h))
-	, Layable z (Schema f h)
+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)
+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))
+	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))
+	, Layable w (Schematic Monad x (y :> z :> f :> h))
+	, Layable x (Schematic Monad y (z :> f :> h))
+	, Layable y (Schematic Monad z (f :> h))
+	, Layable z (Schematic Monad f h)
 	, Wrappable f h
 	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where
 	adapt = lay . lay . lay . lay . lay . lay . lay . wrap
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schematic.hs b/Pandora/Paradigm/Controlflow/Joint/Schematic.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Joint/Schematic.hs
@@ -0,0 +1,3 @@
+module Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) where
+
+type family Schematic (c :: (* -> *) -> k) (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> t u
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer.hs
@@ -1,55 +1,10 @@
-module Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (..), (:>) (..)) where
-
-import Pandora.Core.Morphism ((.))
-import Pandora.Core.Transformation (type (~>))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Divariant (($))
-
-class Interpreted t => Transformer t where
-	{-# MINIMAL lay, wrap #-}
-	type Schema (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> t u
-	lay :: Covariant u => u ~> t :> u
-	wrap :: Pointable u => t ~> t :> u
-
-infixr 3 :>
-newtype (:>) t u a = T { trans :: Schema t u a }
-
-instance Covariant (Schema t u) => Covariant (t :> u) where
-	f <$> T x = T $ f <$> x
-
-instance Pointable (Schema t u) => Pointable (t :> u) where
-	point = T . point
-
-instance Extractable (Schema t u) => Extractable (t :> u) where
-	extract = extract . trans
-
-instance Applicative (Schema t u) => Applicative (t :> u) where
-	T f <*> T x = T $ f <*> x
-
-instance Alternative (Schema t u) => Alternative (t :> u) where
-	T x <+> T y = T $ x <+> y
-
-instance Traversable (Schema t u) => Traversable (t :> u) where
-	T x ->> f = T <$> x ->> f
-
-instance Distributive (Schema t u) => Distributive (t :> u) where
-	x >>- f = T $ x >>- trans . f
+module Pandora.Paradigm.Controlflow.Joint.Transformer (module Exports, Transformer) where
 
-instance Bindable (Schema t u) => Bindable (t :> u) where
-	T x >>= f = T $ x >>= trans . f
+import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic as Exports
+import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic as Exports
 
-instance Extendable (Schema t u) => Extendable (t :> u) where
-	T x =>> f = T $ x =>> f . T
+import Pandora.Pattern.Functor (Monad, Comonad)
 
-instance (Interpreted (Schema t u), Transformer t) => Interpreted (t :> u) where
-	type Primary (t :> u) a = Primary (Schema t u) a
-	unwrap (T x) = unwrap x
+type family Transformer c t where
+	Transformer Monad t = Monadic t
+	Transformer Comonad t = Comonadic t
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE UndecidableInstances #-}
+
+module Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (..), (:<) (..)) where
+
+import Pandora.Core.Transformation (type (~>))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Functor.Divariant (($))
+
+class Interpreted t => Comonadic t where
+	{-# MINIMAL flick, bring #-}
+	flick :: Covariant u => t :< u ~> u
+	bring :: Extractable u => t :< u ~> t
+
+infixr 3 :<
+newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }
+
+instance Covariant (Schematic Comonad t u) => Covariant (t :< u) where
+	f <$> TC x = TC $ f <$> x
+
+instance Pointable (Schematic Comonad t u) => Pointable (t :< u) where
+	point = TC . point
+
+instance Extractable (Schematic Comonad t u) => Extractable (t :< u) where
+	extract = extract . tc
+
+instance Applicative (Schematic Comonad t u) => Applicative (t :< u) where
+	TC f <*> TC x = TC $ f <*> x
+
+instance Alternative (Schematic Comonad t u) => Alternative (t :< u) where
+	TC x <+> TC y = TC $ x <+> y
+
+instance Traversable (Schematic Comonad t u) => Traversable (t :< u) where
+	TC x ->> f = TC <$> x ->> f
+
+instance Distributive (Schematic Comonad t u) => Distributive (t :< u) where
+	x >>- f = TC $ x >>- tc . f
+
+instance Bindable (Schematic Comonad t u) => Bindable (t :< u) where
+	TC x >>= f = TC $ x >>= tc . f
+
+instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where
+	TC x =>> f = TC $ x =>> f . TC
+
+instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where
+	type Primary (t :< u) a = Primary (Schematic Comonad t u) a
+	unwrap (TC x) = unwrap x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE UndecidableInstances #-}
+
+module Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (..), (:>) (..)) where
+
+import Pandora.Core.Transformation (type (~>))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor.Divariant (($))
+
+class Interpreted t => Monadic t where
+	{-# MINIMAL lay, wrap #-}
+	lay :: Covariant u => u ~> t :> u
+	wrap :: Pointable u => t ~> t :> u
+
+infixr 3 :>
+newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
+
+instance Covariant (Schematic Monad t u) => Covariant (t :> u) where
+	f <$> TM x = TM $ f <$> x
+
+instance Pointable (Schematic Monad t u) => Pointable (t :> u) where
+	point = TM . point
+
+instance Extractable (Schematic Monad t u) => Extractable (t :> u) where
+	extract = extract . tm
+
+instance Applicative (Schematic Monad t u) => Applicative (t :> u) where
+	TM f <*> TM x = TM $ f <*> x
+
+instance Alternative (Schematic Monad t u) => Alternative (t :> u) where
+	TM x <+> TM y = TM $ x <+> y
+
+instance Traversable (Schematic Monad t u) => Traversable (t :> u) where
+	TM x ->> f = TM <$> x ->> f
+
+instance Distributive (Schematic Monad t u) => Distributive (t :> u) where
+	x >>- f = TM $ x >>- tm . f
+
+instance Bindable (Schematic Monad t u) => Bindable (t :> u) where
+	TM x >>= f = TM $ x >>= tm . f
+
+instance Extendable (Schematic Monad t u) => Extendable (t :> u) where
+	TM x =>> f = TM $ x =>> f . TM
+
+instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where
+	type Primary (t :> u) a = Primary (Schematic Monad t u) a
+	unwrap (TM x) = unwrap x
diff --git a/Pandora/Paradigm/Controlflow/Observable.hs b/Pandora/Paradigm/Controlflow/Observable.hs
--- a/Pandora/Paradigm/Controlflow/Observable.hs
+++ b/Pandora/Paradigm/Controlflow/Observable.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Controlflow.Observable (Observable, observe,
 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where
 
-import Pandora.Core.Morphism ((.))
+import Pandora.Pattern.Category ((.))
 import Pandora.Paradigm.Basis.Continuation (Continuation (Continuation, continue))
 import Pandora.Pattern.Functor.Applicative (Applicative (forever))
 import Pandora.Pattern.Functor.Divariant (($))
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Inventory (module Exports) where
 
 import Pandora.Paradigm.Inventory.Optics as Exports
-import Pandora.Paradigm.Inventory.Storage as Exports
+import Pandora.Paradigm.Inventory.Store as Exports
 import Pandora.Paradigm.Inventory.State as Exports
 import Pandora.Paradigm.Inventory.Environment as Exports
 import Pandora.Paradigm.Inventory.Accumulator as Exports
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,18 +2,19 @@
 
 module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where
 
-import Pandora.Core.Functor (Variant (Co))
-import Pandora.Core.Morphism ((.))
 import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>) (T))
+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.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 
@@ -33,29 +34,30 @@
 	Accumulator (e :*: x) >>= f = let (e' :*: b) = unwrap $ f x in
 		Accumulator $ e + e':*: b
 
+type instance Schematic Monad (Accumulator e) u = UT Covariant Covariant ((:*:) e) u
+
 instance Interpreted (Accumulator e) where
 	type Primary (Accumulator e) a = e :*: a
 	unwrap (Accumulator x) = x
 
-instance Monoid e => Transformer (Accumulator e) where
-	type Schema (Accumulator e) u = UT 'Co 'Co ((:*:) e) u
-	lay x = T . UT $ (zero :*:) <$> x
-	wrap = T . UT . point . unwrap
+instance Monoid e => Monadic (Accumulator e) where
+	lay x = TM . UT $ (zero :*:) <$> x
+	wrap = TM . UT . point . unwrap
 
 type Accumulated e t = Adaptable (Accumulator e) t
 
-instance Covariant u => Covariant (UT 'Co 'Co ((:*:) e) u) where
+instance Covariant u => Covariant (UT Covariant Covariant ((:*:) e) u) where
 	f <$> UT x = UT $ f <$$> x
 
-instance (Semigroup e, Applicative u) => Applicative (UT 'Co 'Co ((:*:) e) u) where
+instance (Semigroup e, Applicative u) => Applicative (UT Covariant Covariant ((:*:) e) u) where
 	UT f <*> UT x = UT $ k <$> f <*> x where
 		k ~(u :*: g) ~(v :*: y) = u + v :*: g y
 
-instance (Pointable u, Monoid e) => Pointable (UT 'Co 'Co ((:*:) e) u) where
+instance (Pointable u, Monoid e) => Pointable (UT Covariant Covariant ((:*:) e) u) where
 	point = UT . point . (zero :*:)
 
-instance (Semigroup e, Pointable u, Bindable u) => Bindable (UT 'Co 'Co ((:*:) e) u) where
+instance (Semigroup e, Pointable u, Bindable u) => Bindable (UT Covariant Covariant ((:*:) e) u) where
 	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> unwrap (f v)
 
-gather :: (Covariant t, Accumulated e t) => e -> t ()
+gather :: Accumulated e t => e -> t ()
 gather x = adapt . Accumulator $ x :*: ()
diff --git a/Pandora/Paradigm/Inventory/Environment.hs b/Pandora/Paradigm/Inventory/Environment.hs
--- a/Pandora/Paradigm/Inventory/Environment.hs
+++ b/Pandora/Paradigm/Inventory/Environment.hs
@@ -2,12 +2,13 @@
 
 module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where
 
-import Pandora.Core.Functor (Variant (Co))
-import Pandora.Core.Morphism (identity, (.), (!), (%))
+import Pandora.Core.Morphism ((!), (%))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>) (T))
+import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
+import Pandora.Pattern.Category (identity, (.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
@@ -35,28 +36,29 @@
 
 instance Monad (Environment e) where
 
+type instance Schematic Monad (Environment e) u = TU Covariant Covariant ((->) e) u
+
 instance Interpreted (Environment e) where
 	type Primary (Environment e) a = (->) e a
 	unwrap (Environment x) = x
 
-instance Transformer (Environment e) where
-	type Schema (Environment e) u = TU 'Co 'Co ((->) e) u
-	lay = T . TU . (!)
-	wrap x = T. TU $ point <$> unwrap x
+instance Monadic (Environment e) where
+	lay = TM . TU . (!)
+	wrap x = TM. TU $ point <$> unwrap x
 
 type Configured e = Adaptable (Environment e)
 
-instance Covariant u => Covariant (TU 'Co 'Co ((->) e) u) where
+instance Covariant u => Covariant (TU Covariant Covariant ((->) e) u) where
 	f <$> TU x = TU $ \r -> f <$> x r
 
-instance (Covariant u, Pointable u) => Pointable (TU 'Co 'Co ((->) e) u) where
+instance (Covariant u, Pointable u) => Pointable (TU Covariant Covariant ((->) e) u) where
 	point = TU . point . point
 
-instance Applicative u => Applicative (TU 'Co 'Co ((->) e) u) where
+instance Applicative u => Applicative (TU Covariant Covariant ((->) e) u) where
 	TU f <*> TU x = TU $ \r -> f r <*> x r
 
-instance Bindable u => Bindable (TU 'Co 'Co ((->) e) u) where
+instance Bindable u => Bindable (TU Covariant Covariant ((->) e) u) where
 	TU x >>= f = TU $ \e -> x e >>= ($ e) . unwrap . f
 
-env :: (Covariant t, Configured e t) => t e
+env :: Configured e t => t e
 env = adapt $ Environment identity
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
@@ -2,24 +2,25 @@
 
 module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, (^.), (.~), (%~)) where
 
-import Pandora.Core.Morphism ((.), (!), (%))
+import Pandora.Core.Morphism ((!), (%))
 import Pandora.Paradigm.Basis.Product (Product ((:*:)))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (unwrap))
 import Pandora.Paradigm.Inventory.State (State (State))
-import Pandora.Paradigm.Inventory.Storage (Storage (Storage), access, position, retrofit)
+import Pandora.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)
+import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Functor.Divariant (($))
 
-instance Adjoint (Storage s) (State s) where
-	v -| f = State $ \s -> (:*:) s . f . Storage $ s :*: (v !)
-	Storage (s :*: f) |- g = extract . unwrap % s . g $ f s
+instance Adjoint (Store s) (State s) where
+	v -| f = State $ \s -> (:*:) s . f . Store $ s :*: (v !)
+	Store (s :*: f) |- g = extract . unwrap % s . g $ f s
 
 infixr 0 :-.
 type (:-.) src tgt = Lens src tgt
 
-type Lens src tgt = src -> Storage tgt src
+type Lens src tgt = src -> Store tgt src
 
 -- | Lens composition infix operator
 (|>) :: Lens src btw -> Lens btw 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
@@ -2,14 +2,9 @@
 
 module Pandora.Paradigm.Inventory.State (State (..), Stateful, current, modify, replace, fold, find) where
 
-import Pandora.Core.Functor (Variant (Co), type (:.), type (:=))
-import Pandora.Core.Morphism ((.), (%))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>) (T))
-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))
-import Pandora.Paradigm.Basis.Predicate (Predicate (predicate))
-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)
+import Pandora.Core.Functor (type (:.), type (:=))
+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.Avoidable (Avoidable (empty))
@@ -21,6 +16,13 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (bool)
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))
+import Pandora.Paradigm.Basis.Predicate (Predicate (predicate))
+import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)
 
 newtype State s a = State ((->) s :. (:*:) s := a)
 
@@ -52,32 +54,34 @@
 	type Primary (State s) a = (->) s :. (:*:) s := a
 	unwrap (State x) = x
 
-instance Transformer (State s) where
-	type Schema (State s) u = TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)
-	lay x = T . TUV $ \s -> (s :*:) <$> x
-	wrap x = T . TUV $ point <$> unwrap x
+type instance Schematic Monad (State s) u =
+	TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)
 
+instance Monadic (State s) where
+	lay x = TM . TUV $ \s -> (s :*:) <$> x
+	wrap x = TM . TUV $ point <$> unwrap x
+
 type Stateful s = Adaptable (State s)
 
-instance Covariant u => Covariant (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+instance Covariant u => Covariant (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
 	f <$> TUV x = TUV $ \old -> f <$$> x old
 
-instance Bindable u => Applicative (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+instance Bindable u => Applicative (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
 	TUV f <*> TUV x = TUV $ \old -> f old >>= \(new :*: g) -> g <$$> x new
 
-instance Pointable u => Pointable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+instance Pointable u => Pointable (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
 	point x = TUV $ \s -> point $ s :*: x
 
-instance Bindable u => Bindable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+instance Bindable u => Bindable (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
 	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . unwrap . f $ y
 
-instance Monad u => Monad (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+instance Monad u => Monad (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
 
-current :: (Covariant t, Stateful s t) => t s
+current :: Stateful s t => t s
 current = adapt $ State delta
 
-modify :: (Covariant t, Stateful s t) => (s -> s) -> t ()
+modify :: Stateful s t => (s -> s) -> t ()
 modify f = adapt $ State $ \s -> f s :*: ()
 
-replace :: (Covariant t, Stateful s t) => s -> t ()
+replace :: Stateful s t => s -> t ()
 replace s = adapt $ State $ \_ -> s :*: ()
diff --git a/Pandora/Paradigm/Inventory/Storage.hs b/Pandora/Paradigm/Inventory/Storage.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Inventory/Storage.hs
+++ /dev/null
@@ -1,33 +0,0 @@
-module Pandora.Paradigm.Inventory.Storage (Storage (..), position, access, retrofit) where
-
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Core.Morphism ((.), (%))
-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Divariant (($))
-
-newtype Storage p a = Storage { stored :: (:*:) p :. (->) p := a }
-
-instance Covariant (Storage p) where
-	g <$> Storage (p :*: f) = Storage . (:*:) p $ (g .) f
-
-instance Extractable (Storage p) where
-	extract (Storage (p :*: f)) = f p
-
-instance Extendable (Storage p) where
-	Storage (old :*: f) =>> g = Storage . (:*:) old
-		$ \new -> g . Storage $ new :*: f
-
-instance Comonad (Storage p) where
-
-position :: Storage p a -> p
-position (Storage (p :*: _)) = p
-
-access :: p -> Storage p a -> a
-access p = extract % p . stored
-
-retrofit :: (p -> p) -> Storage p a -> Storage p a
-retrofit g (Storage (p :*: f)) = Storage $ g p :*: f
diff --git a/Pandora/Paradigm/Inventory/Store.hs b/Pandora/Paradigm/Inventory/Store.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Inventory/Store.hs
@@ -0,0 +1,61 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Inventory.Store (Store (..), position, access, retrofit) where
+
+import Pandora.Core.Functor (type (:.), type (:=), type (<-|))
+import Pandora.Core.Morphism ((%))
+import Pandora.Core.Transformation (type (~>))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))
+import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
+
+newtype Store p a = Store ((:*:) p :. (->) p := a)
+
+instance Covariant (Store p) where
+	f <$> Store (p :*: x) = Store . (:*:) p $ f <$> x
+
+instance Extractable (Store p) where
+	extract (Store (p :*: f)) = f p
+
+instance Extendable (Store p) where
+	Store (old :*: x) =>> f = Store . (:*:) old
+		$ \new -> f <$> Store $ new :*: x
+
+instance Comonad (Store p) where
+
+instance Interpreted (Store p) where
+	type Primary (Store p) a = (:*:) p :. (->) p := a
+	unwrap (Store x) = x
+
+type instance Schematic Comonad (Store p) u =
+	TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)
+
+instance Comonadic (Store p) where
+	flick (TC (TUV (p :*: f))) = ($ p) <$> f
+	bring (TC (TUV (p :*: f))) = Store $ p :*: extract f
+
+instance Covariant u => Covariant (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
+	f <$> TUV (p :*: x) = TUV . (:*:) p $ f <$$> x
+
+instance Extractable u => Extractable (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
+	extract (TUV (p :*: x)) = extract x p
+
+instance Extendable u => Extendable (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
+	TUV (old :*: x) =>> f = TUV . (:*:) old $ x =>> (\x' new -> f . TUV . (:*:) new $ x')
+
+position :: Store p a -> p
+position (Store (p :*: _)) = p
+
+access :: p -> a <-| Store p
+access p = extract % p . unwrap
+
+retrofit :: (p -> p) -> Store p ~> Store p
+retrofit g (Store (p :*: f)) = Store $ g p :*: f
diff --git a/Pandora/Paradigm/Structure/Specific/Binary.hs b/Pandora/Paradigm/Structure/Specific/Binary.hs
--- a/Pandora/Paradigm/Structure/Specific/Binary.hs
+++ b/Pandora/Paradigm/Structure/Specific/Binary.hs
@@ -2,13 +2,19 @@
 
 import Pandora.Core.Morphism ((&))
 import Pandora.Paradigm.Basis.Wye (Wye (End, Left, Right, Both))
-import Pandora.Paradigm.Basis.Twister (Twister ((:<)))
+import Pandora.Paradigm.Basis.Twister (Twister (Twister))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)), order)
 
 type Binary = Twister Wye
 
 insert :: Chain a => a -> Binary a -> Binary a
-insert x (y :< End) = x <=> y & order (y :< Right (x :< End)) (y :< Right (x :< End)) (y :< Left (x :< End))
-insert x (y :< Left ls) = x <=> y & order (y :< Both ls (x :< End)) (y :< Both ls (x :< End)) (y :< Left (insert x ls))
-insert x (y :< Right rs) = x <=> y & order (y :< Right (insert x rs)) (y :< Right (insert x rs)) (y :< Both (x :< End) rs)
-insert x (y :< Both ls rs) = x <=> y & order (y :< Both ls (insert x rs)) (y :< Both ls (insert x rs)) (y :< Both (insert x ls) rs)
+insert x (Twister y End) = x <=> y & order (Twister y . Right $ Twister x End)
+	(Twister y . Right $ Twister x End) (Twister y . Left $ Twister x End)
+insert x (Twister y (Left ls)) = x <=> y & order (Twister y . Both ls $ Twister x End)
+	(Twister y $ Both ls $ Twister x End) (Twister y . Left $ insert x ls)
+insert x (Twister y (Right rs)) = x <=> y & order (Twister y . Right $ insert x rs)
+	(Twister y $ Right (insert x rs)) (Twister y $ Both (Twister x End) rs)
+insert x (Twister y (Both ls rs)) = x <=> y & order (Twister y . Both ls $ insert x rs)
+	(Twister y . Both ls $ insert x rs) (Twister y $ Both (insert x ls) rs)
diff --git a/Pandora/Paradigm/Structure/Specific/Graph.hs b/Pandora/Paradigm/Structure/Specific/Graph.hs
--- a/Pandora/Paradigm/Structure/Specific/Graph.hs
+++ b/Pandora/Paradigm/Structure/Specific/Graph.hs
@@ -1,29 +1,26 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
 module Pandora.Paradigm.Structure.Specific.Graph (Graph, loose) where
 
-import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Transformation (type (~>))
-import Pandora.Core.Morphism ((.))
-import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))
-import Pandora.Paradigm.Basis.Twister (Twister ((:<)))
-import Pandora.Paradigm.Inventory.State (fold)
+import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-
--- | Acyclic graph structure without loops
-newtype Graph a = Graph (Edges :. Twister Edges := a)
+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)
 
-instance Covariant Graph where
-	f <$> Graph stack = Graph $ f <$$> stack
+-- | Directed acyclic graph structure
+type Graph = UT Covariant Covariant (Twister Edges) Edges
 
-instance Traversable Graph where
-	Graph stack ->> f = Graph <$> stack ->>> f
+instance Covariant (UT Covariant Covariant (Twister Edges) Edges) where
+	f <$> UT g = UT $ f <$$> g
 
-instance Interpreted Graph where
-	type Primary Graph a = Edges :. Twister Edges := a
-	unwrap (Graph stack) = stack
+instance Traversable (UT Covariant Covariant (Twister Edges) Edges) where
+	UT g ->> f = UT <$> g ->>> f
 
 -- | Transform any traversable structure into all loose edges graph
 loose :: Traversable t => t ~> Graph
-loose = Graph . fold Empty (\x -> Overlay . (:<) x)
+loose = UT . fold Empty (\x -> Overlay . Twister x)
diff --git a/Pandora/Paradigm/Structure/Specific/Stack.hs b/Pandora/Paradigm/Structure/Specific/Stack.hs
--- a/Pandora/Paradigm/Structure/Specific/Stack.hs
+++ b/Pandora/Paradigm/Structure/Specific/Stack.hs
@@ -1,13 +1,14 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
 module Pandora.Paradigm.Structure.Specific.Stack (Stack, push, top, pop, filter, linearize) where
 
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Core.Morphism ((.))
 import Pandora.Core.Transformation (type (~>))
 import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))
-import Pandora.Paradigm.Basis.Twister (Twister ((:<)), untwist)
+import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)
 import Pandora.Paradigm.Inventory.State (fold)
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
@@ -20,43 +21,39 @@
 import Pandora.Pattern.Object.Setoid ((?))
 
 -- | Linear data structure that serves as a collection of elements
-newtype Stack a = Stack (Maybe :. Twister Maybe := a)
-
-instance Covariant Stack where
-	f <$> Stack stack = Stack $ f <$$> stack
+type Stack = UT Covariant Covariant (Twister Maybe) Maybe
 
-instance Pointable Stack where
-	point x = Stack . Just $ x :< Nothing
+instance Covariant (UT Covariant Covariant (Twister Maybe) Maybe) where
+	f <$> UT stack = UT $ f <$$> stack
 
-instance Alternative Stack where
-	Stack stack <+> Stack stack' = Stack $ stack <+> stack'
+instance Pointable (UT Covariant Covariant (Twister Maybe) Maybe) where
+	point = UT . Just . point
 
-instance Avoidable Stack where
-	empty = Stack Nothing
+instance Alternative (UT Covariant Covariant (Twister Maybe) Maybe) where
+	UT x <+> UT y = UT $ x <+> y
 
-instance Applicative Stack where
-	Stack f <*> Stack x = Stack $ f <**> x
+instance Avoidable (UT Covariant Covariant (Twister Maybe) Maybe) where
+	empty = UT Nothing
 
-instance Traversable Stack where
-	Stack stack ->> f = Stack <$> stack ->>> f
+instance Applicative (UT Covariant Covariant (Twister Maybe) Maybe) where
+	UT f <*> UT x = UT $ f <**> x
 
-instance Interpreted Stack where
-	type Primary Stack a = Maybe :. Twister Maybe := a
-	unwrap (Stack stack) = stack
+instance Traversable (UT Covariant Covariant (Twister Maybe) Maybe) where
+	UT stack ->> f = UT <$> stack ->>> f
 
 push :: a -> Stack a -> Stack a
-push x (Stack stack) = Stack $ ((:<) x . Just <$> stack) <+> (point . point) x
+push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x
 
 top :: Stack ~> Maybe
-top (Stack stack) = extract <$> stack
+top (UT stack) = extract <$> stack
 
 pop :: Stack ~> Stack
-pop (Stack stack) = Stack $ stack >>= untwist
+pop (UT stack) = UT $ stack >>= untwist
 
 filter :: Predicate a -> Stack a -> Stack a
-filter (Predicate p) = Stack . fold empty
-	(\now new -> p now ? Just (now :< new) $ new)
+filter (Predicate p) = UT . fold empty
+	(\now new -> p now ? Just (Twister now new) $ new)
 
 -- | Transform any traversable structure into a stack
 linearize :: Traversable t => t ~> Stack
-linearize = Stack . fold Nothing (\x -> Just . (:<) x)
+linearize = UT . fold Nothing (\x -> Just . Twister x)
diff --git a/Pandora/Pattern.hs b/Pandora/Pattern.hs
--- a/Pandora/Pattern.hs
+++ b/Pandora/Pattern.hs
@@ -1,5 +1,5 @@
 module Pandora.Pattern (module Exports) where
 
 import Pandora.Pattern.Object as Exports
-import Pandora.Paradigm.Controlflow.Joint as Exports
 import Pandora.Pattern.Functor as Exports
+import Pandora.Pattern.Category as Exports
diff --git a/Pandora/Pattern/Category.hs b/Pandora/Pattern/Category.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Category.hs
@@ -0,0 +1,11 @@
+module Pandora.Pattern.Category (Category (..)) where
+
+infixr 8 .
+
+class Category (m :: * -> * -> *) where
+	identity :: m a a
+	(.) :: m b c -> m a b -> m a c
+
+instance Category (->) where
+	identity x = x
+	f . g = \x -> f (g x)
diff --git a/Pandora/Pattern/Functor/Adjoint.hs b/Pandora/Pattern/Functor/Adjoint.hs
--- a/Pandora/Pattern/Functor/Adjoint.hs
+++ b/Pandora/Pattern/Functor/Adjoint.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Adjoint (Adjoint (..), type (-|)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Core.Morphism (identity)
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 type (-|) = Adjoint
diff --git a/Pandora/Pattern/Functor/Applicative.hs b/Pandora/Pattern/Functor/Applicative.hs
--- a/Pandora/Pattern/Functor/Applicative.hs
+++ b/Pandora/Pattern/Functor/Applicative.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Applicative (Applicative (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Core.Morphism (identity)
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)))
 
 infixl 4 <*>, <*, *>
diff --git a/Pandora/Pattern/Functor/Bindable.hs b/Pandora/Pattern/Functor/Bindable.hs
--- a/Pandora/Pattern/Functor/Bindable.hs
+++ b/Pandora/Pattern/Functor/Bindable.hs
@@ -1,7 +1,8 @@
 module Pandora.Pattern.Functor.Bindable (Bindable (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Core.Morphism ((%), identity)
+import Pandora.Core.Morphism ((%))
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 infixl 1 >>=
diff --git a/Pandora/Pattern/Functor/Contravariant.hs b/Pandora/Pattern/Functor/Contravariant.hs
--- a/Pandora/Pattern/Functor/Contravariant.hs
+++ b/Pandora/Pattern/Functor/Contravariant.hs
@@ -1,7 +1,8 @@
 module Pandora.Pattern.Functor.Contravariant (Contravariant (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Core.Morphism ((.), (!), (%))
+import Pandora.Core.Morphism ((!), (%))
+import Pandora.Pattern.Category ((.))
 
 infixl 4 >$<, $<, >$
 
diff --git a/Pandora/Pattern/Functor/Covariant.hs b/Pandora/Pattern/Functor/Covariant.hs
--- a/Pandora/Pattern/Functor/Covariant.hs
+++ b/Pandora/Pattern/Functor/Covariant.hs
@@ -1,7 +1,8 @@
 module Pandora.Pattern.Functor.Covariant (Covariant (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (<-|))
-import Pandora.Core.Morphism (fix, (.), (!), (%))
+import Pandora.Core.Morphism (fix, (!), (%))
+import Pandora.Pattern.Category ((.))
 
 infixl 4 <$>, <$, $>
 
diff --git a/Pandora/Pattern/Functor/Distributive.hs b/Pandora/Pattern/Functor/Distributive.hs
--- a/Pandora/Pattern/Functor/Distributive.hs
+++ b/Pandora/Pattern/Functor/Distributive.hs
@@ -1,9 +1,9 @@
 module Pandora.Pattern.Functor.Distributive (Distributive (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Core.Morphism (identity, (.), (%))
+import Pandora.Core.Morphism ((%))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-
+import Pandora.Pattern.Category (identity, (.))
 {- |
 > Let f :: Distributive g => (a -> g b)
 
diff --git a/Pandora/Pattern/Functor/Divariant.hs b/Pandora/Pattern/Functor/Divariant.hs
--- a/Pandora/Pattern/Functor/Divariant.hs
+++ b/Pandora/Pattern/Functor/Divariant.hs
@@ -1,8 +1,6 @@
 module Pandora.Pattern.Functor.Divariant (Divariant (..)) where
 
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-import Pandora.Core.Morphism ((.))
+import Pandora.Pattern.Category ((.))
 
 infixl 4 >->
 infixr 0 $
@@ -13,16 +11,14 @@
 > * Interpreted: dimap (f . g) (h . i) ≡ dimap g h . dimap f i
 -}
 
-class (forall a . Covariant (t a)) => Divariant (t :: * -> * -> *) where
+class Divariant (v :: * -> * -> *) where
 	{-# MINIMAL (>->) #-}
-	-- | Infix version of 'comap'
-	(>->) :: (a -> b) -> (c -> d) -> t b c -> t a d
-
+	(>->) :: v a b -> v c d -> v b c -> v a d
 	-- | Prefix version of '>->'
-	dimap :: (a -> b) -> (c -> d) -> t b c -> t a d
-	dimap f g x = (f >-> g) x
-
-	($) :: t a b -> t a b
+	dimap :: v a b -> v c d -> v b c -> v a d
+	dimap f g x = f >-> g $ x
+	-- Generalized function application
+	($) :: v a b -> v a b
 	($) f = f
 
 instance Divariant ((->)) where
diff --git a/Pandora/Pattern/Functor/Extendable.hs b/Pandora/Pattern/Functor/Extendable.hs
--- a/Pandora/Pattern/Functor/Extendable.hs
+++ b/Pandora/Pattern/Functor/Extendable.hs
@@ -1,7 +1,8 @@
 module Pandora.Pattern.Functor.Extendable (Extendable (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Core.Morphism ((.), (%), identity)
+import Pandora.Core.Morphism ((%))
+import Pandora.Pattern.Category (identity, (.))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 infixl 1 =>>
diff --git a/Pandora/Pattern/Functor/Representable.hs b/Pandora/Pattern/Functor/Representable.hs
--- a/Pandora/Pattern/Functor/Representable.hs
+++ b/Pandora/Pattern/Functor/Representable.hs
@@ -1,7 +1,8 @@
 module Pandora.Pattern.Functor.Representable (Representable (..)) where
 
 import Pandora.Core.Functor (type (<-|))
-import Pandora.Core.Morphism (identity, (%))
+import Pandora.Core.Morphism ((%))
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Functor.Pointable (Pointable)
 
 {- |
diff --git a/Pandora/Pattern/Functor/Traversable.hs b/Pandora/Pattern/Functor/Traversable.hs
--- a/Pandora/Pattern/Functor/Traversable.hs
+++ b/Pandora/Pattern/Functor/Traversable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Traversable (Traversable (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Core.Morphism (identity, (.))
+import Pandora.Pattern.Category (identity, (.))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Applicative (Applicative)
 import Pandora.Pattern.Functor.Pointable (Pointable)
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.2.2
+version:             0.2.3
 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
@@ -55,6 +55,9 @@
     Pandora.Paradigm.Controlflow.Joint
     Pandora.Paradigm.Controlflow.Joint.Interpreted
     Pandora.Paradigm.Controlflow.Joint.Transformer
+    Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic
+    Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic
+    Pandora.Paradigm.Controlflow.Joint.Schematic
     Pandora.Paradigm.Controlflow.Joint.Adaptable
     Pandora.Paradigm.Controlflow.Joint.Schemes
     Pandora.Paradigm.Controlflow.Joint.Schemes.TU
@@ -70,7 +73,7 @@
     Pandora.Paradigm.Inventory.Environment
     Pandora.Paradigm.Inventory.Optics
     Pandora.Paradigm.Inventory.State
-    Pandora.Paradigm.Inventory.Storage
+    Pandora.Paradigm.Inventory.Store
     -- Tree-based datastructures
     Pandora.Paradigm.Structure
     Pandora.Paradigm.Structure.Cartesian
@@ -81,6 +84,8 @@
     Pandora.Paradigm.Structure.Specific.Binary
 
     Pandora.Pattern
+    -- Category typeclass
+    Pandora.Pattern.Category
     -- Functor typeclassess
     Pandora.Pattern.Functor
     Pandora.Pattern.Functor.Adjoint
@@ -119,6 +124,5 @@
     FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms
     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes
     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators
-    UndecidableInstances
   default-language: Haskell2010
   ghc-options: -Wall -fno-warn-tabs