diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -488,3 +488,32 @@
 * Remove `Covariant` superclass of `Hoistable`
 
 # 0.4.4
+* Remove experimental `Pointable_` typeclass
+* Use experimental `Covariant_` as superclass of `Distributive`
+* Use experimental `Covariant_` as superclass of `Traversable`
+* Define experimental `Traversable_` typeclass
+* Define experimental `Distributibe_` typeclass
+* Define experimental `-<<-<<-` method of `Traversable_` typeclass
+* Remove `Adjoint` typeclass
+* Rename experimental `Adjoint_` to `Adjoint`
+* Remove `Bivariant` typeclass
+* Rename experimental `Bivariant_` to `Bivariant`
+* Remove `Distributive` typeclass
+* Rename experimental `Distributive_` to `Distributive`
+* Remove `Divariant` typeclass
+* Rename experimental `Divariant_` to `Divariant`
+* Rename `Product` type to `:*:`
+* Move `Paradigm.Primary.Functor.Function` module to `Paradigm.Primary.Algebraic.Exponential`
+* Move `Paradigm.Primary.Functor.Product` module to `Paradigm.Primary.Algebraic.Product`
+* Add `Covariant_`, `Pointable` and `Applicative_` constraints to `Traversable_` typeclass
+* Remove `join_` method from `Bindable_` typeclass
+* Remove `Traversable` typeclass
+* Rename experimental `Traversable_` to `Traversable`
+* Remove `Bindable` typeclass
+* Rename experimental `Bindable_` to `Bindable`
+* Use experimental `Extendable_` as superclass for `Comonad`
+* Remove `Extendable` typeclass
+* Rename experimental `Extendable_` to `Extendable`
+* Rename experimental `Applicative_` to `Semimonoidal`
+
+# 0.4.5
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
@@ -17,60 +17,53 @@
 	{-# MINIMAL adapt #-}
 	adapt :: t ~> 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 Lifting t u = (Monadic t, Liftable (Schematic Monad t), Covariant_ u (->) (->))
+type Lowering t u = (Comonadic t, Lowerable (Schematic Comonad t), 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
+instance Adaptable t t where
 	adapt = identity
 
-instance (Covariant (t :> u), Lifting t u) => Adaptable u (t :> u) where
+instance Lifting t u => Adaptable u (t :> u) where
 	adapt = lift
 
-instance (Covariant (t :> u), Wrappable t u) => Adaptable t (t :> u) where
+instance Wrappable t u => Adaptable t (t :> u) where
 	adapt = wrap
 
-instance (Covariant (t :> u), Lowering t u) => Adaptable (t :< u) u where
+instance Lowering t u => Adaptable (t :< u) u where
 	adapt = lower
 
-instance (Covariant (t :< u), Bringable t u) => Adaptable (t :< u) t where
+instance Bringable t u => Adaptable (t :< u) t where
 	adapt = bring
 
 instance
-	( Covariant (t :> u :> v)
-	, Liftable (Schematic Monad t)
-	, Covariant (Schematic Monad u v)
+	( Liftable (Schematic Monad t)
 	, Covariant_ (Schematic Monad u v) (->) (->)
 	, Wrappable u v
 	) => Adaptable u (t :> u :> v) where
 	adapt = lift . wrap
 
 instance
-	( Covariant (t :> u :> v)
-	, Lifting t (Schematic Monad u v)
+	( Lifting t (Schematic Monad u v)
 	, Lifting u v
 	) => Adaptable v (t :> u :> v) where
 	adapt = lift . lift
 
 instance
-	( Covariant (t :< u :< v)
-	, Lowering t (Schematic Comonad u v)
+	( Lowering t (Schematic Comonad u v)
 	, Bringable u v
 	) => Adaptable (t :< u :< v) u where
 	adapt = bring . lower
 
 instance
-	( Covariant (t :< u :< v)
-	, Lowering t (Schematic Comonad u v)
+	( Lowering t (Schematic Comonad u v)
 	, Lowering u v
 	) => Adaptable (t :< u :< v) v where
 	adapt = lower . lower
 
 instance
-	( Covariant_ t (->) (->) 
- 	, Covariant (t :> u :> v :> w)
-	, Liftable (Schematic Monad t)
+	( Liftable (Schematic Monad t)
 	, Lifting t (Schematic Monad u (v :> w))
 	, Lifting u (Schematic Monad v w)
 	, Wrappable v w
@@ -78,8 +71,7 @@
 	adapt = lift . lift . wrap
 
 instance
-	( Covariant (t :> u :> v :> w)
-	, Lifting t (Schematic Monad u v)
+	( Lifting t (Schematic Monad u v)
 	, Lifting t (Schematic Monad u (v :> w))
 	, Lifting u (Schematic Monad v w)
 	, Lifting v w
@@ -87,16 +79,14 @@
 	adapt = lift . lift . lift
 
 instance
-	( Covariant (t :< u :< v :< w)
-	, Lowering t (Schematic Comonad u (v :< w))
+	( Lowering t (Schematic Comonad u (v :< w))
 	, Lowering u (Schematic Comonad v w)
 	, Bringable v w
 	) => Adaptable (t :< u :< v :< w) v where
 	adapt = bring . lower . lower
 
 instance
-	( Covariant (t :< u :< v :< w)
-	, Lowering t (Schematic Comonad u v)
+	( Lowering t (Schematic Comonad u v)
 	, Lowering t (Schematic Comonad u (v :< w))
 	, Lowering u (Schematic Comonad v w)
 	, Lowering v w
@@ -104,8 +94,7 @@
 	adapt = lower . lower . lower
 
 instance
-	( Covariant (t :> u :> v :> w :> x)
-	, Lifting t (Schematic Monad u (v :> w :> x))
+	( Lifting t (Schematic Monad u (v :> w :> x))
 	, Lifting u (Schematic Monad v (w :> x))
 	, Lifting v (Schematic Monad w x)
 	, Lifting w x
@@ -113,8 +102,7 @@
 	adapt = lift . lift . lift . lift
 
 instance
-	( Covariant (t :> u :> v :> w :> x)
-	, Lifting t (Schematic Monad u (v :> w :> x))
+	( Lifting t (Schematic Monad u (v :> w :> x))
 	, Lifting u (Schematic Monad v (w :> x))
 	, Lifting v (Schematic Monad w x)
 	, Wrappable w x
@@ -122,8 +110,7 @@
 	adapt = lift . lift . lift . wrap
 
 instance
-	( Covariant (t :< u :< v :< w :< x)
-	, Lowering t (Schematic Comonad u (v :< w :< x))
+	( Lowering t (Schematic Comonad u (v :< w :< x))
 	, Lowering u (Schematic Comonad v (w :< x))
 	, Lowering v (Schematic Comonad w x)
 	, Lowering w x
@@ -131,8 +118,7 @@
 	adapt = lower . lower . lower . lower
 
 instance
-	( Covariant (t :< u :< v :< w :< x)
-	, Lowering t (Schematic Comonad u (v :< w :< x))
+	( Lowering t (Schematic Comonad u (v :< w :< x))
 	, Lowering u (Schematic Comonad v (w :< x))
 	, Lowering v (Schematic Comonad w x)
 	, Bringable w x
@@ -140,8 +126,7 @@
 	adapt = bring . lower . lower . lower
 
 instance
-	( Covariant (t :> u :> v :> w :> x :> y)
-	, Lifting t (Schematic Monad u (v :> w :> x :> y))
+	( Lifting t (Schematic Monad u (v :> w :> x :> y))
 	, Lifting u (Schematic Monad v (w :> x :> y))
 	, Lifting v (Schematic Monad w (x :> y))
 	, Lifting w (Schematic Monad x y)
@@ -150,8 +135,7 @@
 	adapt = lift . lift . lift . lift . lift
 
 instance
-	( Covariant (t :> u :> v :> w :> x :> y)
-	, Lifting t (Schematic Monad u (v :> w :> x :> y))
+	( Lifting t (Schematic Monad u (v :> w :> x :> y))
 	, Lifting u (Schematic Monad v (w :> x :> y))
 	, Lifting v (Schematic Monad w (x :> y))
 	, Lifting w (Schematic Monad x y)
@@ -160,8 +144,7 @@
 	adapt = lift . lift . lift . lift . wrap
 
 instance
-	( Covariant (t :< u :< v :< w :< x :< y)
-	, Lowering t (Schematic Comonad u (v :< w :< x :< y))
+	( Lowering t (Schematic Comonad u (v :< w :< x :< y))
 	, Lowering u (Schematic Comonad v (w :< x :< y))
 	, Lowering v (Schematic Comonad w (x :< y))
 	, Lowering w (Schematic Comonad x y)
@@ -170,8 +153,7 @@
 	adapt = lower . lower . lower . lower . lower
 
 instance
-	( Covariant (t :< u :< v :< w :< x :< y)
-	, Lowering t (Schematic Comonad u (v :< w :< x :< y))
+	( Lowering t (Schematic Comonad u (v :< w :< x :< y))
 	, Lowering u (Schematic Comonad v (w :< x :< y))
 	, Lowering v (Schematic Comonad w (x :< y))
 	, Lowering w (Schematic Comonad x y)
@@ -180,8 +162,7 @@
 	adapt = bring . lower . lower . lower . lower
 
 instance
-	( Covariant (t :> u :> v :> w :> x :> y :> z)
-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z))
+	( Lifting t (Schematic Monad u (v :> w :> x :> y :> z))
 	, Lifting u (Schematic Monad v (w :> x :> y :> z))
 	, Lifting v (Schematic Monad w (x :> y :> z))
 	, Lifting w (Schematic Monad x (y :> z))
@@ -191,8 +172,7 @@
 	adapt = lift . lift . lift . lift . lift . lift
 
 instance
-	( Covariant (t :> u :> v :> w :> x :> y :> z)
-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z))
+	( Lifting t (Schematic Monad u (v :> w :> x :> y :> z))
 	, Lifting u (Schematic Monad v (w :> x :> y :> z))
 	, Lifting v (Schematic Monad w (x :> y :> z))
 	, Lifting w (Schematic Monad x (y :> z))
@@ -202,8 +182,7 @@
 	adapt = lift . lift . lift . lift . lift . wrap
 
 instance
-	( Covariant (t :< u :< v :< w :< x :< y :< z)
-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z))
+	( Lowering t (Schematic Comonad u (v :< w :< x :< y :< z))
 	, Lowering u (Schematic Comonad v (w :< x :< y :< z))
 	, Lowering v (Schematic Comonad w (x :< y :< z))
 	, Lowering w (Schematic Comonad x (y :< z))
@@ -213,8 +192,7 @@
 	adapt = lower . lower . lower . lower . lower . lower
 
 instance
-	( Covariant (t :< u :< v :< w :< x :< y :< z)
-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z))
+	( Lowering t (Schematic Comonad u (v :< w :< x :< y :< z))
 	, Lowering u (Schematic Comonad v (w :< x :< y :< z))
 	, Lowering v (Schematic Comonad w (x :< y :< z))
 	, Lowering w (Schematic Comonad x (y :< z))
@@ -224,8 +202,7 @@
 	adapt = bring . lower . lower . lower . lower . lower
 
 instance
-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)
-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f))
+	( Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f))
 	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f))
 	, Lifting v (Schematic Monad w (x :> y :> z :> f))
 	, Lifting w (Schematic Monad x (y :> z :> f))
@@ -236,8 +213,7 @@
 	adapt = lift . lift . lift . lift . lift . lift . lift
 
 instance
-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)
-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f))
+	( Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f))
 	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f))
 	, Lifting v (Schematic Monad w (x :> y :> z :> f))
 	, Lifting w (Schematic Monad x (y :> z :> f))
@@ -248,8 +224,7 @@
 	adapt = lift . lift . lift . lift . lift . lift . wrap
 
 instance
-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)
-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
+	( Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
 	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f))
 	, Lowering v (Schematic Comonad w (x :< y :< z :< f))
 	, Lowering w (Schematic Comonad x (y :< z :< f))
@@ -260,8 +235,7 @@
 	adapt = lower . lower . lower . lower . lower . lower . lower
 
 instance
-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)
-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
+	( Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
 	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f))
 	, Lowering v (Schematic Comonad w (x :< y :< z :< f))
 	, Lowering w (Schematic Comonad x (y :< z :< f))
@@ -272,8 +246,7 @@
 	adapt = bring . lower . lower . lower . lower . lower . lower
 
 instance
-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)
-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
+	( Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
 	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f :> h))
 	, Lifting v (Schematic Monad w (x :> y :> z :> f :> h))
 	, Lifting w (Schematic Monad x (y :> z :> f :> h))
@@ -285,8 +258,7 @@
 	adapt = lift . lift . lift . lift . lift . lift . lift . lift
 
 instance
-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)
-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
+	( Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
 	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f :> h))
 	, Lifting v (Schematic Monad w (x :> y :> z :> f :> h))
 	, Lifting w (Schematic Monad x (y :> z :> f :> h))
@@ -298,8 +270,7 @@
 	adapt = lift . lift . lift . lift . lift . lift . lift . wrap
 
 instance
-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)
-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
+	( Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
 	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f :< h))
 	, Lowering v (Schematic Comonad w (x :< y :< z :< f :< h))
 	, Lowering w (Schematic Comonad x (y :< z :< f :< h))
@@ -311,8 +282,7 @@
 	adapt = lower . lower . lower . lower . lower . lower . lower . lower
 
 instance
-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)
-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
+	( Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
 	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f :< h))
 	, Lowering v (Schematic Comonad w (x :< y :< z :< f :< h))
 	, Lowering w (Schematic Comonad x (y :< z :< f :< h))
@@ -327,9 +297,7 @@
 	adapt = hoist adapt
 
 instance
-	( Covariant u
-	, Covariant v, Covariant_ v (->) (->)
-	, Covariant (Schematic Monad u v)
+	( Covariant_ v (->) (->)
 	, Covariant_ (Schematic Monad u v) (->) (->)
 	, Hoistable ((:>) (t :> u))
 	, Hoistable (Schematic Monad t)
@@ -339,14 +307,11 @@
 	adapt = hoist (hoist adapt)
 
 instance
-	( Covariant u, Covariant_ u (->) (->)
-	, Covariant v, Covariant_ v (->) (->)
-	, Covariant w, Covariant_ w (->) (->)
-	, Covariant (Schematic Monad u v)
+	( Covariant_ u (->) (->)
+	, Covariant_ v (->) (->)
+	, Covariant_ w (->) (->)
 	, 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)
@@ -357,14 +322,9 @@
 	adapt = hoist (hoist (hoist adapt))
 
 instance
-	( 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_ 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)
@@ -376,19 +336,10 @@
 	adapt = hoist (hoist (hoist (hoist adapt)))
 
 instance
-	( 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_ 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)
@@ -401,25 +352,11 @@
 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))
 
 instance
-	( 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 z, Covariant_ 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)
@@ -434,9 +371,7 @@
 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))
 
 instance
-	( Covariant u, Covariant v, Covariant w, Covariant x
-	, Covariant y, Covariant z
-	, Covariant f, Covariant_ f (->) (->)
+	( Covariant f, Covariant_ f (->) (->)
 	, Covariant (Schematic Monad u v)
 	, Covariant (Schematic Monad u (v :> w))
 	, Covariant (Schematic Monad u (v :> (w :> x)))
@@ -476,27 +411,9 @@
 	adapt = hoist (hoist (hoist (hoist (hoist (hoist adapt)))))
 
 instance
-	( Covariant u, Covariant v, Covariant w, Covariant x
-	, 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)))
-	, 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 :> h)))))))
+	( Covariant h, Covariant_ 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))
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
@@ -4,7 +4,7 @@
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)), Covariant_)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 infixr 2 ||=, =||
 
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
@@ -9,10 +9,10 @@
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
@@ -43,19 +43,19 @@
 instance Alternative (Schematic Comonad t u) => Alternative (t :< u) where
 	TC x <+> TC y = TC $ x <+> y
 
