diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -84,3 +84,18 @@
 * Remove `:!:` type operator
 * Define `Composition` and `Transformer` instances for `Maybe` and `Conclusion`
 * Define `Core`, `Paradigm` and `Pattern` umbrella modules
+
+# 0.1.9
+* Change `Stack` definition: from type synonymous to newtype, change operations accordingly
+* Define `.:.` composition: the same thing but with reverse order
+* Change `Nonempty` type family, family instances should be defined for each data structure
+* Define `:>` type operator for transformers
+* Define `Distributive` instance for `->` datatype
+* Rename `idle` method of `Avoidable` typeclass to `empty`
+* Remove `a` parameter from `Layout` to be able to use natural transformations in methods
+* Return `filter` method to `Stack` data structure
+* Rename `unwrap` to `untwist` method in `Twister` module
+* Rename `composition` to `unwrap` and `Outline` to `Primary` in `Composition` typeclass
+* Rename `equip` to `wrap` and `Layout` to `Schema` in `Transformer` typeclass
+* Make `Composition` a superclass for `Transformer` typeclass
+* Move all `Junction` modules to `Pattern` submodule except `Kan`
diff --git a/Pandora/Core/Functor.hs b/Pandora/Core/Functor.hs
--- a/Pandora/Core/Functor.hs
+++ b/Pandora/Core/Functor.hs
@@ -1,9 +1,12 @@
-module Pandora.Core.Functor (Variant (..), type (:.:), type (><)) where
+module Pandora.Core.Functor (Variant (..), type (:.:), type (.:.), type (><)) where
 
 data Variant = Co | Contra
 
 infixr 1 :.:
 type (:.:) t u a = t (u a)
+
+infixr 1 .:.
+type (.:.) t u a = u (t a)
 
 infixr 0 ><
 type (><) t a = t a
diff --git a/Pandora/Paradigm.hs b/Pandora/Paradigm.hs
--- a/Pandora/Paradigm.hs
+++ b/Pandora/Paradigm.hs
@@ -1,7 +1,6 @@
 module Pandora.Paradigm (module Exports) where
 
 import Pandora.Paradigm.Structure as Exports
-import Pandora.Paradigm.Junction as Exports
 import Pandora.Paradigm.Inventory as Exports
 import Pandora.Paradigm.Controlflow as Exports
 import Pandora.Paradigm.Basis as Exports
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,9 @@
 module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), conclusion, fail) where
 
 import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Junction.Composition (Composition (Outline, composition))
-import Pandora.Paradigm.Junction.Transformer (Transformer (Layout, lay, equip))
-import Pandora.Paradigm.Junction.Schemes.UT (UT (UT))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
+import Pandora.Pattern.Junction.Transformer (Transformer (Schema, lay, wrap))
+import Pandora.Pattern.Junction.Schemes.UT (UT (UT))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
@@ -43,13 +43,13 @@
 instance Monad (Conclusion e) where
 
 instance Composition (Conclusion e) where
-	type Outline (Conclusion e) a = Conclusion e a
-	composition x = x
+	type Primary (Conclusion e) a = Conclusion e a
+	unwrap x = x
 
 instance Transformer (Conclusion e) where
-	type Layout (Conclusion e) u a = UT (Conclusion e) () (Conclusion e) u a
+	type Schema (Conclusion e) u = UT (Conclusion e) () (Conclusion e) u
 	lay x = UT $ Success <$> x
-	equip x = UT . point $ x
+	wrap x = UT . point $ x
 
 instance Covariant u => Covariant (UT (Conclusion e) () (Conclusion e) u) where
 	f <$> UT x = UT $ f <$$> x
@@ -61,7 +61,7 @@
 	point = UT . point . point
 
 instance (Pointable u, Bindable u) => Bindable (UT (Conclusion e) () (Conclusion e) u) where
-	UT x >>= f = UT $ x >>= conclusion (point . Failure) (composition . f)
+	UT x >>= f = UT $ x >>= conclusion (point . Failure) (unwrap . f)
 
 instance Monad u => Monad (UT (Conclusion e) () (Conclusion e) u) where
 
diff --git a/Pandora/Paradigm/Basis/Free.hs b/Pandora/Paradigm/Basis/Free.hs
--- a/Pandora/Paradigm/Basis/Free.hs
+++ b/Pandora/Paradigm/Basis/Free.hs
@@ -1,16 +1,16 @@
 module Pandora.Paradigm.Basis.Free (Free (..)) where
 
-import Pandora.Core.Functor (type (:.:))
+import Pandora.Core.Functor (type (:.:), type (><))
 import Pandora.Core.Morphism (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (idle))
+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 ((>>=)))
 
-data Free t a = Pure a | Impure ((t :.: Free t) a)
+data Free t a = Pure a | Impure (t :.: Free t >< a)
 
 instance Covariant t => Covariant (Free t) where
 	f <$> Pure x = Pure $ f x
@@ -25,7 +25,7 @@
 	Impure xs <+> Impure ys = Impure $ xs <+> ys
 
 instance Avoidable t => Avoidable (Free t) where
-	idle = Impure idle
+	empty = Impure empty
 
 instance Covariant t => Applicative (Free t) where
 	Pure f <*> Pure y = Pure $ f y
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
@@ -5,7 +5,7 @@
 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 (idle))
+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))
@@ -28,7 +28,7 @@
 	Other x <+> Other y = Other (x <+> y)
 
 instance Avoidable t => Avoidable (Jack t) where
-	idle = Other idle
+	empty = Other empty
 
 instance Extractable t => Extractable (Jack t) where
 	extract (It x) = x
diff --git a/Pandora/Paradigm/Basis/Jet.hs b/Pandora/Paradigm/Basis/Jet.hs
--- a/Pandora/Paradigm/Basis/Jet.hs
+++ b/Pandora/Paradigm/Basis/Jet.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Basis.Jet (Jet (..)) where
 
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (idle))
+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 ((<*>)))
@@ -18,7 +18,7 @@
 	a :- as ->> f = (:-) <$> f a <*> as ->>> f
 
 instance (forall t' . Avoidable t') => Pointable (Jet t) where
-	point x = x :- idle
+	point x = x :- empty
 
 instance Covariant t => Extractable (Jet t) where
 	extract (x :- _) = x
diff --git a/Pandora/Paradigm/Basis/Kan.hs b/Pandora/Paradigm/Basis/Kan.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Basis/Kan.hs
@@ -0,0 +1,17 @@
+module Pandora.Paradigm.Basis.Kan (Lan (..), Ran (..)) where
+
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+
+newtype Lan (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
+	Lan { lan :: (t b -> a) -> u b }
+
+instance Contravariant (Lan t u b) where
+	f >$< Lan x = Lan $ x . (f .)
+
+newtype Ran (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
+	Ran { ran :: (a -> t b) -> u b }
+
+instance Covariant (Ran t u b) where
+	f <$> Ran x = Ran $ x . (. f)
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 (..), maybe) where
 
 import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Junction.Composition (Composition (Outline, composition))
-import Pandora.Paradigm.Junction.Transformer (Transformer (Layout, lay, equip))
-import Pandora.Paradigm.Junction.Schemes.UT (UT (UT))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
+import Pandora.Pattern.Junction.Transformer (Transformer (Schema, lay, wrap))
+import Pandora.Pattern.Junction.Schemes.UT (UT (UT))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (idle))
+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))
@@ -29,7 +29,7 @@
 	point = Just
 
 instance Avoidable Maybe where
-	idle = Nothing
+	empty = Nothing
 
 instance Applicative Maybe where
 	Just f <*> x = f <$> x
@@ -50,13 +50,13 @@
 instance Monad Maybe where
 
 instance Composition Maybe where
-	type Outline Maybe a = Maybe a
-	composition x = x
+	type Primary Maybe a = Maybe a
+	unwrap x = x
 
 instance Transformer Maybe where
-	type Layout Maybe u a = UT Maybe () Maybe u a
+	type Schema Maybe u = UT Maybe () Maybe u
 	lay x = UT $ Just <$> x
-	equip x = UT . point $ x
+	wrap x = UT . point $ x
 
 instance Covariant u => Covariant (UT Maybe () Maybe u) where
 	f <$> UT x = UT $ f <$$> x
@@ -68,7 +68,7 @@
 	point = UT . point . point
 
 instance (Pointable u, Bindable u) => Bindable (UT Maybe () Maybe u) where
-	UT x >>= f = UT $ x >>= maybe (point Nothing) (composition . f)
+	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f)
 
 instance Monad u => Monad (UT Maybe () Maybe u) where
 
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
@@ -1,9 +1,9 @@
-module Pandora.Paradigm.Basis.Twister (Twister (..), unwrap, coiterate, section) where
+module Pandora.Paradigm.Basis.Twister (Twister (..), untwist, coiterate, section) where
 
-import Pandora.Core.Functor (type (:.:))
+import Pandora.Core.Functor (type (:.:), type (><))
 import Pandora.Core.Transformation (type (~>))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), comap))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (idle))
+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 ((<+>)))
@@ -19,13 +19,13 @@
 
 infixr 5 :<
 
