diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -460,3 +460,31 @@
 * Change `Substructured` constraint - add paramater for `Available`
 * Define experimental `Impliable` typeclass
 * Remove `:-.` type operator in `Optics` module
+
+# 0.4.3
+* Rename `!` to `!.` in `Function` module
+* Rename `!!` to `!..` in `Function` module
+* Rename `!!!` to `!...` in `Function` module
+* Define experimental `Covariant_` typeclass
+* Define experimental `-<$$>-` method of `Covariant_` typeclass
+* Define experimental `-.#..-` method in `Function` module
+* Define experimental `Contravariant_` typeclass
+* Define experimental `Pointable_` typeclass
+* Define experimental `Bindable_` typeclass
+* Define experimental `Bivariant_` typeclass
+* Define experimental `Divariant_` typeclass
+* Define experimental `Extendable_` typeclass
+* Use experimental `Covariant_` as superclass of `Extractable`
+* Define `Covariant_` superclasses for `Bivariant_`
+* Define `Covariant_` and `Contravariant_` superclasses for `Divariant_`
+* Define experimental `-<<$$>-` and `-<$$>>-` methods of `Covariant_` typeclass
+* Use experimental `Covariant_` as superclass of `Pointable`
+* Define experimental `Adjoint_` typeclass
+* Define experimental `Applicative_` typeclass
+* Define experimental `Divisible_` typeclass
+* Define experimental `-<*>-` method
+* Use experimental `Covariant_` as superclass of `Lowerable`
+* Remove `Covariant` superclass of `Liftable`
+* Remove `Covariant` superclass of `Hoistable`
+
+# 0.4.4
diff --git a/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs b/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
@@ -4,23 +4,23 @@
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category (identity, (.))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)
 import Pandora.Pattern.Functor.Pointable (Pointable)
 import Pandora.Pattern.Functor.Extractable (Extractable)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer (Liftable (lift), Lowerable (lower), Hoistable (hoist))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic)
-import Pandora.Paradigm.Controlflow.Effect.Transformer (Transformer, wrap, bring, (:>), (:<))
+import Pandora.Paradigm.Controlflow.Effect.Transformer (Monadic, Comonadic, wrap, bring, (:>), (:<))
 
 class Adaptable t u where
 	{-# MINIMAL adapt #-}
 	adapt :: t ~> u
 
-type Lifting t u = (Transformer Monad t, Liftable (Schematic Monad t), Covariant u)
-type Lowering t u = (Transformer Comonad t, Lowerable (Schematic Comonad t), Covariant u)
-type Wrappable t u = (Transformer Monad t, Pointable u)
-type Bringable t u = (Transformer Comonad t, Extractable u)
+type Lifting t u = (Monadic t, Liftable (Schematic Monad t), Covariant u, Covariant_ u (->) (->))
+type Lowering t u = (Comonadic t, Lowerable (Schematic Comonad t), Covariant u, Covariant_ u (->) (->))
+type Wrappable t u = (Monadic t, Pointable u (->))
+type Bringable t u = (Comonadic t, Extractable u (->))
 
 instance Covariant t => Adaptable t t where
 	adapt = identity
@@ -41,6 +41,7 @@
 	( Covariant (t :> u :> v)
 	, Liftable (Schematic Monad t)
 	, Covariant (Schematic Monad u v)
+	, Covariant_ (Schematic Monad u v) (->) (->)
 	, Wrappable u v
 	) => Adaptable u (t :> u :> v) where
 	adapt = lift . wrap
@@ -67,7 +68,8 @@
 	adapt = lower . lower
 
 instance
-	( Covariant (t :> u :> v :> w)
+	( Covariant_ t (->) (->) 
+ 	, Covariant (t :> u :> v :> w)
 	, Liftable (Schematic Monad t)
 	, Lifting t (Schematic Monad u (v :> w))
 	, Lifting u (Schematic Monad v w)
@@ -321,13 +323,14 @@
 	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where
 	adapt = bring . lower . lower . lower . lower . lower . lower . lower
 
-instance (Covariant u, Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where
+instance (Covariant u, Covariant_ u (->) (->), Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where
 	adapt = hoist adapt
 
 instance
 	( Covariant u
-	, Covariant v
+	, Covariant v, Covariant_ v (->) (->)
 	, Covariant (Schematic Monad u v)
+	, Covariant_ (Schematic Monad u v) (->) (->)
 	, Hoistable ((:>) (t :> u))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -336,10 +339,15 @@
 	adapt = hoist (hoist adapt)
 
 instance
-	( Covariant u, Covariant v, Covariant w
+	( Covariant u, Covariant_ u (->) (->)
+	, Covariant v, Covariant_ v (->) (->)
+	, Covariant w, Covariant_ w (->) (->)
 	, Covariant (Schematic Monad u v)
+	, Covariant_ (Schematic Monad u v) (->) (->)
 	, Covariant (Schematic Monad u (v :> w))
+	, Covariant_ (Schematic Monad u (v :> w)) (->) (->)
 	, Covariant (Schematic Monad v w)
+	, Covariant_ (Schematic Monad v w) (->) (->)
 	, Hoistable ((:>) (t :> u :> v))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -349,12 +357,15 @@
 	adapt = hoist (hoist (hoist adapt))
 
 instance
-	( Covariant u, Covariant v, Covariant w, Covariant x
+	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant_ x (->) (->)
 	, Covariant (Schematic Monad u v)
 	, Covariant (Schematic Monad u (v :> w))
 	, Covariant (Schematic Monad u (v :> (w :> x)))
+	, Covariant_ (Schematic Monad u (v :> (w :> x))) (->) (->)
 	, Covariant (Schematic Monad v (w :> x))
+	, Covariant_ (Schematic Monad v (w :> x)) (->) (->)
 	, Covariant (Schematic Monad w x)
+	, Covariant_ (Schematic Monad w x) (->) (->)
 	, Hoistable ((:>) (t :> u :> v))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -365,15 +376,20 @@
 	adapt = hoist (hoist (hoist (hoist adapt)))
 
 instance
-	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant y
+	( Covariant u, Covariant v, Covariant w, Covariant x
+	, Covariant y, Covariant_ y (->) (->)
 	, Covariant (Schematic Monad u v)
 	, Covariant (Schematic Monad u (v :> w))
 	, Covariant (Schematic Monad u (v :> (w :> x)))
 	, Covariant (Schematic Monad u (v :> (w :> (x :> y))))
+	, Covariant_ (Schematic Monad u (v :> (w :> (x :> y)))) (->) (->)
 	, Covariant (Schematic Monad v (w :> x))
 	, Covariant (Schematic Monad v (w :> (x :> y)))
+	, Covariant_ (Schematic Monad v (w :> (x :> y))) (->) (->)
 	, Covariant (Schematic Monad w (x :> y))
+	, Covariant_ (Schematic Monad w (x :> y)) (->) (->)
 	, Covariant (Schematic Monad x y)
+	, Covariant_ (Schematic Monad x y) (->) (->)
 	, Hoistable ((:>) (t :> u :> v :> w))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -385,20 +401,26 @@
 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))
 
 instance
-	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant y, Covariant z
+	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant y
+	, Covariant z, Covariant_ z (->) (->)
 	, Covariant (Schematic Monad u v)
 	, Covariant (Schematic Monad u (v :> w))
 	, Covariant (Schematic Monad u (v :> (w :> x)))
 	, Covariant (Schematic Monad u (v :> (w :> (x :> y))))
 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z)))))
+	, Covariant_ (Schematic Monad u (v :> (w :> (x :> (y :> z))))) (->) (->)
 	, Covariant (Schematic Monad v (w :> x))
 	, Covariant (Schematic Monad v (w :> (x :> y)))
 	, Covariant (Schematic Monad v (w :> (x :> (y :> z))))
+	, Covariant_ (Schematic Monad v (w :> (x :> (y :> z)))) (->) (->)
 	, Covariant (Schematic Monad w (x :> y))
 	, Covariant (Schematic Monad w (x :> (y :> z)))
+	, Covariant_ (Schematic Monad w (x :> (y :> z))) (->) (->)
 	, Covariant (Schematic Monad x y)
 	, Covariant (Schematic Monad x (y :> z))
+	, Covariant_ (Schematic Monad x (y :> z)) (->) (->)
 	, Covariant (Schematic Monad y z)
+	, Covariant_ (Schematic Monad y z) (->) (->)
 	, Hoistable ((:>) (t :> u :> v :> w))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -413,26 +435,33 @@
 
 instance
 	( Covariant u, Covariant v, Covariant w, Covariant x
-	, Covariant y, Covariant z, Covariant f
+	, Covariant y, Covariant z
+	, Covariant f, Covariant_ f (->) (->)
 	, Covariant (Schematic Monad u v)
 	, Covariant (Schematic Monad u (v :> w))
 	, Covariant (Schematic Monad u (v :> (w :> x)))
 	, Covariant (Schematic Monad u (v :> (w :> (x :> y))))
 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z)))))
 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f))))))
+	, Covariant_ (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f)))))) (->) (->)
 	, Covariant (Schematic Monad v (w :> x))
 	, Covariant (Schematic Monad v (w :> (x :> y)))
 	, Covariant (Schematic Monad v (w :> (x :> (y :> z))))
 	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> f)))))
+	, Covariant_ (Schematic Monad v (w :> (x :> (y :> (z :> f))))) (->) (->)
 	, Covariant (Schematic Monad w (x :> y))
 	, Covariant (Schematic Monad w (x :> (y :> z)))
 	, Covariant (Schematic Monad w (x :> (y :> (z :> f))))
+	, Covariant_ (Schematic Monad w (x :> (y :> (z :> f)))) (->) (->)
 	, Covariant (Schematic Monad x y)
 	, Covariant (Schematic Monad x (y :> z))
 	, Covariant (Schematic Monad x (y :> (z :> f)))
+	, Covariant_ (Schematic Monad x (y :> (z :> f))) (->) (->)
 	, Covariant (Schematic Monad y z)
 	, Covariant (Schematic Monad y (z :> f))
+	, Covariant_ (Schematic Monad y (z :> f)) (->) (->)
 	, Covariant (Schematic Monad z f)
+	, Covariant_ (Schematic Monad z f) (->) (->)
 	, Hoistable ((:>) (t :> u :> v :> w))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -448,7 +477,8 @@
 
 instance
 	( Covariant u, Covariant v, Covariant w, Covariant x
-	, Covariant y, Covariant z, Covariant f, Covariant h
+	, Covariant y, Covariant z, Covariant f
+	, Covariant h, Covariant_ h (->) (->)
 	, Covariant (Schematic Monad u v)
 	, Covariant (Schematic Monad u (v :> w))
 	, Covariant (Schematic Monad u (v :> (w :> x)))
@@ -456,25 +486,32 @@
 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z)))))
 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f))))))
 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h)))))))
+	, Covariant_ (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h))))))) (->) (->)
 	, Covariant (Schematic Monad v (w :> x))
 	, Covariant (Schematic Monad v (w :> (x :> y)))
 	, Covariant (Schematic Monad v (w :> (x :> (y :> z))))
 	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> f)))))
 	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h))))))
+	, Covariant_ (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h)))))) (->) (->)
 	, Covariant (Schematic Monad w (x :> y))
 	, Covariant (Schematic Monad w (x :> (y :> z)))
 	, Covariant (Schematic Monad w (x :> (y :> (z :> f))))
 	, Covariant (Schematic Monad w (x :> (y :> (z :> (f :> h)))))
+	, Covariant_ (Schematic Monad w (x :> (y :> (z :> (f :> h))))) (->) (->)
 	, Covariant (Schematic Monad x y)
 	, Covariant (Schematic Monad x (y :> z))
 	, Covariant (Schematic Monad x (y :> (z :> f)))
 	, Covariant (Schematic Monad x (y :> (z :> (f :> h))))
+	, Covariant_ (Schematic Monad x (y :> (z :> (f :> h)))) (->) (->)
 	, Covariant (Schematic Monad y z)
 	, Covariant (Schematic Monad y (z :> f))
 	, Covariant (Schematic Monad y (z :> (f :> h)))
+	, Covariant_ (Schematic Monad y (z :> (f :> h))) (->) (->)
 	, Covariant (Schematic Monad z f)
 	, Covariant (Schematic Monad z (f :> h))
+	, Covariant_ (Schematic Monad z (f :> h)) (->) (->)
 	, Covariant (Schematic Monad f h)
+	, Covariant_ (Schematic Monad f h) (->) (->)
 	, Hoistable ((:>) (t :> u :> v :> w))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
diff --git a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)), Covariant_)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Paradigm.Primary.Functor.Function ()
 
@@ -54,6 +54,6 @@
 		=> (t a -> u b) -> j :. k :. l :. m := Primary t a -> j :. k :. l :. m := Primary u b
 	f =||$$$$> x = (f =||) <$$$$> x
 
-(-=:) :: (Liftable t, Interpreted (t u), Interpreted (t v), Covariant u)
+(-=:) :: (Liftable t, Interpreted (t u), Interpreted (t v), Covariant u, Covariant_ u (->) (->))
 	=> (t u a -> t v b) -> u a -> Primary (t v) b
 (-=:) f = run . f . lift
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer.hs
@@ -1,10 +1,10 @@
-module Pandora.Paradigm.Controlflow.Effect.Transformer (module Exports, Transformer) where
+module Pandora.Paradigm.Controlflow.Effect.Transformer (module Exports) where
 
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic as Exports
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic as Exports
 
-import Pandora.Pattern.Functor (Monad, Comonad)
+--import Pandora.Pattern.Functor (Monad, Comonad)
 
-type family Transformer c t where
-	Transformer Monad t = Monadic t
-	Transformer Comonad t = Comonadic t
+--type family Transformer c t where
+--	Transformer Monad t = Monadic t
+--	Transformer Comonad t = Comonadic t
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
@@ -4,7 +4,7 @@
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
@@ -20,7 +20,7 @@
 
 class Interpreted t => Comonadic t where
 	{-# MINIMAL bring #-}
-	bring :: Extractable u => t :< u ~> t
+	bring :: Extractable u (->) => t :< u ~> t
 
 infixr 3 :<
 newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }
@@ -28,10 +28,13 @@
 instance Covariant (Schematic Comonad t u) => Covariant (t :< u) where
 	f <$> TC x = TC $ f <$> x
 