-instance Traversable (Schematic Comonad t u) => Traversable (t :< u) where
-	TC x ->> f = TC <$> x ->> f
+instance Traversable (Schematic Comonad t u) (->) (->) => Traversable (t :< u) (->) (->) where
+	f <<- TC x = TC -<$>- f <<- x
 
-instance Distributive (Schematic Comonad t u) => Distributive (t :< u) where
-	x >>- f = TC $ x >>- tc . f
+instance Distributive (Schematic Comonad t u) (->) (->) => Distributive (t :< u) (->) (->) where
+	f -<< x = TC $ tc . f -<< x
 
-instance Bindable (Schematic Comonad t u) => Bindable (t :< u) where
-	TC x >>= f = TC $ x >>= tc . f
+instance Bindable (Schematic Comonad t u) (->) => Bindable (t :< u) (->) where
+	f =<< TC x = TC $ tc . f =<< x
 
-instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where
-	TC x =>> f = TC $ x =>> f . TC
+instance Extendable (Schematic Comonad t u) (->) => Extendable (t :< u) (->) where
+	f <<= TC x = TC $ f . TC <<= x
 
-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
@@ -10,10 +10,10 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
@@ -47,19 +47,19 @@
 instance Avoidable (Schematic Monad t u) => Avoidable (t :> u) where
 	empty = TM empty
 
-instance Traversable (Schematic Monad t u) => Traversable (t :> u) where
-	TM x ->> f = TM <$> x ->> f
+instance Traversable (Schematic Monad t u) (->) (->) => Traversable (t :> u) (->) (->) where
+	f <<- TM x = TM -<$>- f <<- x
 
-instance Distributive (Schematic Monad t u) => Distributive (t :> u) where
-	x >>- f = TM $ x >>- tm . f
+instance Distributive (Schematic Monad t u) (->) (->) => Distributive (t :> u) (->) (->) where
+	f -<< x = TM $ tm . f -<< x
 
-instance Bindable (Schematic Monad t u) => Bindable (t :> u) where
-	TM x >>= f = TM $ x >>= tm . f
+instance Bindable (Schematic Monad t u) (->) => Bindable (t :> u) (->) where
+	f =<< TM x = TM $ tm . f =<< x
 
-instance Extendable (Schematic Monad t u) => Extendable (t :> u) where
-	TM x =>> f = TM $ x =>> f . TM
+instance Extendable (Schematic Monad t u) (->) => Extendable (t :> u) (->) where
+	f <<= TM x = TM $ f . TM <<= x
 
-instance (Covariant_ (Schematic Monad t u) (->) (->), 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
@@ -2,8 +2,8 @@
 
 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.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (!..))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
 
@@ -44,8 +44,8 @@
 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
+impact :: Bindable t (->) => t a -> Pipeline i o t a a
+impact action = Continuation $ \next -> Pipe $ \i o -> (\x -> pipe (next x) i o) =<< action
 
 -- | Compose two pipelines into one
 (=*=) :: forall i e o t . Pointable t (->) => Pipeline i e t () () -> Pipeline e o t () () -> Pipeline i o t () ()
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -17,30 +17,30 @@
 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.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)
 import Pandora.Paradigm.Structure.Ability.Accessible (Accessible (access))
 
-instance Adjoint (Store s) (State s) where
-	(-|) :: a -> (Store s a -> b) -> State s b
-	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
+instance Adjoint (Store s) (State s) (->) (->) where
+	(-|) :: (Store s a -> b) -> a -> State s b
+	f -| x = State $ \s -> (:*:) s . f . Store $ s :*: (x !.)
+	(|-) :: (a -> State s b) -> Store s a -> b
+	g |- Store (s :*: f) = extract . (run % s) . g $ f s
 
-instance Adjoint (Accumulator e) (Imprint e) where
-	x -| f = Imprint $ x -| f . Accumulator
-	x |- g = run x |- run . g
+instance Adjoint (Accumulator e) (Imprint e) (->) (->) where
+	f -| x = Imprint $ f . Accumulator -| x
+	g |- x = run . g |- run x
 
-instance Adjoint (Equipment e) (Environment e) where
-	x -| f = Environment $ x -| f . Equipment
-	x |- g = run x |- run . g
+instance Adjoint (Equipment e) (Environment e) (->) (->) where
+	f -| x = Environment $ f . Equipment -| x
+	g |- x = run . g |- run x
 
 zoom :: Stateful bg t => Lens Identity bg ls -> State ls ~> t
-zoom lens less = let restruct to = (to . Identity <-> identity) . run less . extract @Identity
-	in adapt . State $ (|- restruct) . run . run lens
+zoom lens less = let restruct to = (to . Identity <-> identity @(->)) . run less . extract @Identity
+	in adapt . State $ (restruct |-) . run . run lens
 
 (=<>) :: Stateful src t => Lens mode src tgt -> mode tgt -> t src
 lens =<> new = modify $ set lens new
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
@@ -6,11 +6,11 @@
 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 ((>>=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 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))
@@ -31,8 +31,8 @@
 instance Monoid e => Pointable (Accumulator e) (->) where
 	point = Accumulator . (zero :*:)
 
-instance Semigroup e => Bindable (Accumulator e) where
-	Accumulator (e :*: x) >>= f = let e' :*: b = run $ f x in
+instance Semigroup e => Bindable (Accumulator e) (->) where
+	f =<< Accumulator (e :*: x) = let e' :*: b = run $ f x in
 		Accumulator $ e + e':*: b
 
 type instance Schematic Monad (Accumulator e) = (<.:>) ((:*:) e)
@@ -54,8 +54,8 @@
 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