-data Twister t a = a :< (t :.: Twister t) a
+data Twister t a = a :< (t :.: Twister t >< a)
 
 instance Covariant t => Covariant (Twister t) where
 	f <$> (x :< xs) = f x :< (f <$$> xs)
 
 instance Avoidable t => Pointable (Twister t) where
-	point x = x :< idle
+	point x = x :< empty
 
 instance Covariant t => Extractable (Twister t) where
 	extract (x :< _) = x
@@ -41,7 +41,7 @@
 		y :< ys -> y :< (ys <+> comap (>>= f) xs)
 
 instance Covariant t => Extendable (Twister t) where
-	x =>> f = f x :< (extend f <$> unwrap x)
+	x =>> f = f x :< (extend f <$> untwist x)
 
 instance (Avoidable t, Alternative t) => Monad (Twister t) where
 
@@ -56,8 +56,8 @@
 instance (Monoid a, forall b . Semigroup b => Monoid (t b)) => Monoid (Twister t a) where
 	zero = zero :< zero
 
-unwrap :: Twister t a -> (t :.: Twister t) a
-unwrap (_ :< xs) = xs
+untwist :: Twister t a -> (t :.: Twister t) a
+untwist (_ :< xs) = xs
 
 coiterate :: Covariant t => (a -> t a) -> a -> Twister t a
 coiterate coalgebra x = x :< (coiterate coalgebra <$> coalgebra x)
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
@@ -4,7 +4,7 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (idle))
+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 (phi, psi))
@@ -22,7 +22,7 @@
 	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)
 
 instance Avoidable t => Avoidable (Yoneda t) where
-	idle = Yoneda (idle !)
+	empty = Yoneda (empty !)
 
 instance Pointable t => Pointable (Yoneda t) where
 	point x = Yoneda (\f -> point $ f x)
diff --git a/Pandora/Paradigm/Inventory/Stateful.hs b/Pandora/Paradigm/Inventory/Stateful.hs
--- a/Pandora/Paradigm/Inventory/Stateful.hs
+++ b/Pandora/Paradigm/Inventory/Stateful.hs
@@ -1,16 +1,16 @@
 module Pandora.Paradigm.Inventory.Stateful
-	(Stateful (..), get, modify, put, fold, find) where
+	(Stateful (..), statefully, get, modify, put, fold, find) where
 
 import Pandora.Core.Functor (type (:.:), type (><))
 import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Junction.Composition (Composition (Outline, composition))
-import Pandora.Paradigm.Junction.Transformer (Transformer (Layout, lay, equip))
-import Pandora.Paradigm.Junction.Schemes.TUV (TUV (TUV))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
+import Pandora.Pattern.Junction.Transformer (Transformer (Schema, lay, wrap))
+import Pandora.Pattern.Junction.Schemes.TUV (TUV (TUV))
 import Pandora.Paradigm.Basis.Predicate (Predicate (predicate))
 import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (idle))
+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
@@ -55,16 +55,16 @@
 	struct ->> modify . op $> () *> get
 
 find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a
-find p struct = fold idle (\x s -> (<+>) s . bool idle (point x) . predicate p $ x) struct
+find p struct = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x) struct
 
 instance Composition (Stateful s) where
-	type Outline (Stateful s) a = (->) s :.: (:*:) s >< a
-	composition (Stateful x) = x
+	type Primary (Stateful s) a = (->) s :.: (:*:) s >< a
+	unwrap (Stateful x) = x
 
 instance Transformer (Stateful s) where
-	type Layout (Stateful s) u a = TUV Stateful () Stateful ((->) s) u ((:*:) s) a
+	type Schema (Stateful s) u = TUV Stateful () Stateful ((->) s) u ((:*:) s)
 	lay x = TUV $ \s -> (s :*:) <$> x
-	equip x = TUV $ point <$> composition x
+	wrap x = TUV $ point <$> unwrap x
 
 instance Covariant u => Covariant (TUV Stateful () Stateful ((->) s) u ((:*:) s)) where
 	f <$> TUV x = TUV $ \old -> f <$$> x old
@@ -76,6 +76,6 @@
 	point x = TUV $ \s -> point $ s :*: x
 
 instance Bindable u => Bindable (TUV Stateful () Stateful ((->) s) u ((:*:) s)) where
-	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . composition . f $ y
+	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . unwrap . f $ y
 
 instance Monad u => Monad (TUV Stateful () Stateful ((->) s) u ((:*:) s)) where