-instance Pointable (Schematic Comonad t u) => Pointable (t :< u) where
+instance Covariant_ (Schematic Comonad t u) (->) (->) => Covariant_ (t :< u) (->) (->) where
+	f -<$>- TC x = TC $ f -<$>- x
+
+instance Pointable (Schematic Comonad t u) (->) => Pointable (t :< u) (->) where
 	point = TC . point
 
-instance Extractable (Schematic Comonad t u) => Extractable (t :< u) where
+instance Extractable (Schematic Comonad t u) (->) => Extractable (t :< u) (->) where
 	extract = extract . tc
 
 instance Applicative (Schematic Comonad t u) => Applicative (t :< u) where
@@ -52,7 +55,7 @@
 instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where
 	TC x =>> f = TC $ x =>> f . TC
 
-instance (Extractable (t :< u), Extendable (t :< u)) => Comonad (t :< u) where
+instance (Extractable (t :< u) (->), Extendable (t :< u)) => Comonad (t :< u) (->) where
 
 instance Lowerable (Schematic Comonad t) => Lowerable ((:<) t) where
 	lower (TC x) = lower x
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
@@ -4,7 +4,7 @@
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
@@ -21,7 +21,7 @@
 
 class Interpreted t => Monadic t where
 	{-# MINIMAL wrap #-}
-	wrap :: Pointable u => t ~> t :> u
+	wrap :: Pointable u (->) => t ~> t :> u
 
 infixr 3 :>
 newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
@@ -29,10 +29,13 @@
 instance Covariant (Schematic Monad t u) => Covariant (t :> u) where
 	f <$> TM x = TM $ f <$> x
 
-instance Pointable (Schematic Monad t u) => Pointable (t :> u) where
+instance Covariant_ (Schematic Monad t u) (->) (->) => Covariant_ (t :> u) (->) (->) where
+	f -<$>- TM x = TM $ f -<$>- x
+
+instance Pointable (Schematic Monad t u) (->) => Pointable (t :> u) (->) where
 	point = TM . point
 
-instance Extractable (Schematic Monad t u) => Extractable (t :> u) where
+instance Extractable (Schematic Monad t u) (->) => Extractable (t :> u) (->) where
 	extract = extract . tm
 
 instance Applicative (Schematic Monad t u) => Applicative (t :> u) where
@@ -56,7 +59,7 @@
 instance Extendable (Schematic Monad t u) => Extendable (t :> u) where
 	TM x =>> f = TM $ x =>> f . TM
 
-instance (Pointable (t :> u), Bindable (t :> u)) => Monad (t :> u) where
+instance (Covariant_ (Schematic Monad t u) (->) (->), Pointable (t :> u) (->), Bindable (t :> u)) => Monad (t :> u) where
 
 instance Liftable (Schematic Monad t) => Liftable ((:>) t) where
 	lift = TM . lift
diff --git a/Pandora/Paradigm/Controlflow/Pipeline.hs b/Pandora/Paradigm/Controlflow/Pipeline.hs
--- a/Pandora/Paradigm/Controlflow/Pipeline.hs
+++ b/Pandora/Paradigm/Controlflow/Pipeline.hs
@@ -3,7 +3,7 @@
 import Pandora.Pattern.Category (($), (.), (#))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Paradigm.Primary.Functor.Function ((!), (!!))
+import Pandora.Paradigm.Primary.Functor.Function ((!.), (!..))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
 
@@ -40,23 +40,23 @@
 yield v = Continuation $ \next -> Pipe $ \i (Consumer o) -> o v # pause next i
 
 -- | Pipeline that does nothing
-finish :: Pointable t => Pipeline i o t () ()
-finish = Continuation (Pipe (point () !!) !)
+finish :: Pointable t (->) => Pipeline i o t () ()
+finish = Continuation (Pipe (point () !..) !.)
 
 -- | Do some effectful computation within pipeline
 impact :: Bindable t => t a -> Pipeline i o t a a
 impact action = Continuation $ \next -> Pipe $ \i o -> action >>= \x -> pipe (next x) i o
 
 -- | Compose two pipelines into one
-(=*=) :: forall i e o t . Pointable t => Pipeline i e t () () -> Pipeline e o t () () -> Pipeline i o t () ()
-p =*= q = Continuation $ \_ -> Pipe $ \i -> pipe # run q end # pause (run p end !) i where
+(=*=) :: forall i e o t . Pointable t (->) => Pipeline i e t () () -> Pipeline e o t () () -> Pipeline i o t () ()
+p =*= q = Continuation $ \_ -> Pipe $ \i -> pipe # run q end # pause (run p end !.) i where
 
 	end :: b -> Pipe c d () t ()
-	end _ = Pipe (point () !!)
+	end _ = Pipe (point () !..)
 
 -- | Run pipeline and get result
-pipeline :: Pointable t => Pipeline i o t () () -> t ()
-pipeline p = pipe # run p (Pipe . (!!) . point) # i # o where
+pipeline :: Pointable t (->) => Pipeline i o t () () -> t ()
+pipeline p = pipe # run p (Pipe . (!..) . point) # i # o where
 
 	i :: Producer i t ()
 	i = Producer $ \o' -> produce i o'
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -17,7 +17,7 @@
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Bivariant ((<->))
-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))
+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
@@ -26,7 +26,7 @@
 
 instance Adjoint (Store s) (State s) where
 	(-|) :: a -> (Store s a -> b) -> State s b
-	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !)
+	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !.)
 	(|-) :: Store s a -> (a -> State s b) -> b
 	Store (s :*: f) |- g = extract . (run % s) . g $ f s
 
diff --git a/Pandora/Paradigm/Inventory/Accumulator.hs b/Pandora/Paradigm/Inventory/Accumulator.hs
--- a/Pandora/Paradigm/Inventory/Accumulator.hs
+++ b/Pandora/Paradigm/Inventory/Accumulator.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where
 
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
@@ -21,11 +21,14 @@
 instance Covariant (Accumulator e) where
 	f <$> Accumulator x = Accumulator $ f <$> x
 
+instance Covariant_ (Accumulator e) (->) (->) where
+	f -<$>- Accumulator x = Accumulator $ f -<$>- x
+
 instance Semigroup e => Applicative (Accumulator e) where
 	f <*> v = Accumulator $ k # run f # run v where
 		k ~(e :*: g) ~(e' :*: w) = e + e' :*: g w
 
-instance Monoid e => Pointable (Accumulator e) where
+instance Monoid e => Pointable (Accumulator e) (->) where
 	point = Accumulator . (zero :*:)
 
 instance Semigroup e => Bindable (Accumulator e) where
@@ -48,10 +51,10 @@
 	UT f <*> UT x = UT $ k <$> f <*> x where
 		k ~(u :*: g) ~(v :*: y) = u + v :*: g y
 
-instance {-# OVERLAPS #-} (Pointable u, Monoid e) => Pointable ((:*:) e <.:> u) where
+instance {-# OVERLAPS #-} (Pointable u (->), Monoid e) => Pointable ((:*:) e <.:> u) (->) where
 	point = UT . point . (zero :*:)
 
-instance {-# OVERLAPS #-} (Semigroup e, Pointable u, Bindable u) => Bindable ((:*:) e <.:> u) where
+instance {-# OVERLAPS #-} (Semigroup e, Pointable u (->), Bindable u) => Bindable ((:*:) e <.:> u) where
 	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> run (f v)
 
 gather :: Accumulated e t => e -> t ()
diff --git a/Pandora/Paradigm/Inventory/Environment.hs b/Pandora/Paradigm/Inventory/Environment.hs
--- a/Pandora/Paradigm/Inventory/Environment.hs
+++ b/Pandora/Paradigm/Inventory/Environment.hs
@@ -3,14 +3,14 @@
 module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where
 
 import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))
+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
@@ -21,8 +21,11 @@
 instance Covariant (Environment e) where
 	f <$> Environment x = Environment $ f . x
 
-instance Pointable (Environment e) where
-	point x = Environment (x !)
+instance Covariant_ (Environment e) (->) (->) where
+	f -<$>- Environment x = Environment $ f . x
+
+instance Pointable (Environment e) (->) where
+	point x = Environment (x !.)
 
 instance Applicative (Environment e) where
 	f <*> x = Environment $ run f <*> run x
diff --git a/Pandora/Paradigm/Inventory/Equipment.hs b/Pandora/Paradigm/Inventory/Equipment.hs
--- a/Pandora/Paradigm/Inventory/Equipment.hs
+++ b/Pandora/Paradigm/Inventory/Equipment.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where
 
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
@@ -19,7 +19,10 @@
 instance Covariant (Equipment e) where
 	f <$> Equipment x = Equipment $ f <$> x
 
-instance Extractable (Equipment e) where
+instance Covariant_ (Equipment e) (->) (->) where
+	f -<$>- Equipment x = Equipment $ f -<$>- x
+
+instance Extractable (Equipment e) (->) where
 	extract = extract . run
 
 instance Traversable (Equipment e) where
@@ -43,7 +46,7 @@
 instance {-# OVERLAPS #-} Extendable u => Extendable ((:*:) e <:.> u) where
 	TU (e :*: x) =>> f = TU . (:*:) e $ x =>> f . TU . (:*:) e
 
-instance Comonad (Equipment e) where
+instance Comonad (Equipment e) (->) where
 
 retrieve :: Equipped e t => t a -> e
 retrieve = attached . run @(Equipment _) . adapt
diff --git a/Pandora/Paradigm/Inventory/Imprint.hs b/Pandora/Paradigm/Inventory/Imprint.hs
--- a/Pandora/Paradigm/Inventory/Imprint.hs
+++ b/Pandora/Paradigm/Inventory/Imprint.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Inventory.Imprint (Imprint (..), Traceable) where
 
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
@@ -22,10 +22,13 @@
 instance Covariant (Imprint e) where
 	f <$> Imprint x = Imprint $ f . x
 
+instance Covariant_ (Imprint e) (->) (->) where
+	f -<$>- Imprint x = Imprint $ f . x
+
 instance Distributive (Imprint e) where
 	g >>- f = Imprint $ g >>- (run <$> f)
 
-instance Monoid e => Extractable (Imprint e) where
+instance Monoid e => Extractable (Imprint e) (->) where
 	extract (Imprint x) = x zero
 
 instance Divariant Imprint where
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
@@ -12,7 +12,7 @@
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))
+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
@@ -32,7 +32,7 @@
 	Convex Lens = Lens Identity
 
 instance Category (Lens Identity) where
-	identity = imply @(Convex Lens _ _) identity ((%) (!))
+	identity = imply @(Convex Lens _ _) identity ((%) (!.))
 	P_Q_T to . P_Q_T from = P_Q_T $ \source -> source <$ (to . extract @Identity . position $ from source)
 
 instance Impliable (P_Q_T (->) Store Identity source target) where
@@ -51,7 +51,7 @@
 instance Category (Lens Maybe) where
 	identity = imply @(Obscure Lens _ _) # Just # resolve identity
 	P_Q_T to . P_Q_T from = P_Q_T $ \source -> case position # from source of
-		Nothing -> Store $ Nothing :*: (source !)
+		Nothing -> Store $ Nothing :*: (source !.)
 		Just between -> source <$ to between
 
 -- Lens as natural transformation
diff --git a/Pandora/Paradigm/Inventory/State.hs b/Pandora/Paradigm/Inventory/State.hs
--- a/Pandora/Paradigm/Inventory/State.hs
+++ b/Pandora/Paradigm/Inventory/State.hs
@@ -4,7 +4,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))
@@ -27,10 +27,13 @@
 instance Covariant (State s) where
 	f <$> x = State $ (<$>) f . run x
 
+instance Covariant_ (State s) (->) (->) where
+	f -<$>- x = State $ (-<$>-) f . run x
+
 instance Applicative (State s) where
 	f <*> x = State $ (|- (<$>)) . (run x <-> identity) . run f
 
-instance Pointable (State s) where
+instance Pointable (State s) (->) where
 	point = State . (-| identity)
 
 instance Bindable (State s) where
@@ -68,7 +71,7 @@
 reconcile :: (Bindable t, Stateful s t, Adaptable u t) => (s -> u s) -> t s
 reconcile f = current >>= adapt . f >>= replace
 
-type Memorable s t = (Pointable t, Applicative t, Stateful s t)
+type Memorable s t = (Pointable t (->), Applicative t, Stateful s t)
 
 fold :: (Traversable t, Memorable s u) => (a -> s -> s) -> t a -> u s
 fold op struct = struct ->> modify . op *> current
diff --git a/Pandora/Paradigm/Inventory/Store.hs b/Pandora/Paradigm/Inventory/Store.hs
--- a/Pandora/Paradigm/Inventory/Store.hs
+++ b/Pandora/Paradigm/Inventory/Store.hs
@@ -4,7 +4,7 @@
 
 import Pandora.Core (type (:.), type (:=), type (<:=), type (~>))
 import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (.#..)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (.#..)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
@@ -15,7 +15,8 @@
 import Pandora.Paradigm.Primary.Functor.Function ((%))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
 import Pandora.Paradigm.Primary.Functor ()
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+--import Pandora.Paradigm.Primary.Transformer ()
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))
@@ -27,16 +28,19 @@
 instance Covariant (Store s) where
 	f <$> Store x = Store $ f <$$> x
 
-instance Extractable (Store s) where
+instance Covariant_ (Store s) (->) (->) where
+	f -<$>- Store x = Store $ f -<$$>- x
+
+instance Extractable (Store s) (->) where
 	extract = (|- ($)) . run
 
 instance Extendable (Store s) where
 	Store x =>> f = Store $ f <$$> Store .#.. (-| identity) <$> x
 
-instance Comonad (Store s) where
+instance Comonad (Store s) (->) where
 
 instance Invariant (Flip Store r) where
-	f <$< g = ((f <-> (g >-> identity) ||=) ||=)
+	f <$< g = \(Flip x) -> Flip $ f <-> (g >-> identity) ||= x
 
 instance Interpreted (Store s) where
 	type Primary (Store s) a = (:*:) s :. (->) s := a