-	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> run (f v)
+instance {-# OVERLAPS #-} (Semigroup e, Pointable u (->), Bindable u (->)) => Bindable ((:*:) e <.:> u) (->) where
+	f =<< UT x = UT $ (\(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) -<$>- run (f v)) =<< x
 
 gather :: Accumulated e t => e -> t ()
 gather x = adapt . Accumulator $ x :*: ()
diff --git a/Pandora/Paradigm/Inventory/Environment.hs b/Pandora/Paradigm/Inventory/Environment.hs
--- a/Pandora/Paradigm/Inventory/Environment.hs
+++ b/Pandora/Paradigm/Inventory/Environment.hs
@@ -4,13 +4,15 @@
 
 import Pandora.Pattern.Category (identity, (.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+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.Algebraic.Exponential ((!.), (%))
+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))
@@ -24,21 +26,24 @@
 instance Covariant_ (Environment e) (->) (->) where
 	f -<$>- Environment x = Environment $ f . x
 
+instance Contravariant_ (Flip Environment a) (->) (->) where
+	f ->$<- Flip (Environment g) = Flip . Environment $ g . f
+
 instance Pointable (Environment e) (->) where
 	point x = Environment (x !.)
 
 instance Applicative (Environment e) where
 	f <*> x = Environment $ run f <*> run x
 
-instance Distributive (Environment e) where
-	g >>- f = Environment $ g >>- (run <$> f)
+instance Distributive (Environment e) (->) (->) where
+	f -<< g = Environment $ (run -<$>- f) -<< g
 
-instance Bindable (Environment e) where
-	Environment x >>= f = Environment $ \e -> (run % e) . f . x $ e
+instance Bindable (Environment e) (->) where
+	f =<< Environment x = Environment $ \e -> (run % e) . f . x $ e
 
 instance Monad (Environment e) where
 
-instance Divariant Environment where
+instance Divariant Environment (->) (->) (->) where
 	(>->) ab cd bc = Environment $ ab >-> cd $ run bc
 
 instance Interpreted (Environment e) where
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
@@ -5,10 +5,11 @@
 import Pandora.Pattern.Category ((.), ($))
 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 ((=>>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
+import Pandora.Paradigm.Primary.Algebraic ()
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
@@ -25,11 +26,11 @@
 instance Extractable (Equipment e) (->) where
 	extract = extract . run
 
-instance Traversable (Equipment e) where
-	Equipment x ->> f = Equipment <$> x ->> f
+instance Traversable (Equipment e) (->) (->) where
+	f <<- Equipment x = Equipment -<$>- f <<- x
 
-instance Extendable (Equipment e) where
-	Equipment (e :*: x) =>> f = Equipment . (:*:) e . f . Equipment $ e :*: x
+instance Extendable (Equipment e) (->) where
+	f <<= Equipment (e :*: x) = Equipment . (:*:) e . f . Equipment $ e :*: x
 
 instance Interpreted (Equipment e) where
 	type Primary (Equipment e) a = e :*: a
@@ -43,8 +44,8 @@
 
 type Equipped e t = Adaptable t (Equipment e)
 
-instance {-# OVERLAPS #-} Extendable u => Extendable ((:*:) e <:.> u) where
-	TU (e :*: x) =>> f = TU . (:*:) e $ x =>> f . TU . (:*:) e
+instance {-# OVERLAPS #-} Extendable u (->) => Extendable ((:*:) e <:.> u) (->) where
+	f <<= TU (e :*: x) = TU . (:*:) e $ f . TU . (:*:) e <<= x
 
 instance Comonad (Equipment e) (->) where
 
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
@@ -4,14 +4,16 @@
 
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+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.Comonadic (Comonadic (bring), (:<) (TC))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable)
@@ -23,19 +25,22 @@
 	f <$> Imprint x = Imprint $ f . x
 
 instance Covariant_ (Imprint e) (->) (->) where
-	f -<$>- Imprint x = Imprint $ f . x
+	f -<$>- Imprint g = Imprint $ f . g
 
-instance Distributive (Imprint e) where
-	g >>- f = Imprint $ g >>- (run <$> f)
+instance Contravariant_ (Flip Imprint a) (->) (->) where
+	f ->$<- Flip (Imprint g) = Flip . Imprint $ g . f
 
+instance Distributive (Imprint e) (->) (->) where
+	f -<< g = Imprint $ (run -<$>- f) -<< g
+
 instance Monoid e => Extractable (Imprint e) (->) where
 	extract (Imprint x) = x zero
 
-instance Divariant Imprint where
+instance Divariant Imprint (->) (->) (->) where
 	(>->) ab cd bc = ab >-> cd ||= bc
 
-instance Semigroup e => Extendable (Imprint e) where
-	Imprint x =>> f = Imprint $ \e -> f $ Imprint $ x . (e +)
+instance Semigroup e => Extendable (Imprint e) (->) where
+	f <<= Imprint x = Imprint $ \e -> f $ Imprint $ x . (e +)
 
 instance Interpreted (Imprint e) where
 	type Primary (Imprint e) a = (->) e a
@@ -47,7 +52,7 @@
 instance Monoid e => Comonadic (Imprint e) where
 	bring (TC (UT x)) = Imprint . extract $ x
 
-instance {-# OVERLAPS #-} (Semigroup e, Extendable u) => Extendable ((->) e <.:> u) where
-	UT x =>> f = UT $ x =>> (\x' e -> f . UT . (<$>) (. (e +)) $ x')
+instance {-# OVERLAPS #-} (Semigroup e, Extendable u (->)) => Extendable ((->) e <.:> u) (->) where
+	f <<= UT x = UT $ (\x' e -> f . UT . (-<$>-) (. (e +)) $ x') <<= x
 
 type Traceable e t = Adaptable t (Imprint e)
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
@@ -11,10 +11,10 @@
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
-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))
 import Pandora.Paradigm.Primary.Object.Boolean ((?))
 import Pandora.Paradigm.Inventory.Store (Store (Store), position, look, retrofit)
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
@@ -7,11 +7,11 @@
 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 ((<*>), (*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Adjoint ((-|), (|-), ($|-))
+import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
 import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Paradigm.Primary.Transformer (Flip)
@@ -19,7 +19,7 @@
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))
-import Pandora.Paradigm.Primary.Functor (Product ((:*:)), type (:*:), delta)
+import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (%), (!.), (-<*>-), delta)
 
 -- | Effectful computation with a variable
 newtype State s a = State ((->) s :. (:*:) s := a)
@@ -31,18 +31,24 @@
 	f -<$>- x = State $ (-<$>-) f . run x
 
 instance Applicative (State s) where
-	f <*> x = State $ (|- (<$>)) . (run x <-> identity) . run f
+	f <*> x = State $ ((<$>) |-) . (run x <-> identity @(->)) . run f
 
+instance Semimonoidal (State s) (:*:) (->) (->) where
+	multiply f (State g :*: State h) = State $ \s -> 
+		let old :*: x = g s in
+		let new :*: y = h old in
+		new :*: f (x :*: y)
+
 instance Pointable (State s) (->) where
-	point = State . (-| identity)
+	point = State . (identity @(->) -|)
 
-instance Bindable (State s) where
-	x >>= f = State $ run x $|- run . f
+instance Bindable (State s) (->) where
+	f =<< x = State $ (run . f |-) -<$>- run x
 
 instance Monad (State s) where
 
 instance Invariant (Flip State r) where
-	f <$< g = ((g >-> (f <-> identity) ||=) ||=)
+	f <$< g = ((g >-> ((<->) @_ @_ @(->) @(->) f identity) ||=) ||=)
 
 instance Interpreted (State s) where
 	type Primary (State s) a = (->) s :. (:*:) s := a
@@ -68,10 +74,10 @@
 replace :: Stateful s t => s -> t s
 replace s = adapt . State $ \_ -> s :*: s
 
-reconcile :: (Bindable t, Stateful s t, Adaptable u t) => (s -> u s) -> t s
-reconcile f = current >>= adapt . f >>= replace
+reconcile :: (Bindable t (->), Stateful s t, Adaptable u t) => (s -> u s) -> t s
+reconcile f = replace =<< adapt . f =<< current
 
-type Memorable s t = (Pointable t (->), Applicative t, Stateful s t)
+type Memorable s t = (Pointable t (->), Semimonoidal t (:*:) (->) (->), Stateful s t)
 
-fold :: (Traversable t, Memorable s u) => (a -> s -> s) -> t a -> u s
-fold op struct = struct ->> modify . op *> current
+fold :: (Traversable t (->) (->), Memorable s u) => (a -> s -> s) -> t a -> u s
+fold op struct = ((!.) %) -<$>- (modify . op <<- struct) -<*>- 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
@@ -7,16 +7,15 @@
 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 ((=>>)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
-import Pandora.Paradigm.Primary.Functor.Function ((%))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
-import Pandora.Paradigm.Primary.Functor ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
+import Pandora.Paradigm.Primary.Algebraic ()
 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))
@@ -32,15 +31,15 @@
 	f -<$>- Store x = Store $ f -<$$>- x
 
 instance Extractable (Store s) (->) where
-	extract = (|- ($)) . run
+	extract = (($) |-) . run
 
-instance Extendable (Store s) where
-	Store x =>> f = Store $ f <$$> Store .#.. (-| identity) <$> x
+instance Extendable (Store s) (->) where
+	f <<= Store x = Store $ f -<$$>- (Store .#.. (identity @(->) -|) -<$>- x)
 
 instance Comonad (Store s) (->) where
 
 instance Invariant (Flip Store r) where
-	f <$< g = \(Flip x) -> Flip $ f <-> (g >-> identity) ||= x
+	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
@@ -6,6 +6,7 @@
 import Pandora.Paradigm.Primary.Transformer as Exports
 import Pandora.Paradigm.Primary.Functor as Exports
 import Pandora.Paradigm.Primary.Object as Exports
+import Pandora.Paradigm.Primary.Algebraic as Exports
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Category (Category ((.), ($), (#), identity))
@@ -35,9 +36,9 @@
 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 Adjoint (Flip (:*:) s) ((->) s) (->) (->) where
+	f -| x = \s -> f $ Flip $ x :*: s
+	f |- Flip (x :*: s) = f x s
 
 instance Morphable (Into Maybe) (Conclusion e) where
 	type Morphing (Into Maybe) (Conclusion e) = Maybe
diff --git a/Pandora/Paradigm/Primary/Algebraic.hs b/Pandora/Paradigm/Primary/Algebraic.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Algebraic.hs
@@ -0,0 +1,30 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Primary.Algebraic (module Exports, (-<*>-)) where
+
+import Pandora.Paradigm.Primary.Algebraic.Exponential as Exports
+import Pandora.Paradigm.Primary.Algebraic.Product as Exports
+
+import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Functor.Covariant (Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+
+infixl 4 -<*>-
+
+instance Semimonoidal ((->) e) (:*:) (->) (->) where
+	multiply f (g :*: h) = \x -> f $ g x :*: h x
+
+instance Traversable ((:*:) s) (->) (->) where
+	f <<- x = (attached x :*:) -<$>- f (extract x)
+
+instance Adjoint ((:*:) 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
+
+(-<*>-) :: forall a b t . (Semimonoidal t (:*:) (->) (->)) => t (a -> b) -> t a -> t b
+(-<*>-) = (%) ((-|) @((:*:) (t (a -> b))) (multiply @t @(:*:) @(->) @(->) ((&) |-)))
diff --git a/Pandora/Paradigm/Primary/Algebraic/Exponential.hs b/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
@@ -0,0 +1,85 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Primary.Algebraic.Exponential where
+
+import Pandora.Pattern.Category (Category ((.), ($), (#), identity))
+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.Representable (Representable (Representation, (<#>), tabulate))
+import Pandora.Pattern.Functor.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 9 %
+infixl 1 &
+
+instance Category (->) where
+	identity x = x
+	f . g = \x -> f (g x)
+
+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
+	f -<< g = \e -> (f % e) -<$>- g
+
+instance Pointable ((->) e) (->) where
+	point = (!.)
+
+instance Bindable ((->) e) (->) where
+	f =<< g = \x -> f # g x # x
+
+instance Representable ((->) e) where
+	type Representation ((->) e) = e
+	(<#>) = (identity %)
+	tabulate = identity
+
+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
+
+(-.#..-) :: (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 -> 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
+(%) f x y = f y x
+
+{-# INLINE (&) #-}
+(&) :: a -> (a -> b) -> b
+x & f = f x
+
+fix :: (a -> a) -> a
+fix f = let x = f x in x
diff --git a/Pandora/Paradigm/Primary/Algebraic/Product.hs b/Pandora/Paradigm/Primary/Algebraic/Product.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Algebraic/Product.hs
@@ -0,0 +1,85 @@
+module Pandora.Paradigm.Primary.Algebraic.Product where
+
+import Pandora.Core.Functor (type (:=))
+import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
+import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
+import Pandora.Pattern.Object.Lattice (Lattice)
+import Pandora.Pattern.Object.Group (Group (invert))
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
+
+infixr 0 :*:
+
+data (:*:) s a = s :*: a
+
+instance Covariant ((:*:) s) where
+	f <$> x = attached x :*: f # extract x
+
+instance Covariant_ ((:*:) s) (->) (->) where
+	f -<$>- x = attached x :*: f # extract x
+
+instance Covariant_ (Flip (:*:) a) (->) (->) where
+	f -<$>- (Flip (x :*: y)) = Flip $ f x :*: y
+
+instance Extractable ((:*:) a) (->) where
+	extract ~(_ :*: y) = y
+
+instance Extendable ((:*:) s) (->) where
+	f <<= x = attached x :*: f (attached x :*: extract x)
+
+instance Comonad ((:*:) s) (->) where
+
+instance Bivariant (:*:) (->) (->) (->) 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)
+
+instance (Semigroup s, Semigroup a) => Semigroup (s :*: a) where
+	x + y = attached x + attached y :*: extract x + extract y
+
+instance (Monoid s, Monoid a) => Monoid (s :*: a) where
+	zero = zero :*: zero
+
+instance (Ringoid s, Ringoid a) => Ringoid (s :*: a) where
+	x * y = attached x * attached y :*: extract x * extract y
+
+instance (Quasiring s, Quasiring a) => Quasiring (s :*: a) where
+	one = one :*: one
+
+instance (Infimum s, Infimum a) => Infimum (s :*: a) where
+	x /\ y = attached x /\ attached y :*: extract x /\ extract y
+
+instance (Supremum s, Supremum a) => Supremum (s :*: a) where
+	x \/ y = attached x \/ attached y :*: extract x \/ extract y
+
+instance (Lattice s, Lattice a) => Lattice (s :*: a) where
+
+instance (Group s, Group a) => Group (s :*: a) where
+	invert x = invert # attached x :*: invert # extract x
+
+instance {-# OVERLAPS #-} Applicative t => Applicative (t <:.:> t := (:*:)) where
+	T_U (lfs :*: rfs) <*> T_U (ls :*: rs) = T_U $ lfs <*> ls :*: rfs <*> rs
+
+delta :: a -> a :*: a
+delta x = x :*: x
+
+swap :: a :*: b -> b :*: a
+swap ~(x :*: y) = y :*: x
+
+attached :: a :*: b -> a
+attached ~(x :*: _) = x
+
+twosome :: t a -> u a -> (<:.:>) t u (:*:) a
+twosome x y = T_U $ x :*: y
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,7 +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
@@ -16,37 +16,16 @@
 import Pandora.Paradigm.Primary.Functor.Endo as Exports
 import Pandora.Paradigm.Primary.Functor.Proxy as Exports
 import Pandora.Paradigm.Primary.Functor.Tagged as Exports
-import Pandora.Paradigm.Primary.Functor.Product as Exports
 import Pandora.Paradigm.Primary.Functor.Constant as Exports
 import Pandora.Paradigm.Primary.Functor.Identity as Exports
-import Pandora.Paradigm.Primary.Functor.Function as Exports
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Applicative (Applicative_ (multiply))
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)), Adjoint_ ((--|-), (-|--)))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean, (?))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering)
 
 type Equivalence = Convergence Boolean
 type Comparison = Convergence Ordering
 
-instance Adjoint (Product s) ((->) s) where
-	(-|) :: a -> ((s :*: a) -> b) -> (s -> b)
-	x -| f = \s -> f $ s :*: x
-	(|-) :: (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
@@ -3,19 +3,19 @@
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category (identity, (.), ($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))
+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))
+import Pandora.Pattern.Functor.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.Algebraic.Product ((:*:) ((:*:)))
 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))
@@ -39,19 +39,12 @@
 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
+instance Semimonoidal (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
+instance Semimonoidal (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
@@ -61,27 +54,21 @@
 	Failure _ <+> x = x
 	Success x <+> _ = Success x
 
-instance Traversable (Conclusion e) where
-	Failure y ->> _ = point $ Failure y
-	Success x ->> f = Success <$> f x
-
-instance Bindable (Conclusion e) where
-	Success x >>= f = f x
-	Failure y >>= _ = Failure y
+instance Traversable (Conclusion e) (->) (->) where
+	(<<-) :: (Covariant_ u (->) (->), Pointable u (->), Semimonoidal u (:*:) (->) (->))
+		 => (a -> u b) -> Conclusion e a -> u (Conclusion e b)
+	_ <<- Failure y = point $ Failure y
+	f <<- Success x = Success -<$>- f x
 
-instance Bindable_ (Conclusion e) (->) where
-	join_ (Success (Success x)) = Success x
-	join_ (Success (Failure y)) = Failure y
-	join_ (Failure y) = Failure y
+instance Bindable (Conclusion e) (->) where
+	f =<< Success x = f x
+	_ =<< Failure y = Failure y
 
 instance Monad (Conclusion e) where
 
-instance Bivariant Conclusion 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
 	Failure x == Failure y = x == y
@@ -129,6 +116,6 @@
 	catch (Failure e) handle = handle e
 	catch (Success x) _ = Success x
 
-instance Monad u => Catchable e (Conclusion e <.:> u) where
+instance (Pointable u (->), Bindable u (->)) => Catchable e (Conclusion e <.:> u) where
 	catch (UT x) handle = let conclude = conclusion # run . handle # point . Success
-		in UT $ x >>= conclude
+		in UT $ conclude =<< x
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,11 +1,9 @@
 module Pandora.Paradigm.Primary.Functor.Constant where
 
-import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Category ((.), ($))
 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))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
@@ -16,7 +14,8 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 newtype Constant a b = Constant a
 
@@ -26,16 +25,16 @@
 instance Covariant_ (Constant a) (->) (->) where
 	_ -<$>- Constant x = Constant x
 
+instance Covariant_ (Flip Constant b) (->) (->) where
+	f -<$>- Flip (Constant x) = Flip . Constant $ f x
+
 instance Contravariant (Constant a) where
 	_ >$< Constant x = Constant x
 
 instance Invariant (Constant a) where
 	_ <$< _ = \(Constant x) -> Constant x
 
-instance Traversable (Constant a) where
-	Constant x ->> _ = point $ Constant x
-
-instance Bivariant Constant where
+instance Bivariant Constant (->) (->) (->)where
 	f <-> _ = \(Constant x) -> Constant $ f x
 
 instance Setoid a => Setoid (Constant a b) where
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
@@ -4,7 +4,7 @@
 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 ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 
 data Convergence r a = Convergence (a -> a -> r)
 
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
@@ -3,8 +3,8 @@
 import Pandora.Pattern.Category (($))
 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 ()
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 data Edges a = Empty | Leap a | Connect a | Overlay a
 
@@ -20,11 +20,11 @@
 	f -<$>- Overlay x = Overlay $ f x
 	f -<$>- Leap x = Leap $ f x
 
-instance Traversable Edges where
-	Empty ->> _ = point Empty
-	Connect x ->> f = Connect <$> f x
-	Overlay x ->> f = Overlay <$> f x
-	Leap x ->> f = Leap <$> f x
+instance Traversable Edges (->) (->) where
+	_ <<- Empty = point Empty
+	f <<- Connect x = Connect -<$>- f x
+	f <<- Overlay x = Overlay -<$>- f x
+	f <<- Leap x = Leap -<$>- f x
 
 edges :: r -> (a -> r) -> (a -> r) -> (a -> r) -> Edges a -> r
 edges r _ _ _ Empty = r
diff --git a/Pandora/Paradigm/Primary/Functor/Endo.hs b/Pandora/Paradigm/Primary/Functor/Endo.hs
--- a/Pandora/Paradigm/Primary/Functor/Endo.hs
+++ b/Pandora/Paradigm/Primary/Functor/Endo.hs
@@ -6,7 +6,7 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 newtype Endo a = Endo { endo :: a -> a }
 
diff --git a/Pandora/Paradigm/Primary/Functor/Fix.hs b/Pandora/Paradigm/Primary/Functor/Fix.hs
--- a/Pandora/Paradigm/Primary/Functor/Fix.hs
+++ b/Pandora/Paradigm/Primary/Functor/Fix.hs
@@ -3,7 +3,7 @@
 import Pandora.Core.Functor (type (<:=), type (:=>))
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant (comap))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 newtype Fix t = Fix { unfix :: t (Fix t) }
 
diff --git a/Pandora/Paradigm/Primary/Functor/Function.hs b/Pandora/Paradigm/Primary/Functor/Function.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Functor/Function.hs
+++ /dev/null
@@ -1,94 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Pandora.Paradigm.Primary.Functor.Function where
-
-import Pandora.Pattern.Category (Category ((.), ($), (#), identity))
-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), Pointable_ (point_))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))
-import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
-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 9 %
-infixl 1 &
-
-instance Category (->) where
-	identity x = x
-	f . g = \x -> f (g x)
-
-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 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 %)
-	tabulate = identity
-
-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
-
-(-.#..-) :: (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 -> 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
-(%) f x y = f y x
-
-{-# INLINE (&) #-}
-(&) :: a -> (a -> b) -> b
-x & f = f x
-
-fix :: (a -> a) -> a
-fix f = let x = f x in x
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
@@ -3,12 +3,11 @@
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
@@ -22,7 +21,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.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 newtype Identity a = Identity a
 
@@ -35,31 +34,22 @@
 instance Pointable Identity (->) where
 	point = Identity
 
-instance Pointable_ Identity (->) where
-	point_ = Identity
-
 instance Extractable Identity (->) where
 	extract (Identity x) = x
 
 instance Applicative Identity where
 	Identity f <*> Identity x = Identity $ f x
 
-instance Traversable Identity where
-	Identity x ->> f = Identity <$> f x
-
-instance Distributive Identity where
-	x >>- f = Identity $ extract . f <$> x
-
-instance Bindable Identity where
-	Identity x >>= f = f x
+instance Traversable Identity (->) (->) where
+	f <<- Identity x = Identity -<$>- f x
 
-instance Bindable_ Identity (->) where
-	join_ (Identity x) = x
+instance Bindable Identity (->) where
+	f =<< Identity x = f x	
 
 instance Monad Identity
 
-instance Extendable Identity where
-	x =>> f = Identity . f $ x
+instance Extendable Identity (->) where
+	f <<= x = Identity . f $ x
 
 instance Comonad Identity (->)
 
@@ -68,9 +58,9 @@
 	() <#> Identity x = x
 	tabulate f = Identity $ f ()
 
-instance Adjoint Identity Identity where
-	x -| f = Identity . f . Identity $ x
-	x |- g = extract . extract . comap g $ x
+instance Adjoint Identity Identity (->) (->) where
+	f -| x = Identity . f . Identity $ x
+	g |- x = extract . extract . comap g $ x
 
 instance Setoid a => Setoid (Identity a) where
 	Identity x == Identity y = x == y
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
@@ -4,11 +4,11 @@
 import Pandora.Pattern.Category (identity, (.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))
+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
@@ -23,9 +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.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 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
 
@@ -40,22 +40,15 @@
 instance Pointable Maybe (->) where
 	point = Just
 
-instance Pointable_ Maybe (->) where
-	point_ = Just
-
 instance Avoidable Maybe where
 	empty = Nothing
 
-instance Applicative Maybe where
-	Just f <*> x = f <$> x
-	Nothing <*> _ = Nothing
-
-instance Applicative_ Maybe (:*:) (->) (->) where
+instance Semimonoidal Maybe (:*:) (->) (->) where
 	multiply f (Just x :*: Just y) = Just . f $ x :*: y
 	multiply _ (Nothing :*: _) = Nothing
 	multiply _ (_ :*: Nothing) = Nothing
 
-instance Applicative_ Maybe Conclusion (->) (->) where
+instance Semimonoidal 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
@@ -65,17 +58,13 @@
 	Nothing <+> y = y
 	Just x <+> _ = Just x
 
-instance Traversable Maybe where
-	Nothing ->> _ = point Nothing
-	Just x ->> f = Just <$> f x
-
-instance Bindable Maybe where
-	Just x >>= f = f x
-	Nothing >>= _ = Nothing
+instance Traversable Maybe (->) (->) where
+	_ <<- Nothing = point Nothing
+	f <<- Just x = Just -<$>- f x
 
-instance Bindable_ Maybe (->) where
-	join_ (Just x) = x 
-	join_ Nothing = Nothing
+instance Bindable Maybe (->) where
+	f =<< Just x = f x
+	_ =<< 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
@@ -10,8 +10,8 @@
 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 ((:*:)), type (:*:))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype Predicate a = Predicate (a -> Boolean)
diff --git a/Pandora/Paradigm/Primary/Functor/Product.hs b/Pandora/Paradigm/Primary/Functor/Product.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Functor/Product.hs
+++ /dev/null
@@ -1,97 +0,0 @@
-module Pandora.Paradigm.Primary.Functor.Product where
-
-import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Category (($), (#))
-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 ((=>>)), Extendable_ (duplicate_))
-import Pandora.Pattern.Functor.Comonad (Comonad)
-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))
-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Pattern.Object.Quasiring (Quasiring (one))
-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
-import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
-import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
-
-infixr 0 :*:
-
-data Product s a = s :*: a
-
-type (:*:) = Product
-
-instance Covariant (Product s) where
-	f <$> x = attached x :*: f # extract x
-
-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
-	x ->> f = (attached x :*:) <$> f (extract x)
-
-instance Extendable (Product s) where
-	x =>> f = attached x :*: f (attached x :*: extract x)
-
-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)
-
-instance (Semigroup s, Semigroup a) => Semigroup (s :*: a) where
-	x + y = attached x + attached y :*: extract x + extract y
-
-instance (Monoid s, Monoid a) => Monoid (s :*: a) where
-	zero = zero :*: zero
-
-instance (Ringoid s, Ringoid a) => Ringoid (s :*: a) where
-	x * y = attached x * attached y :*: extract x * extract y
-
-instance (Quasiring s, Quasiring a) => Quasiring (s :*: a) where
-	one = one :*: one
-
-instance (Infimum s, Infimum a) => Infimum (s :*: a) where
-	x /\ y = attached x /\ attached y :*: extract x /\ extract y
-
-instance (Supremum s, Supremum a) => Supremum (s :*: a) where
-	x \/ y = attached x \/ attached y :*: extract x \/ extract y
-
-instance (Lattice s, Lattice a) => Lattice (s :*: a) where
-
-instance (Group s, Group a) => Group (s :*: a) where
-	invert x = invert # attached x :*: invert # extract x
-
-instance {-# OVERLAPS #-} Applicative t => Applicative (t <:.:> t := (:*:)) where
-	T_U (lfs :*: rfs) <*> T_U (ls :*: rs) = T_U $ lfs <*> ls :*: rfs <*> rs
-
-delta :: a -> a :*: a
-delta x = x :*: x
-
-swap :: a :*: b -> b :*: a
-swap ~(x :*: y) = y :*: x
-
-attached :: a :*: b -> a
-attached ~(x :*: _) = x
-
-twosome :: t a -> u a -> (<:.:>) t u (:*:) a
-twosome x y = T_U $ x :*: 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
@@ -2,14 +2,14 @@
 
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.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 ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 data Proxy a = Proxy
 
@@ -25,22 +25,19 @@
 instance Pointable Proxy (->) where
 	point _ = Proxy
 
-instance Pointable_ Proxy (->) where
-	point_ _ = Proxy
-
 instance Applicative Proxy where
 	_ <*> _ = Proxy
 
 instance Alternative Proxy where
 	_ <+> _ = Proxy
 
-instance Distributive Proxy where
-	_ >>- _ = Proxy
+instance Distributive Proxy (->) (->) where
+	_ -<< _ = Proxy
 
-instance Bindable Proxy where
-	_ >>= _ = Proxy
+instance Bindable Proxy (->) where
+	_ =<< _ = Proxy
 
 instance Monad Proxy
 
-instance Extendable Proxy where
-	_ =>> _ = Proxy
+instance Extendable 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
@@ -4,12 +4,12 @@
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
@@ -22,7 +22,8 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 newtype Tagged tag a = Tag a
 
@@ -35,35 +36,35 @@
 instance Covariant_ (Tagged tag) (->) (->) where
 	f -<$>- Tag x = Tag $ f x
 
+instance Covariant_ (Flip Tagged a) (->) (->) where
+	_ -<$>- Flip (Tag x) = Flip $ Tag x
+
 instance Pointable (Tagged tag) (->) where
 	point = Tag
 
-instance Pointable_ (Tagged tag) (->) where
-	point_ = Tag
-
 instance Extractable (Tagged tag) (->) where
 	extract (Tag x) = x
 
 instance Applicative (Tagged tag) where
 	Tag f <*> Tag x = Tag $ f x
 
-instance Traversable (Tagged tag) where
-	Tag x ->> f = Tag <$> f x
+instance Traversable (Tagged tag) (->) (->) where
+	f <<- Tag x = Tag -<$>- f x
 
-instance Distributive (Tagged tag) where
-	x >>- f = Tag $ extract . f <$> x
+instance Distributive (Tagged tag) (->) (->) where
+	f -<< x = Tag $ extract . f -<$>- x
 
-instance Bindable (Tagged tag) where
-	Tag x >>= f = f x
+instance Bindable (Tagged tag) (->) where
+	f =<< Tag x = f x
 
 instance Monad (Tagged tag)
 
-instance Extendable (Tagged tag) where
-	x =>> f = Tag . f $ x
+instance Extendable (Tagged tag) (->) where
+	f <<= x = Tag . f $ x
 
 instance Comonad (Tagged tag) (->)
 
-instance Bivariant Tagged where
+instance Bivariant Tagged (->) (->) (->)where
 	_ <-> g = \(Tag x) -> Tag $ g x
 
 instance Setoid a => Setoid (Tagged tag a) where
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
@@ -2,10 +2,10 @@
 
 import Pandora.Pattern.Category (($), (#))
 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.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 data These e a = This a | That e | These e a
 
@@ -22,13 +22,10 @@
 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
-	That y ->> _ = point $ That y
-	These y x ->> f = These y <$> f x
+instance Traversable (These e) (->) (->) where
+	f <<- This x = This -<$>- f x
+	_ <<- That y = point $ That y
+	f <<- These y x = These y -<$>- f x
 
 instance (Semigroup e, Semigroup a) => Semigroup (These e a) where
 	This x + This x' = This # x + 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
@@ -2,16 +2,16 @@
 
 import Pandora.Pattern.Category ((.), ($), (#))
 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.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Semimonoidal (multiply))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.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.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 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))
@@ -41,16 +41,13 @@
 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
+instance Semigroup e => Semimonoidal (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
@@ -60,15 +57,12 @@
 	Flaws _ <+> x = x
 	Validated x <+> _ = Validated x
 
-instance Traversable (Validation e) where
-	Validated x ->> f = Validated <$> f x
-	Flaws e ->> _ = point $ Flaws e
+instance Traversable (Validation e) (->) (->) where
+	f <<- Validated x = Validated -<$>- f x
+	_ <<- Flaws e = point $ Flaws e
 
-instance Bivariant Validation where
+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
@@ -2,9 +2,9 @@
 
 import Pandora.Pattern.Category (($))
 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 ()
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 data Wedge e a = Nowhere | Here e | There a
 
@@ -21,13 +21,10 @@
 instance Pointable (Wedge e) (->) where
 	point = There
 
-instance Pointable_ (Wedge e) (->) where
-	point_ = There
-
-instance Traversable (Wedge e) where
-	Nowhere ->> _ = point Nowhere
-	Here x ->> _ = point $ Here x
-	There x ->> f = There <$> f x
+instance Traversable (Wedge e) (->) (->) where
+	_ <<- Nowhere = point Nowhere
+	_ <<- Here x = point $ Here x
+	f <<- There x = There -<$>- f x
 
 wedge :: (e -> r) -> (a -> r) -> r -> Wedge e a -> r
 wedge f _ _ (Here x) = f x
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
@@ -3,9 +3,6 @@
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative ((<*>))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
@@ -23,12 +20,6 @@
 	f -<$>- Left x = Left # f x
 	f -<$>- Right y = Right # f y
 	f -<$>- Both x y = Both # f x # f y
-
-instance Traversable Wye where
-	End ->> _ = point End
-	Left x ->> f = Left <$> f x
-	Right y ->> f = Right <$> f y
-	Both x y ->> f = Both <$> f x <*> f y
 
 instance Monotonic a (Wye a) where
 	reduce f r (Left x) = f x r
diff --git a/Pandora/Paradigm/Primary/Linear/Vector.hs b/Pandora/Paradigm/Primary/Linear/Vector.hs
--- a/Pandora/Paradigm/Primary/Linear/Vector.hs
+++ b/Pandora/Paradigm/Primary/Linear/Vector.hs
@@ -10,8 +10,8 @@
 import Pandora.Pattern.Object.Quasiring (Quasiring (one))
 import Pandora.Pattern.Object.Group (Group (invert))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
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,17 +1,19 @@
 module Pandora.Paradigm.Primary.Transformer.Backwards where
 
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (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), Pointable_ (point_))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Functor.Function ((&))
+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype Backwards t a = Backwards (t a)
@@ -25,20 +27,19 @@
 instance Pointable t (->) => Pointable (Backwards t) (->) where
 	point = Backwards . point
 
-instance Pointable_ t (->) => Pointable_ (Backwards t) (->) where
-	point_ = Backwards . point_
-
 instance Extractable t (->) => Extractable (Backwards t) (->) where
 	extract (Backwards x) = extract x
 
-instance Applicative t => Applicative (Backwards t) where
-	Backwards f <*> Backwards x = Backwards # (&) <$> x <*> f
+-- TODO: check that effects evaluation goes in opposite order
+instance Semimonoidal t (:*:) (->) (->) => Semimonoidal (Backwards t) (:*:) (->) (->) where
+	multiply f (Backwards x :*: Backwards y) = Backwards #
+		f .#.. ((:*:) %) -<$>- y -<*>- x
 
-instance Traversable t => Traversable (Backwards t) where
-	Backwards x ->> f = Backwards <$> x ->> f
+instance Traversable t (->) (->) => Traversable (Backwards t) (->) (->) where
+	f <<- Backwards x = Backwards -<$>- f <<- x
 
-instance Distributive t => Distributive (Backwards t) where
-	x >>- f = Backwards $ x >>- run . f
+instance Distributive t (->) (->) => Distributive (Backwards t) (->) (->) where
+	f -<< x = Backwards $ run . f -<< x
 
 instance Contravariant t => Contravariant (Backwards t) where
 	f >$< Backwards x = Backwards $ f >$< x
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
@@ -6,13 +6,13 @@
 import Pandora.Pattern.Category ((.), ($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), ($>>=)) , Bindable_ (join_))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
@@ -21,7 +21,8 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid ((*))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 import Pandora.Paradigm.Schemes (type (<:.>))
@@ -39,26 +40,20 @@
 instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Construction t) (->) where
 	point x = Construct x empty
 
-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
 	~(Construct f fs) <*> ~(Construct x xs) = Construct # f x # fs <**> xs
 
-instance Traversable t => Traversable (Construction t) where
-	~(Construct x xs) ->> f = Construct <$> f x <*> xs ->>> f
-
-instance (Alternative t, Covariant_ t (->) (->)) => Bindable (Construction t) where
-	~(Construct x xs) >>= f = Construct # extract (f x) # deconstruct (f x) <+> xs $>>= f
+instance Traversable t (->) (->) => Traversable (Construction t) (->) (->) where
+	f <<- ~(Construct x xs) = Construct -<$>- f x -<*>- f -<<-<<- xs
 
-instance (Covariant_ t (->) (->), Alternative t) => Bindable_ (Construction t) (->) where
-	join_ (Construct x xs) = Construct # extract x # deconstruct x <+> (join_ @_ @(->) -<$>- xs)
+instance (Covariant_ t (->) (->), Alternative t) => Bindable (Construction t) (->) where
+	f =<< ~(Construct x xs) = Construct # extract (f x) # deconstruct (f x) <+> ((f =<<) -<$>- xs)
 
-instance Covariant t => Extendable (Construction t) where
-	x =>> f = Construct # f x # extend f <$> deconstruct x
+instance Covariant_ t (->) (->) => Extendable (Construction t) (->) where
+	f <<= x = Construct # f x # (f <<=) -<$>- deconstruct x
 
 instance (Avoidable t, Alternative t, Covariant_ t (->) (->)) => Monad (Construction t) where
 
@@ -93,4 +88,4 @@
 f .-+ x = Construct x $ (f .-+) <$> f x
 
 section :: Comonad t (->) => t ~> Construction t
-section xs = Construct # extract xs $ xs =>> section
+section xs = Construct # extract xs $ section <<= xs
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
@@ -1,3 +1,4 @@
+{-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Primary.Transformer.Continuation where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
@@ -5,12 +6,11 @@
 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)
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 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.Algebraic.Exponential ((!.), (%))
 
 newtype Continuation r t a = Continuation ((->) ::|:. a :. t := r)
 
@@ -31,20 +31,20 @@
 instance Covariant t => Applicative (Continuation r t) where
 	f <*> x = Continuation $ \h -> run f $ \g -> run x # h . g
 
-instance Covariant t => Bindable (Continuation r t) where
-	x >>= f = Continuation $ \g -> run x $ \y -> run # f y # g
+instance Covariant_ t (->) (->) => Bindable (Continuation r t) (->) where
+	f =<< x = Continuation $ \g -> run x $ \y -> run # f y # g
 
 instance Monad t => Monad (Continuation r t) where
 
-instance (forall u . Bindable u) => Liftable (Continuation r) where
-	lift = Continuation . (>>=)
+instance (forall u . Bindable u (->)) => Liftable (Continuation r) where
+	lift = Continuation . (%) (=<<)
 
 -- | Call with current continuation
 cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a
 cwcc f = Continuation $ \g -> (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 :: (forall u . Bindable u (->), Monad 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
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
@@ -7,11 +7,11 @@
 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.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.Product (Product ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!..), (-.#..-))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 
 data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a)
 
@@ -31,8 +31,8 @@
 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 !..)
+instance (Extendable t (->), Extendable u (->)) => Extendable (Day t u) (->) where
+	f <<= day@(Day tb uc _) = Day tb uc (f day !..)
 
 instance Extractable t (->) => Lowerable (Day t) where
 	lower (Day tb uc bca) = bca (extract tb) -<$>- uc
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
@@ -9,13 +9,13 @@
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 data Instruction t a = Enter a | Instruct (t :. Instruction t := a)
 
@@ -43,20 +43,22 @@
 	Enter f <*> Instruct y = Instruct $ f <$$> y
 	Instruct f <*> y = Instruct $ (<*> y) <$> f
 
-instance Covariant t => Bindable (Instruction t) where
-	Enter x >>= f = f x
-	Instruct xs >>= f = Instruct $ (>>= f) <$> xs
+instance Covariant_ t (->) (->) => Bindable (Instruction t) (->) where
+	f =<< Enter x = f x
+	f =<< Instruct xs = Instruct $ (f =<<) -<$>- xs
 
-instance Traversable t => Traversable (Instruction t) where
-	Enter x ->> f = Enter <$> f x
-	Instruct xs ->> f = Instruct <$> xs ->>> f
+instance Monad t => Monad (Instruction t) where
 
+instance Traversable t (->) (->) => Traversable (Instruction t) (->) (->) where
+	f <<- Enter x = Enter -<$>- f x
+	f <<- Instruct xs = Instruct -<$>- f -<<-<<- xs
+
 instance Liftable Instruction where
 	lift x = Instruct $ Enter -<$>- x
 
-instance (forall t . Monad t) => Lowerable Instruction where
+instance (forall t . Bindable t (->), forall t . Pointable t (->)) => Lowerable Instruction where
 	lower (Enter x) = point x
-	lower (Instruct xs) = xs >>= lower
+	lower (Instruct xs) = lower =<< xs
 
 instance (forall v . Covariant v) => Hoistable Instruction where
 	_ /|\ Enter x = Enter 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
@@ -9,15 +9,14 @@
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
-import Pandora.Paradigm.Primary.Functor.Function ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
 
@@ -52,20 +51,17 @@
 	Other f <*> It x = Other $ ($ x) <$> f
 	Other f <*> Other y = Other $ f <*> y
 
-instance Traversable t => Traversable (Jack t) where
-	It x ->> f = It <$> f x
-	Other y ->> f = Other <$> y ->> f
-
-instance Distributive t => Distributive (Jack t) where
-	x >>- f = distribute $ f <$> x
+instance Traversable t (->) (->) => Traversable (Jack t) (->) (->) where
+	f <<- It x = It -<$>- f x
+	f <<- Other y = Other -<$>- f <<- y
 
-instance (Pointable t (->), Bindable t) => Bindable (Jack t) where
-	It x >>= f = f x
-	Other x >>= f = Other $ x >>= jack point identity . f
+instance (Pointable t (->), Bindable t (->)) => Bindable (Jack t) (->) where
+	f =<< It x = f x
+	f =<< Other x = Other $ jack point identity . f =<< x
 
-instance Extendable t => Extendable (Jack t) where
-	It x =>> f = It . f $ It x
-	Other x =>> f = Other $ x =>> f . Other
+instance Extendable t (->) => Extendable (Jack t) (->) where
+	f <<= It x = It . f $ It x
+	f <<= Other x = Other $ f . Other <<= x
 
 instance Liftable Jack where
 	lift = Other
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
@@ -6,8 +6,8 @@
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
 
 data Jet t a = Jet a (Jet t (t a))
 
@@ -17,8 +17,8 @@
 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 Traversable t (->) (->) => Traversable (Jet t) (->) (->) where
+	f <<- Jet x xs = Jet -<$>- f x -<*>- f -<<-<<- xs
 
 instance (forall u . Avoidable u, Covariant_ t (->) (->)) => Pointable (Jet t) (->) where
 	point x = Jet x empty
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
@@ -10,7 +10,7 @@
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Functor.Function ((%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 
 data Outline t a where
 	Line :: a -> Outline t a
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
@@ -7,12 +7,13 @@
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
@@ -30,14 +31,14 @@
 instance Extractable t (->) => Extractable (Reverse t) (->) where
 	extract (Reverse x) = extract x
 
-instance Applicative t => Applicative (Reverse t) where
-	Reverse f <*> Reverse x = Reverse # f <*> x
+instance Semimonoidal t (:*:) (->) (->) => Semimonoidal (Reverse t) (:*:) (->) (->) where
+	multiply f (Reverse x :*: Reverse y) = Reverse . multiply f $ x :*: y
 
-instance Traversable t => Traversable (Reverse t) where
-	Reverse x ->> f = Reverse <$> run (x ->> Backwards . f)
+instance Traversable t (->) (->) => Traversable (Reverse t) (->) (->) where
+	f <<- Reverse x = Reverse -<$>- run (Backwards . f <<- x)
 
-instance Distributive t => Distributive (Reverse t) where
-	x >>- f = Reverse $ x >>- run . f
+instance Distributive t (->) (->) => Distributive (Reverse t) (->) (->) where
+	f -<< x = Reverse $ run . f -<< x
 
 instance Contravariant t => Contravariant (Reverse t) where
 	f >$< Reverse x = Reverse # f >$< x
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
@@ -10,19 +10,20 @@
 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.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 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.Algebraic ((-<*>-))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), twosome)
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
-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.Primary.Transformer.Reverse (Reverse (Reverse))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
 import Pandora.Paradigm.Structure.Ability.Substructure
@@ -39,20 +40,20 @@
 instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Tap t) (->) where
 	point = Tap % empty
 
-instance (Covariant t, Covariant_ t (->) (->))  => Extractable (Tap t) (->) where
+instance (Covariant_ t (->) (->)) => Extractable (Tap t) (->) where
 	extract (Tap x _) = x
 
 instance Applicative t => Applicative (Tap t) where
 	Tap f fs <*> Tap x xs = Tap # f x # fs <*> xs
 
-instance Traversable t => Traversable (Tap t) where
-	Tap x xs ->> f = Tap <$> f x <*> xs ->> f
+instance Traversable t (->) (->) => Traversable (Tap t) (->) (->) where
+	f <<- Tap x xs = Tap -<$>- f x -<*>- f <<- xs
 
-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 (Extractable t (->), Alternative t, Bindable t (->)) => Bindable (Tap t) (->) where
+	f =<< Tap x xs = case f x of ~(Tap y ys) -> Tap y $ ys <+> (lower . f =<< xs)
 
-instance (Extendable t, Covariant_ t (->) (->)) => Extendable (Tap t) where
-	x =>> f = Tap # f x $ lower x =>> f . Tap (extract x)
+instance (Extendable t (->), Covariant_ t (->) (->)) => Extendable (Tap t) (->) where
+	f <<= x = Tap # f x $ f . Tap (extract x) <<= lower x
 
 instance Lowerable Tap where
 	lower (Tap _ xs) = xs
@@ -63,9 +64,9 @@
 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 {-# OVERLAPS #-} Traversable t (->) (->) => Traversable (Tap (t <:.:> t := (:*:))) (->) (->) where
+	f <<- Tap x (T_U (future :*: past)) = (\past' x' future' -> Tap x' $ twosome # future' # run past')
+		-<$>- f <<- Reverse past -<*>- f x -<*>- f <<- future
 
 instance (Covariant t, Covariant_ t (->) (->)) => Substructure Root (Tap (t <:.:> t := (:*:))) where
 	type Available Root (Tap (t <:.:> t := (:*:))) = Identity
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
@@ -12,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.Algebraic.Exponential ((!.))
 
 newtype Yoneda t a = Yoneda
 	{ yoneda :: forall b . (a -> b) -> t b }
@@ -41,6 +41,6 @@
 instance Liftable Yoneda where
 	lift x = Yoneda (-<$>- x)
 
-instance (Extractable t (->), Pointable t (->), Extractable u (->) , Pointable u (->)) => Adjoint (Yoneda t) (Yoneda u) where
-	x -| f = point . f . point # x
-	x |- g = extract . extract # g <$> x
+instance (Extractable t (->), Pointable t (->), Extractable u (->) , Pointable u (->)) => Adjoint (Yoneda t) (Yoneda u) (->) (->) where
+	f -| x = point . f . point # x
+	g |- x = extract . extract # g <$> x
diff --git a/Pandora/Paradigm/Schemes.hs b/Pandora/Paradigm/Schemes.hs
--- a/Pandora/Paradigm/Schemes.hs
+++ b/Pandora/Paradigm/Schemes.hs
@@ -19,28 +19,28 @@
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 
-instance (Covariant (v <:.> t), Covariant (u <:.> w), Adjoint t u, Adjoint v w)
-	=> Adjoint (v <:.> t) (u <:.> w) where
-		TU y |- g = y |- (|- run . g)
-		x -| f = TU $ x -| (-| f . TU)
+instance (Covariant (v <:.> t), Covariant (u <:.> w), Adjoint t u (->) (->), Adjoint v w (->) (->))
+	=> Adjoint (v <:.> t) (u <:.> w) (->) (->) where
+		g |- TU y = (run . g |-) |- y
+		f -| x = TU $ (f . TU -|) -| x
 
-instance (Covariant (v <:.> t), Covariant (w <.:> u), Adjoint t u, Adjoint v w)
-	=> Adjoint (v <:.> t) (w <.:> u) where
-		TU t |- g = t |- (|- run . g)
-		x -| f = UT $ x -| (-| f . TU)
+instance (Covariant (v <:.> t), Covariant (w <.:> u), Adjoint t u (->) (->), Adjoint v w (->) (->))
+	=> Adjoint (v <:.> t) (w <.:> u) (->) (->) where
+		g |- TU t = (run . g |-) |- t
+		f -| x = UT $ (f . TU -|) -| x
 
-instance (Covariant (t <.:> v), Covariant (w <.:> u), Adjoint t u, Adjoint v w)
-	=> Adjoint (t <.:> v) (w <.:> u) where
-		UT t |- g = t |- (|- run . g)
-		x -| f = UT $ x -| (-| f . UT)
+instance (Covariant (t <.:> v), Covariant (w <.:> u), Adjoint t u (->) (->), Adjoint v w (->) (->))
+	=> Adjoint (t <.:> v) (w <.:> u) (->) (->) where
+		g |- UT t =  (run . g |-) |- t
+		f -| x = UT $ (f . UT -|) -| x
 
-instance (Covariant (t <.:> v), Covariant (w <:.> u) , Adjoint v u, Adjoint t w)
-	=> Adjoint (t <.:> v) (w <:.> u) where
-		UT t |- g = t |- (|- run . g)
-		x -| f = TU $ x -| (-| f . UT)
+instance (Covariant (t <.:> v), Covariant (w <:.> u) , Adjoint v u (->) (->), Adjoint t w (->) (->))
+	=> Adjoint (t <.:> v) (w <:.> u) (->) (->) where
+		g |- UT x = (run . g |-) |- x
+		f -| x = TU $ (f . UT -|) -| x
 
 instance (Covariant ((t <:<.>:> u) t'), Covariant ((v <:<.>:> w) v')
-	, Adjoint t w, Adjoint t' v', Adjoint t v, Adjoint u v, Adjoint v' t')
-	=> Adjoint ((t <:<.>:> u) t') ((v <:<.>:> w) v') where
-		TUT t |- g = t |- (|- (|- run . g))
-		x -| f = TUT $ x -| (-| (-| f . TUT))
+	, Adjoint t w (->) (->), Adjoint t' v' (->) (->), Adjoint t v (->) (->), Adjoint u v (->) (->), Adjoint v' t' (->) (->))
+	=> Adjoint ((t <:<.>:> u) t') ((v <:<.>:> w) v') (->) (->) where
+		g |- TUT x = ((run . g |-) |-) |- x
+		f -| x = TUT $  ((f . TUT -|) -|) -| 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
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Schemes.TU where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
-import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Category ((.), ($), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
@@ -9,9 +9,9 @@
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), join))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
@@ -52,11 +52,11 @@
 instance (Extractable t (->), Extractable u (->)) => Extractable (t <:.> u) (->) where
 	extract = extract . extract . run
 
-instance (Traversable t, Traversable u) => Traversable (t <:.> u) where
-	x ->> f = TU <$> run x ->>> f
+instance (Traversable t (->) (->), Traversable u (->) (->)) => Traversable (t <:.> u) (->) (->) where
+	f <<- x = TU -<$>- f -<<-<<- run x
 
-instance (Bindable t, Distributive t, Bindable u) => Bindable (t <:.> u) where
-	TU x >>= f = TU $ x >>= \i -> join <$> i >>- run . f
+instance (Bindable t (->), Distributive t (->) (->), Covariant_ u (->) (->), Bindable u (->)) => Bindable (t <:.> u) (->) where
+	f =<< TU x = TU $ (\i -> (identity =<<) -<$>- run . f -<< i) =<< x
 
 instance Pointable t (->) => Liftable (TU Covariant Covariant t) where
 	lift :: Covariant_ u (->) (->) => u ~> t <:.> u
@@ -66,6 +66,6 @@
 	lower :: t <:.> u ~> u
 	lower (TU x) = extract x
 
-instance Covariant t => Hoistable (TU Covariant Covariant t) where
+instance Covariant_ t (->) (->) => Hoistable (TU Covariant Covariant t) where
 	(/|\) :: u ~> v -> (t <:.> u ~> t <:.> v)
-	f /|\ TU x = TU $ f <$> x
+	f /|\ TU x = TU $ f -<$>- 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
@@ -2,17 +2,12 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor ((<*+>))
 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 ((<+>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), ($>>=)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), ($=>>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
@@ -42,31 +37,31 @@
 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 (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 (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
-	empty = TUT $ point empty
+--instance (Pointable t (->), Applicative t, Covariant t', Avoidable u) => Avoidable (t <:<.>:> t' := u) where
+--	empty = TUT $ point empty
 
-instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Pointable u (->), Adjoint t' t) => Pointable (t <:<.>:> t' := u) (->) where
-	point = unite . (-| point)
+instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Pointable u (->), Adjoint t' t (->) (->)) => Pointable (t <:<.>:> t' := u) (->) where
+	point = unite . (point @_ @(->) -|)
 
-instance (Covariant t, Covariant t', Adjoint t' t, Bindable u) => Bindable (t <:<.>:> t' := u) where
-	x >>= f = TUT $ run x $>>= (|- run . f)
+--instance (Covariant t, Covariant t', Adjoint t' t (->) (->), Bindable u (->)) => Bindable (t <:<.>:> t' := u) (->) where
+--	f =<< x = TUT $ ((run . f |-) =<<) -<$>- x
 
-instance (Covariant t', Covariant t, Adjoint t' t, Extendable u) => Extendable (t' <:<.>:> t := u) where
-	x =>> f = TUT $ run x $=>> (-| f . unite)
+instance (Covariant t', Covariant t, Adjoint t' t (->) (->), Extendable u (->)) => Extendable (t' <:<.>:> t := u) (->) where
+	f <<= x = TUT $ ((f . unite -|) <<=) -<$>- run x
 
-instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Adjoint t t', Extractable u (->)) => Extractable (t <:<.>:> t' := u) (->) where
-	extract = (|- extract) . run
+instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Adjoint t t' (->) (->), Extractable u (->)) => Extractable (t <:<.>:> t' := u) (->) where
+	extract = (extract @_ @(->) |-) . run
 
-instance (forall u . Covariant u, Adjoint t' t, Distributive t) => Liftable (t <:<.>:> t') where
+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)
+	lift x = TUT $ (identity @(->) -|) -<< x
 
-instance (forall u . Covariant u, Adjoint t t', Distributive t') => Lowerable (t <:<.>:> t') where
+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)
+	lower (TUT x) = (identity @(->) -<<) |- x
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
@@ -3,8 +3,8 @@
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))
-import Pandora.Pattern.Functor.Divariant (Divariant ((>->))) 
+import Pandora.Pattern.Functor.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))
@@ -21,14 +21,14 @@
 	run ~(T_U x) = x
 	unite = T_U
 
-instance (forall i . Covariant (p i), Bivariant p, Covariant t, Covariant u) => Covariant (t <:.:> u := p) where
+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 (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
+instance (Divariant p (->) (->) (->), Contravariant t, Covariant u) => Covariant (t >:.:> u := p) where
 	f <$> x = (f >$<) >-> (f <$>) ||= x
 
-instance (forall i . Covariant (p i), Bivariant p, Contravariant t, Contravariant u) => Contravariant (t >:.:< u := p) where
+instance (forall i . Covariant (p i), Bivariant p (->) (->) (->), Contravariant t, Contravariant u) => Contravariant (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
@@ -1,18 +1,18 @@
 module Pandora.Paradigm.Schemes.UT where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
-import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Category ((.), ($), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)), Semimonoidal)
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), join))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 
 newtype UT ct cu t u a = UT (u :. t := a)
 