diff --git a/Pandora/Paradigm/Junction.hs b/Pandora/Paradigm/Junction.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module Pandora.Paradigm.Junction (module Exports) where
-
-import Pandora.Paradigm.Junction.Kan as Exports
-import Pandora.Paradigm.Junction.Transformer as Exports
-import Pandora.Paradigm.Junction.Composition as Exports
diff --git a/Pandora/Paradigm/Junction/Composition.hs b/Pandora/Paradigm/Junction/Composition.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction/Composition.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module Pandora.Paradigm.Junction.Composition (Composition (..)) where
-
-class Composition t where
-	{-# MINIMAL composition #-}
-	type Outline t a :: *
-	composition :: t a -> Outline t a
diff --git a/Pandora/Paradigm/Junction/Kan.hs b/Pandora/Paradigm/Junction/Kan.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction/Kan.hs
+++ /dev/null
@@ -1,17 +0,0 @@
-module Pandora.Paradigm.Junction.Kan (Lan (..), Ran (..)) where
-
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-
-newtype Lan (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
-	Lan { lan :: (t b -> a) -> u b }
-
-instance Contravariant (Lan t u b) where
-	f >$< Lan x = Lan $ x . (f .)
-
-newtype Ran (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
-	Ran { ran :: (a -> t b) -> u b }
-
-instance Covariant (Ran t u b) where
-	f <$> Ran x = Ran $ x . (. f)
diff --git a/Pandora/Paradigm/Junction/Schemes.hs b/Pandora/Paradigm/Junction/Schemes.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction/Schemes.hs
+++ /dev/null
@@ -1,7 +0,0 @@
-module Pandora.Paradigm.Junction.Schemes (module Exports) where
-
-import Pandora.Paradigm.Junction.Schemes.UTU as Exports
-import Pandora.Paradigm.Junction.Schemes.UT as Exports
-import Pandora.Paradigm.Junction.Schemes.TUVW as Exports
-import Pandora.Paradigm.Junction.Schemes.TUV as Exports
-import Pandora.Paradigm.Junction.Schemes.TU as Exports
diff --git a/Pandora/Paradigm/Junction/Schemes/TU.hs b/Pandora/Paradigm/Junction/Schemes/TU.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction/Schemes/TU.hs
+++ /dev/null
@@ -1,60 +0,0 @@
-module Pandora.Paradigm.Junction.Schemes.TU (TU (..)) where
-
-import Pandora.Core.Functor (Variant (Co, Contra), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Junction.Composition (Composition (Outline, composition))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), comap))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<), (>$$<)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (idle))
-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.Distributive (Distributive ((>>-), distribute))
-import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
-
-newtype TU ct cu t u a = TU (t :.: u >< a)
-
-instance Composition (TU ct cu t u) where
-	type Outline (TU ct cu t u) a = t :.: u >< a
-	composition (TU x) = x
-
-instance (Covariant t, Covariant u) => Covariant (TU 'Co 'Co t u) where
-	f <$> TU x = TU $ f <$$> x
-
-instance (Covariant t, Contravariant u) => Contravariant (TU 'Co 'Contra t u) where
-	f >$< TU x = TU $ (f >$<) <$> x
-
-instance (Contravariant t, Covariant u) => Contravariant (TU 'Contra 'Co t u) where
-	f >$< TU x = TU $ (f <$>) >$< x
-
-instance (Contravariant t, Contravariant u) => Covariant (TU 'Contra 'Contra t u) where
-	f <$> TU x = TU $ f >$$< x
-
-instance (Pointable t, Pointable u) => Pointable (TU 'Co 'Co t u) where
-	point = TU . point . point
-
-instance (Extractable t, Extractable u) => Extractable (TU 'Co 'Co t u) where
-	extract = extract . extract . composition
-
-instance (Avoidable t, Covariant u) => Avoidable (TU 'Co 'Co t u) where
-	idle = TU idle
-
-instance (Applicative t, Applicative u) => Applicative (TU 'Co 'Co t u) where
-	TU f <*> TU x = TU $ apply <$> f <*> x
-
-instance (Alternative t, Covariant u) => Alternative (TU 'Co 'Co t u) where
-	TU x <+> TU y = TU $ x <+> y
-
-instance (Traversable t, Traversable u) => Traversable (TU 'Co 'Co t u) where
-	TU x ->> f = TU <$> x ->>> f
-
-instance (Distributive t, Distributive u) => Distributive (TU 'Co 'Co t u) where
-	x >>- f = TU . comap distribute . distribute $ composition . f <$> x
-
-type (:-|:) t u = (Extractable t, Pointable t, Extractable u, Pointable u, Adjoint t u)
-
-instance (t :-|: u, v :-|: w) => Adjoint (TU 'Co 'Co t v) (TU 'Co 'Co u w) where
-	phi f = point . f . point
-	psi f = extract . extract . comap f
diff --git a/Pandora/Paradigm/Junction/Schemes/TUV.hs b/Pandora/Paradigm/Junction/Schemes/TUV.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction/Schemes/TUV.hs
+++ /dev/null
@@ -1,88 +0,0 @@
-module Pandora.Paradigm.Junction.Schemes.TUV (TUV (..)) where
-
-import Pandora.Core.Functor (Variant (Co, Contra), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Junction.Composition (Composition (Outline, composition))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), comap))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<), (>$$<), (>$$$<)), contramap)
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (idle))
-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.Distributive (Distributive ((>>-), distribute))
-import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
-
-newtype TUV ct cu cv t u v a = TUV (t :.: u :.: v >< a)
-
-instance Composition (TUV ct cu cv t u v) where
-	type Outline (TUV ct cu cv t u v) a = t :.: u :.: v >< a
-	composition (TUV x) = x
-
-instance (Covariant t, Covariant u, Covariant v)
-	=> Covariant (TUV 'Co 'Co 'Co t u v) where
-	f <$> TUV x = TUV $ f <$$$> x
-
-instance (Covariant t, Covariant u, Contravariant v)
-	=> Contravariant (TUV 'Co 'Co 'Contra t u v) where
-	f >$< TUV x = TUV $ (f >$<) <$$> x
-
-instance (Covariant t, Contravariant u, Covariant v)
-	=> Contravariant (TUV 'Co 'Contra 'Co t u v) where
-	f >$< TUV x = TUV $ contramap (comap f) <$> x
-
-instance (Contravariant t, Covariant u, Covariant v)
-	=> Contravariant (TUV 'Contra 'Co 'Co t u v) where
-	f >$< TUV x = TUV $ (f <$$>) >$< x
-
-instance (Contravariant t, Contravariant u, Covariant v)
-	=> Covariant (TUV 'Contra 'Contra 'Co t u v) where
-	f <$> TUV x = TUV $ contramap (comap f) >$< x
-
-instance (Covariant t, Contravariant u, Contravariant v)
-	=> Covariant (TUV 'Co 'Contra 'Contra t u v) where
-	f <$> TUV x = TUV $ (f >$$<) <$> x
-
-instance (Contravariant t, Covariant u, Contravariant v)
-	=> Covariant (TUV 'Contra 'Co 'Contra t u v) where
-	f <$> TUV x = TUV $ comap (contramap f) >$< x
-
-instance (Contravariant t, Contravariant u, Contravariant v)
-	=> Contravariant (TUV 'Contra 'Contra 'Contra t u v) where
-	f >$< TUV x = TUV $ f >$$$< x
-
-instance (Pointable t, Pointable u, Pointable v)
-	=> Pointable (TUV 'Co 'Co 'Co t u v) where
-	point = TUV . point . point . point
-
-instance (Extractable t, Extractable u, Extractable v)
-	=> Extractable (TUV 'Co 'Co 'Co t u v) where
-	extract = extract . extract . extract . composition
-
-instance (Avoidable t, Covariant u, Covariant v)
-	=> Avoidable (TUV 'Co 'Co 'Co t u v) where
-	idle = TUV idle
-
-instance (Applicative t, Applicative u, Applicative v)
-	=> Applicative (TUV 'Co 'Co 'Co t u v) where
-	TUV f <*> TUV x = TUV $ ((apply <$>) . (apply <$$>) $ f) <*> x
-
-instance (Alternative t, Covariant u, Covariant v)
-	=> Alternative (TUV 'Co 'Co 'Co t u v) where
-	TUV x <+> TUV y = TUV $ x <+> y
-
-instance (Traversable t, Traversable u, Traversable v)
-	=> Traversable (TUV 'Co 'Co 'Co t u v) where
-	TUV x ->> f = TUV <$> x ->>>> f
-
-instance (Distributive t, Distributive u, Distributive v)
-	=> Distributive (TUV 'Co 'Co 'Co t u v) where
-	x >>- f = TUV . (distribute <$$>) . (distribute <$>) . distribute $ composition . f <$> x
-
-type (:-|:) t u = (Extractable t, Pointable t, Extractable u, Pointable u, Adjoint t u)
-
-instance (t :-|: w, v :-|: x, u :-|: y)
-	=> Adjoint (TUV 'Co 'Co 'Co t v u) (TUV 'Co 'Co 'Co w x y) where
-	phi f = point . f . point
-	psi f = extract . extract . comap f
diff --git a/Pandora/Paradigm/Junction/Schemes/TUVW.hs b/Pandora/Paradigm/Junction/Schemes/TUVW.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction/Schemes/TUVW.hs
+++ /dev/null
@@ -1,120 +0,0 @@
-module Pandora.Paradigm.Junction.Schemes.TUVW (TUVW (..)) where
-
-import Pandora.Core.Functor (Variant (Co, Contra), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Junction.Composition (Composition (Outline, composition))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>), comap))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<), (>$$<), (>$$$<), (>$$$$<), contramap))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (idle))
-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.Distributive (Distributive ((>>-), distribute))
-import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
-
-newtype TUVW ct cu cv cw t u v w a = TUVW (t :.: u :.: v :.: w >< a)
-
-instance Composition (TUVW ct cu cv cw t u v w) where
-	type Outline (TUVW ct cu cv cw t u v w) a = t :.: u :.: v :.: w >< a
-	composition (TUVW x) = x
-
-instance (Covariant t, Covariant u, Covariant v, Covariant w)
-	=> Covariant (TUVW 'Co 'Co 'Co 'Co t u v w) where
-	f <$> TUVW x = TUVW $ f <$$$$> x
-
-instance (Covariant t, Covariant u, Covariant v, Contravariant w)
-	=> Contravariant (TUVW 'Co 'Co 'Co 'Contra t u v w) where
-	f >$< TUVW x = TUVW $ (f >$<) <$$$> x
-
-instance (Covariant t, Covariant u, Contravariant v, Covariant w)
-	=> Contravariant (TUVW 'Co 'Co 'Contra 'Co t u v w) where
-	f >$< TUVW x = TUVW $ (contramap (comap f)) <$$> x
-
-instance (Covariant t, Contravariant u, Covariant v, Covariant w)
-	=> Contravariant (TUVW 'Co 'Contra 'Co 'Co t u v w) where
-	f >$< TUVW x = TUVW $ (contramap (comap (comap f))) <$> x
-
-instance (Contravariant t, Covariant u, Covariant v, Covariant w)
-	=> Contravariant (TUVW 'Contra 'Co 'Co 'Co t u v w) where
-	f >$< TUVW x = TUVW $ (f <$$$>) >$< x
-
-instance (Contravariant t, Contravariant u, Covariant v, Covariant w)
-	=> Covariant (TUVW 'Contra 'Contra 'Co 'Co t u v w) where
-	f <$> TUVW x = TUVW $ (contramap . contramap . comap . comap $ f) x
-
-instance (Covariant t, Contravariant u, Contravariant v, Covariant w)
-	=> Covariant (TUVW 'Co 'Contra 'Contra 'Co t u v w) where
-	f <$> TUVW x = TUVW $ (comap . contramap . contramap . comap $ f) x
-
-instance (Covariant t, Covariant u, Contravariant v, Contravariant w)
-	=> Covariant (TUVW 'Co 'Co 'Contra 'Contra t u v w) where
-	f <$> TUVW x = TUVW $ (f >$$<) <$$> x
-
-instance (Covariant t, Contravariant u, Covariant v, Contravariant w)
-	=> Covariant (TUVW 'Co 'Contra 'Co 'Contra t u v w) where
-	f <$> TUVW x = TUVW $ (comap . contramap . comap . contramap $ f) x
-
-instance (Contravariant t, Covariant u, Contravariant v, Covariant w)
-	=> Covariant (TUVW 'Contra 'Co 'Contra 'Co t u v w) where
-	f <$> TUVW x = TUVW $ (contramap . comap . contramap . comap $ f) x
-
-instance (Contravariant t, Covariant u, Covariant v, Contravariant w)
-	=> Covariant (TUVW 'Contra 'Co 'Co 'Contra t u v w) where
-	f <$> TUVW x = TUVW $ (contramap . comap . comap . contramap $ f) x
-
-instance (Contravariant t, Contravariant u, Contravariant v, Covariant w)
-	=> Contravariant (TUVW 'Contra 'Contra 'Contra 'Co t u v w) where
-	f >$< TUVW x = TUVW $ (f <$>) >$$$< x
-
-instance (Covariant t, Contravariant u, Contravariant v, Contravariant w)
-	=> Contravariant (TUVW 'Co 'Contra 'Contra 'Contra t u v w) where
-	f >$< TUVW x = TUVW $ (f >$$$<) <$> x
-
-instance (Contravariant t, Covariant u, Contravariant v, Contravariant w)
-	=> Contravariant (TUVW 'Contra 'Co 'Contra 'Contra t u v w) where
-	f >$< TUVW x = TUVW $ (contramap . comap . contramap . contramap) f x
-
-instance (Contravariant t, Contravariant u, Covariant v, Contravariant w)
-	=> Contravariant (TUVW 'Contra 'Contra 'Co 'Contra t u v w) where
-	f >$< TUVW x = TUVW $ (contramap . contramap . comap . contramap) f x
-
-instance (Contravariant t, Contravariant u, Contravariant v, Contravariant w)
-	=> Covariant (TUVW 'Contra 'Contra 'Contra 'Contra t u v w) where
-	f <$> TUVW x = TUVW $ f >$$$$< x
-
-instance (Pointable t, Pointable u, Pointable v, Pointable w)
-	=> Pointable (TUVW 'Co 'Co 'Co 'Co t u v w) where
-	point = TUVW . point . point . point . point
-
-instance (Extractable t, Extractable u, Extractable v, Extractable w)
-	=> Extractable (TUVW 'Co 'Co 'Co 'Co t u v w) where
-	extract = extract . extract . extract . extract . composition
-
-instance (Avoidable t, Covariant u, Covariant v, Covariant w)
-	=> Avoidable (TUVW 'Co 'Co 'Co 'Co t u v w) where
-	idle = TUVW idle
-
-instance (Applicative t, Applicative u, Applicative v, Applicative w)
-	=> Applicative (TUVW 'Co 'Co 'Co 'Co t u v w) where
-	TUVW f <*> TUVW x = TUVW $ ((apply <$>) . (apply <$$>) . (apply <$$$>) $ f) <*> x
-
-instance (Alternative t, Covariant u, Covariant v, Covariant w)
-	=> Alternative (TUVW 'Co 'Co 'Co 'Co t u v w) where
-	TUVW x <+> TUVW y = TUVW $ x <+> y
-
-instance (Traversable t, Traversable u, Traversable v, Traversable w)
-	=> Traversable (TUVW 'Co 'Co 'Co 'Co t u v w) where
-	TUVW x ->> f = TUVW <$> x ->>>>> f
-
-instance (Distributive t, Distributive u, Distributive v, Distributive w)
-	=> Distributive (TUVW 'Co 'Co 'Co 'Co t u v w) where
-	x >>- f = TUVW . (distribute <$$$>) . (distribute <$$>) . (distribute <$>) . distribute $ composition . f <$> x
-
-type (:-|:) t u = (Extractable t, Pointable t, Extractable u, Pointable u, Adjoint t u)
-
-instance (t :-|: u, v :-|: w, q :-|: q, r :-|: s)
-	=> Adjoint (TUVW 'Co 'Co 'Co 'Co t v q r) (TUVW 'Co 'Co 'Co 'Co u w q s) where
-	phi f = point . f . point
-	psi f = extract . extract . comap f
diff --git a/Pandora/Paradigm/Junction/Schemes/UT.hs b/Pandora/Paradigm/Junction/Schemes/UT.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction/Schemes/UT.hs
+++ /dev/null
@@ -1,67 +0,0 @@
-module Pandora.Paradigm.Junction.Schemes.UT (UT (..)) where
-
-import Pandora.Core.Functor (Variant (Co), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Junction.Composition (Composition (Outline, composition))
-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.Avoidable (Avoidable (idle))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
-import Pandora.Pattern.Functor.Liftable (Liftable (lift))
-import Pandora.Pattern.Functor.Lowerable (Lowerable (lower))
-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))
-
-newtype UT ct cu t u a = UT (u :.: t >< a)
-
-instance Composition (UT ct cu t u) where
-	type Outline (UT ct cu t u) a = u :.: t >< a
-	composition (UT x) = x
-
-instance (Covariant t, Covariant u) => Covariant (UT 'Co 'Co t u) where
-	f <$> UT x = UT $ f <$$> x
-
-instance (Pointable t, Pointable u) => Pointable (UT 'Co 'Co t u) where
-	point = UT . point . point
-
-instance (Extractable t, Extractable u) => Extractable (UT 'Co 'Co t u) where
-	extract = extract . extract . composition
-
-instance (Covariant t, Avoidable u) => Avoidable (UT 'Co 'Co t u) where
-	idle = UT idle
-
-instance (Covariant t, Alternative u) => Alternative (UT 'Co 'Co t u) where
-	UT x <+> UT y = UT $ x <+> y
-
-instance (Applicative t, Applicative u) => Applicative (UT 'Co 'Co t u) where
-	UT f <*> UT x = UT $ apply <$> f <*> x
-
-instance Pointable t => Liftable (UT 'Co 'Co t) where
-	lift x = UT $ point <$> x
-
-instance Extractable t => Lowerable (UT 'Co 'Co t) where
-	lower (UT x) = extract <$> x
-
-instance (Traversable t, Traversable u) => Traversable (UT 'Co 'Co t u) where
-	UT x ->> f = UT <$> x ->>> f
-
-instance (Distributive t, Distributive u) => Distributive (UT 'Co 'Co t u) where
-	x >>- f = UT . comap distribute . distribute $ composition . f <$> x
-
-instance Setoid (u :.: t >< a) => Setoid (UT 'Co 'Co t u a) where
-	UT x == UT y = x == y
-
-instance Chain (u :.: t >< a) => Chain (UT 'Co 'Co t u a) where
-	UT x <=> UT y = x <=> y
-
-instance Semigroup (u :.: t >< a) => Semigroup (UT 'Co 'Co t u a) where
-	UT x + UT y = UT $ x + y
-
-instance Monoid (u :.: t >< a) => Monoid (UT 'Co 'Co t u a) where
-	zero = UT zero
diff --git a/Pandora/Paradigm/Junction/Schemes/UTU.hs b/Pandora/Paradigm/Junction/Schemes/UTU.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction/Schemes/UTU.hs
+++ /dev/null
@@ -1,67 +0,0 @@
-module Pandora.Paradigm.Junction.Schemes.UTU (UTU (..)) where
-
-import Pandora.Core.Functor (Variant (Co), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Junction.Composition (Composition (Outline, composition))
-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.Avoidable (Avoidable (idle))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
-import Pandora.Pattern.Functor.Liftable (Liftable (lift))
-import Pandora.Pattern.Functor.Lowerable (Lowerable (lower))
-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))
-
-newtype UTU ct cu t u a = UTU (u :.: t u >< a)
-
-instance Composition (UTU ct cu t u) where
-	type Outline (UTU ct cu t u) a = u :.: t u >< a
-	composition (UTU x) = x
-
-instance (Covariant (t u), Covariant u) => Covariant (UTU 'Co 'Co t u) where
-	f <$> UTU x = UTU $ f <$$> x
-
-instance (Pointable (t u), Pointable u) => Pointable (UTU 'Co 'Co t u) where
-	point = UTU . point . point
-
-instance (Extractable (t u), Extractable u) => Extractable (UTU 'Co 'Co t u) where
-	extract = extract . extract . composition
-
-instance (Covariant (t u), Avoidable u) => Avoidable (UTU 'Co 'Co t u) where
-	idle = UTU idle
-
-instance (Covariant (t u), Alternative u) => Alternative (UTU 'Co 'Co t u) where
-	UTU x <+> UTU y = UTU $ x <+> y
-
-instance (Applicative (t u), Applicative u) => Applicative (UTU 'Co 'Co t u) where
-	UTU f <*> UTU x = UTU $ apply <$> f <*> x
-
-instance (Traversable (t u), Traversable u) => Traversable (UTU 'Co 'Co t u) where
-	UTU x ->> f = UTU <$> x ->>> f
-
-instance (Distributive (t u), Distributive u) => Distributive (UTU 'Co 'Co t u) where
-	x >>- f = UTU . comap distribute . distribute $ composition . f <$> x
-
-instance (forall u' . Pointable u', Liftable t) => Liftable (UTU 'Co 'Co t) where
-	lift = UTU . point . lift
-
-instance (forall u' . Extractable u', Lowerable t) => Lowerable (UTU 'Co 'Co t) where
-	lower = lower . extract . composition
-
-instance (forall u' . Setoid (u' :.: t u' >< a)) => Setoid (UTU 'Co 'Co t u a) where
-	UTU x == UTU y = x == y
-
-instance (forall u' . Chain (u' :.: t u' >< a)) => Chain (UTU 'Co 'Co t u a) where
-	UTU x <=> UTU y = x <=> y
-
-instance (forall u' . Semigroup (u' :.: t u' >< a)) => Semigroup (UTU 'Co 'Co t u a) where
-	UTU x + UTU y = UTU $ x + y
-
-instance (forall u' . Monoid (u' :.: t u' >< a)) => Monoid (UTU 'Co 'Co t u a) where
-	zero = UTU zero
diff --git a/Pandora/Paradigm/Junction/Transformer.hs b/Pandora/Paradigm/Junction/Transformer.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Junction/Transformer.hs
+++ /dev/null
@@ -1,10 +0,0 @@
-module Pandora.Paradigm.Junction.Transformer (Transformer (..)) where
-
-import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Pointable (Pointable)
-
-class Transformer t where
-	{-# MINIMAL lay, equip #-}
-	type Layout (t :: * -> *) (u :: * -> *) (a :: *) = r | r -> t u
-	lay :: Covariant u => u a -> Layout t u a
-	equip :: Pointable u => t a -> Layout t u a
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -4,9 +4,9 @@
 import Pandora.Paradigm.Structure.Graph as Exports
 import Pandora.Paradigm.Structure.Stack as Exports
 
-import Pandora.Core.Functor (type (:.:))
+import Pandora.Paradigm.Basis.Maybe (Maybe)
 import Pandora.Paradigm.Basis.Twister (Twister)
 
 -- | Type synonymous for at least one element data structure
-type family Nonempty structure :: * where
-	Nonempty ((t :.: Twister t) a) = Twister t a
+type family Nonempty (structure :: * -> *) where
+	Nonempty Stack = Twister Maybe
diff --git a/Pandora/Paradigm/Structure/Graph.hs b/Pandora/Paradigm/Structure/Graph.hs
--- a/Pandora/Paradigm/Structure/Graph.hs
+++ b/Pandora/Paradigm/Structure/Graph.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Structure.Graph (Graph, loose) where
 
-import Pandora.Core.Functor (type (:.:))
+import Pandora.Core.Functor (type (:.:), type (><))
 import Pandora.Core.Morphism ((.))
 import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))
 import Pandora.Paradigm.Basis.Twister (Twister ((:<)))
@@ -8,7 +8,7 @@
 import Pandora.Pattern.Functor.Traversable (Traversable)
 
 -- | Acyclic graph structure without loops
-type Graph a = (Edges :.: Twister Edges) a
+type Graph a = Edges :.: Twister Edges >< a
 
 -- | Transform any traversable structure into all loose edges graph
 loose :: Traversable t => t a -> Graph a
diff --git a/Pandora/Paradigm/Structure/Stack.hs b/Pandora/Paradigm/Structure/Stack.hs
--- a/Pandora/Paradigm/Structure/Stack.hs
+++ b/Pandora/Paradigm/Structure/Stack.hs
@@ -1,29 +1,61 @@
-module Pandora.Paradigm.Structure.Stack (Stack, push, top, pop, linearize) where
+module Pandora.Paradigm.Structure.Stack (Stack, push, top, pop, filter, linearize) where
 
 import Pandora.Core.Functor (type (:.:), type (><))
-import Pandora.Core.Morphism ((.))
-import Pandora.Paradigm.Basis.Twister (Twister ((:<)), unwrap)
+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.Inventory.Stateful (fold)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
+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.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Traversable (Traversable)
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Object.Setoid (bool)
 
 -- | Linear data structure that serves as a collection of elements
-type Stack a = Maybe :.: Twister Maybe >< a
+newtype Stack a = Stack (Maybe :.: Twister Maybe >< a)
 
+instance Covariant Stack where
+	f <$> Stack stack = Stack $ f <$$> stack
+
+instance Pointable Stack where
+	point x = Stack . Just $ x :< Nothing
+
+instance Alternative Stack where
+	Stack stack <+> Stack stack' = Stack $ stack <+> stack'
+
+instance Avoidable Stack where
+	empty = Stack Nothing
+
+instance Applicative Stack where
+	Stack f <*> Stack x = Stack $ f <**> x
+
+instance Traversable Stack where
+	Stack stack ->> f = Stack <$> stack ->>> f
+
+instance Composition Stack where
+	type Primary Stack a = Maybe :.: Twister Maybe >< a
+	unwrap (Stack stack) = stack
+
 push :: a -> Stack a -> Stack a
-push x stack = ((:<) x . Just <$> stack) <+> (point . point) x
+push x (Stack stack) = Stack $ ((:<) x . Just <$> stack) <+> (point . point) x
 
-top :: Stack a -> Maybe a
-top stack = extract <$> stack
+top :: Stack ~> Maybe
+top (Stack stack) = extract <$> stack
 
-pop :: Stack a -> Stack a
-pop stack = stack >>= unwrap
+pop :: Stack ~> Stack
+pop (Stack stack) = Stack $ stack >>= untwist
 
+filter :: Predicate a -> Stack a -> Stack a
+filter (Predicate p) = Stack . fold empty
+	(\now new -> bool new (Just $ now :< new) $ p now)
+
 -- | Transform any traversable structure into a stack
-linearize :: Traversable t => t a -> Stack a
-linearize = fold Nothing (\x -> Just . (:<) x)
+linearize :: Traversable t => t ~> Stack
+linearize = Stack . fold Nothing (\x -> Just . (:<) 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,6 +1,6 @@
 module Pandora.Pattern.Functor.Adjoint (Adjoint (..), type (-|)) where
 
-import Pandora.Core.Functor (type (:.:))
+import Pandora.Core.Functor (type (:.:), type (><))
 import Pandora.Core.Morphism (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
@@ -19,9 +19,9 @@
 	-- | Right adjunction
 	psi :: (a -> u b) -> t a -> b
 
-	eta :: a -> (u :.: t) a
+	eta :: a -> u :.: t >< a
 	eta = phi identity
-	epsilon :: (t :.: u) a -> a
+	epsilon :: t :.: u >< a -> a
 	epsilon = psi identity
 
 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,6 +1,6 @@
 module Pandora.Pattern.Functor.Applicative (Applicative (..)) where
 
-import Pandora.Core.Functor (type (:.:))
+import Pandora.Core.Functor (type (:.:), type (><))
 import Pandora.Core.Morphism (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)))
 
@@ -32,13 +32,13 @@
 	forever x = x *> forever x
 
 	-- | Infix versions of `apply` with various nesting levels
-	(<**>) :: Applicative u => (t :.: u) (a -> b) -> (t :.: u) a -> (t :.: u) b
+	(<**>) :: Applicative u => t :.: u >< (a -> b) -> t :.: u >< a -> t :.: u >< b
 	f <**> x = (<*>) <$> f <*> x
-	(<***>) :: (Applicative u, Applicative v) => (t :.: u :.: v) (a -> b)
-		-> (t :.: u :.: v) a -> (t :.: u :.: v) b
+	(<***>) :: (Applicative u, Applicative v) => t :.: u :.: v >< (a -> b)
+		-> t :.: u :.: v >< a -> t :.: u :.: v >< b
 	f <***> x = (<**>) <$> f <*> x
 	(<****>) :: (Applicative u, Applicative v, Applicative w)
-		=> (t :.: u :.: v :.: w) (a -> b)
-		-> (t :.: u :.: v :.: w) a
-		-> (t :.: u :.: v :.: w) b
+		=> t :.: u :.: v :.: w >< (a -> b)
+		-> t :.: u :.: v :.: w >< a
+		-> t :.: u :.: v :.: w >< b
 	f <****> x = (<***>) <$> f <*> x
diff --git a/Pandora/Pattern/Functor/Avoidable.hs b/Pandora/Pattern/Functor/Avoidable.hs
--- a/Pandora/Pattern/Functor/Avoidable.hs
+++ b/Pandora/Pattern/Functor/Avoidable.hs
@@ -4,9 +4,9 @@
 
 {- |
 > When providing a new instance, you should ensure it satisfies the two laws:
-> * Left absorption: x <+> idle ≡ x
-> * Right absorption: idle <+> x ≡ x
+> * Left absorption: x <+> empty ≡ x
+> * Right absorption: empty <+> x ≡ x
 -}
 
 class Alternative t => Avoidable t where
-	idle :: t a
+	empty :: t a
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,6 +1,6 @@
 module Pandora.Pattern.Functor.Bindable (Bindable (..)) where
 
-import Pandora.Core.Functor (type (:.:))
+import Pandora.Core.Functor (type (:.:), type (><))
 import Pandora.Core.Morphism ((?), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
@@ -24,7 +24,7 @@
 	bind :: (a -> t b) -> t a -> t b
 	bind f t = t >>= f
 	-- | Merge effects/contexts, the dual of 'duplicate'
-	join :: (t :.: t) a -> t a
+	join :: t :.: t >< a -> t a
 	join t = t >>= identity
 	-- | Left-to-right Kleisli composition
 	(>=>) :: (a -> t b) -> (b -> t c) -> (a -> t c)
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,8 +1,8 @@
 module Pandora.Pattern.Functor.Distributive (Distributive (..)) where
 
-import Pandora.Core.Functor (type (:.:))
-import Pandora.Core.Morphism (identity, (.))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Core.Functor (type (:.:), type (><))
+import Pandora.Core.Morphism (identity, (.), (?))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 
 {- |
 > Let f :: Distributive g => (a -> g b)
@@ -17,22 +17,25 @@
 class Covariant u => Distributive u where
 	{-# MINIMAL (>>-) #-}
 	-- | Infix version of 'collect'
-	(>>-) :: Covariant t => t a -> (a -> u b) -> (u :.: t) b
+	(>>-) :: Covariant t => t a -> (a -> u b) -> u :.: t >< b
 
 	-- | Prefix version of '>>-'
-	collect :: Covariant t => (a -> u b) -> t a -> (u :.: t) b
+	collect :: Covariant t => (a -> u b) -> t a -> u :.: t >< b
 	collect f t = t >>- f
 	-- | The dual of 'sequence'
-	distribute :: Covariant t => (t :.: u) a -> (u :.: t) a
+	distribute :: Covariant t => t :.: u >< a -> u :.: t >< a
 	distribute t = t >>- identity
 
 	-- | Infix versions of `collect` with various nesting levels
 	(>>>-) :: (Covariant t, Covariant v)
-		=> (t :.: v) a -> (a -> u b) -> (u :.: t :.: v) b
+		=> t :.: v >< a -> (a -> u b) -> u :.: t :.: v >< b
 	x >>>- f = (collect . collect) f x
 	(>>>>-) :: (Covariant t, Covariant v, Covariant w)
-		=> (t :.: v :.: w) a -> (a -> u b) -> (u :.: t :.: v :.: w) b
+		=> t :.: v :.: w >< a -> (a -> u b) -> u :.: t :.: v :.: w >< b
 	x >>>>- f = (collect . collect . collect) f x
 	(>>>>>-) :: (Covariant t, Covariant v, Covariant w, Covariant j)
-		=> (t :.: v :.: w :.: j) a -> (a -> u b) -> (u :.: t :.: v :.: w :.: j) b
+		=> t :.: v :.: w :.: j >< a -> (a -> u b) -> u :.: t :.: v :.: w :.: j >< b
 	x >>>>>- f = (collect . collect . collect . collect) f x
+
+instance Distributive ((->) e) where
+	g >>- f = \e -> (f ? e) <$> g
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,6 +1,6 @@
 module Pandora.Pattern.Functor.Extendable (Extendable (..)) where
 
-import Pandora.Core.Functor (type (:.:))
+import Pandora.Core.Functor (type (:.:), type (><))
 import Pandora.Core.Morphism ((.), (?), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
@@ -25,7 +25,7 @@
 	extend :: (t a -> b) -> t a -> t b
 	extend f t = t =>> f
 	-- | Clone existing structure, the dual of 'join'
-	duplicate :: t a -> (t :.: t) a
+	duplicate :: t a -> t :.: t >< a
 	duplicate t = t =>> identity
 	-- | Right-to-left Cokleisli composition
 	(=<=) :: (t b -> c) -> (t a -> b) -> t a -> c
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,6 +1,6 @@
 module Pandora.Pattern.Functor.Traversable (Traversable (..)) where
 
-import Pandora.Core.Functor (type (:.:))
+import Pandora.Core.Functor (type (:.:), type (><))
 import Pandora.Core.Morphism (identity, (.))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Applicative (Applicative)
@@ -22,22 +22,22 @@
 class Covariant t => Traversable t where
 	{-# MINIMAL (->>) #-}
 	-- | Infix version of 'traverse'
-	(->>) :: (Pointable u, Applicative u) => t a -> (a -> u b) -> (u :.: t) b
+	(->>) :: (Pointable u, Applicative u) => t a -> (a -> u b) -> u :.: t >< b
 
 	-- | Prefix version of '->>'
-	traverse :: (Pointable u, Applicative u) => (a -> u b) -> t a -> (u :.: t) b
+	traverse :: (Pointable u, Applicative u) => (a -> u b) -> t a -> u :.: t >< b
 	traverse f t = t ->> f
 	-- | The dual of 'distribute'
-	sequence :: (Pointable u, Applicative u) => (t :.: u) a -> (u :.: t) a
+	sequence :: (Pointable u, Applicative u) => (t :.: u) a -> u :.: t >< a
 	sequence t = t ->> identity
 
 	-- | Infix versions of `traverse` with various nesting levels
 	(->>>) :: (Pointable u, Applicative u, Traversable v)
-		=> (v :.: t) a -> (a -> u b) -> (u :.: v :.: t) b
+		=> v :.: t >< a -> (a -> u b) -> u :.: v :.: t >< b
 	x ->>> f = (traverse . traverse) f x
 	(->>>>) :: (Pointable u, Applicative u, Traversable v, Traversable w)
-		=> (w :.: v :.: t) a -> (a -> u b) -> (u :.: w :.: v :.: t) b
+		=> w :.: v :.: t >< a -> (a -> u b) -> u :.: w :.: v :.: t >< b
 	x ->>>> f = (traverse . traverse . traverse) f x
 	(->>>>>) :: (Pointable u, Applicative u, Traversable v, Traversable w, Traversable j)
-		=> (j :.: w :.: v :.: t) a -> (a -> u b) -> (u :.: j :.: w :.: v :.: t) b
+		=> j :.: w :.: v :.: t >< a -> (a -> u b) -> u :.: j :.: w :.: v :.: t >< b
 	x ->>>>> f = (traverse . traverse . traverse . traverse) f x
diff --git a/Pandora/Pattern/Junction.hs b/Pandora/Pattern/Junction.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Junction.hs
@@ -0,0 +1,9 @@
+module Pandora.Pattern.Junction (module Exports) where
+
+import Pandora.Pattern.Junction.Schemes.UTU as Exports
+import Pandora.Pattern.Junction.Schemes.UT as Exports
+import Pandora.Pattern.Junction.Schemes.TUVW as Exports
+import Pandora.Pattern.Junction.Schemes.TUV as Exports
+import Pandora.Pattern.Junction.Schemes.TU as Exports
+import Pandora.Pattern.Junction.Transformer as Exports
+import Pandora.Pattern.Junction.Composition as Exports
diff --git a/Pandora/Pattern/Junction/Composition.hs b/Pandora/Pattern/Junction/Composition.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Junction/Composition.hs
@@ -0,0 +1,6 @@
+module Pandora.Pattern.Junction.Composition (Composition (..)) where
+
+class Composition t where
+	{-# MINIMAL unwrap #-}
+	type Primary t a :: *
+	unwrap :: t a -> Primary t a
diff --git a/Pandora/Pattern/Junction/Schemes/TU.hs b/Pandora/Pattern/Junction/Schemes/TU.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Junction/Schemes/TU.hs
@@ -0,0 +1,60 @@
+module Pandora.Pattern.Junction.Schemes.TU (TU (..)) where
+
+import Pandora.Core.Functor (Variant (Co, Contra), type (:.:), type (><))
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), comap))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<), (>$$<)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+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.Distributive (Distributive ((>>-), distribute))
+import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
+
+newtype TU ct cu t u a = TU (t :.: u >< a)
+
+instance Composition (TU ct cu t u) where
+	type Primary (TU ct cu t u) a = t :.: u >< a
+	unwrap (TU x) = x
+
+instance (Covariant t, Covariant u) => Covariant (TU 'Co 'Co t u) where
+	f <$> TU x = TU $ f <$$> x
+
+instance (Covariant t, Contravariant u) => Contravariant (TU 'Co 'Contra t u) where
+	f >$< TU x = TU $ (f >$<) <$> x
+
+instance (Contravariant t, Covariant u) => Contravariant (TU 'Contra 'Co t u) where
+	f >$< TU x = TU $ (f <$>) >$< x
+
+instance (Contravariant t, Contravariant u) => Covariant (TU 'Contra 'Contra t u) where
+	f <$> TU x = TU $ f >$$< x
+
+instance (Pointable t, Pointable u) => Pointable (TU 'Co 'Co t u) where
+	point = TU . point . point
+
+instance (Extractable t, Extractable u) => Extractable (TU 'Co 'Co t u) where
+	extract = extract . extract . unwrap
+
+instance (Avoidable t, Covariant u) => Avoidable (TU 'Co 'Co t u) where
+	empty = TU empty
+
+instance (Applicative t, Applicative u) => Applicative (TU 'Co 'Co t u) where
+	TU f <*> TU x = TU $ apply <$> f <*> x
+
+instance (Alternative t, Covariant u) => Alternative (TU 'Co 'Co t u) where
+	TU x <+> TU y = TU $ x <+> y
+
+instance (Traversable t, Traversable u) => Traversable (TU 'Co 'Co t u) where
+	TU x ->> f = TU <$> x ->>> f
+
+instance (Distributive t, Distributive u) => Distributive (TU 'Co 'Co t u) where
+	x >>- f = TU . comap distribute . distribute $ unwrap . f <$> x
+
+type (:-|:) t u = (Extractable t, Pointable t, Extractable u, Pointable u, Adjoint t u)
+
+instance (t :-|: u, v :-|: w) => Adjoint (TU 'Co 'Co t v) (TU 'Co 'Co u w) where
+	phi f = point . f . point
+	psi f = extract . extract . comap f
diff --git a/Pandora/Pattern/Junction/Schemes/TUV.hs b/Pandora/Pattern/Junction/Schemes/TUV.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Junction/Schemes/TUV.hs
@@ -0,0 +1,88 @@
+module Pandora.Pattern.Junction.Schemes.TUV (TUV (..)) where
+
+import Pandora.Core.Functor (Variant (Co, Contra), type (:.:), type (><))
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), comap))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<), (>$$<), (>$$$<)), contramap)
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+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.Distributive (Distributive ((>>-), distribute))
+import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
+
+newtype TUV ct cu cv t u v a = TUV (t :.: u :.: v >< a)
+
+instance Composition (TUV ct cu cv t u v) where
+	type Primary (TUV ct cu cv t u v) a = t :.: u :.: v >< a
+	unwrap (TUV x) = x
+
+instance (Covariant t, Covariant u, Covariant v)
+	=> Covariant (TUV 'Co 'Co 'Co t u v) where
+	f <$> TUV x = TUV $ f <$$$> x
+
+instance (Covariant t, Covariant u, Contravariant v)
+	=> Contravariant (TUV 'Co 'Co 'Contra t u v) where
+	f >$< TUV x = TUV $ (f >$<) <$$> x
+
+instance (Covariant t, Contravariant u, Covariant v)
+	=> Contravariant (TUV 'Co 'Contra 'Co t u v) where
+	f >$< TUV x = TUV $ contramap (comap f) <$> x
+
+instance (Contravariant t, Covariant u, Covariant v)
+	=> Contravariant (TUV 'Contra 'Co 'Co t u v) where
+	f >$< TUV x = TUV $ (f <$$>) >$< x
+
+instance (Contravariant t, Contravariant u, Covariant v)
+	=> Covariant (TUV 'Contra 'Contra 'Co t u v) where
+	f <$> TUV x = TUV $ contramap (comap f) >$< x
+
+instance (Covariant t, Contravariant u, Contravariant v)
+	=> Covariant (TUV 'Co 'Contra 'Contra t u v) where
+	f <$> TUV x = TUV $ (f >$$<) <$> x
+
+instance (Contravariant t, Covariant u, Contravariant v)
+	=> Covariant (TUV 'Contra 'Co 'Contra t u v) where
+	f <$> TUV x = TUV $ comap (contramap f) >$< x
+
+instance (Contravariant t, Contravariant u, Contravariant v)
+	=> Contravariant (TUV 'Contra 'Contra 'Contra t u v) where
+	f >$< TUV x = TUV $ f >$$$< x
+
+instance (Pointable t, Pointable u, Pointable v)
+	=> Pointable (TUV 'Co 'Co 'Co t u v) where
+	point = TUV . point . point . point
+
+instance (Extractable t, Extractable u, Extractable v)
+	=> Extractable (TUV 'Co 'Co 'Co t u v) where
+	extract = extract . extract . extract . unwrap
+
+instance (Avoidable t, Covariant u, Covariant v)
+	=> Avoidable (TUV 'Co 'Co 'Co t u v) where
+	empty = TUV empty
+
+instance (Applicative t, Applicative u, Applicative v)
+	=> Applicative (TUV 'Co 'Co 'Co t u v) where
+	TUV f <*> TUV x = TUV $ ((apply <$>) . (apply <$$>) $ f) <*> x
+
+instance (Alternative t, Covariant u, Covariant v)
+	=> Alternative (TUV 'Co 'Co 'Co t u v) where
+	TUV x <+> TUV y = TUV $ x <+> y
+
+instance (Traversable t, Traversable u, Traversable v)
+	=> Traversable (TUV 'Co 'Co 'Co t u v) where
+	TUV x ->> f = TUV <$> x ->>>> f
+
+instance (Distributive t, Distributive u, Distributive v)
+	=> Distributive (TUV 'Co 'Co 'Co t u v) where
+	x >>- f = TUV . (distribute <$$>) . (distribute <$>) . distribute $ unwrap . f <$> x
+
+type (:-|:) t u = (Extractable t, Pointable t, Extractable u, Pointable u, Adjoint t u)
+
+instance (t :-|: w, v :-|: x, u :-|: y)
+	=> Adjoint (TUV 'Co 'Co 'Co t v u) (TUV 'Co 'Co 'Co w x y) where
+	phi f = point . f . point
+	psi f = extract . extract . comap f
diff --git a/Pandora/Pattern/Junction/Schemes/TUVW.hs b/Pandora/Pattern/Junction/Schemes/TUVW.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Junction/Schemes/TUVW.hs
@@ -0,0 +1,120 @@
+module Pandora.Pattern.Junction.Schemes.TUVW (TUVW (..)) where
+
+import Pandora.Core.Functor (Variant (Co, Contra), type (:.:), type (><))
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>), comap))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<), (>$$<), (>$$$<), (>$$$$<), contramap))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+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.Distributive (Distributive ((>>-), distribute))
+import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
+
+newtype TUVW ct cu cv cw t u v w a = TUVW (t :.: u :.: v :.: w >< a)
+
+instance Composition (TUVW ct cu cv cw t u v w) where
+	type Primary (TUVW ct cu cv cw t u v w) a = t :.: u :.: v :.: w >< a
+	unwrap (TUVW x) = x
+
+instance (Covariant t, Covariant u, Covariant v, Covariant w)
+	=> Covariant (TUVW 'Co 'Co 'Co 'Co t u v w) where
+	f <$> TUVW x = TUVW $ f <$$$$> x
+
+instance (Covariant t, Covariant u, Covariant v, Contravariant w)
+	=> Contravariant (TUVW 'Co 'Co 'Co 'Contra t u v w) where
+	f >$< TUVW x = TUVW $ (f >$<) <$$$> x
+
+instance (Covariant t, Covariant u, Contravariant v, Covariant w)
+	=> Contravariant (TUVW 'Co 'Co 'Contra 'Co t u v w) where
+	f >$< TUVW x = TUVW $ (contramap (comap f)) <$$> x
+
+instance (Covariant t, Contravariant u, Covariant v, Covariant w)
+	=> Contravariant (TUVW 'Co 'Contra 'Co 'Co t u v w) where
+	f >$< TUVW x = TUVW $ (contramap (comap (comap f))) <$> x
+
+instance (Contravariant t, Covariant u, Covariant v, Covariant w)
+	=> Contravariant (TUVW 'Contra 'Co 'Co 'Co t u v w) where
+	f >$< TUVW x = TUVW $ (f <$$$>) >$< x
+
+instance (Contravariant t, Contravariant u, Covariant v, Covariant w)
+	=> Covariant (TUVW 'Contra 'Contra 'Co 'Co t u v w) where
+	f <$> TUVW x = TUVW $ (contramap . contramap . comap . comap $ f) x
+
+instance (Covariant t, Contravariant u, Contravariant v, Covariant w)
+	=> Covariant (TUVW 'Co 'Contra 'Contra 'Co t u v w) where
+	f <$> TUVW x = TUVW $ (comap . contramap . contramap . comap $ f) x
+
+instance (Covariant t, Covariant u, Contravariant v, Contravariant w)
+	=> Covariant (TUVW 'Co 'Co 'Contra 'Contra t u v w) where
+	f <$> TUVW x = TUVW $ (f >$$<) <$$> x
+
+instance (Covariant t, Contravariant u, Covariant v, Contravariant w)
+	=> Covariant (TUVW 'Co 'Contra 'Co 'Contra t u v w) where
+	f <$> TUVW x = TUVW $ (comap . contramap . comap . contramap $ f) x
+
+instance (Contravariant t, Covariant u, Contravariant v, Covariant w)
+	=> Covariant (TUVW 'Contra 'Co 'Contra 'Co t u v w) where
+	f <$> TUVW x = TUVW $ (contramap . comap . contramap . comap $ f) x
+
+instance (Contravariant t, Covariant u, Covariant v, Contravariant w)
+	=> Covariant (TUVW 'Contra 'Co 'Co 'Contra t u v w) where
+	f <$> TUVW x = TUVW $ (contramap . comap . comap . contramap $ f) x
+
+instance (Contravariant t, Contravariant u, Contravariant v, Covariant w)
+	=> Contravariant (TUVW 'Contra 'Contra 'Contra 'Co t u v w) where
+	f >$< TUVW x = TUVW $ (f <$>) >$$$< x
+
+instance (Covariant t, Contravariant u, Contravariant v, Contravariant w)
+	=> Contravariant (TUVW 'Co 'Contra 'Contra 'Contra t u v w) where
+	f >$< TUVW x = TUVW $ (f >$$$<) <$> x
+
+instance (Contravariant t, Covariant u, Contravariant v, Contravariant w)
+	=> Contravariant (TUVW 'Contra 'Co 'Contra 'Contra t u v w) where
+	f >$< TUVW x = TUVW $ (contramap . comap . contramap . contramap) f x
+
+instance (Contravariant t, Contravariant u, Covariant v, Contravariant w)
+	=> Contravariant (TUVW 'Contra 'Contra 'Co 'Contra t u v w) where
+	f >$< TUVW x = TUVW $ (contramap . contramap . comap . contramap) f x
+
+instance (Contravariant t, Contravariant u, Contravariant v, Contravariant w)
+	=> Covariant (TUVW 'Contra 'Contra 'Contra 'Contra t u v w) where
+	f <$> TUVW x = TUVW $ f >$$$$< x
+
+instance (Pointable t, Pointable u, Pointable v, Pointable w)
+	=> Pointable (TUVW 'Co 'Co 'Co 'Co t u v w) where
+	point = TUVW . point . point . point . point
+
+instance (Extractable t, Extractable u, Extractable v, Extractable w)
+	=> Extractable (TUVW 'Co 'Co 'Co 'Co t u v w) where
+	extract = extract . extract . extract . extract . unwrap
+
+instance (Avoidable t, Covariant u, Covariant v, Covariant w)
+	=> Avoidable (TUVW 'Co 'Co 'Co 'Co t u v w) where
+	empty = TUVW empty
+
+instance (Applicative t, Applicative u, Applicative v, Applicative w)
+	=> Applicative (TUVW 'Co 'Co 'Co 'Co t u v w) where
+	TUVW f <*> TUVW x = TUVW $ ((apply <$>) . (apply <$$>) . (apply <$$$>) $ f) <*> x
+
+instance (Alternative t, Covariant u, Covariant v, Covariant w)
+	=> Alternative (TUVW 'Co 'Co 'Co 'Co t u v w) where
+	TUVW x <+> TUVW y = TUVW $ x <+> y
+
+instance (Traversable t, Traversable u, Traversable v, Traversable w)
+	=> Traversable (TUVW 'Co 'Co 'Co 'Co t u v w) where
+	TUVW x ->> f = TUVW <$> x ->>>>> f
+
+instance (Distributive t, Distributive u, Distributive v, Distributive w)
+	=> Distributive (TUVW 'Co 'Co 'Co 'Co t u v w) where
+	x >>- f = TUVW . (distribute <$$$>) . (distribute <$$>) . (distribute <$>) . distribute $ unwrap . f <$> x
+
+type (:-|:) t u = (Extractable t, Pointable t, Extractable u, Pointable u, Adjoint t u)
+
+instance (t :-|: u, v :-|: w, q :-|: q, r :-|: s)
+	=> Adjoint (TUVW 'Co 'Co 'Co 'Co t v q r) (TUVW 'Co 'Co 'Co 'Co u w q s) where
+	phi f = point . f . point
+	psi f = extract . extract . comap f
diff --git a/Pandora/Pattern/Junction/Schemes/UT.hs b/Pandora/Pattern/Junction/Schemes/UT.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Junction/Schemes/UT.hs
@@ -0,0 +1,67 @@
+module Pandora.Pattern.Junction.Schemes.UT (UT (..)) where
+
+import Pandora.Core.Functor (Variant (Co), type (:.:), type (><))
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
+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.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
+import Pandora.Pattern.Functor.Liftable (Liftable (lift))
+import Pandora.Pattern.Functor.Lowerable (Lowerable (lower))
+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))
+
+newtype UT ct cu t u a = UT (u :.: t >< a)
+
+instance Composition (UT ct cu t u) where
+	type Primary (UT ct cu t u) a = u :.: t >< a
+	unwrap (UT x) = x
+
+instance (Covariant t, Covariant u) => Covariant (UT 'Co 'Co t u) where
+	f <$> UT x = UT $ f <$$> x
+
+instance (Pointable t, Pointable u) => Pointable (UT 'Co 'Co t u) where
+	point = UT . point . point
+
+instance (Extractable t, Extractable u) => Extractable (UT 'Co 'Co t u) where
+	extract = extract . extract . unwrap
+
+instance (Covariant t, Avoidable u) => Avoidable (UT 'Co 'Co t u) where
+	empty = UT empty
+
+instance (Covariant t, Alternative u) => Alternative (UT 'Co 'Co t u) where
+	UT x <+> UT y = UT $ x <+> y
+
+instance (Applicative t, Applicative u) => Applicative (UT 'Co 'Co t u) where
+	UT f <*> UT x = UT $ apply <$> f <*> x
+
+instance Pointable t => Liftable (UT 'Co 'Co t) where
+	lift x = UT $ point <$> x
+
+instance Extractable t => Lowerable (UT 'Co 'Co t) where
+	lower (UT x) = extract <$> x
+
+instance (Traversable t, Traversable u) => Traversable (UT 'Co 'Co t u) where
+	UT x ->> f = UT <$> x ->>> f
+
+instance (Distributive t, Distributive u) => Distributive (UT 'Co 'Co t u) where
+	x >>- f = UT . comap distribute . distribute $ unwrap . f <$> x
+
+instance Setoid (u :.: t >< a) => Setoid (UT 'Co 'Co t u a) where
+	UT x == UT y = x == y
+
+instance Chain (u :.: t >< a) => Chain (UT 'Co 'Co t u a) where
+	UT x <=> UT y = x <=> y
+
+instance Semigroup (u :.: t >< a) => Semigroup (UT 'Co 'Co t u a) where
+	UT x + UT y = UT $ x + y
+
+instance Monoid (u :.: t >< a) => Monoid (UT 'Co 'Co t u a) where
+	zero = UT zero
diff --git a/Pandora/Pattern/Junction/Schemes/UTU.hs b/Pandora/Pattern/Junction/Schemes/UTU.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Junction/Schemes/UTU.hs
@@ -0,0 +1,67 @@
+module Pandora.Pattern.Junction.Schemes.UTU (UTU (..)) where
+
+import Pandora.Core.Functor (Variant (Co), type (:.:), type (><))
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
+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.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
+import Pandora.Pattern.Functor.Liftable (Liftable (lift))
+import Pandora.Pattern.Functor.Lowerable (Lowerable (lower))
+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))
+
+newtype UTU ct cu t u a = UTU (u :.: t u >< a)
+
+instance Composition (UTU ct cu t u) where
+	type Primary (UTU ct cu t u) a = u :.: t u >< a
+	unwrap (UTU x) = x
+
+instance (Covariant (t u), Covariant u) => Covariant (UTU 'Co 'Co t u) where
+	f <$> UTU x = UTU $ f <$$> x
+
+instance (Pointable (t u), Pointable u) => Pointable (UTU 'Co 'Co t u) where
+	point = UTU . point . point
+
+instance (Extractable (t u), Extractable u) => Extractable (UTU 'Co 'Co t u) where
+	extract = extract . extract . unwrap
+
+instance (Covariant (t u), Avoidable u) => Avoidable (UTU 'Co 'Co t u) where
+	empty = UTU empty
+
+instance (Covariant (t u), Alternative u) => Alternative (UTU 'Co 'Co t u) where
+	UTU x <+> UTU y = UTU $ x <+> y
+
+instance (Applicative (t u), Applicative u) => Applicative (UTU 'Co 'Co t u) where
+	UTU f <*> UTU x = UTU $ apply <$> f <*> x
+
+instance (Traversable (t u), Traversable u) => Traversable (UTU 'Co 'Co t u) where
+	UTU x ->> f = UTU <$> x ->>> f
+
+instance (Distributive (t u), Distributive u) => Distributive (UTU 'Co 'Co t u) where
+	x >>- f = UTU . comap distribute . distribute $ unwrap . f <$> x
+
+instance (forall u' . Pointable u', Liftable t) => Liftable (UTU 'Co 'Co t) where
+	lift = UTU . point . lift
+
+instance (forall u' . Extractable u', Lowerable t) => Lowerable (UTU 'Co 'Co t) where
+	lower = lower . extract . unwrap
+
+instance (forall u' . Setoid (u' :.: t u' >< a)) => Setoid (UTU 'Co 'Co t u a) where
+	UTU x == UTU y = x == y
+
+instance (forall u' . Chain (u' :.: t u' >< a)) => Chain (UTU 'Co 'Co t u a) where
+	UTU x <=> UTU y = x <=> y
+
+instance (forall u' . Semigroup (u' :.: t u' >< a)) => Semigroup (UTU 'Co 'Co t u a) where
+	UTU x + UTU y = UTU $ x + y
+
+instance (forall u' . Monoid (u' :.: t u' >< a)) => Monoid (UTU 'Co 'Co t u a) where
+	zero = UTU zero
diff --git a/Pandora/Pattern/Junction/Transformer.hs b/Pandora/Pattern/Junction/Transformer.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Junction/Transformer.hs
@@ -0,0 +1,15 @@
+module Pandora.Pattern.Junction.Transformer (Transformer (..), type (:>)) where
+
+import Pandora.Core.Transformation (type (~>))
+import Pandora.Pattern.Junction.Composition (Composition)
+import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Pointable (Pointable)
+
+class Composition t => Transformer t where
+	{-# MINIMAL lay, wrap #-}
+	type Schema (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> t u
+	lay :: Covariant u => u ~> Schema t u
+	wrap :: Pointable u => t ~> Schema t u
+
+infixr 1 :>
+type (:>) t u a = Transformer t => Schema t u a
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.1.8
+version:             0.1.9
 synopsis:            A box of patterns and paradigms
 description:         Humble attempt to define a library for problem solving based on math abstractions.
 homepage:            https://github.com/iokasimov/pandora
@@ -38,6 +38,7 @@
     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
@@ -48,17 +49,6 @@
     Pandora.Paradigm.Basis.Variation
     Pandora.Paradigm.Basis.Wye
     Pandora.Paradigm.Basis.Yoneda
-    -- Universal functors constructions
-    Pandora.Paradigm.Junction
-    Pandora.Paradigm.Junction.Composition
-    Pandora.Paradigm.Junction.Transformer
-    Pandora.Paradigm.Junction.Kan
-    Pandora.Paradigm.Junction.Schemes
-    Pandora.Paradigm.Junction.Schemes.TU
-    Pandora.Paradigm.Junction.Schemes.TUV
-    Pandora.Paradigm.Junction.Schemes.TUVW
-    Pandora.Paradigm.Junction.Schemes.UT
-    Pandora.Paradigm.Junction.Schemes.UTU
     -- Control flow primitives
     Pandora.Paradigm.Controlflow
     Pandora.Paradigm.Controlflow.Observable
@@ -96,6 +86,15 @@
     Pandora.Pattern.Functor.Monad
     Pandora.Pattern.Functor.Pointable
     Pandora.Pattern.Functor.Traversable
+    -- Typeclassess about functor junctions
+    Pandora.Pattern.Junction
+    Pandora.Pattern.Junction.Composition
+    Pandora.Pattern.Junction.Transformer
+    Pandora.Pattern.Junction.Schemes.TU
+    Pandora.Pattern.Junction.Schemes.TUV
+    Pandora.Pattern.Junction.Schemes.TUVW
+    Pandora.Pattern.Junction.Schemes.UT
+    Pandora.Pattern.Junction.Schemes.UTU
     -- Typeclassess about object internals
     Pandora.Pattern.Object
     Pandora.Pattern.Object.Chain