diff --git a/Pandora/Paradigm/Primary.hs b/Pandora/Paradigm/Primary.hs
--- a/Pandora/Paradigm/Primary.hs
+++ b/Pandora/Paradigm/Primary.hs
@@ -11,6 +11,7 @@
 import Pandora.Pattern.Category (Category ((.), ($), (#), identity))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-), (-|)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
@@ -31,12 +32,16 @@
 instance Covariant (Flip (:*:) a) where
 	f <$> (Flip (x :*: y)) = Flip $ f x :*: y
 
-instance Extractable (Flip (:*:) a) where
+instance Extractable (Flip (:*:) a) (->) where
 	extract (Flip (x :*: _)) = x
 
+instance Adjoint (Flip Product s) ((->) s) where
+	x -| f = \s -> f $ Flip $ x :*: s
+	Flip (x :*: s) |- f = f x s
+
 instance Morphable (Into Maybe) (Conclusion e) where
 	type Morphing (Into Maybe) (Conclusion e) = Maybe
-	morphing = conclusion (Nothing !) Just . premorph
+	morphing = conclusion (Nothing !.) Just . premorph
 
 instance Morphable (Into (Conclusion e)) Maybe where
 	type Morphing (Into (Conclusion e)) Maybe = (->) e <:.> Conclusion e
@@ -99,7 +104,7 @@
 	substructure = P_Q_T $ \new -> case lower new of
 		End -> Store $ Nothing :*: lift . resolve Left End . (extract <$>)
 		Left x -> Store $ Just (Identity x) :*: lift . resolve Left End . (extract <$>)
-		Right y -> Store $ Nothing :*: (lift # Right y !) . (extract <$>)
+		Right y -> Store $ Nothing :*: (lift # Right y !.) . (extract <$>)
 		Both x y -> Store $ Just (Identity x) :*: lift . resolve (Both % y) (Right y) . (extract <$>)
 
 instance Substructure Right Wye where
@@ -107,6 +112,6 @@
 	type Substance Right Wye = Identity
 	substructure = P_Q_T $ \new -> case lower new of
 		End -> Store $ Nothing :*: lift . resolve Right End . (extract <$>)
-		Left x -> Store $ Nothing :*: (lift # Left x !) . (extract <$>)
+		Left x -> Store $ Nothing :*: (lift # Left x !.) . (extract <$>)
 		Right y -> Store $ Just (Identity y) :*: lift . resolve Right End . (extract <$>)
 		Both x y -> Store $ Just (Identity y) :*: lift . resolve (Both x) (Left x) . (extract <$>)
diff --git a/Pandora/Paradigm/Primary/Functor.hs b/Pandora/Paradigm/Primary/Functor.hs
--- a/Pandora/Paradigm/Primary/Functor.hs
+++ b/Pandora/Paradigm/Primary/Functor.hs
@@ -1,6 +1,7 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Primary.Functor (module Exports, Equivalence, Comparison, match) where
+module Pandora.Paradigm.Primary.Functor (module Exports, Equivalence, Comparison, match, (-<*>-)) where
 
 import Pandora.Paradigm.Primary.Functor.Fix as Exports
 import Pandora.Paradigm.Primary.Functor.Convergence as Exports
@@ -21,7 +22,8 @@
 import Pandora.Paradigm.Primary.Functor.Function as Exports
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Pattern.Functor.Applicative (Applicative_ (multiply))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)), Adjoint_ ((--|-), (-|--)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean, (?))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering)
 
@@ -34,5 +36,17 @@
 	(|-) :: (s :*: a) -> (a -> s -> b) -> b
 	~(s :*: x) |- f = f x s
 
+instance Adjoint_ (Product s) ((->) s) (->) (->) where
+	(--|-) :: ((s :*: a) -> b) -> a -> (s -> b)
+	f --|- x = \s -> f $ s :*: x
+	(-|--) :: (a -> s -> b) -> (s :*: a) -> b
+	f -|-- ~(s :*: x) = f x s
+
+instance Applicative_ ((->) e) (:*:) (->) (->) where
+	multiply f (g :*: h) = \x -> f $ g x :*: h x
+
 match :: Predicate a -> (a -> r) -> a -> r -> r :*: a
 match (Predicate p) f x r = p x ? (f x :*: x) $ r :*: x
+
+(-<*>-) :: forall a b t v . (Applicative_ t v (->) (->), Adjoint_ (v (a -> b)) ((->) (a -> b)) (->) (->), Adjoint_ (v (t (a -> b))) ((->) (t (a -> b))) (->) (->)) => t (a -> b) -> t a -> t b
+(-<*>-) = (%) ((--|-) @(v (t (a -> b))) (multiply @t @v @(->) @(->) ((&) -|--)))
diff --git a/Pandora/Paradigm/Primary/Functor/Conclusion.hs b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
--- a/Pandora/Paradigm/Primary/Functor/Conclusion.hs
+++ b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
@@ -2,19 +2,21 @@
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category (identity, (.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
@@ -26,13 +28,35 @@
 	f <$> Success x = Success $ f x
 	_ <$> Failure y = Failure y
 
-instance Pointable (Conclusion e) where
+instance Covariant_ (Conclusion e) (->) (->) where
+	f -<$>- Success x = Success $ f x
+	_ -<$>- Failure y = Failure y
+
+instance Covariant_ (Flip Conclusion e) (->) (->) where
+	_ -<$>- Flip (Success x) = Flip $ Success x
+	f -<$>- Flip (Failure y) = Flip . Failure $ f y
+
+instance Pointable (Conclusion e) (->) where
 	point = Success
 
+instance Pointable_ (Conclusion e) (->) where
+	point_ = Success
+
 instance Applicative (Conclusion e) where
 	Success f <*> x = f <$> x
 	Failure y <*> _ = Failure y
 
+instance Applicative_ (Conclusion e) (:*:) (->) (->) where
+	multiply f (Success x :*: Success y) = Success . f $ x :*: y
+	multiply _ (Failure x :*: _) = Failure x
+	multiply _ (_ :*: Failure x) = Failure x
+
+instance Applicative_ (Conclusion e) Conclusion (->) (->) where
+	multiply f (Failure (Success x)) = Success . f $ Failure x
+	multiply f (Success (Success y)) = Success . f $ Success y
+	multiply _ (Failure (Failure e)) = Failure e
+	multiply _ (Success (Failure e)) = Failure e
+
 instance Alternative (Conclusion e) where
 	Failure _ <+> x = x
 	Success x <+> _ = Success x
@@ -45,10 +69,18 @@
 	Success x >>= f = f x
 	Failure y >>= _ = Failure y
 
+instance Bindable_ (Conclusion e) (->) where
+	join_ (Success (Success x)) = Success x
+	join_ (Success (Failure y)) = Failure y
+	join_ (Failure y) = Failure y
+
 instance Monad (Conclusion e) where
 
 instance Bivariant Conclusion where
 	f <-> g = conclusion # Failure . f # Success . g
+
+instance Bivariant_ Conclusion (->) (->) (->) where
+	f -<->- g = conclusion # Failure . f # Success . g
 
 instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where
 	Success x == Success y = x == y
diff --git a/Pandora/Paradigm/Primary/Functor/Constant.hs b/Pandora/Paradigm/Primary/Functor/Constant.hs
--- a/Pandora/Paradigm/Primary/Functor/Constant.hs
+++ b/Pandora/Paradigm/Primary/Functor/Constant.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Constant where
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -22,6 +22,9 @@
 
 instance Covariant (Constant a) where
 	_ <$> Constant x = Constant x
+
+instance Covariant_ (Constant a) (->) (->) where
+	_ -<$>- Constant x = Constant x
 
 instance Contravariant (Constant a) where
 	_ >$< Constant x = Constant x
diff --git a/Pandora/Paradigm/Primary/Functor/Convergence.hs b/Pandora/Paradigm/Primary/Functor/Convergence.hs
--- a/Pandora/Paradigm/Primary/Functor/Convergence.hs
+++ b/Pandora/Paradigm/Primary/Functor/Convergence.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Convergence where
 
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)), Contravariant_ ((->$<-)))
 import Pandora.Pattern.Functor.Divisible (Divisible ((>*<)))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
@@ -10,6 +10,9 @@
 
 instance Contravariant (Convergence r) where
 	f >$< Convergence g = Convergence $ \x y -> g # f x # f y
+
+instance Contravariant_ (Convergence r) (->) (->) where
+	f ->$<- Convergence g = Convergence $ \x y -> g # f x # f y
 
 instance Ringoid r => Divisible (Convergence r) where
 	Convergence g >*< Convergence h = Convergence $
diff --git a/Pandora/Paradigm/Primary/Functor/Edges.hs b/Pandora/Paradigm/Primary/Functor/Edges.hs
--- a/Pandora/Paradigm/Primary/Functor/Edges.hs
+++ b/Pandora/Paradigm/Primary/Functor/Edges.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Edges where
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Paradigm.Primary.Functor.Function ()
@@ -13,6 +13,12 @@
 	f <$> Connect x = Connect $ f x
 	f <$> Overlay x = Overlay $ f x
 	f <$> Leap x = Leap $ f x
+
+instance Covariant_ Edges (->) (->) where
+	_ -<$>- Empty = Empty
+	f -<$>- Connect x = Connect $ f x
+	f -<$>- Overlay x = Overlay $ f x
+	f -<$>- Leap x = Leap $ f x
 
 instance Traversable Edges where
 	Empty ->> _ = point Empty
diff --git a/Pandora/Paradigm/Primary/Functor/Function.hs b/Pandora/Paradigm/Primary/Functor/Function.hs
--- a/Pandora/Paradigm/Primary/Functor/Function.hs
+++ b/Pandora/Paradigm/Primary/Functor/Function.hs
@@ -3,17 +3,19 @@
 module Pandora.Paradigm.Primary.Functor.Function where
 
 import Pandora.Pattern.Category (Category ((.), ($), (#), identity))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
-import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
+import Pandora.Pattern.Functor.Divariant (Divariant ((>->)), Divariant_ ((->->-)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
-infixr 2 !
+infixr 2 !.
 infixr 9 %
 infixl 1 &
 
@@ -24,18 +26,30 @@
 instance Covariant ((->) a) where
 	(<$>) = (.)
 
+instance Covariant_ ((->) a) (->) (->) where
+	(-<$>-) = (.)
+
+instance Contravariant_ (Flip (->) a) (->) (->) where
+	f ->$<- Flip g = Flip $ g . f
+
 instance Applicative ((->) e) where
 	(<*>) f g x = f x $ g x
 
 instance Distributive ((->) e) where
 	g >>- f = \e -> (f % e) <$> g
 
-instance Pointable ((->) e) where
-	point = (!)
+instance Pointable ((->) e) (->) where
+	point = (!.)
 
+instance Pointable_ ((->) e) (->) where
+	point_ = (!.)
+
 instance Bindable ((->) e) where
 	f >>= g = \x -> g # f x # x
 
+instance Bindable_ ((->) e) (->) where
+	join_ f = \x -> f x # x
+
 instance Representable ((->) e) where
 	type Representation ((->) e) = e
 	(<#>) = (identity %)
@@ -44,23 +58,29 @@
 instance Divariant ((->)) where
 	(>->) ab cd bc = cd . bc . ab
 
+instance Divariant_ ((->)) (->) (->) (->) where
+	(->->-) ab cd bc = cd . bc . ab
+
 instance Semigroup r => Semigroup (e -> r) where
 	f + g = \e -> f e + g e
 
 instance Ringoid r => Ringoid (e -> r) where
 	f * g = \e -> f e * g e
 
-{-# INLINE (!) #-}
-(!) :: a -> b -> a
-x ! _ = x
+(-.#..-) :: (Covariant_ (v a) (->) target, Category v) => v c d -> target (v a (v b c)) (v a (v b d))
+(-.#..-) f = (-<$>-) (f .)
 
-{-# INLINE (!!) #-}
-(!!) :: a -> b -> c -> a
-(!!) x _ _ = x
+{-# INLINE (!.) #-}
+(!.) :: a -> b -> a
+x !. _ = x
 
-{-# INLINE (!!!) #-}
-(!!!) :: a -> b -> c -> d -> a
-(!!!) x _ _ _ = x
+{-# INLINE (!..) #-}
+(!..) :: a -> b -> c -> a
+(!..) x _ _ = x
+
+{-# INLINE (!...) #-}
+(!...) :: a -> b -> c -> d -> a
+(!...) x _ _ _ = x
 
 {-# INLINE (%) #-}
 (%) :: (a -> b -> c) -> b -> a -> c
diff --git a/Pandora/Paradigm/Primary/Functor/Identity.hs b/Pandora/Paradigm/Primary/Functor/Identity.hs
--- a/Pandora/Paradigm/Primary/Functor/Identity.hs
+++ b/Pandora/Paradigm/Primary/Functor/Identity.hs
@@ -1,13 +1,13 @@
 module Pandora.Paradigm.Primary.Functor.Identity where
 
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
@@ -29,10 +29,16 @@
 instance Covariant Identity where
 	f <$> Identity x = Identity $ f x
 
-instance Pointable Identity where
+instance Covariant_ Identity (->) (->) where
+	f -<$>- Identity x = Identity $ f x
+
+instance Pointable Identity (->) where
 	point = Identity
 
-instance Extractable Identity where
+instance Pointable_ Identity (->) where
+	point_ = Identity
+
+instance Extractable Identity (->) where
 	extract (Identity x) = x
 
 instance Applicative Identity where
@@ -47,12 +53,15 @@
 instance Bindable Identity where
 	Identity x >>= f = f x
 
+instance Bindable_ Identity (->) where
+	join_ (Identity x) = x
+
 instance Monad Identity
 
 instance Extendable Identity where
 	x =>> f = Identity . f $ x
 
-instance Comonad Identity
+instance Comonad Identity (->)
 
 instance Representable Identity where
 	type Representation Identity = ()
diff --git a/Pandora/Paradigm/Primary/Functor/Maybe.hs b/Pandora/Paradigm/Primary/Functor/Maybe.hs
--- a/Pandora/Paradigm/Primary/Functor/Maybe.hs
+++ b/Pandora/Paradigm/Primary/Functor/Maybe.hs
@@ -2,13 +2,13 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
@@ -23,7 +23,9 @@
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
+import Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (Failure, Success))
 import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
 
 data Maybe a = Nothing | Just a
 
@@ -31,9 +33,16 @@
 	f <$> Just x = Just $ f x
 	_ <$> Nothing = Nothing
 
-instance Pointable Maybe where
+instance Covariant_ Maybe (->) (->) where
+	f -<$>- Just x = Just $ f x
+	_ -<$>- Nothing = Nothing
+
+instance Pointable Maybe (->) where
 	point = Just
 
+instance Pointable_ Maybe (->) where
+	point_ = Just
+
 instance Avoidable Maybe where
 	empty = Nothing
 
@@ -41,6 +50,17 @@
 	Just f <*> x = f <$> x
 	Nothing <*> _ = Nothing
 
+instance Applicative_ Maybe (:*:) (->) (->) where
+	multiply f (Just x :*: Just y) = Just . f $ x :*: y
+	multiply _ (Nothing :*: _) = Nothing
+	multiply _ (_ :*: Nothing) = Nothing
+
+instance Applicative_ Maybe Conclusion (->) (->) where
+	multiply f (Failure (Just x)) = Just . f $ Failure x
+	multiply f (Success (Just y)) = Just . f $ Success y
+	multiply _ (Failure Nothing) = Nothing
+	multiply _ (Success Nothing) = Nothing
+
 instance Alternative Maybe where
 	Nothing <+> y = y
 	Just x <+> _ = Just x
@@ -52,6 +72,10 @@
 instance Bindable Maybe where
 	Just x >>= f = f x
 	Nothing >>= _ = Nothing
+
+instance Bindable_ Maybe (->) where
+	join_ (Just x) = x 
+	join_ Nothing = Nothing
 
 instance Monad Maybe where
 
diff --git a/Pandora/Paradigm/Primary/Functor/Predicate.hs b/Pandora/Paradigm/Primary/Functor/Predicate.hs
--- a/Pandora/Paradigm/Primary/Functor/Predicate.hs
+++ b/Pandora/Paradigm/Primary/Functor/Predicate.hs
@@ -2,16 +2,16 @@
 
 import Pandora.Core.Functor (type (~>), type (:=>))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Divisible (Divisible ((>*<)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)), Contravariant_ ((->$<-)))
+import Pandora.Pattern.Functor.Divisible (Divisible ((>*<)), Divisible_ (divide))
 import Pandora.Pattern.Functor.Determinable (Determinable (determine))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Ringoid ((*))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), bool, (?))
-import Pandora.Paradigm.Primary.Functor.Function ((!))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
+import Pandora.Paradigm.Primary.Functor.Function ((!.))
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype Predicate a = Predicate (a -> Boolean)
@@ -24,16 +24,23 @@
 instance Contravariant Predicate where
 	f >$< Predicate g = Predicate $ g . f
 
+instance Contravariant_ Predicate (->) (->) where
+	f ->$<- Predicate g = Predicate $ g . f
+
 instance Divisible Predicate where
 	Predicate g >*< Predicate h = Predicate $ \(b :*: c) -> g b * h c
 
+instance Divisible_ Predicate (:*:) (->) (->) where
+	divide f (Predicate g :*: Predicate h) = Predicate $ \r -> case f r of
+		b :*: c -> g b * h c
+
 instance Determinable Predicate where
-	determine = Predicate (True !)
+	determine = Predicate (True !.)
 
 equate :: Setoid a => a :=> Predicate
 equate x = Predicate (== x)
 
-satisfy :: (Pointable t, Avoidable t) => Predicate a -> a -> t a
+satisfy :: (Pointable t (->), Avoidable t) => Predicate a -> a -> t a
 satisfy p x = run p x ? point x $ empty
 
 not :: Predicate ~> Predicate
diff --git a/Pandora/Paradigm/Primary/Functor/Product.hs b/Pandora/Paradigm/Primary/Functor/Product.hs
--- a/Pandora/Paradigm/Primary/Functor/Product.hs
+++ b/Pandora/Paradigm/Primary/Functor/Product.hs
@@ -2,13 +2,13 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)), Extendable_ (duplicate_))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
@@ -17,6 +17,7 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 
 infixr 0 :*:
@@ -28,7 +29,13 @@
 instance Covariant (Product s) where
 	f <$> x = attached x :*: f # extract x
 
-instance Extractable (Product a) where
+instance Covariant_ (Product s) (->) (->) where
+	f -<$>- x = attached x :*: f # extract x
+
+instance Covariant_ (Flip (:*:) a) (->) (->) where
+	f -<$>- (Flip (x :*: y)) = Flip $ f x :*: y
+
+instance Extractable (Product a) (->) where
 	extract ~(_ :*: y) = y
 
 instance Traversable (Product s) where
@@ -37,10 +44,16 @@
 instance Extendable (Product s) where
 	x =>> f = attached x :*: f (attached x :*: extract x)
 
-instance Comonad (Product s) where
+instance Extendable_ (Product s) (->) where
+	duplicate_ (s :*: x) = s :*: (s :*: x) 
 
+instance Comonad (Product s) (->) where
+
 instance Bivariant Product where
 	f <-> g = \ ~(s :*: x) -> f s :*: g x
+
+instance Bivariant_ Product (->) (->) (->) where
+	f -<->- g = \ ~(s :*: x) -> f s :*: g x
 
 instance (Setoid s, Setoid a) => Setoid (s :*: a) where
 	x == y = (attached x == attached y) * (extract x == extract y)
diff --git a/Pandora/Paradigm/Primary/Functor/Proxy.hs b/Pandora/Paradigm/Primary/Functor/Proxy.hs
--- a/Pandora/Paradigm/Primary/Functor/Proxy.hs
+++ b/Pandora/Paradigm/Primary/Functor/Proxy.hs
@@ -1,25 +1,32 @@
 module Pandora.Paradigm.Primary.Functor.Proxy where
 
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Paradigm.Primary.Functor.Function ()
 
 data Proxy a = Proxy
 
 instance Covariant Proxy where
 	_ <$> Proxy = Proxy
 
+instance Covariant_ Proxy (->) (->) where
+	_ -<$>- Proxy = Proxy
+
 instance Contravariant Proxy where
 	_ >$< _ = Proxy
 
-instance Pointable Proxy where
+instance Pointable Proxy (->) where
 	point _ = Proxy
+
+instance Pointable_ Proxy (->) where
+	point_ _ = Proxy
 
 instance Applicative Proxy where
 	_ <*> _ = Proxy
diff --git a/Pandora/Paradigm/Primary/Functor/Tagged.hs b/Pandora/Paradigm/Primary/Functor/Tagged.hs
--- a/Pandora/Paradigm/Primary/Functor/Tagged.hs
+++ b/Pandora/Paradigm/Primary/Functor/Tagged.hs
@@ -2,9 +2,9 @@
 
 import Pandora.Core.Functor (type (:=>), type (~>))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
@@ -32,10 +32,16 @@
 instance Covariant (Tagged tag) where
 	f <$> Tag x = Tag $ f x
 
-instance Pointable (Tagged tag) where
+instance Covariant_ (Tagged tag) (->) (->) where
+	f -<$>- Tag x = Tag $ f x
+
+instance Pointable (Tagged tag) (->) where
 	point = Tag
 
-instance Extractable (Tagged tag) where
+instance Pointable_ (Tagged tag) (->) where
+	point_ = Tag
+
+instance Extractable (Tagged tag) (->) where
 	extract (Tag x) = x
 
 instance Applicative (Tagged tag) where
@@ -55,7 +61,7 @@
 instance Extendable (Tagged tag) where
 	x =>> f = Tag . f $ x
 
-instance Comonad (Tagged tag)
+instance Comonad (Tagged tag) (->)
 
 instance Bivariant Tagged where
 	_ <-> g = \(Tag x) -> Tag $ g x
diff --git a/Pandora/Paradigm/Primary/Functor/These.hs b/Pandora/Paradigm/Primary/Functor/These.hs
--- a/Pandora/Paradigm/Primary/Functor/These.hs
+++ b/Pandora/Paradigm/Primary/Functor/These.hs
@@ -1,8 +1,8 @@
 module Pandora.Paradigm.Primary.Functor.These where
 
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Functor.Function ()
@@ -14,8 +14,16 @@
 	_ <$> That y = That y
 	f <$> These y x = These y $ f x
 
-instance Pointable (These e) where
+instance Covariant_ (These e) (->) (->) where
+	f -<$>- This x = This $ f x
+	_ -<$>- That y = That y
+	f -<$>- These y x = These y $ f x
+
+instance Pointable (These e) (->) where
 	point = This
+
+instance Pointable_ (These e) (->) where
+	point_ = This
 
 instance Traversable (These e) where
 	This x ->> f = This <$> f x
diff --git a/Pandora/Paradigm/Primary/Functor/Validation.hs b/Pandora/Paradigm/Primary/Functor/Validation.hs
--- a/Pandora/Paradigm/Primary/Functor/Validation.hs
+++ b/Pandora/Paradigm/Primary/Functor/Validation.hs
@@ -1,16 +1,18 @@
 module Pandora.Paradigm.Primary.Functor.Validation where
 
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
 
@@ -20,15 +22,40 @@
 	_ <$> Flaws e = Flaws e
 	f <$> Validated x = Validated $ f x
 
-instance Pointable (Validation e) where
+instance Covariant_ (Validation e) (->) (->) where
+	_ -<$>- Flaws e = Flaws e
+	f -<$>- Validated x = Validated $ f x
+	_ -<$>- Flaws e = Flaws e
+	f -<$>- Validated x = Validated $ f x
+	_ -<$>- Flaws e = Flaws e
+	f -<$>- Validated x = Validated $ f x
+
+instance Covariant_ (Flip Validation a) (->) (->) where
+	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e
+	_ -<$>- Flip (Validated x) = Flip $ Validated x
+	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e
+	_ -<$>- Flip (Validated x) = Flip $ Validated x
+	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e
+	_ -<$>- Flip (Validated x) = Flip $ Validated x
+
+instance Pointable (Validation e) (->) where
 	point = Validated
 
+instance Pointable_ (Validation e) (->) where
+	point_ = Validated
+
 instance Semigroup e => Applicative (Validation e) where
 	Flaws e <*> Flaws e' = Flaws $ e + e'
 	Flaws e <*> Validated _ = Flaws e
 	Validated _ <*> Flaws e' = Flaws e'
 	Validated f <*> Validated x = Validated $ f x
 
+instance Semigroup e => Applicative_ (Validation e) (:*:) (->) (->) where
+	multiply f (Validated x :*: Validated y) = Validated . f $ x :*: y
+	multiply _ (Flaws x :*: Flaws y) = Flaws $ x + y
+	multiply _ (Validated _ :*: Flaws y) = Flaws y
+	multiply _ (Flaws x :*: Validated _) = Flaws x
+
 instance Alternative (Validation e) where
 	Flaws _ <+> x = x
 	Validated x <+> _ = Validated x
@@ -39,6 +66,9 @@
 
 instance Bivariant Validation where
 	f <-> g = validation # Flaws . f # Validated . g
+
+instance Bivariant_ Validation (->) (->) (->) where
+	f -<->- g = validation # Flaws . f # Validated . g
 
 instance (Setoid e, Setoid a) => Setoid (Validation e a) where
 	Validated x == Validated y = x == y
diff --git a/Pandora/Paradigm/Primary/Functor/Wedge.hs b/Pandora/Paradigm/Primary/Functor/Wedge.hs
--- a/Pandora/Paradigm/Primary/Functor/Wedge.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wedge.hs
@@ -1,8 +1,8 @@
 module Pandora.Paradigm.Primary.Functor.Wedge where
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Paradigm.Primary.Functor.Function ()
 
@@ -13,8 +13,16 @@
 	_ <$> Here x = Here x
 	f <$> There x = There $ f x
 
-instance Pointable (Wedge e) where
+instance Covariant_ (Wedge e) (->) (->) where
+	_ -<$>- Nowhere = Nowhere
+	_ -<$>- Here x = Here x
+	f -<$>- There x = There $ f x
+
+instance Pointable (Wedge e) (->) where
 	point = There
+
+instance Pointable_ (Wedge e) (->) where
+	point_ = There
 
 instance Traversable (Wedge e) where
 	Nowhere ->> _ = point Nowhere
diff --git a/Pandora/Paradigm/Primary/Functor/Wye.hs b/Pandora/Paradigm/Primary/Functor/Wye.hs
--- a/Pandora/Paradigm/Primary/Functor/Wye.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wye.hs
@@ -2,9 +2,9 @@
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Applicative ((<*>))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
@@ -17,6 +17,12 @@
 	f <$> Left x = Left # f x
 	f <$> Right y = Right # f y
 	f <$> Both x y = Both # f x # f y
+
+instance Covariant_ Wye (->) (->) where
+	_ -<$>- End = End
+	f -<$>- Left x = Left # f x
+	f -<$>- Right y = Right # f y
+	f -<$>- Both x y = Both # f x # f y
 
 instance Traversable Wye where
 	End ->> _ = point End
diff --git a/Pandora/Paradigm/Primary/Transformer.hs b/Pandora/Paradigm/Primary/Transformer.hs
--- a/Pandora/Paradigm/Primary/Transformer.hs
+++ b/Pandora/Paradigm/Primary/Transformer.hs
@@ -1,3 +1,5 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
 module Pandora.Paradigm.Primary.Transformer (module Exports) where
 
 import Pandora.Paradigm.Primary.Transformer.Yoneda as Exports
@@ -13,3 +15,10 @@
 import Pandora.Paradigm.Primary.Transformer.Reverse as Exports
 import Pandora.Paradigm.Primary.Transformer.Backwards as Exports
 import Pandora.Paradigm.Primary.Transformer.Flip as Exports
+
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+
+instance Interpreted (Flip v a) where
+	type Primary (Flip v a) e = v e a
+	run ~(Flip x) = x
+	unite = Flip
diff --git a/Pandora/Paradigm/Primary/Transformer/Backwards.hs b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
--- a/Pandora/Paradigm/Primary/Transformer/Backwards.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Primary.Transformer.Backwards where
 
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
@@ -19,10 +19,16 @@
 instance Covariant t => Covariant (Backwards t) where
 	f <$> Backwards x = Backwards $ f <$> x
 
-instance Pointable t => Pointable (Backwards t) where
+instance Covariant_ t (->) (->) => Covariant_ (Backwards t) (->) (->) where
+	f -<$>- Backwards x = Backwards $ f -<$>- x
+
+instance Pointable t (->) => Pointable (Backwards t) (->) where
 	point = Backwards . point
 
-instance Extractable t => Extractable (Backwards t) where
+instance Pointable_ t (->) => Pointable_ (Backwards t) (->) where
+	point_ = Backwards . point_
+
+instance Extractable t (->) => Extractable (Backwards t) (->) where
 	extract (Backwards x) = extract x
 
 instance Applicative t => Applicative (Backwards t) where
diff --git a/Pandora/Paradigm/Primary/Transformer/Construction.hs b/Pandora/Paradigm/Primary/Transformer/Construction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Construction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Construction.hs
@@ -4,14 +4,14 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (:=>), type (~>))
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), ($>>=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), ($>>=)) , Bindable_ (join_))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
@@ -33,10 +33,16 @@
 instance Covariant t => Covariant (Construction t) where
 	f <$> ~(Construct x xs) = Construct # f x # f <$$> xs
 
-instance Avoidable t => Pointable (Construction t) where
+instance Covariant_ t (->) (->) => Covariant_ (Construction t) (->) (->) where
+	f -<$>- ~(Construct x xs) = Construct # f x # f -<$$>- xs
+
+instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Construction t) (->) where
 	point x = Construct x empty
 
-instance Covariant t => Extractable (Construction t) where
+instance (Avoidable t, Covariant_ t (->) (->)) => Pointable_ (Construction t) (->) where
+	point_ x = Construct x empty
+
+instance Covariant_ t (->) (->) => Extractable (Construction t) (->) where
 	extract ~(Construct x _) = x
 
 instance Applicative t => Applicative (Construction t) where
@@ -45,29 +51,32 @@
 instance Traversable t => Traversable (Construction t) where
 	~(Construct x xs) ->> f = Construct <$> f x <*> xs ->>> f
 
-instance Alternative t => Bindable (Construction t) where
+instance (Alternative t, Covariant_ t (->) (->)) => Bindable (Construction t) where
 	~(Construct x xs) >>= f = Construct # extract (f x) # deconstruct (f x) <+> xs $>>= f
 
+instance (Covariant_ t (->) (->), Alternative t) => Bindable_ (Construction t) (->) where
+	join_ (Construct x xs) = Construct # extract x # deconstruct x <+> (join_ @_ @(->) -<$>- xs)
+
 instance Covariant t => Extendable (Construction t) where
 	x =>> f = Construct # f x # extend f <$> deconstruct x
 
-instance (Avoidable t, Alternative t) => Monad (Construction t) where
+instance (Avoidable t, Alternative t, Covariant_ t (->) (->)) => Monad (Construction t) where
 
-instance Covariant t => Comonad (Construction t) where
+instance (Covariant t, Covariant_ t (->) (->)) => Comonad (Construction t) (->) where
 
 instance Lowerable Construction where
-	lower x = extract <$> deconstruct x
+	lower x = extract @_ @(->) -<$>- deconstruct x
 
 instance Hoistable Construction where
-	f /|\ x = Construct # extract x $ f # hoist f <$> deconstruct x
+	f /|\ x = Construct # extract x $ f # hoist f -<$>- deconstruct x
 
-instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant t) => Setoid (Construction t a) where
+instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant t, Covariant_ t (->) (->)) => Setoid (Construction t a) where
 	x == y = (extract x == extract y) * (deconstruct x == deconstruct y)
 
-instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant t) => Semigroup (Construction t a) where
+instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant t, Covariant_ t (->) (->)) => Semigroup (Construction t a) where
 	x + y = Construct # extract x + extract y # deconstruct x + deconstruct y
 
-instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant t) => Monoid (Construction t a) where
+instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant t, Covariant_ t (->) (->)) => Monoid (Construction t a) where
 	zero = Construct zero zero
 
 instance Monotonic a (t :. Construction t := a) => Monotonic a (Construction t a) where