@@ -40,8 +40,8 @@
 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 (Traversable t (->) (->), Bindable t (->), Semimonoidal u (:*:) (->) (->), Pointable u (->), Bindable u (->)) => Bindable (t <.:> u) (->) where
+	f =<< UT x = UT $ ((identity =<<) -<$>-) . (run . f <<-) =<< x
 
 instance (Extractable t (->), Extractable u (->)) => Extractable (t <.:> u) (->) where
 	extract = extract . extract . run
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -18,12 +18,12 @@
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (||=))
 import Pandora.Paradigm.Inventory.Optics ()
 import Pandora.Paradigm.Inventory.Store (Store (Store))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached, twosome)
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
-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))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached, twosome)
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Both, Left, Right, End))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
@@ -69,15 +69,15 @@
 	type Morphing (Into (o ds)) Binary = Maybe <:.> Morphing (Into (o ds)) (Construction Wye)
 	morphing (premorph -> xs) = comap (into @(o ds)) ||= xs
 
-instance Substructure Left (Flip Product a) where
-	type Available Left (Flip Product a) = Identity
-	type Substance Left (Flip Product a) = Identity
+instance Substructure Left (Flip (:*:) a) where
+	type Available Left (Flip (:*:) a) = Identity
+	type Substance Left (Flip (:*:) a) = Identity
 	substructure = P_Q_T $ \product -> case run # lower product of
 		s :*: x -> Store $ Identity (Identity s) :*: lift . Flip . (:*: x) . extract . extract
 
