diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -99,3 +99,14 @@
 * 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`
+
+# 0.2.0
+* Define `Representable` functor typeclass
+* Define `Pointable`, `Applicative`, `Bindable` and `Representable` instances for `->`
+* Define infix `Adjoint` operators - `-|` and `|-`
+* Define `Adjoint` instance for `Stateful` and `Storage` datatypes
+* Change `Graph` definition: from type synonymous to newtype
+* Rename `><` to `>`, `:.:` to `.:`, `.:.` to `:.`
+* Remove all instances for `Junction` schemes
+* Define type operators for profunctorish types: `::|:.`, `::|.:` and `::|::`
+* Define `Divariant` (also known as `Profunctor`) `Functor` typeclass
diff --git a/Pandora/Core/Functor.hs b/Pandora/Core/Functor.hs
--- a/Pandora/Core/Functor.hs
+++ b/Pandora/Core/Functor.hs
@@ -1,12 +1,17 @@
-module Pandora.Core.Functor (Variant (..), type (:.:), type (.:.), type (><)) where
+module Pandora.Core.Functor where
 
 data Variant = Co | Contra
 
-infixr 1 :.:
-type (:.:) t u a = t (u a)
+infixr 1 :.
+type (:.) t u a = t (u a)
 
-infixr 1 .:.
-type (.:.) t u a = u (t a)
+infixr 1 .:
+type (.:) t u a = u (t a)
 
-infixr 0 ><
-type (><) t a = t a
+infixr 0 >
+type (>) t a = t a
+
+infixr 2 ::|:., ::|.:, ::|::
+type (::|:.) p a b = p (p a b) b
+type (::|.:) p a b = p a (p a b)
+type (::|::) p a b = p (p a b) (p a 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,5 +1,6 @@
 module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), conclusion, fail) where
 
+import Pandora.Core.Functor (Variant (Co))
 import Pandora.Core.Morphism ((.), ($))
 import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
 import Pandora.Pattern.Junction.Transformer (Transformer (Schema, lay, wrap))
@@ -47,23 +48,23 @@
 	unwrap x = x
 
 instance Transformer (Conclusion e) where
-	type Schema (Conclusion e) u = UT (Conclusion e) () (Conclusion e) u
+	type Schema (Conclusion e) u = UT 'Co 'Co (Conclusion e) u
 	lay x = UT $ Success <$> x
 	wrap x = UT . point $ x
 
-instance Covariant u => Covariant (UT (Conclusion e) () (Conclusion e) u) where
+instance Covariant u => Covariant (UT 'Co 'Co (Conclusion e) u) where
 	f <$> UT x = UT $ f <$$> x
 
-instance Applicative u => Applicative (UT (Conclusion e) () (Conclusion e) u) where
+instance Applicative u => Applicative (UT 'Co 'Co (Conclusion e) u) where
 	UT f <*> UT x = UT $ apply <$> f <*> x
 
-instance Pointable u => Pointable (UT (Conclusion e) () (Conclusion e) u) where
+instance Pointable u => Pointable (UT 'Co 'Co (Conclusion e) u) where
 	point = UT . point . point
 
-instance (Pointable u, Bindable u) => Bindable (UT (Conclusion e) () (Conclusion e) u) where
+instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co (Conclusion e) u) where
 	UT x >>= f = UT $ x >>= conclusion (point . Failure) (unwrap . f)
 
-instance Monad u => Monad (UT (Conclusion e) () (Conclusion e) u) where
+instance Monad u => Monad (UT 'Co 'Co (Conclusion e) u) where
 
 instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where
 	Success x == Success y = x == y
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,5 +1,6 @@
 module Pandora.Paradigm.Basis.Continuation (Continuation (..), oblige, cwcc, reset, shift) where
 
+import Pandora.Core.Functor (type (:.), type (>), type (::|:.))
 import Pandora.Core.Morphism ((.), ($), (!), (?))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -7,7 +8,7 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 
-newtype Continuation r t a = Continuation { continue :: (a -> t r) -> t r }
+newtype Continuation r t a = Continuation { continue :: (->) ::|:. a :. t > r }
 
 instance Covariant t => Covariant (Continuation r t) where
 	f <$> Continuation continuation = Continuation $ continuation . (. f)
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,6 +1,6 @@
 module Pandora.Paradigm.Basis.Free (Free (..)) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
+import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Core.Morphism (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
@@ -10,7 +10,7 @@
 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
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
@@ -11,7 +11,7 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
@@ -52,8 +52,8 @@
 instance Comonad Identity
 
 instance Adjoint Identity Identity where
-	phi f = Identity . f . Identity
-	psi f = extract . extract . comap f
+	x -| f = Identity . f . Identity $ x
+	x |- g = extract . extract . comap g $ x
 
 instance Setoid a => Setoid (Identity a) where
 	Identity x == Identity y = x == y
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,5 +1,6 @@
 module Pandora.Paradigm.Basis.Maybe (Maybe (..), maybe) where
 
+import Pandora.Core.Functor (Variant (Co))
 import Pandora.Core.Morphism ((.), ($))
 import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
 import Pandora.Pattern.Junction.Transformer (Transformer (Schema, lay, wrap))
@@ -54,23 +55,23 @@
 	unwrap x = x
 
 instance Transformer Maybe where
-	type Schema Maybe u = UT Maybe () Maybe u
+	type Schema Maybe u = UT 'Co 'Co Maybe u
 	lay x = UT $ Just <$> x
 	wrap x = UT . point $ x
 
-instance Covariant u => Covariant (UT Maybe () Maybe u) where
+instance Covariant u => Covariant (UT 'Co 'Co Maybe u) where
 	f <$> UT x = UT $ f <$$> x
 
-instance Applicative u => Applicative (UT Maybe () Maybe u) where
+instance Applicative u => Applicative (UT 'Co 'Co Maybe u) where
 	UT f <*> UT x = UT $ apply <$> f <*> x
 
-instance Pointable u => Pointable (UT Maybe () Maybe u) where
+instance Pointable u => Pointable (UT 'Co 'Co Maybe u) where
 	point = UT . point . point
 
-instance (Pointable u, Bindable u) => Bindable (UT Maybe () Maybe u) where
+instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co Maybe u) where
 	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f)
 
-instance Monad u => Monad (UT Maybe () Maybe u) where
+instance Monad u => Monad (UT 'Co 'Co Maybe u) where
 
 instance Setoid a => Setoid (Maybe a) where
 	Just x == Just y = x == y
diff --git a/Pandora/Paradigm/Basis/Product.hs b/Pandora/Paradigm/Basis/Product.hs
--- a/Pandora/Paradigm/Basis/Product.hs
+++ b/Pandora/Paradigm/Basis/Product.hs
@@ -7,7 +7,7 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)), (&&))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
@@ -37,8 +37,8 @@
 instance Comonad (Product a) where
 
 instance Adjoint (Product a) ((->) a) where
-	phi f x y = f $ y :*: x
-	psi f (y :*: x) = f x y
+	x -| f = \y -> f $ y :*: x
+	(y :*: x) |- f = f x y
 
 instance (Setoid a, Setoid b) => Setoid (Product a b) where
 	(x :*: y) == (x' :*: y') = x == x' && y == y'
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,6 +1,6 @@
 module Pandora.Paradigm.Basis.Twister (Twister (..), untwist, coiterate, section) where
 
-import Pandora.Core.Functor (type (:.:), 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 (empty))
@@ -19,7 +19,7 @@
 
 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)
@@ -56,7 +56,7 @@
 instance (Monoid a, forall b . Semigroup b => Monoid (t b)) => Monoid (Twister t a) where
 	zero = zero :< zero
 
-untwist :: Twister t a -> (t :.: Twister t) a
+untwist :: Twister t a -> (t :. Twister t) a
 untwist (_ :< xs) = xs
 
 coiterate :: Covariant t => (a -> t a) -> a -> Twister t a
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
@@ -1,10 +1,17 @@
 module Pandora.Paradigm.Inventory.Optics
 	(Lens, type (:-.), (|>), view, set, over, (^.), (.~), (%~)) where
 
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Inventory.Storage (Storage, access, position, retrofit)
+import Pandora.Core.Morphism ((.), ($), (!))
+import Pandora.Paradigm.Basis.Product (Product ((:*:)))
+import Pandora.Paradigm.Inventory.Stateful (Stateful (Stateful), statefully)
+import Pandora.Paradigm.Inventory.Storage (Storage (Storage), access, position, retrofit)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+
+instance Adjoint (Storage s) (Stateful s) where
+	v -| f = Stateful $ \s -> (:*:) s . f . Storage $ s :*: (v !)
+	Storage (s :*: f) |- g = extract . statefully s . g $ f s
 
 infixr 0 :-.
 type (:-.) src tgt = Lens src tgt
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,7 +1,7 @@
 module Pandora.Paradigm.Inventory.Stateful
 	(Stateful (..), statefully, get, modify, put, fold, find) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
+import Pandora.Core.Functor (Variant (Co), type (:.), type (>))
 import Pandora.Core.Morphism ((.), ($))
 import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
 import Pandora.Pattern.Junction.Transformer (Transformer (Schema, lay, wrap))
@@ -19,7 +19,7 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Object.Setoid (bool)
 
-newtype Stateful s a = Stateful ((->) s :.: (:*:) s >< a)
+newtype Stateful s a = Stateful ((->) s :. (:*:) s > a)
 
 statefully :: s -> Stateful s a -> s :*: a
 statefully initial (Stateful state) = state initial
@@ -58,24 +58,24 @@
 find p struct = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x) struct
 
 instance Composition (Stateful s) where
-	type Primary (Stateful s) a = (->) s :.: (:*:) s >< a
+	type Primary (Stateful s) a = (->) s :. (:*:) s > a
 	unwrap (Stateful x) = x
 
 instance Transformer (Stateful s) where
-	type Schema (Stateful s) u = TUV Stateful () Stateful ((->) s) u ((:*:) s)
+	type Schema (Stateful s) u = TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)
 	lay x = TUV $ \s -> (s :*:) <$> x
 	wrap x = TUV $ point <$> unwrap x
 
-instance Covariant u => Covariant (TUV Stateful () Stateful ((->) s) u ((:*:) s)) where
+instance Covariant u => Covariant (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
 	f <$> TUV x = TUV $ \old -> f <$$> x old
 
-instance Bindable u => Applicative (TUV Stateful () Stateful ((->) s) u ((:*:) s)) where
+instance Bindable u => Applicative (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
 	TUV f <*> TUV x = TUV $ \old -> f old >>= \(new :*: g) -> g <$$> x new
 
-instance Pointable u => Pointable (TUV Stateful () Stateful ((->) s) u ((:*:) s)) where
+instance Pointable u => Pointable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
 	point x = TUV $ \s -> point $ s :*: x
 
-instance Bindable u => Bindable (TUV Stateful () Stateful ((->) s) u ((:*:) s)) where
+instance Bindable u => Bindable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
 	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . unwrap . f $ y
 
-instance Monad u => Monad (TUV Stateful () Stateful ((->) s) u ((:*:) s)) where
+instance Monad u => Monad (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
diff --git a/Pandora/Paradigm/Inventory/Storage.hs b/Pandora/Paradigm/Inventory/Storage.hs
--- a/Pandora/Paradigm/Inventory/Storage.hs
+++ b/Pandora/Paradigm/Inventory/Storage.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Inventory.Storage (Storage (..), position, access, retrofit) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
+import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Core.Morphism ((.), ($), (?))
 import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
@@ -8,13 +8,13 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 
-newtype Storage p a = Storage { stored :: (:*:) p :.: (->) p >< a }
+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 :*: x)) = x p
+	extract (Storage (p :*: f)) = f p
 
 instance Extendable (Storage p) where
 	Storage (old :*: f) =>> g = Storage . (:*:) old
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,15 +1,27 @@
 module Pandora.Paradigm.Structure.Graph (Graph, loose) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
-import Pandora.Core.Morphism ((.))
+import Pandora.Core.Functor (type (:.), type (>))
+import Pandora.Core.Morphism ((.), ($))
 import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))
 import Pandora.Paradigm.Basis.Twister (Twister ((:<)))
 import Pandora.Paradigm.Inventory.Stateful (fold)
-import Pandora.Pattern.Functor.Traversable (Traversable)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
+import Pandora.Pattern.Junction.Composition (Composition (Primary, unwrap))
 
 -- | Acyclic graph structure without loops
-type Graph a = Edges :.: Twister Edges >< a
+newtype Graph a = Graph (Edges :. Twister Edges > a)
 
+instance Covariant Graph where
+	f <$> Graph stack = Graph $ f <$$> stack
+
+instance Traversable Graph where
+	Graph stack ->> f = Graph <$> stack ->>> f
+
+instance Composition Graph where
+	type Primary Graph a = Edges :. Twister Edges > a
+	unwrap (Graph stack) = stack
+
 -- | Transform any traversable structure into all loose edges graph
 loose :: Traversable t => t a -> Graph a
-loose = fold Empty (\x -> Overlay . (:<) x)
+loose = Graph . fold Empty (\x -> Overlay . (:<) x)
diff --git a/Pandora/Paradigm/Structure/Stack.hs b/Pandora/Paradigm/Structure/Stack.hs
--- a/Pandora/Paradigm/Structure/Stack.hs
+++ b/Pandora/Paradigm/Structure/Stack.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Structure.Stack (Stack, push, top, pop, filter, linearize) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
+import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Core.Morphism ((.), ($))
 import Pandora.Core.Transformation (type (~>))
 import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
@@ -19,7 +19,7 @@
 import Pandora.Pattern.Object.Setoid (bool)
 
 -- | Linear data structure that serves as a collection of elements
-newtype Stack a = Stack (Maybe :.: Twister Maybe >< a)
+newtype Stack a = Stack (Maybe :. Twister Maybe > a)
 
 instance Covariant Stack where
 	f <$> Stack stack = Stack $ f <$$> stack
@@ -40,7 +40,7 @@
 	Stack stack ->> f = Stack <$> stack ->>> f
 
 instance Composition Stack where
-	type Primary Stack a = Maybe :.: Twister Maybe >< a
+	type Primary Stack a = Maybe :. Twister Maybe > a
 	unwrap (Stack stack) = stack
 
 push :: a -> Stack a -> Stack a
diff --git a/Pandora/Pattern.hs b/Pandora/Pattern.hs
--- a/Pandora/Pattern.hs
+++ b/Pandora/Pattern.hs
@@ -1,4 +1,5 @@
 module Pandora.Pattern (module Exports) where
 
 import Pandora.Pattern.Object as Exports
+import Pandora.Pattern.Junction as Exports
 import Pandora.Pattern.Functor as Exports
diff --git a/Pandora/Pattern/Functor.hs b/Pandora/Pattern/Functor.hs
--- a/Pandora/Pattern/Functor.hs
+++ b/Pandora/Pattern/Functor.hs
@@ -1,9 +1,11 @@
 module Pandora.Pattern.Functor (module Exports) where
 
+import Pandora.Pattern.Functor.Divariant as Exports
 import Pandora.Pattern.Functor.Lowerable as Exports
 import Pandora.Pattern.Functor.Liftable as Exports
 import Pandora.Pattern.Functor.Comonad as Exports
 import Pandora.Pattern.Functor.Monad as Exports
+import Pandora.Pattern.Functor.Representable as Exports
 import Pandora.Pattern.Functor.Adjoint as Exports
 import Pandora.Pattern.Functor.Extendable as Exports
 import Pandora.Pattern.Functor.Bindable as Exports
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,9 +1,13 @@
 module Pandora.Pattern.Functor.Adjoint (Adjoint (..), type (-|)) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
+import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Core.Morphism (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
+type (-|) = Adjoint
+
+infixl 4 -|, |-
+
 {- |
 > When providing a new instance, you should ensure it satisfies the four laws:
 > * Left adjunction identity: phi cozero ≡ identity
@@ -13,15 +17,21 @@
 -}
 
 class (Covariant t, Covariant u) => Adjoint t u where
-	{-# MINIMAL phi, psi #-}
+	{-# MINIMAL (-|), (|-) #-}
 	-- | Left adjunction
-	phi :: (t a -> b) -> a -> u b
+	(-|) :: a -> (t a -> b) -> u b
 	-- | Right adjunction
-	psi :: (a -> u b) -> t a -> b
+	(|-) :: t a -> (a -> u b) -> b
 
-	eta :: a -> u :.: t >< a
+	-- | Prefix and flipped version of '-|'
+	phi :: (t a -> b) -> a -> u b
+	phi f x = x -| f
+	-- | Prefix and flipped version of '|-'
+	psi :: (a -> u b) -> t a -> b
+	psi g x = x |- g
+	-- | Also known as 'unit'
+	eta :: a -> u :. t > a
 	eta = phi identity
-	epsilon :: t :.: u >< a -> a
+	-- | Also known as 'counit'
+	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,7 +1,7 @@
 module Pandora.Pattern.Functor.Applicative (Applicative (..)) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
-import Pandora.Core.Morphism (identity)
+import Pandora.Core.Functor (type (:.), type (>))
+import Pandora.Core.Morphism (identity, ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)))
 
 infixl 4 <*>, <*, *>
@@ -32,13 +32,16 @@
 	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
+
+instance Applicative ((->) e) where
+	(<*>) f g x = f x $ g x
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 (:.:), 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)
@@ -32,3 +32,6 @@
 	-- | Right-to-left Kleisli composition
 	(<=<) :: (b -> t c) -> (a -> t b) -> (a -> t c)
 	(<=<) = (?) (>=>)
+
+instance Bindable ((->) e) where
+	f >>= g = \x -> g (f x) x
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,6 +1,6 @@
 module Pandora.Pattern.Functor.Contravariant (Contravariant (..)) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
+import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Core.Morphism ((.), (!), (?))
 
 infixl 4 >$<, $<, >$
@@ -33,21 +33,21 @@
 	x >&< f = f >$< x
 
 	-- | Infix versions of `contramap` with various nesting levels
-	(>$$<) :: Contravariant u => (a -> b) -> t :.: u >< a -> t :.: u >< b
+	(>$$<) :: Contravariant u => (a -> b) -> t :. u > a -> t :. u > b
 	(>$$<) = (>$<) . (>$<)
 	(>$$$<) :: (Contravariant u, Contravariant v)
-		=> (a -> b) -> t :.: u :.: v >< b -> t :.: u :.: v >< a
+		=> (a -> b) -> t :. u :. v > b -> t :. u :. v > a
 	(>$$$<) = (>$<) . (>$<) . (>$<)
 	(>$$$$<) :: (Contravariant u, Contravariant v, Contravariant w)
-		=> (a -> b) -> t :.: u :.: v :.: w >< a -> t :.: u :.: v :.: w >< b
+		=> (a -> b) -> t :. u :. v :. w > a -> t :. u :. v :. w > b
 	(>$$$$<) = (>$<) . (>$<) . (>$<) . (>$<)
 
 	-- | Infix flipped versions of `contramap` with various nesting levels
-	(>&&<) :: Contravariant u => t :.: u >< a -> (a -> b) -> t :.: u >< b
+	(>&&<) :: Contravariant u => t :. u > a -> (a -> b) -> t :. u > b
 	x >&&< f = f >$$< x
 	(>&&&<) :: (Contravariant u, Contravariant v)
-		=> t :.: u :.: v >< b -> (a -> b) -> t :.: u :.: v >< a
+		=> t :. u :. v > b -> (a -> b) -> t :. u :. v > a
 	x >&&&< f = f >$$$< x
 	(>&&&&<) :: (Contravariant u, Contravariant v, Contravariant w)
-		=> t :.: u :.: v :.: w >< a -> (a -> b) -> t :.: u :.: v :.: w >< b
+		=> t :. u :. v :. w > a -> (a -> b) -> t :. u :. v :. w > b
 	x >&&&&< f = f >$$$$< x
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,6 +1,6 @@
 module Pandora.Pattern.Functor.Covariant (Covariant (..)) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
+import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Core.Morphism (fix, (.), ($), (!), (?))
 
 infixl 4 <$>, <$, $>
@@ -36,23 +36,23 @@
 	x <&> f = f <$> x
 
 	-- | Infix versions of `comap` with various nesting levels
-	(<$$>) :: Covariant u => (a -> b) -> t :.: u >< a -> t :.: u >< b
+	(<$$>) :: Covariant u => (a -> b) -> t :. u > a -> t :. u > b
 	(<$$>) = (<$>) . (<$>)
 	(<$$$>) :: (Covariant u, Covariant v)
-		=> (a -> b) -> t :.: u :.: v >< a -> t :.: u :.: v >< b
+		=> (a -> b) -> t :. u :. v > a -> t :. u :. v > b
 	(<$$$>) = (<$>) . (<$>) . (<$>)
 	(<$$$$>) :: (Covariant u, Covariant v, Covariant w)
-		=> (a -> b) -> t :.: u :.: v :.: w >< a -> t :.: u :.: v :.: w >< b
+		=> (a -> b) -> t :. u :. v :. w > a -> t :. u :. v :. w > b
 	(<$$$$>) = (<$>) . (<$>) . (<$>) . (<$>)
 
 	-- | Infix flipped versions of `comap` with various nesting levels
-	(<&&>) :: Covariant u => t :.: u >< a -> (a -> b) -> t :.: u >< b
+	(<&&>) :: Covariant u => t :. u > a -> (a -> b) -> t :. u > b
 	x <&&> f = f <$$> x
 	(<&&&>) :: (Covariant u, Covariant v)
-		=> t :.: u :.: v >< a -> (a -> b) -> t :.: u :.: v >< b
+		=> t :. u :. v > a -> (a -> b) -> t :. u :. v > b
 	x <&&&> f = f <$$$> x
 	(<&&&&>) :: (Covariant u, Covariant v, Covariant w)
-		=> t :.: u :.: v :.: w >< a -> (a -> b) -> t :.: u :.: v :.: w >< b
+		=> t :. u :. v :. w > a -> (a -> b) -> t :. u :. v :. w > b
 	x <&&&&> f = f <$$$$> x
 
 instance Covariant ((->) a) where
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,6 +1,6 @@
 module Pandora.Pattern.Functor.Distributive (Distributive (..)) where
 
-import Pandora.Core.Functor (type (:.:), type (><))
+import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Core.Morphism (identity, (.), (?))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 
@@ -16,25 +16,25 @@
 
 class Covariant u => Distributive u where
 	{-# MINIMAL (>>-) #-}
-	-- | Infix version of 'collect'
-	(>>-) :: Covariant t => t a -> (a -> u b) -> u :.: t >< b
+	-- | Infix and flipped version of 'collect'
+	(>>-) :: 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
diff --git a/Pandora/Pattern/Functor/Divariant.hs b/Pandora/Pattern/Functor/Divariant.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Functor/Divariant.hs
@@ -0,0 +1,25 @@
+module Pandora.Pattern.Functor.Divariant (Divariant (..)) where
+
+import Pandora.Pattern.Functor.Covariant (Covariant)
+
+import Pandora.Core.Morphism ((.), ($))
+
+infixl 4 >->
+
+{- |
+> When providing a new instance, you should ensure it satisfies the two laws:
+> * Identity: dimap identity identity ≡ identity
+> * Composition: dimap (f . g) (h . i) ≡ dimap g h . dimap f i
+-}
+
+class (forall a . Covariant (t a)) => Divariant (t :: * -> * -> *) where
+	{-# MINIMAL (>->) #-}
+	-- | Infix version of 'comap'
+	(>->) :: (a -> b) -> (c -> d) -> t b c -> t a d
+
+	-- | Prefix version of '>->'
+	dimap :: (a -> b) -> (c -> d) -> t b c -> t a d
+	dimap f g x = f >-> g $ x
+
+instance Divariant ((->)) where
+	(>->) ab cd bc = cd . bc . ab
diff --git a/Pandora/Pattern/Functor/Extendable.hs b/Pandora/Pattern/Functor/Extendable.hs
--- a/Pandora/Pattern/Functor/Extendable.hs
+++ b/Pandora/Pattern/Functor/Extendable.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Extendable (Extendable (..)) where
 
-import Pandora.Core.Functor (type (:.:), 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/Pointable.hs b/Pandora/Pattern/Functor/Pointable.hs
--- a/Pandora/Pattern/Functor/Pointable.hs
+++ b/Pandora/Pattern/Functor/Pointable.hs
@@ -1,6 +1,10 @@
 module Pandora.Pattern.Functor.Pointable (Pointable (..)) where
 
+import Pandora.Core.Morphism ((!))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 class Covariant t => Pointable t where
 	point :: a -> t a
+
+instance Pointable ((->) e) where
+	point = (!)
diff --git a/Pandora/Pattern/Functor/Representable.hs b/Pandora/Pattern/Functor/Representable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Functor/Representable.hs
@@ -0,0 +1,28 @@
+module Pandora.Pattern.Functor.Representable (Representable (..)) where
+
+import Pandora.Core.Morphism (identity, (?))
+import Pandora.Pattern.Functor.Pointable (Pointable)
+
+{- |
+> When providing a new instance, you should ensure it satisfies the three laws:
+> * Isomorphism (to): tabulate . index ≡ identity
+> * Isomorphism (from): index . tabulate ≡ identity
+> * Right adjoint: tabulate . point ≡ point
+> * Interchange tabulation: comap f . tabulate ≡ tabulate . comap f
+-}
+
+class Pointable t => Representable t where
+	{-# MINIMAL (<#>), tabulate #-}
+	type Representation t :: *
+	-- | Infix and flipped version of 'index'
+	(<#>) :: Representation t -> t a -> a
+	-- Build with a function which describes value
+	tabulate :: (Representation t -> a) -> t a
+	-- | Prefix and flipped version of '<#>'
+	index :: t a -> Representation t -> a
+	index x f = f <#> x
+
+instance Representable ((->) e) where
+	type Representation ((->) e) = e
+	(<#>) = (identity ?)
+	tabulate = identity
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 (:.:), 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
--- a/Pandora/Pattern/Junction.hs
+++ b/Pandora/Pattern/Junction.hs
@@ -1,9 +1,5 @@
 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.Schemes as Exports
 import Pandora.Pattern.Junction.Transformer as Exports
 import Pandora.Pattern.Junction.Composition as Exports
diff --git a/Pandora/Pattern/Junction/Schemes.hs b/Pandora/Pattern/Junction/Schemes.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Junction/Schemes.hs
@@ -0,0 +1,7 @@
+module Pandora.Pattern.Junction.Schemes (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
diff --git a/Pandora/Pattern/Junction/Schemes/TU.hs b/Pandora/Pattern/Junction/Schemes/TU.hs
--- a/Pandora/Pattern/Junction/Schemes/TU.hs
+++ b/Pandora/Pattern/Junction/Schemes/TU.hs
@@ -1,60 +1,10 @@
 module Pandora.Pattern.Junction.Schemes.TU (TU (..)) where
 
-import Pandora.Core.Functor (Variant (Co, Contra), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
+import Pandora.Core.Functor (type (:.), type (>))
 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)
+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
+	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
--- a/Pandora/Pattern/Junction/Schemes/TUV.hs
+++ b/Pandora/Pattern/Junction/Schemes/TUV.hs
@@ -1,88 +1,10 @@
 module Pandora.Pattern.Junction.Schemes.TUV (TUV (..)) where
 
-import Pandora.Core.Functor (Variant (Co, Contra), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
+import Pandora.Core.Functor (type (:.), type (>))
 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)
+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
+	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
--- a/Pandora/Pattern/Junction/Schemes/TUVW.hs
+++ b/Pandora/Pattern/Junction/Schemes/TUVW.hs
@@ -1,120 +1,10 @@
 module Pandora.Pattern.Junction.Schemes.TUVW (TUVW (..)) where
 
-import Pandora.Core.Functor (Variant (Co, Contra), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
+import Pandora.Core.Functor (type (:.), type (>))
 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)
+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
+	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
--- a/Pandora/Pattern/Junction/Schemes/UT.hs
+++ b/Pandora/Pattern/Junction/Schemes/UT.hs
@@ -1,67 +1,10 @@
 module Pandora.Pattern.Junction.Schemes.UT (UT (..)) where
 
-import Pandora.Core.Functor (Variant (Co), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
+import Pandora.Core.Functor (type (:.), type (>))
 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)
+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
+	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
--- a/Pandora/Pattern/Junction/Schemes/UTU.hs
+++ b/Pandora/Pattern/Junction/Schemes/UTU.hs
@@ -1,67 +1,10 @@
 module Pandora.Pattern.Junction.Schemes.UTU (UTU (..)) where
 
-import Pandora.Core.Functor (Variant (Co), type (:.:), type (><))
-import Pandora.Core.Morphism ((.), ($))
+import Pandora.Core.Functor (type (:.), type (>))
 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)
+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
+	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/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -14,9 +14,3 @@
 * Library: http://hackage.haskell.org/package/semigroupoids
 * Library: http://hackage.haskell.org/package/transformers
 * Library: http://hackage.haskell.org/package/invariant
-
-## Diagram of functor patterns:
-![Functors diagram](/Diagrams/Functors.png)
-
-## Diagram of object patterns:
-![Objects diagram](/Diagrams/Objects.png)
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.1.9
+version:             0.2.0
 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
@@ -85,11 +85,14 @@
     Pandora.Pattern.Functor.Lowerable
     Pandora.Pattern.Functor.Monad
     Pandora.Pattern.Functor.Pointable
+    Pandora.Pattern.Functor.Representable
     Pandora.Pattern.Functor.Traversable
+    Pandora.Pattern.Functor.Divariant
     -- Typeclassess about functor junctions
     Pandora.Pattern.Junction
     Pandora.Pattern.Junction.Composition
     Pandora.Pattern.Junction.Transformer
+    Pandora.Pattern.Junction.Schemes
     Pandora.Pattern.Junction.Schemes.TU
     Pandora.Pattern.Junction.Schemes.TUV
     Pandora.Pattern.Junction.Schemes.TUVW