@@ -83,5 +92,5 @@
 (.-+) :: Covariant t => a :=> t -> a :=> Construction t
 f .-+ x = Construct x $ (f .-+) <$> f x
 
-section :: Comonad t => t ~> Construction t
+section :: Comonad t (->) => t ~> Construction t
 section xs = Construct # extract xs $ xs =>> section
diff --git a/Pandora/Paradigm/Primary/Transformer/Continuation.hs b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
--- a/Pandora/Paradigm/Primary/Transformer/Continuation.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable)
@@ -10,7 +10,7 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))
+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))
 
 newtype Continuation r t a = Continuation ((->) ::|:. a :. t := r)
 
@@ -22,7 +22,10 @@
 instance Covariant t => Covariant (Continuation r t) where
 	f <$> Continuation continuation = Continuation $ continuation . (. f)
 
-instance Covariant t => Pointable (Continuation r t) where
+instance Covariant_ t (->) (->) => Covariant_ (Continuation r t) (->) (->) where
+	f -<$>- Continuation continuation = Continuation $ continuation . (. f)
+
+instance Covariant_ t (->) (->) => Pointable (Continuation r t) (->) where
 	point x = Continuation ($ x)
 
 instance Covariant t => Applicative (Continuation r t) where
@@ -38,15 +41,15 @@
 
 -- | Call with current continuation
 cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a