-instance Substructure Right (Product s) where
-	type Available Right (Product s) = Identity
-	type Substance Right (Product s) = Identity
+instance Substructure Right ((:*:) s) where
+	type Available Right ((:*:) s) = Identity
+	type Substance Right ((:*:) s) = Identity
 	substructure = P_Q_T $ \product -> case lower product of
 		s :*: x -> Store $ Identity (Identity x) :*: lift . (s :*:) . extract . extract
 
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.Algebraic.Exponential ((!.))
 
 class Monotonic a e where
 	{-# MINIMAL reduce #-}
diff --git a/Pandora/Paradigm/Structure/Ability/Morphable.hs b/Pandora/Paradigm/Structure/Ability/Morphable.hs
--- a/Pandora/Paradigm/Structure/Ability/Morphable.hs
+++ b/Pandora/Paradigm/Structure/Ability/Morphable.hs
@@ -7,12 +7,12 @@
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Setoid (Setoid)
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Functor (Comparison)
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
@@ -65,5 +65,5 @@
 lookup :: forall mod key struct a . (Morphed (Lookup mod) struct ((->) key <:.> Maybe)) => key -> struct a -> Maybe a
 lookup key struct = run # morph @(Lookup mod) struct # key
 
-vary :: forall mod key value struct . (Morphed (Vary mod) struct ((Product key <:.> Identity) <:.:> struct := (->))) => key -> value -> struct value -> struct value
+vary :: forall mod key value struct . (Morphed (Vary mod) struct (((:*:) key <:.> Identity) <:.:> struct := (->))) => key -> value -> struct value -> struct value
 vary key value xs = run # morph @(Vary mod) @struct xs # TU (key :*: Identity value)
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
@@ -4,15 +4,16 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 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.Algebraic ()
+import Pandora.Paradigm.Primary.Algebraic.Product (attached)
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)
-import Pandora.Paradigm.Primary.Functor.Product (attached)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean)
 import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Zero))
 import Pandora.Paradigm.Schemes.T_U (type (<:.:>))