-cwcc f = Continuation $ \g -> (run % g) . f $ Continuation . (!) . g
+cwcc f = Continuation $ \g -> (run % g) . f $ Continuation . (!.) . g
 
 -- | Delimit the continuation of any 'shift'
 reset :: (forall u . Bindable u, Monad t, Traversable t) => Continuation r t r -> Continuation s t r
 reset = lift . (run % point)
 
 -- | Capture the continuation up to the nearest enclosing 'reset' and pass it
-shift :: Pointable t => ((a -> t r) -> Continuation r t r) -> Continuation r t a
+shift :: Pointable t (->) => ((a -> t r) -> Continuation r t r) -> Continuation r t a
 shift f = Continuation $ (run % point) . f
 
-interruptable :: Pointable t => ((a -> Continuation a t a) -> Continuation a t a) -> t a
+interruptable :: Pointable t (->) => ((a -> Continuation a t a) -> Continuation a t a) -> t a
 interruptable = (run % point) . cwcc
diff --git a/Pandora/Paradigm/Primary/Transformer/Day.hs b/Pandora/Paradigm/Primary/Transformer/Day.hs
--- a/Pandora/Paradigm/Primary/Transformer/Day.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Day.hs
@@ -1,14 +1,16 @@
+{-# LANGUAGE UndecidableInstances #-}
+
 module Pandora.Paradigm.Primary.Transformer.Day where
 
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Functor.Function ((!!))
+import Pandora.Paradigm.Primary.Functor.Function ((!..), (-.#..-))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 
 data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a)
@@ -16,21 +18,24 @@
 instance Covariant (Day t u) where
 	f <$> Day tb uc g = Day tb uc # f .#.. g
 
-instance (Pointable t, Pointable u) => Pointable (Day t u) where
-	point x = Day # point () # point () # (x !!)
+instance Covariant_ (Day t u) (->) (->) where
+	f -<$>- Day tb uc g = Day tb uc # f -.#..- g
 
+instance (Pointable t (->), Pointable u (->)) => Pointable (Day t u) (->) where
+	point x = Day # point () # point () # (x !..)
+
 instance (Applicative t, Applicative u) => Applicative (Day t u) where
 	Day tb uc bcad <*> Day vb wc bca = Day # (:*:) <$> tb <*> vb # (:*:) <$> uc <*> wc
 		$ \(b :*: b') (c :*: c') -> bcad b c $ bca b' c'
 
-instance (Extractable t, Extractable u) => Extractable (Day t u) where
+instance (Extractable t (->), Extractable u (->)) => Extractable (Day t u) (->) where
 	extract (Day tb uc bcad) = bcad # extract tb # extract uc
 
 instance (Extendable t, Extendable u) => Extendable (Day t u) where
-	day@(Day tb uc _) =>> f = Day tb uc (f day !!)
+	day@(Day tb uc _) =>> f = Day tb uc (f day !..)
 
-instance Extractable t => Lowerable (Day t) where
-	lower (Day tb uc bca) = bca (extract tb) <$> uc
+instance Extractable t (->) => Lowerable (Day t) where
+	lower (Day tb uc bca) = bca (extract tb) -<$>- uc
 
 instance Hoistable (Day t) where
 	g /|\ Day tb uc bca = Day tb # g uc # bca
diff --git a/Pandora/Paradigm/Primary/Transformer/Flip.hs b/Pandora/Paradigm/Primary/Transformer/Flip.hs
--- a/Pandora/Paradigm/Primary/Transformer/Flip.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Flip.hs
@@ -1,17 +1,3 @@
-{-# LANGUAGE UndecidableInstances #-}
-
 module Pandora.Paradigm.Primary.Transformer.Flip where
 
-import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))
-
 newtype Flip (v :: * -> * -> *) a e = Flip (v e a)
-
-instance Interpreted (Flip v a) where
-	type Primary (Flip v a) e = v e a
-	run ~(Flip x) = x
-	unite = Flip
-
-instance (forall i . Covariant (Flip v i), Bivariant v) => Bivariant (Flip v) where
-	f <-> g = (g <-> f ||=)
diff --git a/Pandora/Paradigm/Primary/Transformer/Instruction.hs b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Instruction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
@@ -4,7 +4,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
@@ -23,7 +23,11 @@
 	f <$> Enter x = Enter $ f x
 	f <$> Instruct xs = Instruct $ f <$$> xs
 
-instance Covariant t => Pointable (Instruction t) where
+instance Covariant_ t (->) (->) => Covariant_ (Instruction t) (->) (->) where
+	f -<$>- Enter x = Enter $ f x
+	f -<$>- Instruct xs = Instruct $ f -<$$>- xs
+
+instance Covariant_ t (->) (->) => Pointable (Instruction t) (->) where
 	point = Enter
 
 instance Alternative t => Alternative (Instruction t) where
@@ -48,7 +52,7 @@
 	Instruct xs ->> f = Instruct <$> xs ->>> f
 
 instance Liftable Instruction where
-	lift x = Instruct $ Enter <$> x
+	lift x = Instruct $ Enter -<$>- x
 
 instance (forall t . Monad t) => Lowerable Instruction where
 	lower (Enter x) = point x
diff --git a/Pandora/Paradigm/Primary/Transformer/Jack.hs b/Pandora/Paradigm/Primary/Transformer/Jack.hs
--- a/Pandora/Paradigm/Primary/Transformer/Jack.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Jack.hs
@@ -1,7 +1,9 @@
+{-# LANGUAGE UndecidableInstances #-}
+
 module Pandora.Paradigm.Primary.Transformer.Jack where
 
 import Pandora.Pattern.Category (identity, (.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
@@ -25,7 +27,11 @@
 	f <$> It x = It $ f x
 	f <$> Other y = Other $ f <$> y
 
-instance Covariant t => Pointable (Jack t) where
+instance Covariant_ t (->) (->) => Covariant_ (Jack t) (->) (->) where
+	f -<$>- It x = It $ f x
+	f -<$>- Other y = Other $ f -<$>- y
+
+instance Covariant_ t (->) (->) => Pointable (Jack t) (->) where
 	point = It
 
 instance Alternative t => Alternative (Jack t) where
@@ -36,7 +42,7 @@
 instance Avoidable t => Avoidable (Jack t) where
 	empty = Other empty
 
-instance Extractable t => Extractable (Jack t) where
+instance Extractable t (->) => Extractable (Jack t) (->) where
 	extract (It x) = x
 	extract (Other y) = extract y
 
@@ -53,7 +59,7 @@
 instance Distributive t => Distributive (Jack t) where
 	x >>- f = distribute $ f <$> x
 
-instance (Pointable t, Bindable t) => Bindable (Jack t) where
+instance (Pointable t (->), Bindable t) => Bindable (Jack t) where
 	It x >>= f = f x
 	Other x >>= f = Other $ x >>= jack point identity . f
 
diff --git a/Pandora/Paradigm/Primary/Transformer/Jet.hs b/Pandora/Paradigm/Primary/Transformer/Jet.hs
--- a/Pandora/Paradigm/Primary/Transformer/Jet.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Jet.hs
@@ -1,6 +1,8 @@
+{-# LANGUAGE UndecidableInstances #-}
+
 module Pandora.Paradigm.Primary.Transformer.Jet where
 
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
@@ -12,11 +14,14 @@
 instance Covariant t => Covariant (Jet t) where
 	f <$> Jet x xs = Jet (f x) (f <$$> xs)
 
+instance Covariant_ t (->) (->) => Covariant_ (Jet t) (->) (->) where
+	f -<$>- Jet x xs = Jet (f x) (f -<$$>- xs)
+
 instance Traversable t => Traversable (Jet t) where
 	Jet x xs ->> f = Jet <$> f x <*> xs ->>> f
 
-instance (forall u . Avoidable u) => Pointable (Jet t) where
+instance (forall u . Avoidable u, Covariant_ t (->) (->)) => Pointable (Jet t) (->) where
 	point x = Jet x empty
 
-instance Covariant t => Extractable (Jet t) where
+instance Covariant_ t (->) (->) => Extractable (Jet t) (->) where
 	extract (Jet x _) = x
diff --git a/Pandora/Paradigm/Primary/Transformer/Kan.hs b/Pandora/Paradigm/Primary/Transformer/Kan.hs
--- a/Pandora/Paradigm/Primary/Transformer/Kan.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Kan.hs
@@ -1,8 +1,8 @@
 module Pandora.Paradigm.Primary.Transformer.Kan where
 
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))
+import Pandora.Pattern.Functor.Covariant (Covariant_ ((-<$>-)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 
@@ -10,8 +10,8 @@
 
 data instance Kan Left t u b a = Lan ((t b -> a) -> u b)
 
-instance Contravariant (Kan Left t u b) where
-	f >$< Lan x = Lan $ x . (f .)
+instance Contravariant_ (Kan Left t u b) (->) (->) where
+	f ->$<- Lan x = Lan $ x . (f .)
 
 instance Interpreted (Kan Left t u b) where
 	type Primary (Kan Left t u b) a = (t b -> a) -> u b
@@ -20,8 +20,8 @@
 
 data instance Kan Right t u b a = Ran ((a -> t b) -> u b)
 
-instance Covariant (Kan Right t u b) where
-	f <$> Ran x = Ran $ x . (. f)
+instance Covariant_ (Kan Right t u b) (->) (->) where
+	f -<$>- Ran x = Ran $ x . (. f)
 
 instance Interpreted (Kan Right t u b) where
 	type Primary (Kan Right t u b) a = (a -> t b) -> u b
diff --git a/Pandora/Paradigm/Primary/Transformer/Outline.hs b/Pandora/Paradigm/Primary/Transformer/Outline.hs
--- a/Pandora/Paradigm/Primary/Transformer/Outline.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Outline.hs
@@ -1,7 +1,9 @@
+{-# LANGUAGE UndecidableInstances #-}
+
 module Pandora.Paradigm.Primary.Transformer.Outline where
 
 import Pandora.Pattern.Category (identity, (.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
@@ -18,10 +20,14 @@
 	f <$> Line a = Line $ f a
 	f <$> Outlined x y = Outlined x # (.) f <$> y
 
-instance Pointable (Outline t) where
+instance Covariant_ (Outline t) (->) (->) where
+	f -<$>- Line a = Line $ f a
+	f -<$>- Outlined x y = Outlined x # (.) f -<$>- y
+
+instance Pointable (Outline t) (->) where
 	point = Line
 
-instance Extractable t => Extractable (Outline t) where
+instance Extractable t (->) => Extractable (Outline t) (->) where
 	extract (Line x) = x
 	extract (Outlined x y) = extract y # extract x
 
@@ -36,7 +42,7 @@
 	_ /|\ Line x = Line x
 	f /|\ Outlined x y = Outlined # f x # f /|\ y
 
-instance (Extractable t, Pointable t, Applicative t) => Interpreted (Outline t) where
+instance (Extractable t (->), Pointable t (->), Applicative t) => Interpreted (Outline t) where
 	type Primary (Outline t) a = t a
 	run (Line x) = point x
 	run (Outlined t f) = run f <*> t
diff --git a/Pandora/Paradigm/Primary/Transformer/Reverse.hs b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
--- a/Pandora/Paradigm/Primary/Transformer/Reverse.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
@@ -1,7 +1,9 @@
+{-# LANGUAGE UndecidableInstances #-}
+
 module Pandora.Paradigm.Primary.Transformer.Reverse where
 
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -19,10 +21,13 @@
 instance Covariant t => Covariant (Reverse t) where
 	f <$> Reverse x = Reverse # f <$> x
 
-instance Pointable t => Pointable (Reverse t) where
+instance Covariant_ t (->) (->) => Covariant_ (Reverse t) (->) (->) where
+	f -<$>- Reverse x = Reverse # f -<$>- x
+
+instance Pointable t (->) => Pointable (Reverse t) (->) where
 	point = Reverse . point
 
-instance Extractable t => Extractable (Reverse t) where
+instance Extractable t (->) => Extractable (Reverse t) (->) where
 	extract (Reverse x) = extract x
 
 instance Applicative t => Applicative (Reverse t) where
diff --git a/Pandora/Paradigm/Primary/Transformer/Tap.hs b/Pandora/Paradigm/Primary/Transformer/Tap.hs
--- a/Pandora/Paradigm/Primary/Transformer/Tap.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Tap.hs
@@ -1,8 +1,10 @@
+{-# LANGUAGE UndecidableInstances #-}
+
 module Pandora.Paradigm.Primary.Transformer.Tap where
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
@@ -15,9 +17,11 @@
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Inventory.Store (Store (Store))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) 
 import Pandora.Paradigm.Primary.Functor.Function ((%))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), twosome)
+import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
@@ -29,10 +33,13 @@
 instance Covariant t => Covariant (Tap t) where
 	f <$> Tap x xs = Tap # f x # f <$> xs
 
-instance Avoidable t => Pointable (Tap t) where
+instance Covariant_ t (->) (->) => Covariant_ (Tap t) (->) (->) where
+	f -<$>- Tap x xs = Tap # f x # f -<$>- xs
+
+instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Tap t) (->) where
 	point = Tap % empty
 
-instance Covariant t => Extractable (Tap t) where
+instance (Covariant t, Covariant_ t (->) (->))  => Extractable (Tap t) (->) where
 	extract (Tap x _) = x
 
 instance Applicative t => Applicative (Tap t) where
@@ -41,10 +48,10 @@
 instance Traversable t => Traversable (Tap t) where
 	Tap x xs ->> f = Tap <$> f x <*> xs ->> f
 
-instance (Extractable t, Alternative t, Bindable t) => Bindable (Tap t) where
+instance (Extractable t (->), Alternative t, Bindable t) => Bindable (Tap t) where
 	Tap x xs >>= f = case f x of ~(Tap y ys) -> Tap y $ ys <+> (xs >>= lower . f)
 
-instance Extendable t => Extendable (Tap t) where
+instance (Extendable t, Covariant_ t (->) (->)) => Extendable (Tap t) where
 	x =>> f = Tap # f x $ lower x =>> f . Tap (extract x)
 
 instance Lowerable Tap where
@@ -53,19 +60,26 @@
 instance Hoistable Tap where
 	f /|\ Tap x xs = Tap x # f xs
 
-instance Covariant t => Substructure Root (Tap (t <:.:> t := (:*:))) where
+instance {-# OVERLAPS #-} Applicative t => Applicative (Tap (t <:.:> t := (:*:))) where
+	Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs)
+
+instance {-# OVERLAPS #-} Traversable t => Traversable (Tap (t <:.:> t := (:*:))) where
+	Tap x (T_U (future :*: past)) ->> f = (\past' x' future' -> Tap x' $ twosome # future' # run past')
+		<$> Reverse past ->> f <*> f x <*> future ->> f
+
+instance (Covariant t, Covariant_ t (->) (->)) => Substructure Root (Tap (t <:.:> t := (:*:))) where
 	type Available Root (Tap (t <:.:> t := (:*:))) = Identity
 	type Substance Root (Tap (t <:.:> t := (:*:))) = Identity
 	substructure = P_Q_T $ \zipper -> case lower zipper of
 		Tap x xs -> Store $ Identity (Identity x) :*: lift . (Tap % xs) . extract . extract
 
-instance Covariant t => Substructure Left (Tap (t <:.:> t := (:*:))) where
+instance (Covariant t, Covariant_ t (->) (->)) => Substructure Left (Tap (t <:.:> t := (:*:))) where
 	type Available Left (Tap (t <:.:> t := (:*:))) = Identity
 	type Substance Left (Tap (t <:.:> t := (:*:))) = t
 	substructure = P_Q_T $ \zipper -> case lower zipper of
 		Tap x (T_U (future :*: past)) -> Store $ Identity future :*: lift . Tap x . T_U . (:*: past) . extract
 
-instance Covariant t => Substructure Right (Tap (t <:.:> t := (:*:))) where
+instance (Covariant t, Covariant_ t (->) (->)) => Substructure Right (Tap (t <:.:> t := (:*:))) where
 	type Available Right (Tap (t <:.:> t := (:*:))) = Identity
 	type Substance Right (Tap (t <:.:> t := (:*:))) = t
 	substructure = P_Q_T $ \zipper -> case lower zipper of
diff --git a/Pandora/Paradigm/Primary/Transformer/Yoneda.hs b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
--- a/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
@@ -1,8 +1,10 @@
+{-# LANGUAGE UndecidableInstances #-}
+
 module Pandora.Paradigm.Primary.Transformer.Yoneda where
 
 import Pandora.Pattern.Category (identity, (.), ($), (#))
 import Pandora.Pattern.Functor ((<*+>))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
@@ -10,7 +12,7 @@
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Paradigm.Primary.Functor.Function ((!))
+import Pandora.Paradigm.Primary.Functor.Function ((!.))
 
 newtype Yoneda t a = Yoneda
 	{ yoneda :: forall b . (a -> b) -> t b }
@@ -18,6 +20,9 @@
 instance Covariant (Yoneda t) where
 	f <$> x = Yoneda (\k -> yoneda x (k . f))
 
+instance Covariant_ (Yoneda t) (->) (->) where
+	f -<$>- x = Yoneda (\k -> yoneda x (k . f))
+
 instance Alternative t => Alternative (Yoneda t) where
 	Yoneda f <+> Yoneda g = Yoneda (f <*+> g)
 
@@ -25,17 +30,17 @@
 	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)
 
 instance Avoidable t => Avoidable (Yoneda t) where
-	empty = Yoneda (empty !)
+	empty = Yoneda (empty !.)
 
-instance Pointable t => Pointable (Yoneda t) where
+instance Pointable t (->) => Pointable (Yoneda t) (->) where
 	point x = Yoneda (\f -> point $ f x)
 
-instance Extractable t => Extractable (Yoneda t) where
+instance Extractable t (->) => Extractable (Yoneda t) (->) where
 	extract (Yoneda f) = extract $ f identity
 
 instance Liftable Yoneda where
-	lift x = Yoneda (<$> x)
+	lift x = Yoneda (-<$>- x)
 
-instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where
+instance (Extractable t (->), Pointable t (->), Extractable u (->) , Pointable u (->)) => Adjoint (Yoneda t) (Yoneda u) where
 	x -| f = point . f . point # x
 	x |- g = extract . extract # g <$> x
diff --git a/Pandora/Paradigm/Schemes/TU.hs b/Pandora/Paradigm/Schemes/TU.hs
--- a/Pandora/Paradigm/Schemes/TU.hs
+++ b/Pandora/Paradigm/Schemes/TU.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
@@ -34,6 +34,9 @@
 instance (Covariant t, Covariant u) => Covariant (t <:.> u) where
 	f <$> x = TU $ f <$$> run x
 
+instance (Covariant_ t (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <:.> u) (->) (->) where
+	f -<$>- x = TU $ f -<$$>- run x
+
 instance (Applicative t, Applicative u) => Applicative (t <:.> u) where
 	TU f <*> TU x = TU $ f <**> x
 
@@ -43,10 +46,10 @@
 instance (Covariant u, Avoidable t) => Avoidable (t <:.> u) where
 	empty = TU empty
 
-instance (Pointable t, Pointable u) => Pointable (t <:.> u) where
+instance (Pointable t (->), Pointable u (->)) => Pointable (t <:.> u) (->) where
 	point = TU . point . point
 
-instance (Extractable t, Extractable u) => Extractable (t <:.> u) where
+instance (Extractable t (->), Extractable u (->)) => Extractable (t <:.> u) (->) where
 	extract = extract . extract . run
 
 instance (Traversable t, Traversable u) => Traversable (t <:.> u) where
@@ -55,11 +58,11 @@
 instance (Bindable t, Distributive t, Bindable u) => Bindable (t <:.> u) where
 	TU x >>= f = TU $ x >>= \i -> join <$> i >>- run . f
 
-instance Pointable t => Liftable (TU Covariant Covariant t) where
-	lift :: Covariant u => u ~> t <:.> u
+instance Pointable t (->) => Liftable (TU Covariant Covariant t) where
+	lift :: Covariant_ u (->) (->) => u ~> t <:.> u
 	lift = TU . point
 
-instance Extractable t => Lowerable (TU Covariant Covariant t) where
+instance Extractable t (->) => Lowerable (TU Covariant Covariant t) where
 	lower :: t <:.> u ~> u
 	lower (TU x) = extract x
 
diff --git a/Pandora/Paradigm/Schemes/TUT.hs b/Pandora/Paradigm/Schemes/TUT.hs
--- a/Pandora/Paradigm/Schemes/TUT.hs
+++ b/Pandora/Paradigm/Schemes/TUT.hs
@@ -3,7 +3,7 @@
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Category (identity, (.), ($))
 import Pandora.Pattern.Functor ((<*+>))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$$>)), Covariant_ ((-<$>-)), (-<$$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
@@ -39,31 +39,34 @@
 instance (Covariant t, Covariant t', Covariant u) => Covariant (t <:<.>:> t' := u) where
 	f <$> TUT x = TUT $ f <$$$> x
 
-instance (Adjoint t' t, Bindable u) => Applicative (t <:<.>:> t' := u) where
+instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <:<.>:> t' := u) (->) (->)where
+	f -<$>- TUT x = TUT $ f -<$$$>- x
+
+instance (Covariant t, Covariant t', Adjoint t' t, Bindable u) => Applicative (t <:<.>:> t' := u) where
 	f <*> x = TUT $ (>>= (|- (<$$$> run x))) <$> run f
 
 instance (Applicative t, Covariant t', Alternative u) => Alternative (t <:<.>:> t' := u) where
 	x <+> y = TUT $ run x <*+> run y
 
-instance (Pointable t, Applicative t, Covariant t', Avoidable u) => Avoidable (t <:<.>:> t' := u) where
+instance (Pointable t (->), Applicative t, Covariant t', Avoidable u) => Avoidable (t <:<.>:> t' := u) where
 	empty = TUT $ point empty
 
-instance (Pointable u, Adjoint t' t) => Pointable (t <:<.>:> t' := u) where
+instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Pointable u (->), Adjoint t' t) => Pointable (t <:<.>:> t' := u) (->) where
 	point = unite . (-| point)
 
-instance (Adjoint t' t, Bindable u) => Bindable (t <:<.>:> t' := u) where
+instance (Covariant t, Covariant t', Adjoint t' t, Bindable u) => Bindable (t <:<.>:> t' := u) where
 	x >>= f = TUT $ run x $>>= (|- run . f)
 
-instance (Adjoint t' t, Extendable u) => Extendable (t' <:<.>:> t := u) where
+instance (Covariant t', Covariant t, Adjoint t' t, Extendable u) => Extendable (t' <:<.>:> t := u) where
 	x =>> f = TUT $ run x $=>> (-| f . unite)
 
-instance (Adjoint t t', Extractable u) => Extractable (t <:<.>:> t' := u) where
+instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Adjoint t t', Extractable u (->)) => Extractable (t <:<.>:> t' := u) (->) where
 	extract = (|- extract) . run
 
-instance (Adjoint t' t, Distributive t) => Liftable (t <:<.>:> t') where
-	lift :: Covariant u => u ~> t <:<.>:> t' := u
+instance (forall u . Covariant u, Adjoint t' t, Distributive t) => Liftable (t <:<.>:> t') where
+	lift :: Covariant_ u (->) (->) => u ~> t <:<.>:> t' := u
 	lift x = TUT $ x >>- (-| identity)
 
-instance (Adjoint t t', Distributive t') => Lowerable (t <:<.>:> t') where
-	lower :: Covariant u => (t <:<.>:> t' := u) ~> u
+instance (forall u . Covariant u, Adjoint t t', Distributive t') => Lowerable (t <:<.>:> t') where
+	lower :: Covariant_ u (->) (->) => (t <:<.>:> t' := u) ~> u
 	lower (TUT x) = x |- (>>- identity)
diff --git a/Pandora/Paradigm/Schemes/T_U.hs b/Pandora/Paradigm/Schemes/T_U.hs
--- a/Pandora/Paradigm/Schemes/T_U.hs
+++ b/Pandora/Paradigm/Schemes/T_U.hs
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Schemes.T_U where
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
-import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))
+import Pandora.Pattern.Functor.Divariant (Divariant ((>->))) 
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))
 
 newtype T_U ct cu p t u a = T_U (p (t a) (u a))
@@ -23,6 +23,9 @@
 
 instance (forall i . Covariant (p i), Bivariant p, Covariant t, Covariant u) => Covariant (t <:.:> u := p) where
 	f <$> x = (f <$>) <-> (f <$>) ||= x
+
+instance (forall i . Covariant_ (p i) (->) (->), Bivariant_ p (->) (->) (->), Covariant_ t (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <:.:> u := p) (->) (->) where
+	f -<$>- x = (f -<$>-) -<->- (f -<$>-) ||= x
 
 instance (Divariant p, Contravariant t, Covariant u) => Covariant (t >:.:> u := p) where
 	f <$> x = (f >$<) >-> (f <$>) ||= x
diff --git a/Pandora/Paradigm/Schemes/UT.hs b/Pandora/Paradigm/Schemes/UT.hs
--- a/Pandora/Paradigm/Schemes/UT.hs
+++ b/Pandora/Paradigm/Schemes/UT.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -31,22 +31,25 @@
 instance (Covariant t, Covariant u) => Covariant (t <.:> u) where
 	f <$> UT x = UT $ f <$$> x
 
+instance (Covariant_ t (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <.:> u) (->) (->) where
+	f -<$>- UT x = UT $ f -<$$>- x
+
 instance (Applicative t, Applicative u) => Applicative (t <.:> u) where
 	UT f <*> UT x = UT $ f <**> x
 
-instance (Pointable t, Pointable u) => Pointable (t <.:> u) where
+instance (Pointable t (->), Pointable u (->)) => Pointable (t <.:> u) (->) where
 	point = UT . point . point
 
 instance (Traversable t, Bindable t, Applicative u, Monad u) => Bindable (t <.:> u) where
 	UT x >>= f = UT $ x >>= \i -> join <$> i ->> run . f
 
-instance (Extractable t, Extractable u) => Extractable (t <.:> u) where
+instance (Extractable t (->), Extractable u (->)) => Extractable (t <.:> u) (->) where
 	extract = extract . extract . run
 
-instance Pointable t => Liftable (UT Covariant Covariant t) where
-	lift :: Covariant u => u ~> t <.:> u
-	lift x = UT $ point <$> x
+instance Pointable t (->) => Liftable (UT Covariant Covariant t) where
+	lift :: Covariant_ u (->) (->) => u ~> t <.:> u
+	lift x = UT $ point @_ @(->) -<$>- x
 
-instance Extractable t => Lowerable (UT Covariant Covariant t) where
-	lower :: Covariant u => t <.:> u ~> u
-	lower (UT x) = extract <$> x
+instance Extractable t (->) => Lowerable (UT Covariant Covariant t) where
+	lower :: Covariant_ u (->) (->) => t <.:> u ~> u
+	lower (UT x) = extract @_ @(->) -<$>- x
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -9,7 +9,7 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Category (($), (.), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant (comap))
+import Pandora.Pattern.Functor.Covariant (Covariant (comap), Covariant_)
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Pointable (point)
 import Pandora.Pattern.Transformer.Liftable (lift)
@@ -38,7 +38,7 @@
 instance Nullable Maybe where
 	null = Predicate $ \case { Just _ -> True ; _ -> False }
 
-instance Covariant t => Substructure Tail (Tap t) where
+instance (Covariant t, Covariant_ t (->) (->)) => Substructure Tail (Tap t) where
 	type Available Tail (Tap t) = Identity
 	type Substance Tail (Tap t) = t
 	substructure = P_Q_T $ \tap -> case extract # run tap of
@@ -90,13 +90,13 @@
 instance {-# OVERLAPS #-} Accessible b a => Accessible b (s :*: a) where
 	access = access @b . access @a
 
-instance Covariant t => Substructure Left (t <:.:> t := (:*:)) where
+instance (Covariant t, Covariant_ t (->) (->)) => Substructure Left (t <:.:> t := (:*:)) where
 	type Available Left (t <:.:> t := (:*:)) = Identity
 	type Substance Left (t <:.:> t := (:*:)) = t
 	substructure = P_Q_T $ \x -> case run # lower x of
 		ls :*: rs -> Store $ Identity ls :*: lift . (twosome % rs) . extract
 
-instance Covariant t => Substructure Right (t <:.:> t := (:*:)) where
+instance (Covariant t, Covariant_ t (->) (->)) => Substructure Right (t <:.:> t := (:*:)) where
 	type Available Right (t <:.:> t := (:*:)) = Identity
 	type Substance Right (t <:.:> t := (:*:)) = t
 	substructure = P_Q_T $ \x -> case run # lower x of
diff --git a/Pandora/Paradigm/Structure/Ability/Monotonic.hs b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
--- a/Pandora/Paradigm/Structure/Ability/Monotonic.hs
+++ b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant ((.#..))
-import Pandora.Paradigm.Primary.Functor.Function ((!))
+import Pandora.Paradigm.Primary.Functor.Function ((!.))
 
 class Monotonic a e where
 	{-# MINIMAL reduce #-}
@@ -10,7 +10,7 @@
 
 	-- | Version of `reduce` which ignores accumulator
 	resolve :: (a -> r) -> r -> e -> r
-	resolve g = reduce # g .#.. (!)
+	resolve g = reduce # g .#.. (!.)
 
 instance Monotonic a a where
 	reduce f r x = f x r
diff --git a/Pandora/Paradigm/Structure/Ability/Substructure.hs b/Pandora/Paradigm/Structure/Ability/Substructure.hs
--- a/Pandora/Paradigm/Structure/Ability/Substructure.hs
+++ b/Pandora/Paradigm/Structure/Ability/Substructure.hs
@@ -4,7 +4,7 @@
 module Pandora.Paradigm.Structure.Ability.Substructure where
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
@@ -23,5 +23,5 @@
 	type Substance segment structure :: * -> *
 	substructure :: (Tagged segment <:.> structure) #=@ Substance segment structure := Available segment structure
 
-	sub :: Covariant structure => structure #=@ Substance segment structure := Available segment structure
+	sub :: (Covariant structure, Covariant_ structure (->) (->)) => structure #=@ Substance segment structure := Available segment structure
 	sub = lift >-> (lower <$>) ||= substructure @segment @structure
diff --git a/Pandora/Paradigm/Structure/Interface/Set.hs b/Pandora/Paradigm/Structure/Interface/Set.hs
--- a/Pandora/Paradigm/Structure/Interface/Set.hs
+++ b/Pandora/Paradigm/Structure/Interface/Set.hs
@@ -8,7 +8,7 @@
 import Pandora.Pattern.Object.Setoid (Setoid ((!=)))
 import Pandora.Pattern.Object.Semigroup ((+))
 import Pandora.Pattern.Object.Quasiring (one)
-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))
+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)
@@ -26,4 +26,4 @@
 subset = Convergence $ \s ss -> Nothing != ss ->> (find @f @t @Maybe % s) . equate
 
 cardinality :: Traversable t => t a -> Numerator
-cardinality s = attached . run @(State _) % Zero $ s ->> (modify @Numerator (+ one) !)
+cardinality s = attached . run @(State _) % Zero $ s ->> (modify @Numerator (+ one) !.)
diff --git a/Pandora/Paradigm/Structure/Modification/Comprehension.hs b/Pandora/Paradigm/Structure/Modification/Comprehension.hs
--- a/Pandora/Paradigm/Structure/Modification/Comprehension.hs
+++ b/Pandora/Paradigm/Structure/Modification/Comprehension.hs
@@ -5,7 +5,7 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant ((>$<))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
@@ -37,7 +37,10 @@
 instance Covariant (t <:.> Construction t) => Covariant (Comprehension t) where
 	f <$> Comprehension x = Comprehension $ f <$> x
 
-instance (Avoidable t, Pointable t) => Pointable (Comprehension t) where
+instance Covariant_ (t <:.> Construction t) (->) (->) => Covariant_ (Comprehension t) (->) (->) where
+	f -<$>- Comprehension x = Comprehension $ f -<$>- x
+
+instance (Avoidable t, Pointable t (->)) => Pointable (Comprehension t) (->) where
 	point = Comprehension . TU . point . Construct % empty
 
 instance Alternative t => Alternative (Comprehension t) where
@@ -49,13 +52,13 @@
 instance Traversable (t <:.> Construction t) => Traversable (Comprehension t) where
 	Comprehension x ->> f = Comprehension <$> x ->> f
 
-instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t, Pointable t, Avoidable t) => Applicative (Comprehension t) where
+instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t, Pointable t (->), Avoidable t) => Applicative (Comprehension t) where
 	fs <*> xs = fs >>= \f -> xs >>= Comprehension . TU . point . point . f
 
 instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t) => Bindable (Comprehension t) where
 	Comprehension (TU t) >>= f = Comprehension . TU $ t >>= \(Construct x xs) -> run . run $ f x + (Comprehension (TU xs) >>= f)
 
-instance (forall a . Semigroup (t <:.> Construction t := a), Pointable t, Avoidable t, Bindable t) => Monad (Comprehension t) where
+instance (forall a . Semigroup (t <:.> Construction t := a), Pointable t (->), Avoidable t, Bindable t) => Monad (Comprehension t) where
 
 instance Setoid (t <:.> Construction t := a) => Setoid (Comprehension t a) where
 	Comprehension ls == Comprehension rs = ls == rs
@@ -66,7 +69,7 @@
 instance Monoid (t <:.> Construction t := a) => Monoid (Comprehension t a) where
 	zero = Comprehension zero
 
-instance Pointable t => Morphable Push (Comprehension t) where
+instance (Covariant t, Covariant_ t (->) (->), Pointable t (->)) => Morphable Push (Comprehension t) where
 	type Morphing Push (Comprehension t) = Identity <:.:> Comprehension t := (->)
 	morphing (run . premorph -> xs) = T_U $ \(Identity x) -> Comprehension . lift . Construct x . run $ xs
 
diff --git a/Pandora/Paradigm/Structure/Modification/Prefixed.hs b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
--- a/Pandora/Paradigm/Structure/Modification/Prefixed.hs
+++ b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
@@ -5,7 +5,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
 import Pandora.Pattern.Functor.Extractable (extract)
@@ -27,10 +27,13 @@
 instance Covariant t => Covariant (Prefixed t k) where
 	f <$> Prefixed x = Prefixed $ f <$$> x
 
+instance Covariant_ t (->) (->) => Covariant_ (Prefixed t k) (->) (->) where
+	f -<$>- Prefixed x = Prefixed $ f -<$$>- x
+
 instance Traversable t => Traversable (Prefixed t k) where
 	Prefixed x ->> f = Prefixed <$> x ->>> f
 
-instance (Monoid k, Pointable t) => Pointable (Prefixed t k) where
+instance (Monoid k, Pointable t (->)) => Pointable (Prefixed t k) (->) where
 	point = Prefixed . point . (:*:) zero
 
 instance Alternative t => Alternative (Prefixed t k) where
diff --git a/Pandora/Paradigm/Structure/Some/Binary.hs b/Pandora/Paradigm/Structure/Some/Binary.hs
--- a/Pandora/Paradigm/Structure/Some/Binary.hs
+++ b/Pandora/Paradigm/Structure/Some/Binary.hs
@@ -4,7 +4,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (:=>), type (:::))
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($$$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($$$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Avoidable (empty)
 import Pandora.Pattern.Functor.Bindable ((>>=))
@@ -168,6 +168,11 @@
 	_ <$> Top = Top
 	f <$> Leftward l = Leftward $ f l
 	f <$> Rightward r = Rightward $ f r
+
+instance Covariant_ Biforked (->) (->) where
+	_ -<$>- Top = Top
+	f -<$>- Leftward l = Leftward $ f l
+	f -<$>- Rightward r = Rightward $ f r
 
 type Bifurcation = Biforked <:.> Construction Biforked
 
diff --git a/Pandora/Paradigm/Structure/Some/List.hs b/Pandora/Paradigm/Structure/Some/List.hs
--- a/Pandora/Paradigm/Structure/Some/List.hs
+++ b/Pandora/Paradigm/Structure/Some/List.hs
@@ -210,13 +210,6 @@
 
 type instance Zipper (Construction Maybe) (Left ::: Right) = Tap (Construction Maybe <:.:> Construction Maybe := (:*:))
 
-instance {-# OVERLAPS #-} Applicative (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
-	Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs)
-
-instance {-# OVERLAPS #-} Traversable (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
-	Tap x (T_U (future :*: past)) ->> f = (\past' x' future' -> Tap x' $ twosome # future' # run past')
-		<$> Reverse past ->> f <*> f x <*> future ->> f
-
 instance Morphable (Rotate Left) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
 	type Morphing (Rotate Left) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) =
 		Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))
diff --git a/Pandora/Paradigm/Structure/Some/Rose.hs b/Pandora/Paradigm/Structure/Some/Rose.hs
--- a/Pandora/Paradigm/Structure/Some/Rose.hs
+++ b/Pandora/Paradigm/Structure/Some/Rose.hs
@@ -13,7 +13,7 @@
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Setoid (Setoid ((==), (!=)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?))
-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))
+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate), equate)
@@ -50,7 +50,7 @@
 	type Available Just Rose = Identity
 	type Substance Just Rose = List <:.> Construction List
 	substructure = P_Q_T $ \rose -> case run . extract . run # rose of
-		Nothing -> Store $ Identity empty :*: (lift empty !)
+		Nothing -> Store $ Identity empty :*: (lift empty !.)
 		Just (Construct x xs) -> Store $ Identity (TU xs) :*: lift . lift . Construct x . run . extract
 
 --------------------------------------- Non-empty rose tree ----------------------------------------
diff --git a/Pandora/Pattern/Functor/Adjoint.hs b/Pandora/Pattern/Functor/Adjoint.hs
--- a/Pandora/Pattern/Functor/Adjoint.hs
+++ b/Pandora/Pattern/Functor/Adjoint.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Adjoint where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)), Covariant_)
 
 type (-|) = Adjoint
 
@@ -15,7 +15,7 @@
 > * Right adjunction interchange: psi f ≡ epsilon . comap f
 -}
 
-class (Covariant t, Covariant u) => Adjoint t u where
+class Adjoint t u where
 	{-# MINIMAL (-|), (|-) #-}
 	-- | Left adjunction
 	(-|) :: a -> (t a -> b) -> u b
@@ -50,3 +50,7 @@
 	($$$$|-) :: (Covariant v, Covariant w, Covariant x, Covariant y) =>
 		v :. w :. x :. y :. t := a -> (a -> u b) -> v :. w :. x :. y := b
 	x $$$$|- f = (|- f) <$$$$> x
+
+class (Covariant_ t target source, Covariant_ u source target) => Adjoint_ t u source target where
+	(--|-) :: source (t a) b -> target a (u b)
+	(-|--) :: target a (u b) -> source (t a) b
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
@@ -2,6 +2,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)))
+import Pandora.Pattern.Functor.Bivariant (Bivariant)
 
 infixl 4 <*>, <*, *>
 infixl 3 <**>
@@ -45,3 +46,6 @@
 		-> t :. u :. v :. w := a
 		-> t :. u :. v :. w := b
 	f <****> x = (<***>) <$> f <*> x
+
+class Bivariant v => Applicative_ t v source target where
+	multiply :: source (v a b) r -> target (v (t a) (t b)) (t r)
diff --git a/Pandora/Pattern/Functor/Bindable.hs b/Pandora/Pattern/Functor/Bindable.hs
--- a/Pandora/Pattern/Functor/Bindable.hs
+++ b/Pandora/Pattern/Functor/Bindable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Bindable where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)
 
 infixl 1 >>=
 infixr 1 =<<, <=<, >=>