@@ -20,10 +21,10 @@
 import Pandora.Paradigm.Inventory.State (State, modify)
 import Pandora.Paradigm.Controlflow.Effect (run)
 
-type Set t f a = (Traversable t, Setoid a, Setoid (t a), Morphable (Find f) t)
+type Set t f a = (Traversable t (->) (->), Setoid a, Setoid (t a), Morphable (Find f) t)
 
 subset :: forall t f a . (Set t f a, Morphing (Find f) t ~ (Predicate <:.:> Maybe := (->))) => Convergence Boolean := t a
-subset = Convergence $ \s ss -> Nothing != ss ->> (find @f @t @Maybe % s) . equate
+subset = Convergence $ \s ss -> Nothing != (find @f @t @Maybe % s) . equate <<- ss
 
-cardinality :: Traversable t => t a -> Numerator
-cardinality s = attached . run @(State _) % Zero $ s ->> (modify @Numerator (+ one) !.)
+cardinality :: Traversable t (->) (->) => t a -> Numerator
+cardinality s = attached . run @(State _) % Zero $ (modify @Numerator (+ one) !.) <<- s
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
@@ -11,15 +11,15 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
-import Pandora.Paradigm.Primary.Functor.Function ((%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
@@ -49,16 +49,17 @@
 instance (Avoidable t, Alternative t) => Avoidable (Comprehension t) where
 	empty = Comprehension empty
 
-instance Traversable (t <:.> Construction t) => Traversable (Comprehension t) where
-	Comprehension x ->> f = Comprehension <$> x ->> f
+instance Traversable (t <:.> Construction t) (->) (->) => Traversable (Comprehension t) (->) (->) where
+	f <<- Comprehension x = Comprehension -<$>- f <<- x
 
-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 (->), Pointable t (->), Avoidable t) => Applicative (Comprehension t) where
+	fs <*> xs = (\f -> Comprehension . TU . point . point . f =<< xs) =<< fs
 
-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), Bindable t (->)) => Bindable (Comprehension t) (->) where
+	f =<< Comprehension (TU t) = Comprehension . TU $ (\(Construct x xs) -> run . run $ f x + (f =<< Comprehension (TU xs))) =<< t
+		-- 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
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
@@ -7,20 +7,21 @@
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic ()
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into), premorph)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 
-newtype Prefixed t k a = Prefixed (t :. Product k := a)
+newtype Prefixed t k a = Prefixed (t :. (:*:) k := a)
 
 instance Interpreted (Prefixed t k) where
-	type Primary (Prefixed t k) a = t :. Product k := a
+	type Primary (Prefixed t k) a = t :. (:*:) k := a
 	run ~(Prefixed x) = x
 	unite = Prefixed
 
@@ -30,8 +31,8 @@
 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 Traversable t (->) (->) => Traversable (Prefixed t k) (->) (->) where
+	f <<- Prefixed x = Prefixed -<$>- f -<<-<<- x
 
 instance (Monoid k, Pointable t (->)) => Pointable (Prefixed t k) (->) where
 	point = Prefixed . point . (:*:) zero
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
@@ -7,23 +7,23 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($$$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Avoidable (empty)
-import Pandora.Pattern.Functor.Bindable ((>>=))
+import Pandora.Pattern.Functor.Bindable ((=<<))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Paradigm.Primary ()
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), type (:*:), attached, twosome)
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), (&))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (order)
 import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Numerator, Zero))
 import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (One))
 import Pandora.Paradigm.Primary.Functor (Comparison)
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
-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))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached, twosome)
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
 import Pandora.Paradigm.Schemes (TU (TU), T_U (T_U), P_Q_T (P_Q_T), type (<:.>), type (<:.:>))
@@ -138,11 +138,11 @@
 	morphing (run . run . premorph -> Nothing) = lift Nothing
 	morphing (run . run . premorph -> Just tree) = TU $ \key ->
 		let root = extract tree in key <=> attached root & order (Just # extract root)
-			(view # sub @Left # tree >>= lookup @Key key . Prefixed)
-			(view # sub @Right # tree >>= lookup @Key key . Prefixed)
+			(lookup @Key key . Prefixed =<< view # sub @Left # tree)
+			(lookup @Key key . Prefixed =<< view # sub @Right # tree)
 
 instance Chain k => Morphable (Vary Element) (Prefixed Binary k) where
-	type Morphing (Vary Element) (Prefixed Binary k) = (Product k <:.> Identity) <:.:> Prefixed Binary k := (->)
+	type Morphing (Vary Element) (Prefixed Binary k) = ((:*:) k <:.> Identity) <:.:> Prefixed Binary k := (->)
 	morphing (run . run . premorph -> Nothing) = T_U $ \(TU (key :*: Identity value)) -> Prefixed . lift . leaf $ key :*: value
 	morphing (run . run . premorph -> Just tree) = T_U $ \(TU (key :*: Identity value)) ->
 		let continue = ((vary @Element @k @_ @(Prefixed Binary _) key value =||) =||)
@@ -157,8 +157,8 @@
 	type Morphing (Lookup Key) (Prefixed (Construction Wye) key) = (->) key <:.> Maybe
 	morphing (run . premorph -> Construct x xs) = TU $ \key ->
 		key <=> attached x & order (Just # extract x)
-			(view # sub @Left # xs >>= lookup @Key key . Prefixed . extract)
-			(view # sub @Right # xs >>= lookup @Key key . Prefixed . extract)
+			(lookup @Key key . Prefixed . extract =<< view # sub @Left # xs)
+			(lookup @Key key . Prefixed . extract =<< view # sub @Left # xs)
 
 -------------------------------------- Zipper of binary tree ---------------------------------------
 
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
@@ -5,16 +5,14 @@
 import Pandora.Core.Functor (type (:.), type (:=), type (:::))
 import Pandora.Core.Impliable (imply)
 import Pandora.Pattern.Category ((.), ($), (#), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Avoidable (empty)
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Bindable ((>>=))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Bivariant ((<->))
-import Pandora.Pattern.Functor.Adjoint ((|-))
-import Pandora.Pattern.Functor ()
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
@@ -23,11 +21,12 @@
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?))
 import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Numerator))
 import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (One))
-import Pandora.Paradigm.Primary.Functor.Function ((%))
+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached, twosome)
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached, twosome)
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+))
 import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap))
@@ -118,7 +117,7 @@
 		Nothing -> Store $ Identity empty :*: lift . identity . extract
 
 -- | Transform any traversable structure into a stack
-linearize :: forall t a . Traversable t => t a -> List a
+linearize :: forall t a . Traversable t (->) (->) => t a -> List a
 linearize = TU . extract . (run @(State (Maybe :. Nonempty List := a)) % Nothing) . fold (Just .#.. Construct)
 
 ----------------------------------------- Non-empty list -------------------------------------------
@@ -132,7 +131,7 @@
 instance Morphable (Find Element) (Construction Maybe) where
 	type Morphing (Find Element) (Construction Maybe) = Predicate <:.:> Maybe := (->)
 	morphing (premorph -> Construct x xs) = T_U $ \p ->
-		run p x ? Just x $ xs >>= find @Element @(Nonempty List) @Maybe # p
+		run p x ? Just x $ find @Element @(Nonempty List) @Maybe # p =<< xs
 
 instance Morphable (Into List) (Construction Maybe) where
 	type Morphing (Into List) (Construction Maybe) = List
@@ -167,16 +166,16 @@
 
 type instance Zipper List (Left ::: Right) = Tap (List <:.:> List := (:*:))
 
-instance {-# OVERLAPS #-} Applicative (Tap (List <:.:> List := (:*:))) where
-	Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs)
+--instance {-# OVERLAPS #-} Applicative (Tap (List <:.:> List := (:*:))) 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 (List <:.:> List := (:*:))) 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 {-# OVERLAPS #-} Traversable (Tap (List <:.:> List := (:*:))) (->) (->) where
+	f <<- Tap x (T_U (future :*: past)) = (\past' x' future' -> Tap x' $ twosome # future' # run past')
+		-<$>- f <<- Reverse past -<*>- f x -<*>- f <<- future
 
-instance {-# OVERLAPS #-} Extendable (Tap (List <:.:> List := (:*:))) where
-	z =>> f = let move rtt = TU . deconstruct $ run . rtt .-+ z in
-		Tap # f z $ twosome # f <$> move (rotate @Left) # f <$> move (rotate @Right)
+instance {-# OVERLAPS #-} Extendable (Tap (List <:.:> List := (:*:))) (->) where
+	f <<= z = let move rtt = TU . deconstruct $ run . rtt .-+ z in
+		Tap # f z $ twosome # f -<$>- move (rotate @Left) # f -<$>- move (rotate @Right)
 
 instance Morphable (Rotate Left) (Tap (List <:.:> List := (:*:))) where
 	type Morphing (Rotate Left) (Tap (List <:.:> List := (:*:))) = Maybe <:.> Tap (List <:.:> List := (:*:))
@@ -197,13 +196,13 @@
 instance Morphable (Into List) (Tap (List <:.:> List := (:*:))) where
 	type Morphing (Into List) (Tap (List <:.:> List := (:*:))) = List
 	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)
-		# past ->> modify . item @Push @List
+		# modify . item @Push @List <<- past
 		# item @Push x future
 
 instance Morphable (Into (Comprehension Maybe)) (Tap (List <:.:> List := (:*:))) where
 	type Morphing (Into (Comprehension Maybe)) (Tap (List <:.:> List := (:*:))) = Comprehension Maybe
 	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)
-		# past ->> modify . item @Push @(Comprehension Maybe)
+		# modify . item @Push @(Comprehension Maybe) <<- past
 		# item @Push x (Comprehension future)
 
 ------------------------------------- Zipper of non-empty list -------------------------------------
@@ -228,22 +227,22 @@
 	type Morphing (Into (Tap (List <:.:> List := (:*:)))) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = Tap (List <:.:> List := (:*:))
 	morphing (premorph -> zipper) = Tap # extract zipper $ lift <-> lift ||= lower zipper
 
-instance Morphable (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) where
-	type Morphing (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) =
-		Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))
-	morphing (premorph -> zipper) = let spread x y = (:*:) <$> x <*> y in TU $
-		Tap (extract zipper) . T_U <$> ((|- spread) . (run <-> run) . run $ lower zipper)
+--instance Morphable (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) where
+	--type Morphing (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) =
+		--Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))
+	--morphing (premorph -> zipper) = let spread x y = (:*:) -<$>- x -<*>- y in TU $
+		--Tap (extract zipper) . T_U -<$>- ((spread |-) . (run <-> run) . run $ lower zipper)
 
 instance Morphable (Into (Construction Maybe)) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
 	type Morphing (Into (Construction Maybe)) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = Construction Maybe
 	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)
-		# past ->> modify . item @Push @(Nonempty List)
+		# modify . item @Push @(Nonempty List) <<- past
 		# item @Push x future
 
 instance Morphable (Into List) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
 	type Morphing (Into List) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = List
 	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)
-		# past ->> modify . item @Push @List
+		# modify . item @Push @List <<- past
 		# item @Push x (lift future)
 
 ------------------------------------ Zipper of combinative list ------------------------------------
@@ -257,11 +256,11 @@
 
 instance Setoid key => Morphable (Lookup Key) (Prefixed List key) where
 	type Morphing (Lookup Key) (Prefixed List key) = (->) key <:.> Maybe
-	morphing (run . premorph -> list) = TU $ \key -> Prefixed <$> run list >>= lookup @Key key
+	morphing (run . premorph -> list) = TU $ \key -> lookup @Key key =<< Prefixed -<$>- run list 
 
 ------------------------------------ Prefixed non-empty list ---------------------------------------
 
 instance Setoid key => Morphable (Lookup Key) (Prefixed (Construction Maybe) key) where
 	type Morphing (Lookup Key) (Prefixed (Construction Maybe) key) = (->) key <:.> Maybe
 	morphing (run . premorph -> Construct x xs) = TU $ \key -> extract <$> search key where
-		search key = key == attached x ? Just x $ xs >>= find @Element # Predicate ((key ==) . attached)
+		search key = key == attached x ? Just x $ find @Element # Predicate ((key ==) . attached) =<< xs
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
@@ -8,16 +8,16 @@
 import Pandora.Pattern.Functor.Contravariant ((>$<))
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 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.Algebraic.Product ((:*:) ((:*:)), attached)
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))
 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)
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
 import Pandora.Paradigm.Schemes (TU (TU), T_U (T_U), P_Q_T (P_Q_T), type (<:.>), type (<:.:>))
@@ -77,7 +77,7 @@
 
 -- TODO: Ineffiecient - we iterate over all branches in subtree, but we need to short-circuit on the first matching part of
 instance Setoid k => Morphable (Vary Element) (Prefixed Rose k) where
-	type Morphing (Vary Element) (Prefixed Rose k) = (Product (Nonempty List k) <:.> Identity) <:.:> Prefixed Rose k := (->)
+	type Morphing (Vary Element) (Prefixed Rose k) = ((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed Rose k := (->)
 	morphing (run . run . premorph -> Nothing) = T_U $ \(TU (Construct key _ :*: Identity value)) -> Prefixed . lift $ Construct (key :*: value) empty
 	morphing (run . run . premorph -> Just (Construct focused subtree)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
 		Construct key Nothing -> Prefixed . lift $ attached focused == key ? Construct (key :*: value) subtree $ Construct focused subtree
@@ -89,7 +89,7 @@
 -- TODO: Ineffiecient - we iterate over all branches in subtree, but we need to short-circuit on the first matching part of
 instance Setoid k => Morphable (Vary Element) (Prefixed (Construction List) k) where
 	type Morphing (Vary Element) (Prefixed (Construction List) k) =
-		(Product (Nonempty List k) <:.> Identity) <:.:> Prefixed (Construction List) k := (->)
+		((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed (Construction List) k := (->)
 	morphing (run . premorph -> Construct x (TU Nothing)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
 		Construct key Nothing -> Prefixed $ attached x == key ? Construct (key :*: value) empty $ Construct x empty
 		Construct _ (Just _) -> Prefixed $ Construct x (TU Nothing)
@@ -101,7 +101,7 @@
 
 find_rose_sub_tree :: forall k a . Setoid k => Nonempty List k -> Nonempty Rose := k :*: a -> Maybe a
 find_rose_sub_tree (Construct k Nothing) tree = k == attached (extract tree) ? Just (extract $ extract tree) $ Nothing
-find_rose_sub_tree (Construct k (Just ks)) tree = k != attached (extract tree) ? Nothing $ subtree >>= find_rose_sub_tree ks where
+find_rose_sub_tree (Construct k (Just ks)) tree = k != attached (extract tree) ? Nothing $ find_rose_sub_tree ks =<< subtree where
 
 	subtree :: Maybe :. Nonempty Rose := k :*: a
 	subtree = find @Element # attached . extract >$< equate (extract ks) # deconstruct tree
diff --git a/Pandora/Paradigm/Structure/Some/Splay.hs b/Pandora/Paradigm/Structure/Some/Splay.hs
--- a/Pandora/Paradigm/Structure/Some/Splay.hs
+++ b/Pandora/Paradigm/Structure/Some/Splay.hs
@@ -5,13 +5,13 @@
 
 import Pandora.Core.Functor (type (~>), type (:.), type (:=))
 import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Applicative ((<*>))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Paradigm.Primary ()
+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
+import Pandora.Paradigm.Primary.Algebraic.Product (twosome)
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
-import Pandora.Paradigm.Primary.Functor.Product (twosome)
 import Pandora.Paradigm.Primary.Functor.Tagged (type (:#))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
@@ -27,39 +27,39 @@
 
 instance Morphable (Rotate (Left Zig)) Binary where
 	type Morphing (Rotate (Left Zig)) Binary = Binary
-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Left Zig)
+	morphing (premorph -> binary) = unite $ run . rotate @(Left Zig) =<< run binary
 
 instance Morphable (Rotate (Right Zig)) Binary where
 	type Morphing (Rotate (Right Zig)) Binary = Binary
-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Right Zig)
+	morphing (premorph -> binary) = unite $ run . rotate @(Right Zig) =<< run binary
 
 instance Morphable (Rotate (Left (Zig Zig))) Binary where
 	type Morphing (Rotate (Left (Zig Zig))) Binary = Binary
-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Left (Zig Zig))
+	morphing (premorph -> binary) = unite $ run . rotate @(Left (Zig Zig)) =<< run binary
 
 instance Morphable (Rotate (Right (Zig Zig))) Binary where
 	type Morphing (Rotate (Right (Zig Zig))) Binary = Binary
-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Right (Zig Zig))
+	morphing (premorph -> binary) = unite $ run . rotate @(Right (Zig Zig)) =<< run binary
 
 instance Morphable (Rotate (Left (Zig Zag))) Binary where
 	type Morphing (Rotate (Left (Zig Zag))) Binary = Binary
-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Left (Zig Zag))
+	morphing (premorph -> binary) = unite $ run . rotate @(Left (Zig Zag)) =<< run binary
 
 instance Morphable (Rotate (Right (Zig Zag))) Binary where
 	type Morphing (Rotate (Right (Zig Zag))) Binary = Binary
-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Right (Zig Zag))
+	morphing (premorph -> binary) = unite $ run . rotate @(Right (Zig Zag)) =<< run binary
 
 -------------------------------------- Non-empty Splay tree ----------------------------------------
 
 instance Morphable (Rotate (Left Zig)) (Construction Wye) where
 	type Morphing (Rotate (Left Zig)) (Construction Wye) = Binary
 	morphing :: forall a . (:#) (Rotate (Left Zig)) <:.> Construction Wye := a -> Binary a
-	morphing (premorph -> Construct x xs) = TU $ Construct <$> parent <*> Just nodes where
+	morphing (premorph -> Construct x xs) = TU $ Construct -<$>- parent -<*>- Just nodes where
 
 		nodes :: Wye :. Nonempty Binary := a
 		nodes = into @Wye . twosome (branch @Left xs) . Just . Construct x
-			. into @Wye $ twosome (deconstruct <$> branch @Right xs >>= branch @Left)
-				(deconstruct <$> branch @Right xs >>= branch @Right)
+			. into @Wye $ twosome (branch @Left =<< deconstruct <$> branch @Right xs)
+				(branch @Right =<< deconstruct <$> branch @Right xs)
 
 		parent :: Maybe a
 		parent = extract <$> branch @Right xs
@@ -67,11 +67,11 @@
 instance Morphable (Rotate (Right Zig)) (Construction Wye) where
 	type Morphing (Rotate (Right Zig)) (Construction Wye) = Binary
 	morphing :: forall a . (:#) (Rotate (Right Zig)) <:.> Construction Wye := a -> Binary a
-	morphing (premorph -> Construct x xs) = TU $ Construct <$> parent <*> Just nodes where
+	morphing (premorph -> Construct x xs) = TU $ Construct -<$>- parent -<*>- Just nodes where
 
 		nodes :: Wye :. Nonempty Binary := a
-		nodes = into @Wye . twosome (deconstruct <$> branch @Left xs >>= branch @Left) . Just . Construct x
-			. into @Wye $ twosome (deconstruct <$> branch @Left xs >>= branch @Right) # branch @Right xs
+		nodes = into @Wye . twosome (branch @Left =<< deconstruct <$> branch @Left xs) . Just . Construct x
+			. into @Wye $ twosome (branch @Right =<< deconstruct <$> branch @Left xs) # branch @Right xs
 
 		parent :: Maybe a
 		parent = extract <$> branch @Left xs
@@ -79,22 +79,22 @@
 -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary
 instance Morphable (Rotate (Left (Zig Zig))) (Construction Wye) where
 	type Morphing (Rotate (Left (Zig Zig))) (Construction Wye) = Binary
-	morphing (premorph -> tree) = TU $ run # rotate @(Left Zig) tree >>= run . rotate @(Left Zig)
+	morphing (premorph -> tree) = TU $ run . rotate @(Left Zig) =<< run # rotate @(Left Zig) tree
 
 -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary
 instance Morphable (Rotate (Right (Zig Zig))) (Construction Wye) where
 	type Morphing (Rotate (Right (Zig Zig))) (Construction Wye) = Binary
-	morphing (premorph -> tree) = TU $ run # rotate @(Right Zig) tree >>= run . rotate @(Right Zig)
+	morphing (premorph -> tree) = TU $ run . rotate @(Right Zig) =<< run # rotate @(Right Zig) tree
 
 -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary
 instance Morphable (Rotate (Left (Zig Zag))) (Construction Wye) where
 	type Morphing (Rotate (Left (Zig Zag))) (Construction Wye) = Binary
-	morphing = rotate @(Left Zig) . over (sub @Left) (>>= run . rotate @(Right Zig)) . premorph
+	morphing = rotate @(Left Zig) . over (sub @Left) (run . rotate @(Right Zig) =<<) . premorph
 
 -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary
 instance Morphable (Rotate (Right (Zig Zag))) (Construction Wye) where
 	type Morphing (Rotate (Right (Zig Zag))) (Construction Wye) = Binary
-	morphing = rotate @(Right Zig) . over (sub @Right) (>>= run . rotate @(Left Zig)) . premorph
+	morphing = rotate @(Right Zig) . over (sub @Right) (run . rotate @(Left Zig) =<<) . premorph
 
 branch :: forall b . Morphable (Into (b Maybe)) Wye => Wye ~> Morphing (Into (b Maybe)) Wye
 branch = into @(b Maybe)
diff --git a/Pandora/Paradigm/Structure/Some/Stream.hs b/Pandora/Paradigm/Structure/Some/Stream.hs
--- a/Pandora/Paradigm/Structure/Some/Stream.hs
+++ b/Pandora/Paradigm/Structure/Some/Stream.hs
@@ -7,8 +7,8 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (point)
 import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), twosome)
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), twosome)
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+))
@@ -31,8 +31,8 @@
 	morphing (premorph -> Tap x (T_U (bs :*: fs))) = Tap # extract fs
 		$ twosome # Construct x (point bs) # extract (deconstruct fs)
 
-instance {-# OVERLAPS #-} Extendable (Tap (Stream <:.:> Stream := (:*:))) where
-	z =>> f = let move rtt = extract . deconstruct $ point . rtt .-+ z
+instance {-# OVERLAPS #-} Extendable (Tap (Stream <:.:> Stream := (:*:))) (->) where
+	f <<= z = let move rtt = extract . deconstruct $ point . rtt .-+ z
 		in f <$> Tap z (twosome # (move $ rotate @Left) # (move $ rotate @Right))
 
 repeat :: a :=> Stream
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,11 +1,10 @@
 module Pandora.Pattern.Functor.Adjoint where
 
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)), Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 
 type (-|) = Adjoint
 
-infixl 3 -|, |-, -|$, $|-, $$|-, $$$|-, $$$$|-
+infixl 3 -|, |-
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -15,42 +14,6 @@
 > * Right adjunction interchange: psi f ≡ epsilon . comap f
 -}
 