@@ -34,3 +34,6 @@
 
 	($>>=) :: Covariant u => u :. t := a -> (a -> t b) -> u :. t := b
 	x $>>= f = (>>= f) <$> x
+
+class Covariant_ t source source => Bindable_ t source where
+	join_ :: source (t (t a)) (t a)
diff --git a/Pandora/Pattern/Functor/Bivariant.hs b/Pandora/Pattern/Functor/Bivariant.hs
--- a/Pandora/Pattern/Functor/Bivariant.hs
+++ b/Pandora/Pattern/Functor/Bivariant.hs
@@ -1,6 +1,7 @@
 module Pandora.Pattern.Functor.Bivariant where
 
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip)
 
 infixl 4 <->
 
@@ -17,3 +18,7 @@
 	-- | Prefix version of '<->'
 	bimap :: (forall i . Covariant (v i)) => (a -> b) -> (c -> d) -> v a c -> v b d
 	bimap f g x = (f <-> g) x
+
+class (forall i . Covariant_ (v i) left target, forall i . Covariant_ (Flip v i) right target)
+	=> Bivariant_ v left right target where
+	(-<->-) :: left a b -> right c d -> target (v a c) (v b d) 
diff --git a/Pandora/Pattern/Functor/Comonad.hs b/Pandora/Pattern/Functor/Comonad.hs
--- a/Pandora/Pattern/Functor/Comonad.hs
+++ b/Pandora/Pattern/Functor/Comonad.hs
@@ -13,4 +13,4 @@
 > * Associativity: extend f . extend g ≡ extend (f . extend g)
 -}
 
-class (Extractable t, Extendable t) => Comonad t
+class (Extractable t source, Extendable t) => Comonad t source
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,8 +1,9 @@
 module Pandora.Pattern.Functor.Contravariant where
 
 import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Pattern.Category (Category)
 
-infixl 4 >$<, $<, >$
+infixl 4 >$<, ->$<-, $<, >$
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -50,3 +51,6 @@
 	(>&&&&<) :: (Contravariant u, Contravariant v, Contravariant w)
 		=> t :. u :. v :. w := a -> (a -> b) -> t :. u :. v :. w := b
 	x >&&&&< f = f >$$$$< x
+
+class (Category source, Category target) => Contravariant_ t source target where
+	(->$<-) :: source a b -> target (t b) (t a)
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
@@ -3,8 +3,8 @@
 import Pandora.Core.Functor (type (:.), type (:=), type (<:=))
 import Pandora.Pattern.Category (Category ((.)))
 
-infixl 4 <$>, <$, $>
-infixl 3 <$$>
+infixl 4 <$>, -<$>-, <$, $>
+infixl 3 <$$>, -<<$$>-, -<$$>>-
 infixl 2 <$$$>
 infixl 1 <$$$$>
 
@@ -94,3 +94,28 @@
 
 	($$$$>) :: (Covariant u, Covariant v, Covariant w) => t :. u :. v :. w := a -> b -> t :. u :. v :. w := b
 	s $$$$> x = (\_-> x) <$$$$> s