-class Adjoint t u where
-	{-# MINIMAL (-|), (|-) #-}
-	-- | Left adjunction
-	(-|) :: a -> (t a -> b) -> u b
-	-- | Right adjunction
-	(|-) :: t a -> (a -> u b) -> b
-
-	-- | Prefix and flipped version of '-|'
-	phi :: (t a -> b) -> a -> u b
-	phi f x = x -| f
-	-- | Prefix and flipped version of '|-'
-	psi :: (a -> u b) -> t a -> b
-	psi g x = x |- g
-	-- | Also known as 'unit'
-	eta :: a -> u :. t := a
-	eta = phi (\x -> x)
-	-- | Also known as 'counit'
-	epsilon :: t :. u := a -> a
-	epsilon = psi (\x -> x)
-
-	(-|$) :: Covariant v => v a -> (t a -> b) -> v (u b)
-	x -|$ f = (-| f) <$> x
-
-	-- | Versions of `|-` with various nesting levels
-	($|-) :: Covariant v => v (t a) -> (a -> u b) -> v b
-	x $|- f = (|- f) <$> x
-	($$|-) :: (Covariant v, Covariant w) =>
-		v :. w :. t := a -> (a -> u b) -> v :. w := b
-	x $$|- f = (|- f) <$$> x
-	($$$|-) :: (Covariant v, Covariant w, Covariant x) =>
-		v :. w :. x :. t := a -> (a -> u b) -> v :. w :. x := b
-	x $$$|- f = (|- f) <$$$> x
-	($$$$|-) :: (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
+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
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Applicative where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)), Covariant_)
 import Pandora.Pattern.Functor.Bivariant (Bivariant)
 
 infixl 4 <*>, <*, *>
@@ -47,5 +47,5 @@
 		-> t :. u :. v :. w := b
 	f <****> x = (<***>) <$> f <*> x
 
-class Bivariant v => Applicative_ t v source target where
+class (Covariant_ t source target, Bivariant v source source target) => Semimonoidal 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,39 +1,13 @@
 module Pandora.Pattern.Functor.Bindable where
 
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 
-infixl 1 >>=
-infixr 1 =<<, <=<, >=>
+infixr 1 =<<
 
 {- |
 > When providing a new instance, you should ensure it satisfies :
 > * Interchange: t >>= f = join (f <$> t)
 -}
 
-class Covariant t => Bindable t where
-	{-# MINIMAL (>>=) #-}
-	-- | Infix and flipped version of 'bind', the dual of '=>>'
-	(>>=) :: t a -> (a -> t b) -> t b
-
-	-- | Flipped version of '>>=', the dual of '<<='
-	(=<<) :: (a -> t b) -> t a -> t b
-	f =<< x = x >>= f
-	-- | Prefix and flipped version of '>>=', the dual of 'extend'
-	bind :: (a -> t b) -> t a -> t b
-	bind f t = t >>= f
-	-- | Merge effects/contexts, the dual of 'duplicate'
-	join :: t :. t := a -> t a
-	join t = t >>= \x -> x
-	-- | Left-to-right Kleisli composition
-	(>=>) :: (a -> t b) -> (b -> t c) -> (a -> t c)
-	f >=> g = \x -> f x >>= g
-	-- | Right-to-left Kleisli composition
-	(<=<) :: (b -> t c) -> (a -> t b) -> (a -> t c)
-	g <=< f = f >=> g
-
-	($>>=) :: 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)
+class Covariant_ t source source => Bindable t source where
+	(=<<) :: source a (t b) -> source (t a) (t b)
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,24 +1,16 @@
 module Pandora.Pattern.Functor.Bivariant where
 
-import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip)
 
 infixl 4 <->
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
-> * Identity: bimap identity identity ≡ identity
-> * Parametricity: bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
+> * Identity: identity <-> identity ≡ identity
+> * Parametricity: (f . g) <-> (h . i) ≡ f <-> h . g <-> i
 -}
 
-class (forall i . Covariant (v i)) => Bivariant (v :: * -> * -> *) where
-	{-# MINIMAL (<->) #-}
-	(<->) :: (forall i . Covariant (v i)) => (a -> b) -> (c -> d) -> v a c -> v b d
-
-	-- | 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) 
+	=> 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 source, Extendable t) => Comonad t source
+class (Extractable t source, Extendable t (->)) => Comonad t source
diff --git a/Pandora/Pattern/Functor/Distributive.hs b/Pandora/Pattern/Functor/Distributive.hs
--- a/Pandora/Pattern/Functor/Distributive.hs
+++ b/Pandora/Pattern/Functor/Distributive.hs
@@ -1,37 +1,16 @@
 module Pandora.Pattern.Functor.Distributive where
 
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 
 {- |
 > Let f :: Distributive g => (a -> g b)
 
 > When providing a new instance, you should ensure it satisfies:
-> * Identity morphism: distribute . distribute ≡ identity
-> * Interchange collection: collect f ≡ distribute . comap f
+> * Identity morphism: (identity -<<) . (identity -<<) ≡ identity
+> * Interchange collection: (f -<<) ≡ (identity -<<) . (f -<$>-)
 -}
 
-infixl 5 >>-, >>>-, >>>>-, >>>>>-
-
-class Covariant t => Distributive t where
-	{-# MINIMAL (>>-) #-}
-	-- | Infix and flipped version of 'collect'
-	(>>-) :: Covariant u => u a -> (a -> t b) -> t :. u := b
-
-	-- | Prefix version of '>>-'
-	collect :: Covariant u => (a -> t b) -> u a -> t :. u := b
-	collect f t = t >>- f
-	-- | The dual of 'sequence'
-	distribute :: Covariant u => u :. t := a -> t :. u := a
-	distribute t = t >>- (\x -> x)
+infixl 5 -<<
 
-	-- | Infix versions of `collect` with various nesting levels
-	(>>>-) :: (Covariant u, Covariant v)
-		=> u :. v := a -> (a -> t b) -> t :. u :. v := b
-	x >>>- f = x >>- (>>- f)
-	(>>>>-) :: (Covariant u, Covariant v, Covariant w)
-		=> u :. v :. w := a -> (a -> t b) -> t :. u :. v :. w := b
-	x >>>>- f = x >>- (>>- (>>- f))
-	(>>>>>-) :: (Covariant u, Covariant v, Covariant w, Covariant j)
-		=> u :. v :. w :. j := a -> (a -> t b) -> t :. u :. v :. w :. j := b
-	x >>>>>- f = x >>- (>>- (>>- (>>- f)))
+class Covariant_ t source target => Distributive t source target where
+	(-<<) :: Covariant_ u source target => source a (t b) -> target (u a) (t (u b))
diff --git a/Pandora/Pattern/Functor/Divariant.hs b/Pandora/Pattern/Functor/Divariant.hs
--- a/Pandora/Pattern/Functor/Divariant.hs
+++ b/Pandora/Pattern/Functor/Divariant.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Divariant where
 
-import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
 import Pandora.Pattern.Functor.Contravariant (Contravariant_)
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip)
 
@@ -8,17 +8,17 @@
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
-> * Identity: dimap identity identity ≡ identity
-> * Interpreted: dimap (f . g) (h . i) ≡ dimap g h . dimap f i
+> * Identity: identity >-> identity ≡ identity
+> * Interpreted: f . g >-> h . i ≡ g >-> h . f >-> i
 -}
 
-class (forall i . Covariant (v i)) => Divariant (v :: * -> * -> *) where
-	{-# MINIMAL (>->) #-}
-	(>->) :: (a -> b) -> (c -> d) -> v b c -> v a d
-	-- | Prefix version of '>->'
-	dimap :: (a -> b) -> (c -> d) -> v b c -> v a d
-	dimap f g x = (f >-> g) x
+--class (forall i . Covariant (v i)) => Divariant (v :: * -> * -> *) where
+--	{-# MINIMAL (>->) #-}
+--	(>->) :: (a -> b) -> (c -> d) -> v b c -> v a d
+--	-- | 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)
+	=> 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
@@ -2,7 +2,7 @@
 
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Bivariant (Bivariant)
-import Pandora.Paradigm.Primary.Functor.Product (type (:*:))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 
 infixr 5 >*<
 
@@ -10,5 +10,5 @@
 	{-# 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)
+class Bivariant v source source target => Divisible_ t v source target where
+	divide :: 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
@@ -3,42 +3,13 @@
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)
 
-infixl 1 =>>
-infixr 1 <<=, =<=, =>=
+infixr 1 <<=
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
-> * Duplication interchange: comap (comap f) . duplicate ≡ duplicate . comap f
-> * Extension interchange: extend f ≡ comap f . duplicate
+> * Duplication interchange: (f -<$$>-) . (identity <<=) ≡ (identity <<=) . (f -<$>-)
+> * Extension interchange: (f <<=) ≡ (f -<$>-) . (identity <<=)
 -}
 
-class Covariant t => Extendable t where
-	{-# MINIMAL (=>>) #-}
-	-- | Infix and flipped version of 'extend', the dual of '>>='
-	(=>>) :: t a -> (t a -> b) -> t b
-
-	-- | Flipped version of '>>=', the dual of '=<<'
-	(<<=) :: (t a -> b) -> t a -> t b
-	f <<= x = x =>> f
-	-- | Prefix and flipped version of '=>>', the dual of 'bind'
-	extend :: (t a -> b) -> t a -> t b
-	extend f t = t =>> f
-	-- | Clone existing structure, the dual of 'join'
-	duplicate :: t a -> t :. t := a
-	duplicate t = t =>> (\x -> x)
-	-- | Right-to-left Cokleisli composition
-	(=<=) :: (t b -> c) -> (t a -> b) -> t a -> c
-	f =<= g = \x -> f (extend g x)
-
-	-- | Left-to-right Cokleisli composition
-	(=>=) :: (t a -> b) -> (t b -> c) -> t a -> c
-	f =>= g = \x -> g (extend f x)
-
-	-- | Experimental methods
-	($=>>) :: Covariant u => u :. t := a -> (t a -> b) -> u :. t := b
-	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))
+class Covariant_ t source source => Extendable t source where
+	(<<=) :: source (t a) b -> source (t a) (t b)
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,8 +1,8 @@
 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))
+import Pandora.Pattern.Functor.Bindable (Bindable)
+import Pandora.Pattern.Functor.Pointable (Pointable)
 
 {- |
 > Let f :: (Pointable t, Bindable t) => a -> t a
@@ -15,15 +15,15 @@
 > * Associativity: h >>= (f >=> g) ≡ (h >>= f) >>= g
 -}
 
-infixl 1 >>=-, ->>=
-infixr 1 -=<<, =<<-
+--infixl 1 >>=-, ->>=
+--infixr 1 -=<<, =<<-
 
-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
-	(->>=) x y = x >>= \_ -> y >>= \r -> point r
-	(-=<<) :: t a -> t b -> t b
-	(-=<<) x y = x >>= \_ -> y >>= \r -> point r
-	(=<<-) :: t a -> t b -> t a
-	(=<<-) x y = x >>= \r -> y >>= \_ -> point r
+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
+	--(->>=) x y = x >>= \_ -> y >>= \r -> point r
+	--(-=<<) :: t a -> t b -> t b
+	--(-=<<) x y = x >>= \_ -> y >>= \r -> point r
+	--(=<<-) :: t a -> t b -> t a
+	--(=<<-) x y = x >>= \r -> y >>= \_ -> point r
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
@@ -5,6 +5,3 @@
 class Covariant_ t source source => Pointable t source where
 	{-# MINIMAL point #-}
 	point :: source a (t a)
-
-class Pointable_ t target where
-	point_ :: target a (t a)
diff --git a/Pandora/Pattern/Functor/Traversable.hs b/Pandora/Pattern/Functor/Traversable.hs
--- a/Pandora/Pattern/Functor/Traversable.hs
+++ b/Pandora/Pattern/Functor/Traversable.hs
@@ -1,42 +1,27 @@
 module Pandora.Pattern.Functor.Traversable where
 
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Applicative (Applicative)
+import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Applicative (Semimonoidal)
 import Pandora.Pattern.Functor.Pointable (Pointable)
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 
 {- |
 > Let f :: (Applicative t, Applicative g) => t a -> u a
 > Let p :: (Pointable t, Pointable g) => t a -> u a
 
 > When providing a new instance, you should ensure it satisfies:
-> * Numeratority of traversing: g . traverse f ≡ traverse (g . f)
-> * Numeratority of sequencing: f . sequence = sequence . comap f
+> * Numeratority of traversing: g . (f <<--) ≡ (g . f <<--)
+> * Numeratority of sequencing: f . (identity <<--)= (identity <<--) . (f -<$>-)
 > * Preserving point: p (point x) ≡ point x
-> * Preserving apply: f (x <*> y) ≡ f x <*> f y
+> * Preserving apply: f (x -<*>- y) ≡ f x -<*>- f y
 -}
 
-infixl 5 ->>, ->>>, ->>>>, ->>>>>
-
-class Covariant t => Traversable t where
-	{-# MINIMAL (->>) #-}
-	-- | Infix version of 'traverse'
-	(->>) :: (Pointable u (->), Applicative u) => t a -> (a -> u b) -> u :. t := b
+infixl 5 <<-, -<<-<<-
 
-	-- | Prefix version of '->>'
-	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 t = t ->> (\x -> x)
+class Covariant_ t source target => Traversable t source target where
+	(<<-) :: (Covariant_ u source target, Pointable u target, Semimonoidal u (:*:) source target) => source a (u b) -> target (t a) (u (t b))
 
-	-- | Infix versions of `traverse` with various nesting levels
-	(->>>) :: (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)
-		=> 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)
-		=> j :. w :. v :. t := a -> (a -> u b) -> u :. j :. w :. v :. t := b
-	x ->>>>> f = x ->> (->> (->> (->> f)))
+(-<<-<<-) :: forall t u v category a b . 
+	(Traversable t category category, Covariant_ u category category, Pointable u category, Semimonoidal u (:*:) category category, Traversable v category category)
+	=> category a (u b) -> category (v (t a)) (u (v (t b)))
+(-<<-<<-) f = ((<<-) ((<<-) @t @category @category f))
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.4.3
+version:             0.4.4
 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
@@ -28,12 +28,14 @@
     -- Basic constructions
     Pandora.Paradigm.Primary
     Pandora.Paradigm.Primary.Object
+    Pandora.Paradigm.Primary.Algebraic
+    Pandora.Paradigm.Primary.Algebraic.Exponential
+    Pandora.Paradigm.Primary.Algebraic.Product
     Pandora.Paradigm.Primary.Object.Boolean
     Pandora.Paradigm.Primary.Object.Ordering
     Pandora.Paradigm.Primary.Object.Numerator
     Pandora.Paradigm.Primary.Object.Denumerator
     Pandora.Paradigm.Primary.Functor
-    Pandora.Paradigm.Primary.Functor.Function
     Pandora.Paradigm.Primary.Functor.Conclusion
     Pandora.Paradigm.Primary.Functor.Constant
     Pandora.Paradigm.Primary.Functor.Edges
@@ -41,7 +43,6 @@
     Pandora.Paradigm.Primary.Functor.Fix
     Pandora.Paradigm.Primary.Functor.Identity
     Pandora.Paradigm.Primary.Functor.Maybe
-    Pandora.Paradigm.Primary.Functor.Product
     Pandora.Paradigm.Primary.Functor.Proxy
     Pandora.Paradigm.Primary.Functor.Tagged
     Pandora.Paradigm.Primary.Functor.These