+
+class (Category source, Category target) => Covariant_ t source target where
+	(-<$>-) :: source a b -> target (t a) (t b)
+	
+(-<$$>-) :: forall t u category a b 
+	. (Covariant_ u category category, Covariant_ t category category) 
+	=> category a b -> category (t (u a)) (t (u b))
+(-<$$>-) s = ((-<$>-) ((-<$>-) @u @category @category s))
+
+(-<<$$>-) :: forall t u source target a b 
+	. (Covariant_ u source source, Covariant_ t source target) 
+	=> source a b -> target (t (u a)) (t (u b))
+(-<<$$>-) s = ((-<$>-) ((-<$>-) @u @source @source s))
+
+(-<$$>>-) :: forall t u source target a b 
+	. (Covariant_ u source target, Covariant_ t target target) 
+	=> source a b -> target (t (u a)) (t (u b))
+(-<$$>>-) s = ((-<$>-) ((-<$>-) @u @source @target s))
+
+-- TODO: Figure out how to work with hidden type variables
+-- to put intermediate category `between`
+(-<$$$>-) :: forall t u v source target a b
+	. (Covariant_ u source source, Covariant_ t source target, Covariant_ v target target) 
+	=> source a b -> target (v (t (u a))) (v (t (u b)))
+(-<$$$>-) s = ((-<$>-) ((-<$>-) @t @source @target ((-<$>-) @u @source @source s)))
diff --git a/Pandora/Pattern/Functor/Divariant.hs b/Pandora/Pattern/Functor/Divariant.hs
--- a/Pandora/Pattern/Functor/Divariant.hs
+++ b/Pandora/Pattern/Functor/Divariant.hs
@@ -1,6 +1,8 @@
 module Pandora.Pattern.Functor.Divariant where
 
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)
+import Pandora.Pattern.Functor.Contravariant (Contravariant_)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip)
 
 infixl 4 >->
 
@@ -16,3 +18,7 @@
 	-- | Prefix version of '>->'
 	dimap :: (a -> b) -> (c -> d) -> v b c -> v a d
 	dimap f g x = (f >-> g) x
+
+class (forall i . Contravariant_ (Flip v i) left target, forall i . Covariant_ (v i) right target) 
+	=> Divariant_ v left right target where
+	(->->-) :: left a b -> right c d -> target (v b c) (v a d)
diff --git a/Pandora/Pattern/Functor/Divisible.hs b/Pandora/Pattern/Functor/Divisible.hs
--- a/Pandora/Pattern/Functor/Divisible.hs
+++ b/Pandora/Pattern/Functor/Divisible.hs
@@ -1,11 +1,14 @@
 module Pandora.Pattern.Functor.Divisible where
 
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
+import Pandora.Pattern.Functor.Bivariant (Bivariant)
 import Pandora.Paradigm.Primary.Functor.Product (type (:*:))
 
 infixr 5 >*<
 
 class Contravariant t => Divisible t where
 	{-# MINIMAL (>*<) #-}
-
 	(>*<) :: t b -> t c -> t (b :*: c)
+
+class Bivariant v => Divisible_ t v source target where
+	divide :: Bivariant v => source r (v a b) -> target (v (t a) (t b)) (t r)
diff --git a/Pandora/Pattern/Functor/Extendable.hs b/Pandora/Pattern/Functor/Extendable.hs
--- a/Pandora/Pattern/Functor/Extendable.hs
+++ b/Pandora/Pattern/Functor/Extendable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Extendable where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)
 
 infixl 1 =>>
 infixr 1 <<=, =<=, =>=
@@ -39,3 +39,6 @@
 	x $=>> f = (=>> f) <$> x
 	(<<=$) :: Covariant u => u :. t := a -> (t a -> b) -> u :. t := b
 	x <<=$ f = (=>> f) <$> x
+
+class Covariant_ t source source => Extendable_ t source where
+	duplicate_ :: source (t a) (t (t a))
diff --git a/Pandora/Pattern/Functor/Extractable.hs b/Pandora/Pattern/Functor/Extractable.hs
--- a/Pandora/Pattern/Functor/Extractable.hs
+++ b/Pandora/Pattern/Functor/Extractable.hs
@@ -1,8 +1,7 @@
 module Pandora.Pattern.Functor.Extractable where
 
-import Pandora.Core.Functor (type (<:=))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 
-class Covariant t => Extractable t where
+class Covariant_ t source source => Extractable t source where
 	{-# MINIMAL extract #-}
-	extract :: a <:= t
+	extract :: source (t a) a
diff --git a/Pandora/Pattern/Functor/Monad.hs b/Pandora/Pattern/Functor/Monad.hs
--- a/Pandora/Pattern/Functor/Monad.hs
+++ b/Pandora/Pattern/Functor/Monad.hs
@@ -1,5 +1,6 @@
 module Pandora.Pattern.Functor.Monad where
 
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 
@@ -17,7 +18,7 @@
 infixl 1 >>=-, ->>=
 infixr 1 -=<<, =<<-
 
-class (Pointable t, Bindable t) => Monad t where
+class (Covariant_ t (->) (->), Pointable t (->), Bindable t) => Monad t where
 	(>>=-) :: t a -> t b -> t a
 	(>>=-) x y = x >>= \r -> y >>= \_ -> point r
 	(->>=) :: t a -> t b -> t b
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,11 +1,10 @@
 module Pandora.Pattern.Functor.Pointable where
 
-import Pandora.Core.Functor (type (:=>))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 
-class Covariant t => Pointable t where
+class Covariant_ t source source => Pointable t source where
 	{-# MINIMAL point #-}
-	point :: a :=> t
+	point :: source a (t a)
 
-	pass :: t ()
-	pass = point ()
+class Pointable_ t target where
+	point_ :: target a (t a)
diff --git a/Pandora/Pattern/Functor/Representable.hs b/Pandora/Pattern/Functor/Representable.hs
--- a/Pandora/Pattern/Functor/Representable.hs
+++ b/Pandora/Pattern/Functor/Representable.hs
@@ -13,7 +13,7 @@
 
 infixr 6 <#>
 
-class Pointable t => Representable t where
+class Pointable t (->) => Representable t where
 	{-# MINIMAL (<#>), tabulate #-}
 	type Representation t :: *
 	-- | Infix and flipped version of 'index'
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
@@ -21,22 +21,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 ->> (\x -> x)
 
 	-- | Infix versions of `traverse` with various nesting levels
-	(->>>) :: (Pointable u, Applicative u, Traversable v)
+	(->>>) :: (Pointable u (->), Applicative u, Traversable v)
 		=> v :. t := a -> (a -> u b) -> u :. v :. t := b
 	x ->>> f = x ->> (->> f)
-	(->>>>) :: (Pointable u, Applicative u, Traversable v, Traversable w)
+	(->>>>) :: (Pointable u (->), Applicative u, Traversable v, Traversable w)
 		=> w :. v :. t := a -> (a -> u b) -> u :. w :. v :. t := b
 	x ->>>> f = x ->> (->> (->> f))
-	(->>>>>) :: (Pointable u, Applicative u, Traversable v, Traversable w, Traversable j)
+	(->>>>>) :: (Pointable u (->), Applicative u, Traversable v, Traversable w, Traversable j)
 		=> j :. w :. v :. t := a -> (a -> u b) -> u :. j :. w :. v :. t := b
 	x ->>>>> f = x ->> (->> (->> (->> f)))
diff --git a/Pandora/Pattern/Transformer/Hoistable.hs b/Pandora/Pattern/Transformer/Hoistable.hs
--- a/Pandora/Pattern/Transformer/Hoistable.hs
+++ b/Pandora/Pattern/Transformer/Hoistable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Transformer.Hoistable (Hoistable (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 
 {- |
 > When providing a new instance, you should ensure it satisfies one law:
@@ -13,7 +13,7 @@
 
 class Hoistable t where
 	{-# MINIMAL (/|\) #-}
-	(/|\) :: Covariant u => u ~> v -> t u ~> t v
+	(/|\) :: (Covariant_ u (->) (->)) => u ~> v -> t u ~> t v
 
-	hoist :: Covariant u => u ~> v -> t u ~> t v
+	hoist :: (Covariant_ u (->) (->)) => u ~> v -> t u ~> t v
 	hoist = (/|\)
diff --git a/Pandora/Pattern/Transformer/Liftable.hs b/Pandora/Pattern/Transformer/Liftable.hs
--- a/Pandora/Pattern/Transformer/Liftable.hs
+++ b/Pandora/Pattern/Transformer/Liftable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Transformer.Liftable (Liftable (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 
 {- |
 > When providing a new instance, you should ensure it satisfies one law:
@@ -9,4 +9,4 @@
 -}
 
 class Liftable t where
-	lift :: Covariant u => u ~> t u
+	lift :: (Covariant_ u (->) (->)) => u ~> t u
diff --git a/Pandora/Pattern/Transformer/Lowerable.hs b/Pandora/Pattern/Transformer/Lowerable.hs
--- a/Pandora/Pattern/Transformer/Lowerable.hs
+++ b/Pandora/Pattern/Transformer/Lowerable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Transformer.Lowerable (Lowerable (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 
 {- |
 > When providing a new instance, you should ensure it satisfies one law:
@@ -9,4 +9,4 @@
 -}
 
 class Lowerable t where
-	lower :: Covariant u => t u ~> u
+	lower :: (Covariant_ u (->) (->)) => t u ~> u
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.4.2
+version:             0.4.3
 synopsis:            A box of patterns and paradigms
 description:         Humble attempt to define a library for problem solving based on math abstractions.
 homepage:            https://github.com/iokasimov/pandora