diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -549,3 +549,37 @@
 * Rename experimental `Contravariant_` to `Contravariant`
 
 # 0.4.6
+* Define `void` method in `Algebraic` module
+* Define `<--` type synonymous for reverted arrows
+* Define `Zero` module in `Algebraic` directory
+* Define `One` module in `Algebraic` directory
+* Rename `One` constructor in `Denumerator` to `Single`
+* Define `Unit` type family
+* Define `Monoidal` typeclass
+* Define `absurd` method
+* Define `empty` method
+* Define `sum` method
+* Add `Monoidal` constraint to `Applicative` and `Alternative` constraints
+* Define `point_` method
+* Use `Monoidal` superclass in `Traversable` instead of `Pointable`
+* Use `Monoidal` superclass in `Monad` instead of `Pointable`
+* Remove `Pointable` typeclass
+* Rename `point_` to `point`
+* Define `extract_` method
+* Remove `Extractable` typeclass
+* Rename `extract_` to `extract`
+* Use `Monoidal` as superclass of `Comonad`
+* Rename `multiply_` to `multiply`
+* Rearrange type parameters in `Covariant` typeclass
+* Rearrange type parameters in `Contravariant` typeclass
+* Rearrange type parameters in `Semimonoidal` typeclass
+* Rearrange type parameters in `Adjoint` typeclass
+* Rearrange type parameters in `Bivariant` typeclass
+* Rearrange type parameters in `Traversable` typeclass
+* Rearrange type parameters in `Distributive` typeclass
+* Rearrange type parameters in `Bindaple` typeclass
+* Rearrange type parameters in `Extendable` typeclass
+* Rearrange type parameters in `Monoidal` typeclass
+* Rearrange type parameters in `Divariant` typeclass
+* Generalize `Liftable` typeclass
+* Generalize `Lowerable` typeclass
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
@@ -6,11 +6,12 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Pointable (Pointable)
-import Pandora.Pattern.Functor.Extractable (Extractable)
+import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer (Liftable (lift), Lowerable (lower), Hoistable (hoist))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Primary.Algebraic (Extractable_)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer (Monadic, Comonadic, wrap, bring, (:>), (:<))
 
@@ -18,10 +19,10 @@
 	{-# MINIMAL adapt #-}
 	adapt :: t ~> 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 (->))
+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, Monoidal (->) (->) (:*:) (:*:) u)
+type Bringable t u = (Comonadic t, Extractable_ u)
 
 instance Adaptable t t where
 	adapt = identity
@@ -39,8 +40,8 @@
 	adapt = bring
 
 instance
-	( 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
@@ -64,7 +65,7 @@
 	adapt = lower . lower
 
 instance
-	( Liftable (Schematic Monad t)
+	( Liftable (->) (Schematic Monad t)
 	, Lifting t (Schematic Monad u (v :> w))
 	, Lifting u (Schematic Monad v w)
 	, Wrappable v w
@@ -294,12 +295,12 @@
 	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where
 	adapt = bring . lower . lower . lower . lower . lower . lower . lower
 
-instance (Covariant u (->) (->), Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where
+instance (Covariant (->) (->) u, Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where
 	adapt = hoist adapt
 
 instance
-	( Covariant v (->) (->)
-	, Covariant (Schematic Monad u v) (->) (->)
+	( Covariant (->) (->) v
+	, Covariant (->) (->) (Schematic Monad u v)
 	, Hoistable ((:>) (t :> u))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -308,12 +309,12 @@
 	adapt = hoist (hoist adapt)
 
 instance
-	( Covariant u (->) (->)
-	, Covariant v (->) (->)
-	, Covariant w (->) (->)
-	, Covariant (Schematic Monad u v) (->) (->)
-	, Covariant (Schematic Monad u (v :> w)) (->) (->)
-	, Covariant (Schematic Monad v w) (->) (->)
+	( Covariant (->) (->) u
+	, Covariant (->) (->) v
+	, Covariant (->) (->) w
+	, Covariant (->) (->) (Schematic Monad u v)
+	, Covariant (->) (->) (Schematic Monad u (v :> w))
+	, Covariant (->) (->) (Schematic Monad v w)
 	, Hoistable ((:>) (t :> u :> v))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -323,10 +324,10 @@
 	adapt = hoist (hoist (hoist adapt))
 
 instance
-	( Covariant x (->) (->)
-	, Covariant (Schematic Monad u (v :> (w :> x))) (->) (->)
-	, Covariant (Schematic Monad v (w :> x)) (->) (->)
-	, Covariant (Schematic Monad w x) (->) (->)
+	( Covariant (->) (->) x
+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> x)))
+	, Covariant (->) (->) (Schematic Monad v (w :> x))
+	, Covariant (->) (->) (Schematic Monad w x)
 	, Hoistable ((:>) (t :> u :> v))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -337,11 +338,11 @@
 	adapt = hoist (hoist (hoist (hoist adapt)))
 
 instance
-	( Covariant y (->) (->)
-	, Covariant (Schematic Monad u (v :> (w :> (x :> y)))) (->) (->)
-	, Covariant (Schematic Monad v (w :> (x :> y))) (->) (->)
-	, Covariant (Schematic Monad w (x :> y)) (->) (->)
-	, Covariant (Schematic Monad x y) (->) (->)
+	( Covariant (->) (->) y
+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> (x :> y))))
+	, Covariant (->) (->) (Schematic Monad v (w :> (x :> y)))
+	, Covariant (->) (->) (Schematic Monad w (x :> y))
+	, Covariant (->) (->) (Schematic Monad x y)
 	, Hoistable ((:>) (t :> u :> v :> w))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -353,12 +354,12 @@
 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))
 
 instance
-	( Covariant z (->) (->)
-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z))))) (->) (->)
-	, Covariant (Schematic Monad v (w :> (x :> (y :> z)))) (->) (->)
-	, Covariant (Schematic Monad w (x :> (y :> z))) (->) (->)
-	, Covariant (Schematic Monad x (y :> z)) (->) (->)
-	, Covariant (Schematic Monad y z) (->) (->)
+	( Covariant (->) (->) z
+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> (x :> (y :> z)))))
+	, Covariant (->) (->) (Schematic Monad v (w :> (x :> (y :> z))))
+	, Covariant (->) (->) (Schematic Monad w (x :> (y :> z)))
+	, Covariant (->) (->) (Schematic Monad x (y :> z))
+	, Covariant (->) (->) (Schematic Monad y z)
 	, Hoistable ((:>) (t :> u :> v :> w))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -372,13 +373,13 @@
 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))
 
 instance
-	( Covariant f (->) (->)
-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f)))))) (->) (->)
-	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> f))))) (->) (->)
-	, Covariant (Schematic Monad w (x :> (y :> (z :> f)))) (->) (->)
-	, Covariant (Schematic Monad x (y :> (z :> f))) (->) (->)
-	, Covariant (Schematic Monad y (z :> f)) (->) (->)
-	, Covariant (Schematic Monad z f) (->) (->)
+	( Covariant (->) (->) f
+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f))))))
+	, Covariant (->) (->) (Schematic Monad v (w :> (x :> (y :> (z :> f)))))
+	, Covariant (->) (->) (Schematic Monad w (x :> (y :> (z :> f))))
+	, Covariant (->) (->) (Schematic Monad x (y :> (z :> f)))
+	, Covariant (->) (->) (Schematic Monad y (z :> f))
+	, Covariant (->) (->) (Schematic Monad z f)
 	, Hoistable ((:>) (t :> u :> v :> w))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
@@ -393,14 +394,14 @@
 	adapt = hoist (hoist (hoist (hoist (hoist (hoist adapt)))))
 
 instance
-	( Covariant h (->) (->)
-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h))))))) (->) (->)
-	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h)))))) (->) (->)
-	, Covariant (Schematic Monad w (x :> (y :> (z :> (f :> h))))) (->) (->)
-	, Covariant (Schematic Monad x (y :> (z :> (f :> h)))) (->) (->)
-	, Covariant (Schematic Monad y (z :> (f :> h))) (->) (->)
-	, Covariant (Schematic Monad z (f :> h)) (->) (->)
-	, Covariant (Schematic Monad f h) (->) (->)
+	( Covariant (->) (->) h
+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h)))))))
+	, Covariant (->) (->) (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h))))))
+	, Covariant (->) (->) (Schematic Monad w (x :> (y :> (z :> (f :> h)))))
+	, Covariant (->) (->) (Schematic Monad x (y :> (z :> (f :> h))))
+	, Covariant (->) (->) (Schematic Monad y (z :> (f :> h)))
+	, Covariant (->) (->) (Schematic Monad z (f :> h))
+	, Covariant (->) (->) (Schematic Monad f h)
 	, Hoistable ((:>) (t :> u :> v :> w))
 	, Hoistable (Schematic Monad t)
 	, Hoistable (Schematic Monad u)
diff --git a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
@@ -22,38 +22,38 @@
 	(=||) :: Interpreted u => (t a -> u b) -> Primary t a -> Primary u b
 	(=||) f = run . f . unite
 
-	(<$||=) :: (Covariant j (->) (->), Interpreted u)
+	(<$||=) :: (Covariant (->) (->) j, Interpreted u)
 		=> (Primary t a -> Primary u b) -> j := t a -> j := u b
 	f <$||= x = (f ||=) -<$>- x
 
-	(<$$||=) :: (Covariant j (->) (->), Covariant k (->) (->), Interpreted u)
+	(<$$||=) :: (Covariant (->) (->) j, Covariant (->) (->) k, Interpreted u)
 		=> (Primary t a -> Primary u b) -> j :. k := t a -> j :. k := u b
 	f <$$||= x = (f ||=) -<$$>- x
 
-	(<$$$||=) :: (Covariant j (->) (->), Covariant k (->) (->), Covariant l (->) (->), Interpreted u)
+	(<$$$||=) :: (Covariant (->) (->) j, Covariant (->) (->) k, Covariant (->) (->) l, Interpreted u)
 		=> (Primary t a -> Primary u b) -> j :. k :. l := t a -> j :. k :. l := u b
 	f <$$$||= x = (f ||=) -<$$$>- x
 
-	(<$$$$||=) :: (Covariant j (->) (->), Covariant k (->) (->), Covariant l (->) (->), Covariant m (->) (->), Interpreted u)
+	(<$$$$||=) :: (Covariant (->) (->) j, Covariant (->) (->) k, Covariant (->) (->) l, Covariant (->) (->) m, Interpreted u)
 		=> (Primary t a -> Primary u b) -> j :. k :. l :. m := t a -> j :. k :. l :. m := u b
 	f <$$$$||= x = (f ||=) -<$$$$>- x
 
-	(=||$>) :: (Covariant j (->) (->), Interpreted u)
+	(=||$>) :: (Covariant (->) (->) j, Interpreted u)
 		=> (t a -> u b) -> j := Primary t a -> j := Primary u b
 	f =||$> x = (f =||) -<$>- x
 
-	(=||$$>) :: (Covariant j (->) (->), Covariant k (->) (->), Interpreted u)
+	(=||$$>) :: (Covariant (->) (->) j, Covariant (->) (->) k, Interpreted u)
 		=> (t a -> u b) -> j :. k := Primary t a -> j :. k := Primary u b
 	f =||$$> x = (f =||) -<$$>- x
 
-	(=||$$$>) :: (Covariant j (->) (->), Covariant k (->) (->), Covariant l (->) (->), Interpreted u)
+	(=||$$$>) :: (Covariant (->) (->) j, Covariant (->) (->) k, Covariant (->) (->) l, Interpreted u)
 		=> (t a -> u b) -> j :. k :. l := Primary t a -> j :. k :. l := Primary u b
 	f =||$$$> x = (f =||) -<$$$>- x
 
-	(=||$$$$>) :: (Covariant j (->) (->), Covariant k (->) (->), Covariant l (->) (->), Covariant m (->) (->), Interpreted u)
+	(=||$$$$>) :: (Covariant (->) (->) j, Covariant (->) (->) k, Covariant (->) (->) l, Covariant (->) (->) m, Interpreted u)
 		=> (t a -> u b) -> j :. k :. l :. m := Primary t a -> j :. k :. l :. m := Primary u b
 	f =||$$$$> x = (f =||) -<$$$$>- x
 
-(-=:) :: (Liftable t, Interpreted (t u), Interpreted (t v), Covariant u (->) (->))
+(-=:) :: (Liftable (->) t, Interpreted (t u), Interpreted (t v), Covariant (->) (->) u)
 	=> (t u a -> t v b) -> u a -> Primary (t v) b
 (-=:) f = run . f . lift
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
@@ -6,9 +6,8 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -17,42 +16,41 @@
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (Extractable_, point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 
 class Interpreted t => Comonadic t where
 	{-# MINIMAL bring #-}
-	bring :: Extractable u (->) => t :< u ~> t
+	bring :: Extractable_ u => t :< u ~> t
 
 infixr 3 :<
 newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }
 
-instance Covariant (Schematic Comonad t u) (->) (->) => Covariant (t :< u) (->) (->) where
+instance Covariant (->) (->) (Schematic Comonad t u) => Covariant (->) (->) (t :< u) where
 	f -<$>- TC x = TC $ f -<$>- x
 
-instance Pointable (Schematic Comonad t u) (->) => Pointable (t :< u) (->) where
-	point = TC . point
-
-instance Extractable (Schematic Comonad t u) (->) => Extractable (t :< u) (->) where
-	extract = extract . tc
+instance Semimonoidal (->) (:*:) (:*:) (Schematic Comonad t u) => Semimonoidal (->) (:*:) (:*:) (t :< u) where
+	multiply (TC f :*: TC x) = TC $ multiply $ f :*: x
 
-instance Semimonoidal (Schematic Comonad t u) (->) (:*:) (:*:) => Semimonoidal (t :< u) (->) (:*:) (:*:) where
-	multiply_ (TC f :*: TC x) = TC $ multiply_ $ f :*: x
+instance Monoidal (->) (->) (:*:) (:*:) (Schematic Comonad t u) => Monoidal (->) (->) (:*:) (:*:) (t :< u) where
+	unit _ f = TC . point $ f One
 
-instance Traversable (Schematic Comonad t u) (->) (->) => Traversable (t :< u) (->) (->) where
+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
+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
+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
+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
+instance Lowerable (->) (Schematic Comonad t) => Lowerable (->) ((:<) t) where
 	lower (TC x) = lower x
 
 instance Hoistable (Schematic Comonad t) => Hoistable ((:<) t) where
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
@@ -6,9 +6,8 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -17,42 +16,41 @@
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 
 class Interpreted t => Monadic t where
 	{-# MINIMAL wrap #-}
-	wrap :: Pointable u (->) => t ~> t :> u
+	wrap :: Monoidal (->) (->) (:*:) (:*:) u => t ~> t :> u
 
 infixr 3 :>
 newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
 
-instance Covariant (Schematic Monad t u) (->) (->) => Covariant (t :> u) (->) (->) where
+instance Covariant (->) (->) (Schematic Monad t u) => Covariant (->) (->) (t :> u) where
 	f -<$>- TM x = TM $ f -<$>- x
 
-instance Pointable (Schematic Monad t u) (->) => Pointable (t :> u) (->) where
-	point = TM . point
-
-instance Extractable (Schematic Monad t u) (->) => Extractable (t :> u) (->) where
-	extract = extract . tm
+instance Semimonoidal (->) (:*:) (:*:) (Schematic Monad t u) => Semimonoidal (->) (:*:) (:*:) (t :> u) where
+	multiply (TM f :*: TM x) = TM $ multiply $ f :*: x
 
-instance Semimonoidal (Schematic Monad t u) (->) (:*:) (:*:) => Semimonoidal (t :> u) (->) (:*:) (:*:) where
-	multiply_ (TM f :*: TM x) = TM $ multiply_ $ f :*: x
+instance Monoidal (->) (->) (:*:) (:*:) (Schematic Monad t u) => Monoidal (->) (->) (:*:) (:*:) (t :> u) where
+	unit _ f = TM . point $ f One
 
-instance Traversable (Schematic Monad t u) (->) (->) => Traversable (t :> u) (->) (->) where
+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
+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
+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
+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), Monoidal (->) (->) (:*:) (:*:) (Schematic Monad t u), Bindable (->) (t :> u)) => Monad (t :> u) where
 
-instance Liftable (Schematic Monad t) => Liftable ((:>) t) where
+instance Liftable (->) (Schematic Monad t) => Liftable (->) ((:>) t) where
 	lift = TM . lift
 
 instance Hoistable (Schematic Monad t) => Hoistable ((:>) t) where
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,9 +2,11 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (!..))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Primary.Algebraic (point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
 
@@ -41,22 +43,22 @@
 yield v = Continuation $ \next -> Pipe $ \i (Consumer o) -> o v # pause next i
 
 -- | Pipeline that does nothing
-finish :: Pointable t (->) => Pipeline i o t () ()
+finish :: Monoidal (->) (->) (:*:) (:*:) t => Pipeline i o t () ()
 finish = Continuation (Pipe (point () !..) !.)
 
 -- | Do some effectful computation within pipeline
-impact :: Bindable t (->) => t a -> Pipeline i o t a a
+impact :: 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 () ()
+(=*=) :: forall i e o t . Monoidal (->) (->) (:*:) (:*:) t => Pipeline i e t () () -> Pipeline e o t () () -> Pipeline i o t () ()
 p =*= q = Continuation $ \_ -> Pipe $ \i -> pipe # run q end # pause (run p end !.) i where
 
 	end :: b -> Pipe c d () t ()
 	end _ = Pipe (point () !..)
 
 -- | Run pipeline and get result
-pipeline :: Pointable t (->) => Pipeline i o t () () -> t ()
+pipeline :: Monoidal (->) (->) (:*:) (:*:) t => Pipeline i o t () () -> t ()
 pipeline p = pipe # run p (Pipe . (!..) . point) # i # o where
 
 	i :: Producer i t ()
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -15,26 +15,26 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#), identity)
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))
+import Pandora.Paradigm.Primary.Algebraic (extract)
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 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
+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
+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
+instance Adjoint (->) (->) (Equipment e) (Environment e) where
 	f -| x = Environment $ f . Equipment -| x
 	g |- x = run . g |- run x
 
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
@@ -5,13 +5,13 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Monoid (Monoid)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic (point)
 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))
@@ -19,17 +19,14 @@
 
 newtype Accumulator e a = Accumulator (e :*: a)
 
-instance Covariant (Accumulator e) (->) (->) where
+instance Covariant (->) (->) (Accumulator e) where
 	f -<$>- Accumulator x = Accumulator $ f -<$>- x
 
-instance Semigroup e => Semimonoidal (Accumulator e) (->) (:*:) (:*:) where
-	multiply_ (x :*: y) = Accumulator $ k # run x # run y where
+instance Semigroup e => Semimonoidal (->) (:*:) (:*:) (Accumulator e) where
+	multiply (x :*: y) = Accumulator $ k # run x # run y where
 		k ~(ex :*: x') ~(ey :*: y') = ex + ey :*: x' :*: y'
 
-instance Monoid e => Pointable (Accumulator e) (->) where
-	point = Accumulator . (zero :*:)
-
-instance Semigroup e => Bindable (Accumulator e) (->) where
+instance Semigroup e => Bindable (->) (Accumulator e) where
 	f =<< Accumulator (e :*: x) = let e' :*: b = run $ f x in
 		Accumulator $ e + e':*: b
 
@@ -44,12 +41,6 @@
 	wrap = TM . UT . point . run
 
 type Accumulated e t = Adaptable (Accumulator e) t
-
-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
-	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
@@ -6,15 +6,17 @@
 import Pandora.Pattern.Category (identity, ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 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.Algebraic.Exponential ((!.), (%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Algebraic ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point)
 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))
@@ -23,27 +25,27 @@
 
 newtype Environment e a = Environment (e -> a)
 
-instance Covariant (Environment e) (->) (->) where
+instance Covariant (->) (->) (Environment e) where
 	f -<$>- Environment x = Environment $ f . x
 
-instance Contravariant (Flip Environment a) (->) (->) where
+instance Contravariant (->) (->) (Flip Environment a) where
 	f ->$<- Flip (Environment g) = Flip . Environment $ g . f
 
-instance Pointable (Environment e) (->) where
-	point x = Environment (x !.)
+instance Semimonoidal (->) (:*:) (:*:) (Environment e) where
+	multiply (x :*: y) = unite $ multiply $ run x :*: run y
 
-instance Semimonoidal (Environment e) (->) (:*:) (:*:) where
-	multiply_ (x :*: y) = unite $ multiply_ $ run x :*: run y
+instance Monoidal (->) (->) (:*:) (:*:) (Environment e) where
+	unit _ f = Environment $ \_ -> f One
 
-instance Distributive (Environment e) (->) (->) where
+instance Distributive (->) (->) (Environment e) where
 	f -<< g = Environment $ (run -<$>- f) -<< g
 
-instance Bindable (Environment e) (->) where
+instance Bindable (->) (Environment e) where
 	f =<< Environment x = Environment $ \e -> (run % e) . f . x $ e
 
-instance Monad (Environment e) where
+--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
@@ -54,7 +56,7 @@
 type instance Schematic Monad (Environment e) = (<:.>) ((->) e)
 
 instance Monadic (Environment e) where
-	wrap x = TM . TU $ point @_ @(->) -<$>- run x
+	wrap x = TM . TU $ point -<$>- run x
 
 type Configured e = Adaptable (Environment e)
 
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,29 +5,24 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.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.Comonad (Comonad)
 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))
 import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 
 newtype Equipment e a = Equipment (e :*: a)
 
-instance Covariant (Equipment e) (->) (->) where
+instance Covariant (->) (->) (Equipment e) where
 	f -<$>- Equipment x = Equipment $ f -<$>- x
 
-instance Extractable (Equipment e) (->) where
-	extract = extract . run
-
-instance Traversable (Equipment e) (->) (->) where
+instance Traversable (->) (->) (Equipment e) where
 	f <<- Equipment x = Equipment -<$>- f <<- x
 
-instance Extendable (Equipment e) (->) where
+instance Extendable (->) (Equipment e) where
 	f <<= Equipment (e :*: x) = Equipment . (:*:) e . f . Equipment $ e :*: x
 
 instance Interpreted (Equipment e) where
@@ -37,15 +32,10 @@
 
 type instance Schematic Comonad (Equipment e) = (<:.>) ((:*:) e)
 
-instance Comonadic (Equipment e) where
-	bring (TC (TU x)) = Equipment $ extract @_ @(->) -<$>- x
-
 type Equipped e t = Adaptable t (Equipment e)
 
-instance {-# OVERLAPS #-} Extendable u (->) => Extendable ((:*:) e <:.> u) (->) where
+instance {-# OVERLAPS #-} Extendable (->) u => Extendable (->) ((:*:) e <:.> u) where
 	f <<= TU (e :*: x) = TU . (:*:) e $ f . TU . (:*:) e <<= x
-
-instance Comonad (Equipment e) (->) where
 
 retrieve :: Equipped e t => t a -> e
 retrieve = attached . run @(Equipment _) . adapt
diff --git a/Pandora/Paradigm/Inventory/Imprint.hs b/Pandora/Paradigm/Inventory/Imprint.hs
--- a/Pandora/Paradigm/Inventory/Imprint.hs
+++ b/Pandora/Paradigm/Inventory/Imprint.hs
@@ -6,38 +6,32 @@
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.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.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.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)
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
 
 newtype Imprint e a = Imprint (e -> a)
 
-instance Covariant (Imprint e) (->) (->) where
+instance Covariant (->) (->) (Imprint e) where
 	f -<$>- Imprint g = Imprint $ f . g
 
-instance Contravariant (Flip Imprint a) (->) (->) where
+instance Contravariant (->) (->) (Flip Imprint a) where
 	f ->$<- Flip (Imprint g) = Flip . Imprint $ g . f
 
-instance Distributive (Imprint e) (->) (->) where
+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
+instance Semigroup e => Extendable (->) (Imprint e) where
 	f <<= Imprint x = Imprint $ \e -> f $ Imprint $ x . (e +)
 
 instance Interpreted (Imprint e) where
@@ -47,10 +41,7 @@
 
 type instance Schematic Comonad (Imprint e) = (<.:>) ((->) e)
 
-instance Monoid e => Comonadic (Imprint e) where
-	bring (TC (UT x)) = Imprint . extract $ x
-
-instance {-# OVERLAPS #-} (Semigroup e, Extendable u (->)) => Extendable ((->) e <.:> u) (->) where
+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
@@ -6,7 +6,6 @@
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (Category (identity, ($), (#)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
@@ -14,7 +13,7 @@
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))
-import Pandora.Paradigm.Primary.Algebraic (($>-))
+import Pandora.Paradigm.Primary.Algebraic (($>-), extract)
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
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,8 +7,8 @@
 import Pandora.Pattern.Category (identity, ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -21,29 +21,31 @@
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))
 import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (*>-), delta)
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point)
 
 -- | Effectful computation with a variable
 newtype State s a = State ((->) s :. (:*:) s := a)
 
-instance Covariant (State s) (->) (->) where
+instance Covariant (->) (->) (State s) where
 	f -<$>- x = State $ (-<$>-) f . run x
 
-instance Semimonoidal (State s) (->) (:*:) (:*:) where
-	multiply_ (State g :*: State h) = State $ \s -> 
+instance Semimonoidal (->) (:*:) (:*:) (State s) where
+	multiply (State g :*: State h) = State $ \s -> 
 		let old :*: x = g s in 
 	  	let new :*: y = h old in
 		new :*: x :*: y
 
-instance Pointable (State s) (->) where
-	point = State . (identity @(->) -|)
+instance Monoidal (->) (->) (:*:) (:*:) (State s) where
+	unit _ f = State . (identity @(->) -|) $ f One
 
-instance Bindable (State s) (->) where
+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
@@ -53,7 +55,7 @@
 type instance Schematic Monad (State s) = (->) s <:<.>:> (:*:) s
 
 instance Monadic (State s) where
-	wrap x = TM . TUT $ point @_ @(->) -<$>- run x
+	wrap x = TM . TUT $ point -<$>- run x
 
 type Stateful s = Adaptable (State s)
 
@@ -69,10 +71,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 :: (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 (->), Semimonoidal t (->) (:*:) (:*:), Stateful s t)
+type Memorable s t = (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t,  Stateful s t)
 
-fold :: (Traversable t (->) (->), Memorable s u) => (a -> s -> s) -> t a -> u s
+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
@@ -6,16 +6,17 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 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.Algebraic.Exponential ((%), (-.#..-))
+import Pandora.Pattern.Functor.Adjoint ((-|))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), (%), (!.), (-.#..-))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
-import Pandora.Paradigm.Primary.Algebraic ()
+import Pandora.Paradigm.Primary.Algebraic (extract)
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic)
@@ -25,19 +26,24 @@
 -- | Context based computation on value
 newtype Store s a = Store ((:*:) s :. (->) s := a)
 
-instance Covariant (Store s) (->) (->) where
+instance Covariant (->) (->) (Store s) where
 	f -<$>- Store x = Store $ f -<$$>- x
 
-instance Extractable (Store s) (->) where
-	extract = (($) |-) . run
+instance Semimonoidal (<--) (:*:) (:*:) (Store s) where
+	multiply = Flip $ \(Store (s :*: f)) -> 
+		let (x :*: y) = f s in
+		Store (s :*: (x !.)) :*: Store (s :*: (y !.))
 
-instance Extendable (Store s) (->) where
+instance Monoidal (<--) (->) (:*:) (:*:) (Store s) where
+	unit _ = Flip $ \(Store (s :*: f)) -> (\_ -> f s)
+
+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
@@ -10,10 +10,9 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (Category (($), (#), identity))
+import Pandora.Pattern.Category (Category (($), (#)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-), (-|)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
@@ -23,16 +22,7 @@
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into), premorph)
 import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Available, Substance, substructure))
 
-instance Semigroupoid (Flip (->)) where
-	Flip f . Flip g = Flip $ \x -> g (f x)
-
-instance Category (Flip (->)) where
-	identity = Flip identity
-
-instance Extractable (Flip (:*:) a) (->) where
-	extract (Flip (x :*: _)) = x
-
-instance Adjoint (Flip (:*:) s) ((->) s) (->) (->) where
+instance Adjoint (->) (->) (Flip (:*:) s) ((->) s) where
 	f -| x = \s -> f $ Flip $ x :*: s
 	f |- Flip (x :*: s) = f x s
 
@@ -99,16 +89,16 @@
 	type Available Left Wye = Maybe
 	type Substance Left Wye = Identity
 	substructure = P_Q_T $ \new -> case lower new of
-		End -> Store $ Nothing :*: lift . resolve Left End . (extract @_ @(->) -<$>-)
-		Left x -> Store $ Just (Identity x) :*: lift . resolve Left End . (extract @_ @(->) -<$>-)
-		Right y -> Store $ Nothing :*: (lift # Right y !.) . (extract @_ @(->) -<$>-)
-		Both x y -> Store $ Just (Identity x) :*: lift . resolve (Both % y) (Right y) . (extract @_ @(->) -<$>-)
+		End -> Store $ Nothing :*: lift . resolve Left End . (extract -<$>-)
+		Left x -> Store $ Just (Identity x) :*: lift . resolve Left End . (extract -<$>-)
+		Right y -> Store $ Nothing :*: (lift # Right y !.) . (extract -<$>-)
+		Both x y -> Store $ Just (Identity x) :*: lift . resolve (Both % y) (Right y) . (extract -<$>-)
 
 instance Substructure Right Wye where
 	type Available Right Wye = Maybe
 	type Substance Right Wye = Identity
 	substructure = P_Q_T $ \new -> case lower new of
-		End -> Store $ Nothing :*: lift . resolve Right End . (extract @_ @(->) -<$>-)
-		Left x -> Store $ Nothing :*: (lift # Left x !.) . (extract @_ @(->) -<$>-)
-		Right y -> Store $ Just (Identity y) :*: lift . resolve Right End . (extract @_ @(->) -<$>-)
-		Both x y -> Store $ Just (Identity y) :*: lift . resolve (Both x) (Left x) . (extract @_ @(->) -<$>-)
+		End -> Store $ Nothing :*: lift . resolve Right End . (extract -<$>-)
+		Left x -> Store $ Nothing :*: (lift # Left x !.) . (extract -<$>-)
+		Right y -> Store $ Just (Identity y) :*: lift . resolve Right End . (extract -<$>-)
+		Both x y -> Store $ Just (Identity y) :*: lift . resolve (Both x) (Left x) . (extract -<$>-)
diff --git a/Pandora/Paradigm/Primary/Algebraic.hs b/Pandora/Paradigm/Primary/Algebraic.hs
--- a/Pandora/Paradigm/Primary/Algebraic.hs
+++ b/Pandora/Paradigm/Primary/Algebraic.hs
@@ -1,60 +1,108 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Primary.Algebraic (module Exports, Applicative_, Alternative_, ($>-), ($$>-), ($$$>-), (-<*>-), (*>-), forever_, (-+-)) where
+module Pandora.Paradigm.Primary.Algebraic (module Exports, Applicative_, Alternative_, Extractable_, ($>-), ($$>-), ($$$>-), (-<*>-), (*>-), forever_, (-+-), void, empty, point, extract) where
 
 import Pandora.Paradigm.Primary.Algebraic.Exponential as Exports
 import Pandora.Paradigm.Primary.Algebraic.Product as Exports
 import Pandora.Paradigm.Primary.Algebraic.Sum as Exports
+import Pandora.Paradigm.Primary.Algebraic.Zero as Exports
+import Pandora.Paradigm.Primary.Algebraic.One as Exports
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor (Endofunctor)
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-), (-<$$$>-))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit), Unit)
+import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Paradigm.Primary.Functor.Proxy (Proxy (Proxy))
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
+type instance Unit (:*:) = One
+type instance Unit (:+:) = Zero
+
 infixl 4 -<*>-
 
-($>-) :: Covariant t (->) (->) => t a -> b -> t b
+($>-) :: Covariant (->) (->) t => t a -> b -> t b
 x $>- r = (r !.) -<$>- x
 
-($$>-) :: (Covariant t (->) (->), Covariant u (->) (->)) => t (u a) -> b -> t (u b)
+($$>-) :: (Covariant (->) (->) t, Covariant (->) (->) u) => t (u a) -> b -> t (u b)
 x $$>- r = (r !.) -<$$>- x
 
-($$$>-) :: (Covariant t (->) (->), Covariant u (->) (->), Covariant v (->) (->)) => t (u (v a)) -> b -> t (u (v b))
+($$$>-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Covariant (->) (->) v) => t (u (v a)) -> b -> t (u (v b))
 x $$$>- r = (r !.) -<$$$>- x
 
-instance Traversable ((:*:) s) (->) (->) where
+void :: Covariant (->) (->) t => t a -> t ()
+void x = x $>- ()
+
+instance Traversable (->) (->) ((:*:) s) where
 	f <<- x = (attached x :*:) -<$>- f (extract x)
 
-instance Adjoint ((:*:) s) ((->) s) (->) (->) where
+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
 
-instance Semimonoidal ((->) e) (->) (:*:) (:*:) where
-	multiply_ :: ((e -> a) :*: (e -> b)) -> e -> (a :*: b)
-	multiply_ (g :*: h) = \x -> g x :*: h x
+instance Semimonoidal (->) (:*:) (:*:) ((->) e) where
+	multiply :: ((e -> a) :*: (e -> b)) -> e -> (a :*: b)
+	multiply (g :*: h) = \x -> g x :*: h x
 
-instance Semimonoidal ((:+:) e) (->) (:*:) (:+:) where
-	multiply_ :: ((e :+: a) :*: (e :+: b)) -> e :+: a :+: b
-	multiply_ (Option _ :*: Option e') = Option e'
-	multiply_ (Option _ :*: Adoption y) = Adoption $ Adoption y
-	multiply_ (Adoption x :*: _) = Adoption $ Option x
+instance Semimonoidal (<--) (:*:) (:*:) ((->) e) where
+	multiply = Flip $ \f -> (\e -> attached $ f e) :*: (\e -> extract $ f e)
 
-type Applicative_ t = (Endofunctor Covariant t (->), Semimonoidal t (->) (:*:) (:*:))
-type Alternative_ t = (Endofunctor Covariant t (->), Semimonoidal t (->) (:*:) (:+:))
+instance Semimonoidal (->) (:*:) (:+:) ((:+:) e) where
+	multiply :: ((e :+: a) :*: (e :+: b)) -> e :+: a :+: b
+	multiply (Option _ :*: Option e') = Option e'
+	multiply (Option _ :*: Adoption y) = Adoption $ Adoption y
+	multiply (Adoption x :*: _) = Adoption $ Option x
 
-(-<*>-) :: Applicative_ t => t (a -> b) -> t a -> t b
-f -<*>- x = (|-) @_ @_ @(->) @(->) (&) -<$>- multiply_ @_ @_ @_ @(:*:) (f :*: x)
+instance Semimonoidal (->) (:*:) (:*:) ((:+:) e) where
+	multiply (Adoption x :*: Adoption y) = Adoption $ x :*: y
+	multiply (Option e :*: _) = Option e
+	multiply (_ :*: Option e) = Option e
 
-forever_ :: Applicative_ t => t a -> t b
+instance Monoidal (->) (->) (:*:) (:*:) ((:+:) e) where
+	unit _ f = Adoption $ f One
+
+instance Semimonoidal (<--) (:*:) (:*:) ((:*:) s) where
+	multiply = Flip $ \(s :*: x :*: y) -> (s :*: x) :*: (s :*: y)
+
+instance Monoidal (<--) (->) (:*:) (:*:) ((:*:) s) where
+	unit _ = Flip $ \(_ :*: x) -> (\_ -> x)
+
+instance Comonad ((:*:) s) (->) where
+
+instance Semimonoidal (<--) (:*:) (:*:) (Flip (:*:) a) where
+	multiply = Flip $ \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
+
+instance Monoidal (<--) (->) (:*:) (:*:) (Flip (:*:) a) where
+	unit _ = Flip $ \(Flip (s :*: _)) -> (\_ -> s)
+
+type Applicative_ t = (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t, Monoidal (->) (->) (:*:) (:*:) t)
+type Alternative_ t = (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:+:) t, Monoidal (->) (->) (:*:) (:+:) t)
+
+(-<*>-) :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t)
+	=> t (a -> b) -> t a -> t b
+f -<*>- x = (|-) @(->) @(->) (&) -<$>- multiply @_ @_ @(:*:) (f :*: x)
+
+forever_ :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => t a -> t b
 forever_ x = let r = x *>- r in r
 
-(*>-) :: Applicative_ t => t a -> t b -> t b
+(*>-) :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => t a -> t b -> t b
 x *>- y = ((!.) %) -<$>- x -<*>- y
 
-(-+-) :: Alternative_ t => t a -> t b -> (a :+: b -> r) -> t r
-x -+- y = \f -> f -<$>- multiply_ (x :*: y)
+(-+-) :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:+:) t)
+	  => t a -> t b -> (a :+: b -> r) -> t r
+x -+- y = \f -> f -<$>- multiply (x :*: y)
+
+point :: Monoidal (->) (->) (:*:) (:*:) t => a -> t a
+point x = unit (Proxy @(:*:)) (\One -> x)
+
+empty :: Monoidal (->) (->) (:*:) (:+:) t => t a
+empty = unit (Proxy @(:*:)) absurd
+
+type Extractable_ t = Monoidal (<--) (->) (:*:) (:*:) t
+
+extract :: Extractable_ t => t a -> a
+extract j = let Flip f = unit @(<--) @(->) @(:*:) @(:*:) Proxy in f j $ One
diff --git a/Pandora/Paradigm/Primary/Algebraic/Exponential.hs b/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
--- a/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
+++ b/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
@@ -7,9 +7,7 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
 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 ((*)))
@@ -26,26 +24,15 @@
 instance Category (->) where
 	identity x = x
 
-instance Covariant ((->) a) (->) (->) where
+instance Covariant (->) (->) ((->) a) where
 	(-<$>-) = (.)
 
-instance Contravariant (Flip (->) a) (->) (->) where
-	f ->$<- Flip g = Flip $ g . f
-
-instance Distributive ((->) e) (->) (->) where
+instance Distributive (->) (->) ((->) e) where
 	f -<< g = \e -> (f % e) -<$>- g
 
-instance Pointable ((->) e) (->) where
-	point = (!.)
-
-instance Bindable ((->) e) (->) where
+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
 
@@ -55,7 +42,18 @@
 instance Ringoid r => Ringoid (e -> r) where
 	f * g = \e -> f e * g e
 
-(-.#..-) :: (Covariant (v a) (->) target, Semigroupoid v) => v c d -> target (v a (v b c)) (v a (v b d))
+type (<--) = Flip (->)
+
+instance Semigroupoid (<--) where
+	Flip f . Flip g = Flip $ \x -> g (f x)
+
+instance Category (<--) where
+	identity = Flip identity
+
+instance Contravariant (->) (->) ((<--) a) where
+	f ->$<- Flip g = Flip $ g . f
+
+(-.#..-) :: (Covariant (->) target (v a), Semigroupoid v) => v c d -> target (v a (v b c)) (v a (v b d))
 (-.#..-) f = (-<$>-) (f .)
 
 {-# INLINE (!.) #-}
diff --git a/Pandora/Paradigm/Primary/Algebraic/One.hs b/Pandora/Paradigm/Primary/Algebraic/One.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Algebraic/One.hs
@@ -0,0 +1,3 @@
+module Pandora.Paradigm.Primary.Algebraic.One where
+
+data One = One
diff --git a/Pandora/Paradigm/Primary/Algebraic/Product.hs b/Pandora/Paradigm/Primary/Algebraic/Product.hs
--- a/Pandora/Paradigm/Primary/Algebraic/Product.hs
+++ b/Pandora/Paradigm/Primary/Algebraic/Product.hs
@@ -3,10 +3,8 @@
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
 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 ((+)))
@@ -16,6 +14,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.Algebraic.Exponential (type (<--))
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 
@@ -23,51 +22,55 @@
 
 data (:*:) s a = s :*: a
 
-instance Covariant ((:*:) s) (->) (->) where
-	f -<$>- x = attached x :*: f # extract x
+instance Covariant (->) (->) ((:*:) s) where
+	f -<$>- ~(s :*: x) = s :*: f x
 
-instance Covariant (Flip (:*:) a) (->) (->) where
+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 Extendable (->) ((:*:) s) where
+	f <<= ~(s :*: x) = s :*: f (s :*: x)
 
-instance Bivariant (:*:) (->) (->) (->) 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)
+	~(sx :*: x) == ~(sy :*: y) = (sx == sy) * (x == y)
 
 instance (Semigroup s, Semigroup a) => Semigroup (s :*: a) where
-	x + y = attached x + attached y :*: extract x + extract y
+	~(sx :*: x) + ~(sy :*: y) = sx + sy :*: x + 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
+	~(sx :*: x) * ~(sy :*: y) = sx * sy :*: x * 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
+	~(sx :*: x) /\ ~(sy :*: y) = sx /\ sy :*: x /\ y
 
 instance (Supremum s, Supremum a) => Supremum (s :*: a) where
-	x \/ y = attached x \/ attached y :*: extract x \/ extract y
+	~(sx :*: x) \/ ~(sy :*: y) = sx \/ sy :*: x \/ 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
+	invert ~(s :*: x) = invert # s :*: invert # x
 
-instance {-# OVERLAPS #-} Semimonoidal t (->) (:*:) (:*:) => Semimonoidal (t <:.:> t := (:*:)) (->) (:*:) (:*:) where
-	multiply_ (T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) = T_U $ multiply_ (xls :*: yls) :*: multiply_ (xrs :*: yrs)
+instance {-# OVERLAPS #-} Semimonoidal (->) (:*:) (:*:) t => Semimonoidal (->) (:*:) (:*:) (t <:.:> t := (:*:)) where
+	multiply (T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) = T_U $ multiply (xls :*: yls) :*: multiply (xrs :*: yrs)
+
+-- TODO: Generalize (:*:) as Bivariant p
+instance (Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:.:> u := (:*:)) where
+	multiply = Flip $ \(T_U (lxys :*: rxys)) ->
+		let Flip f = multiply @(<--) @(:*:) @(:*:) in
+		let Flip g = multiply @(<--) @(:*:) @(:*:) in
+		let (lxs :*: lys) = f lxys in
+		let (rxs :*: rys) = g rxys in
+		T_U (lxs :*: rxs) :*: T_U (lys :*: rys)
 
 delta :: a -> a :*: a
 delta x = x :*: x
diff --git a/Pandora/Paradigm/Primary/Algebraic/Sum.hs b/Pandora/Paradigm/Primary/Algebraic/Sum.hs
--- a/Pandora/Paradigm/Primary/Algebraic/Sum.hs
+++ b/Pandora/Paradigm/Primary/Algebraic/Sum.hs
@@ -3,7 +3,6 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
@@ -12,18 +11,19 @@
 
 data (:+:) s a = Option s | Adoption a
 
-instance Covariant ((:+:) s) (->) (->) where
+instance Covariant (->) (->) ((:+:) s) where
 	_ -<$>- Option s = Option s
 	f -<$>- Adoption x = Adoption $ f x
 
-instance Pointable ((:+:) e) (->) where
-	point = Adoption
-
-instance Bivariant (:+:) (->) (->) (->) where
+instance Bivariant (->) (->) (->) (:+:) where
 	f <-> g = \case
 		Option s -> Option $ f s
 		Adoption x -> Adoption $ g x
 
-instance Covariant (Flip (:+:) a) (->) (->) where
+instance Covariant (->) (->) (Flip (:+:) a) where
 	_ -<$>- Flip (Adoption x) = Flip $ Adoption x
 	f -<$>- Flip (Option y) = Flip . Option $ f y
+
+sum :: (e -> r) -> (a -> r) -> e :+: a -> r
+sum f _ (Option x) = f x
+sum _ s (Adoption x) = s x
diff --git a/Pandora/Paradigm/Primary/Algebraic/Zero.hs b/Pandora/Paradigm/Primary/Algebraic/Zero.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Algebraic/Zero.hs
@@ -0,0 +1,8 @@
+{-# LANGUAGE EmptyCase #-}
+
+module Pandora.Paradigm.Primary.Algebraic.Zero where
+
+data Zero
+
+absurd :: Zero -> a
+absurd x = case x of {}
diff --git a/Pandora/Paradigm/Primary/Functor.hs b/Pandora/Paradigm/Primary/Functor.hs
--- a/Pandora/Paradigm/Primary/Functor.hs
+++ b/Pandora/Paradigm/Primary/Functor.hs
@@ -1,6 +1,3 @@
-{-# LANGUAGE AllowAmbiguousTypes #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
 module Pandora.Paradigm.Primary.Functor (module Exports, Equivalence, Comparison, match) where
 
 import Pandora.Paradigm.Primary.Functor.Fix as Exports
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,10 +3,10 @@
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($), (#))
-import Pandora.Pattern.Functor (Endofunctor)
+--import Pandora.Pattern.Functor (Endofunctor)
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -23,42 +23,44 @@
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point)
 
 data Conclusion e a = Failure e | Success a
 
-instance Covariant (Conclusion e) (->) (->) where
+instance Covariant (->) (->) (Conclusion e) where
 	f -<$>- Success x = Success $ f x
 	_ -<$>- Failure y = Failure y
 
-instance Covariant (Flip Conclusion e) (->) (->) where
+instance Covariant (->) (->) (Flip Conclusion e) where
 	_ -<$>- Flip (Success x) = Flip $ Success x
 	f -<$>- Flip (Failure y) = Flip . Failure $ f y
 
-instance Pointable (Conclusion e) (->) where
-	point = Success
+instance Semimonoidal (->) (:*:) (:*:) (Conclusion e) where
+	multiply (Success x :*: Success y) = Success $ x :*: y
+	multiply (Failure x :*: _) = Failure x
+	multiply (_ :*: Failure x) = Failure x
 
-instance Semimonoidal (Conclusion e) (->) (:*:) (:*:) where
-	multiply_ (Success x :*: Success y) = Success $ x :*: y
-	multiply_ (Failure x :*: _) = Failure x
-	multiply_ (_ :*: Failure x) = Failure x
+instance Monoidal (->) (->) (:*:) (:*:) (Conclusion e) where
+	unit _ f = Success $ f One
 
-instance Semigroup e => Semimonoidal (Conclusion e) (->) (:*:) (:+:) where
-	multiply_ (Failure _ :*: x) = Adoption -<$>- x
-	multiply_ (Success x :*: _) = Option -<$>- Success x
+instance Semigroup e => Semimonoidal (->) (:*:) (:+:) (Conclusion e) where
+	multiply (Failure _ :*: x) = Adoption -<$>- x
+	multiply (Success x :*: _) = Option -<$>- Success x
 
-instance Traversable (Conclusion e) (->) (->) where
-	(<<-) :: (Endofunctor Covariant u (->), Pointable u (->), Semimonoidal u (->) (:*:) (:*:))
+instance Traversable (->) (->) (Conclusion e) where
+	(<<-) :: (Covariant (->) (->) u, Monoidal (->) (->) (:*:) (:*:) 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
+instance Bindable (->) (Conclusion e) where
 	f =<< Success x = f x
 	_ =<< Failure y = Failure y
 
-instance Monad (Conclusion e) where
+--instance Monad (Conclusion e) where
 
-instance Bivariant Conclusion (->) (->) (->) where
+instance Bivariant (->) (->) (->) Conclusion where
 	f <-> g = conclusion # Failure . f # Success . g
 
 instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where
@@ -108,6 +110,6 @@
 	catch (Failure e) handle = handle e
 	catch (Success x) _ = Success x
 
-instance (Pointable u (->), Bindable u (->)) => Catchable e (Conclusion e <.:> u) where
+instance (Monoidal (->) (->) (:*:) (:*:) u, Bindable (->) u) => Catchable e (Conclusion e <.:> u) where
 	catch (UT x) handle = let conclude = conclusion # run . handle # point . Success
 		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
@@ -20,19 +20,19 @@
 
 newtype Constant a b = Constant a
 
-instance Covariant (Constant a) (->) (->) where
+instance Covariant (->) (->) (Constant a) where
 	_ -<$>- Constant x = Constant x
 
-instance Covariant (Flip Constant b) (->) (->) where
+instance Covariant (->) (->) (Flip Constant b) where
 	f -<$>- Flip (Constant x) = Flip . Constant $ f x
 
-instance Contravariant (Constant a) (->) (->) where
+instance Contravariant (->) (->) (Constant a) where
 	_ ->$<- Constant x = Constant x
 
 instance Invariant (Constant a) where
 	_ <$< _ = \(Constant x) -> 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
@@ -6,5 +6,5 @@
 
 data Convergence r a = Convergence (a -> a -> r)
 
-instance Contravariant (Convergence r) (->) (->) where
+instance Contravariant (->) (->) (Convergence r) where
 	f ->$<- Convergence g = Convergence $ \x y -> g # f x # f y
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
@@ -2,19 +2,19 @@
 
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic (point)
 
 data Edges a = Empty | Leap a | Connect a | Overlay a
 
-instance Covariant Edges (->) (->) where
+instance Covariant (->) (->) Edges where
 	_ -<$>- Empty = Empty
 	f -<$>- Connect x = Connect $ f x
 	f -<$>- Overlay x = Overlay $ f x
 	f -<$>- Leap x = Leap $ f x
 
-instance Traversable Edges (->) (->) where
+instance Traversable (->) (->) Edges where
 	_ <<- Empty = point Empty
 	f <<- Connect x = Connect -<$>- f x
 	f <<- Overlay x = Overlay -<$>- f x
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
@@ -7,11 +7,11 @@
 
 newtype Fix t = Fix { unfix :: t (Fix t) }
 
-cata :: Covariant t (->) (->) => (a <:= t) -> Fix t -> a
+cata :: Covariant (->) (->) t => (a <:= t) -> Fix t -> a
 cata f = f . (cata f -<$>-) . unfix
 
-ana :: Covariant t (->) (->) => (a :=> t) -> a -> Fix t
+ana :: Covariant (->) (->) t => (a :=> t) -> a -> Fix t
 ana f = Fix . (ana f -<$>-) . f
 
-hylo :: Covariant t (->) (->) => (b <:= t) -> (a :=> t) -> (a -> b)
+hylo :: Covariant (->) (->) t => (b <:= t) -> (a :=> t) -> (a -> b)
 hylo phi psi = cata phi . ana psi
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,14 +3,14 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 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))
+--import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
@@ -21,38 +21,48 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (extract)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 newtype Identity a = Identity a
 
-instance Covariant Identity (->) (->) where
+instance Covariant (->) (->) Identity where
 	f -<$>- Identity x = Identity $ f x
 
-instance Pointable Identity (->) where
-	point = Identity
+instance Semimonoidal (->) (:*:) (:*:) Identity where
+	multiply (Identity x :*: Identity y) = Identity $ x :*: y
 
-instance Extractable Identity (->) where
-	extract (Identity x) = x
+instance Monoidal (->) (->) (:*:) (:*:) Identity where
+	unit _ f = Identity $ f One
 
-instance Traversable Identity (->) (->) where
+instance Semimonoidal (<--) (:*:) (:*:) Identity where
+	multiply = Flip $ \(Identity (x :*: y)) -> Identity x :*: Identity y
+
+instance Monoidal (<--) (->) (:*:) (:*:) Identity where
+	unit _ = Flip $ \(Identity x) -> (\_ -> x)
+
+instance Traversable (->) (->) Identity where
 	f <<- Identity x = Identity -<$>- f x
 
-instance Bindable Identity (->) where
+instance Bindable (->) Identity where
 	f =<< Identity x = f x	
 
 instance Monad Identity
 
-instance Extendable Identity (->) where
+instance Extendable (->) Identity where
 	f <<= x = Identity . f $ x
 
 instance Comonad Identity (->)
 
-instance Representable Identity where
-	type Representation Identity = ()
-	() <#> Identity x = x
-	tabulate f = Identity $ f ()
+--instance Representable Identity where
+	--type Representation Identity = ()
+	--() <#> Identity x = x
+	--tabulate f = Identity $ f ()
 
-instance Adjoint Identity Identity (->) (->) where
+instance Adjoint (->) (->) Identity Identity where
 	f -| x = Identity . f . Identity $ x
 	g |- x = extract . extract . (g -<$>-) $ x
 
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,8 +4,8 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -22,38 +22,50 @@
 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.Exponential (type (<--))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 data Maybe a = Nothing | Just a
 
-instance Covariant Maybe (->) (->) where
+instance Covariant (->) (->) Maybe where
 	f -<$>- Just x = Just $ f x
 	_ -<$>- Nothing = Nothing
 
-instance Pointable Maybe (->) where
-	point = Just
+instance Semimonoidal (->) (:*:) (:*:) Maybe where
+	multiply (Just x :*: Just y) = Just $ x :*: y
+	multiply (Nothing :*: _) = Nothing
+	multiply (_ :*: Nothing) = Nothing
 
-instance Semimonoidal Maybe (->) (:*:) (:*:) where
-	multiply_ (Just x :*: Just y) = Just $ x :*: y
-	multiply_ (Nothing :*: _) = Nothing
-	multiply_ (_ :*: Nothing) = Nothing
+instance Semimonoidal (->) (:*:) (:+:) Maybe where
+	multiply (Just x :*: _) = Just $ Option x
+	multiply (Nothing :*: Just y) = Just $ Adoption y
+	multiply (Nothing :*: Nothing) = Nothing
 
-instance Semimonoidal Maybe (->) (:*:) (:+:) where
-	multiply_ (Just x :*: Just _) = Just $ Option x
-	multiply_ (Nothing :*: Just y) = Just $ Adoption y
-	multiply_ (Nothing :*: Nothing) = Nothing
+instance Monoidal (->) (->) (:*:) (:*:) Maybe where
+	unit _ f = Just $ f One
 
-instance Traversable Maybe (->) (->) where
+instance Monoidal (->) (->) (:*:) (:+:) Maybe where
+	unit _ _ = Nothing
+
+-- TODO: Check laws
+instance Semimonoidal (<--) (:*:) (:*:) Maybe where
+	multiply = Flip $ \case
+		Just (x :*: y) -> Just x :*: Just y
+		Nothing -> Nothing :*: Nothing
+
+instance Traversable (->) (->) Maybe where
 	_ <<- Nothing = point Nothing
 	f <<- Just x = Just -<$>- f x
 
-instance Bindable Maybe (->) where
+instance Bindable (->) Maybe where
 	f =<< Just x = f x
 	_ =<< Nothing = Nothing
 
-instance Monad Maybe where
+--instance Monad Maybe where
 
 instance Setoid a => Setoid (Maybe a) where
 	Just x == Just y = x == y
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
@@ -15,7 +15,7 @@
 	run ~(Predicate f) = f
 	unite = Predicate
 
-instance Contravariant Predicate (->) (->) where
+instance Contravariant (->) (->) Predicate where
 	f ->$<- Predicate g = Predicate $ g . f
 
 equate :: Setoid a => a :=> Predicate
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,31 +2,27 @@
 
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
 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.Monad (Monad)
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 data Proxy a = Proxy
 
-instance Covariant Proxy (->) (->) where
+instance Covariant (->) (->) Proxy where
 	_ -<$>- Proxy = Proxy
 
-instance Contravariant Proxy (->) (->) where
+instance Contravariant (->) (->) Proxy where
 	_ ->$<- _ = Proxy
 
-instance Pointable Proxy (->) where
-	point _ = Proxy
-
-instance Distributive Proxy (->) (->) where
+instance Distributive (->) (->) Proxy where
 	_ -<< _ = Proxy
 
-instance Bindable Proxy (->) where
+instance Bindable (->) Proxy where
 	_ =<< _ = Proxy
 
-instance Monad Proxy
+--instance Monad Proxy
 
-instance Extendable Proxy (->) where
+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,8 +4,8 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -22,7 +22,10 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (extract)
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 newtype Tagged tag a = Tag a
@@ -30,35 +33,41 @@
 infixr 0 :#
 type (:#) tag = Tagged tag
 
-instance Covariant (Tagged tag) (->) (->) where
+instance Covariant (->) (->) (Tagged tag) where
 	f -<$>- Tag x = Tag $ f x
 
-instance Covariant (Flip Tagged a) (->) (->) where
+instance Covariant (->) (->) (Flip Tagged a) where
 	_ -<$>- Flip (Tag x) = Flip $ Tag x
 
-instance Pointable (Tagged tag) (->) where
-	point = Tag
+instance Semimonoidal (->) (:*:) (:*:) (Tagged tag) where
+	multiply (x :*: y) = Tag $ extract x :*: extract y
 
-instance Extractable (Tagged tag) (->) where
-	extract (Tag x) = x
+instance Monoidal (->) (->) (:*:) (:*:) (Tagged tag) where
+	unit _ f = Tag $ f One
 
-instance Traversable (Tagged tag) (->) (->) where
+instance Semimonoidal (<--) (:*:) (:*:) (Tagged tag) where
+	multiply = Flip $ \(Tag (x :*: y)) -> Tag x :*: Tag y
+
+instance Monoidal (<--) (->) (:*:) (:*:) (Tagged tag) where
+	unit _ = Flip $ \(Tag x) -> (\_ -> x)
+
+instance Traversable (->) (->) (Tagged tag) where
 	f <<- Tag x = Tag -<$>- f x
 
-instance Distributive (Tagged tag) (->) (->) where
+instance Distributive (->) (->) (Tagged tag) where
 	f -<< x = Tag $ extract . f -<$>- x
 
-instance Bindable (Tagged tag) (->) where
+instance Bindable (->) (Tagged tag) where
 	f =<< Tag x = f x
 
 instance Monad (Tagged tag)
 
-instance Extendable (Tagged tag) (->) where
+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,22 +2,19 @@
 
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic (point)
 
 data These e a = This a | That e | These e a
 
-instance Covariant (These e) (->) (->) where
+instance Covariant (->) (->) (These e) where
 	f -<$>- This x = This $ f x
 	_ -<$>- That y = That y
 	f -<$>- These y x = These y $ f x
 
-instance Pointable (These e) (->) where
-	point = This
-
-instance Traversable (These e) (->) (->) where
+instance Traversable (->) (->) (These e) where
 	f <<- This x = This -<$>- f x
 	_ <<- That y = point $ That y
 	f <<- These y x = These y -<$>- f x
diff --git a/Pandora/Paradigm/Primary/Functor/Validation.hs b/Pandora/Paradigm/Primary/Functor/Validation.hs
--- a/Pandora/Paradigm/Primary/Functor/Validation.hs
+++ b/Pandora/Paradigm/Primary/Functor/Validation.hs
@@ -3,8 +3,8 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
@@ -13,13 +13,15 @@
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point)
 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))
 
 data Validation e a = Flaws e | Validated a
 
-instance Covariant (Validation e) (->) (->) where
+instance Covariant (->) (->) (Validation e) where
 	_ -<$>- Flaws e = Flaws e
 	f -<$>- Validated x = Validated $ f x
 	_ -<$>- Flaws e = Flaws e
@@ -27,7 +29,7 @@
 	_ -<$>- Flaws e = Flaws e
 	f -<$>- Validated x = Validated $ f x
 
-instance Covariant (Flip Validation a) (->) (->) where
+instance Covariant (->) (->) (Flip Validation a) where
 	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e
 	_ -<$>- Flip (Validated x) = Flip $ Validated x
 	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e
@@ -35,24 +37,24 @@
 	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e
 	_ -<$>- Flip (Validated x) = Flip $ Validated x
 
-instance Pointable (Validation e) (->) where
-	point = Validated
+instance Semigroup e => Semimonoidal (->) (:*:) (:*:) (Validation e) where
+	multiply (Validated x :*: Validated y) = Validated $ x :*: y
+	multiply (Flaws x :*: Flaws y) = Flaws $ x + y
+	multiply (Validated _ :*: Flaws y) = Flaws y
+	multiply (Flaws x :*: Validated _) = Flaws x
 
-instance Semigroup e => Semimonoidal (Validation e) (->) (:*:) (:*:) where
-	multiply_ (Validated x :*: Validated y) = Validated $ x :*: y
-	multiply_ (Flaws x :*: Flaws y) = Flaws $ x + y
-	multiply_ (Validated _ :*: Flaws y) = Flaws y
-	multiply_ (Flaws x :*: Validated _) = Flaws x
+instance Semigroup e => Monoidal (->) (->) (:*:) (:*:) (Validation e) where
+	unit _ f = Validated $ f One
 
-instance Semigroup e => Semimonoidal (Validation e) (->) (:*:) (:+:) where
-	multiply_ (Flaws _ :*: y) = Adoption -<$>- y
-	multiply_ (Validated x :*: _) = Option -<$>- Validated x
+instance Semigroup e => Semimonoidal (->) (:*:) (:+:) (Validation e) where
+	multiply (Flaws _ :*: y) = Adoption -<$>- y
+	multiply (Validated x :*: _) = Option -<$>- Validated x
 
-instance Traversable (Validation e) (->) (->) where
+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 (Setoid e, Setoid a) => Setoid (Validation e a) where
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,21 +2,18 @@
 
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic (point)
 
 data Wedge e a = Nowhere | Here e | There a
 
-instance Covariant (Wedge e) (->) (->) where
+instance Covariant (->) (->) (Wedge e) where
 	_ -<$>- Nowhere = Nowhere
 	_ -<$>- Here x = Here x
 	f -<$>- There x = There $ f x
 
-instance Pointable (Wedge e) (->) where
-	point = There
-
-instance Traversable (Wedge e) (->) (->) where
+instance Traversable (->) (->) (Wedge e) where
 	_ <<- Nowhere = point Nowhere
 	_ <<- Here x = point $ Here x
 	f <<- There x = There -<$>- 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
@@ -1,20 +1,31 @@
 module Pandora.Paradigm.Primary.Functor.Wye where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category ((#))
+import Pandora.Pattern.Category ((#), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 
 data Wye a = End | Left a | Right a | Both a a
 
-instance Covariant Wye (->) (->) where
+instance Covariant (->) (->) Wye where
 	_ -<$>- End = End
 	f -<$>- Left x = Left # f x
 	f -<$>- Right y = Right # f y
 	f -<$>- Both x y = Both # f x # f y
 
+instance Semimonoidal (<--) (:*:) (:*:) Wye where
+	multiply = Flip $ \case
+		End -> End :*: End
+		Left (x :*: y) -> Left x :*: Left y
+		Right (x :*: y) -> Right x :*: Right y
+		Both (x :*: y) (x' :*: y') -> Both x x' :*: Both y y'
+	
 instance Monotonic a (Wye a) where
 	reduce f r (Left x) = f x r
 	reduce f r (Right x) = f x r
diff --git a/Pandora/Paradigm/Primary/Object/Denumerator.hs b/Pandora/Paradigm/Primary/Object/Denumerator.hs
--- a/Pandora/Paradigm/Primary/Object/Denumerator.hs
+++ b/Pandora/Paradigm/Primary/Object/Denumerator.hs
@@ -7,23 +7,23 @@
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater))
 
-data Denumerator = One | Denumerator Denumerator
+data Denumerator = Single | Denumerator Denumerator
 
 instance Setoid Denumerator where
-	One == One = True
+	Single == Single = True
 	Denumerator n == Denumerator m = n == m
 	_ == _ = False
 
 instance Chain Denumerator where
-	One <=> One = Equal
-	One <=> Denumerator _ = Less
-	Denumerator _ <=> One = Greater
+	Single <=> Single = Equal
+	Single <=> Denumerator _ = Less
+	Denumerator _ <=> Single = Greater
 	Denumerator n <=> Denumerator m = n <=> m
 
 instance Semigroup Denumerator where
-	One + m = Denumerator m
+	Single + m = Denumerator m
 	Denumerator n + m = Denumerator (n + m)
 
 instance Ringoid Denumerator where
-	One * n = n
+	Single * n = n
 	Denumerator n * m = m + n * m
diff --git a/Pandora/Paradigm/Primary/Object/Numerator.hs b/Pandora/Paradigm/Primary/Object/Numerator.hs
--- a/Pandora/Paradigm/Primary/Object/Numerator.hs
+++ b/Pandora/Paradigm/Primary/Object/Numerator.hs
@@ -8,7 +8,7 @@
 import Pandora.Pattern.Object.Quasiring (Quasiring (one))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater))
-import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (One))
+import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (Single))
 
 data Numerator = Zero | Numerator Denumerator
 
@@ -37,4 +37,4 @@
 	zero = Zero
 
 instance Quasiring Numerator where
-	one = Numerator One
+	one = Numerator Single
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
@@ -4,42 +4,50 @@
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
 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 ((-<*>-))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), (%))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point, extract)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype Backwards t a = Backwards (t a)
 
-instance Covariant t (->) (->) => Covariant (Backwards t) (->) (->) where
+instance Covariant (->) (->) t => Covariant (->) (->) (Backwards t) where
 	f -<$>- Backwards x = Backwards $ f -<$>- x
 
-instance Pointable t (->) => Pointable (Backwards t) (->) where
-	point = Backwards . point
-
-instance Extractable t (->) => Extractable (Backwards t) (->) where
-	extract (Backwards x) = extract x
-
 -- TODO: check that effects evaluation goes in opposite order
-instance (Semimonoidal t (->) (:*:) (:*:), Covariant t (->) (->)) => Semimonoidal (Backwards t) (->) (:*:) (:*:) where
-	multiply_ (Backwards x :*: Backwards y) = Backwards #
+instance (Semimonoidal (->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (->) (:*:) (:*:) (Backwards t) where
+	multiply (Backwards x :*: Backwards y) = Backwards #
 		((:*:) %) -<$>- y -<*>- x
 
-instance Traversable t (->) (->) => Traversable (Backwards t) (->) (->) where
+instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t) => Monoidal (->) (->) (:*:) (:*:) (Backwards t) where
+	unit _ f = Backwards . point $ f One
+
+instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Backwards t) where
+	multiply = Flip $ \(Backwards x) -> 
+		let Flip f = multiply @(<--) @(:*:) @(:*:) in
+		(Backwards <-> Backwards) $ f x
+
+instance (Covariant (->) (->) t, Monoidal (<--) (->) (:*:) (:*:) t) => Monoidal (<--) (->) (:*:) (:*:) (Backwards t) where
+	unit _ = Flip $ \(Backwards x) -> (\_ -> extract x)
+
+instance Traversable (->) (->) t => Traversable (->) (->) (Backwards t) where
 	f <<- Backwards x = Backwards -<$>- f <<- x
 
-instance Distributive t (->) (->) => Distributive (Backwards t) (->) (->) where
+instance Distributive (->) (->) t => Distributive (->) (->) (Backwards t) where
 	f -<< x = Backwards $ run . f -<< x
 
-instance Contravariant t (->) (->) => Contravariant (Backwards t) (->) (->) where
+instance Contravariant (->) (->) t => Contravariant (->) (->) (Backwards t) where
 	f ->$<- Backwards x = Backwards $ f ->$<- x
 
 instance Interpreted (Backwards t) where
@@ -47,10 +55,10 @@
 	run ~(Backwards x) = x
 	unite = Backwards
 
-instance Liftable Backwards where
+instance Liftable (->) Backwards where
 	lift = Backwards
 
-instance Lowerable Backwards where
+instance Lowerable (->) Backwards where
 	lower = run
 
 instance Hoistable Backwards where
diff --git a/Pandora/Paradigm/Primary/Transformer/Construction.hs b/Pandora/Paradigm/Primary/Transformer/Construction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Construction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Construction.hs
@@ -6,20 +6,22 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid ((*))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Primary.Algebraic ((-<*>-), extract)
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 import Pandora.Paradigm.Schemes (type (<:.>))
@@ -28,36 +30,42 @@
 
 data Construction t a = Construct a (t :. Construction t := a)
 
-instance Covariant t (->) (->) => Covariant (Construction t) (->) (->) where
+instance Covariant (->) (->) t => Covariant (->) (->) (Construction t) where
 	f -<$>- ~(Construct x xs) = Construct # f x # f -<$$>- xs
 
-instance Covariant t (->) (->) => Extractable (Construction t) (->) where
-	extract ~(Construct x _) = x
+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Semimonoidal (->) (:*:) (:*:) (Construction t) where
+	multiply (Construct x xs :*: Construct y ys) = Construct (x :*: y) (multiply @(->) @(:*:) -<$>- multiply (xs :*: ys))
 
-instance (Covariant t (->) (->), Semimonoidal t (->) (:*:) (:*:)) => Semimonoidal (Construction t) (->) (:*:) (:*:) where
-	multiply_ (Construct x xs :*: Construct y ys) = Construct (x :*: y) (multiply_ @_ @(->) @(:*:) -<$>- multiply_ (xs :*: ys))
+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Semimonoidal (<--) (:*:) (:*:) (Construction t) where
+	multiply = Flip $ \(Construct (x :*: y) xys) ->
+		let Flip f = multiply @(<--) @(:*:) @(:*:) in
+		let Flip g = multiply @(<--) @(:*:) @(:*:) in
+		(Construct x <-> Construct y) $ f $ g -<$>- xys
 
-instance Traversable t (->) (->) => Traversable (Construction t) (->) (->) where
+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoidal (<--) (->) (:*:) (:*:) (Construction t) where
+	unit _ = Flip $ \(Construct x _) -> (\_ -> x)
+
+instance Traversable (->) (->) t => Traversable (->) (->) (Construction t) where
 	f <<- ~(Construct x xs) = Construct -<$>- f x -<*>- f -<<-<<- xs
 
-instance Covariant t (->) (->) => Extendable (Construction t) (->) where
+instance Covariant (->) (->) t => Extendable (->) (Construction t) where
 	f <<= x = Construct # f x # (f <<=) -<$>- deconstruct x
 
-instance (Covariant t (->) (->)) => Comonad (Construction t) (->) where
+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Comonad (Construction t) (->) where
 
-instance Lowerable Construction where
-	lower x = extract @_ @(->) -<$>- deconstruct x
+instance (forall u . Semimonoidal (<--) (:*:) (:*:) u) => Lowerable (->) Construction where
+	lower x = extract -<$>- deconstruct x
 
-instance Hoistable Construction where
+instance (forall u . Semimonoidal (<--) (:*:) (:*:) u) => Hoistable Construction where
 	f /|\ x = Construct # extract x $ f # hoist f -<$>- deconstruct x
 
-instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant t (->) (->)) => Setoid (Construction t a) where
+instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Setoid (Construction t a) where
 	x == y = (extract x == extract y) * (deconstruct x == deconstruct y)
 
-instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant t (->) (->)) => Semigroup (Construction t a) where
+instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Semigroup (Construction t a) where
 	x + y = Construct # extract x + extract y # deconstruct x + deconstruct y
 
-instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant t (->) (->)) => Monoid (Construction t a) where
+instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoid (Construction t a) where
 	zero = Construct zero zero
 
 instance Monotonic a (t :. Construction t := a) => Monotonic a (Construction t a) where
@@ -70,8 +78,8 @@
 deconstruct ~(Construct _ xs) = xs
 
 -- Generate a construction from seed using effectful computation
-(.-+) :: Covariant t (->) (->) => a :=> t -> a :=> Construction t
+(.-+) :: Covariant (->) (->) t => a :=> t -> a :=> Construction t
 f .-+ x = Construct x $ (f .-+) -<$>- f x
 
-section :: Comonad t (->) => t ~> Construction t
+section :: (Comonad t (->), Monoidal (<--) (->) (:*:) (:*:) t) => t ~> Construction t
 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
@@ -5,12 +5,14 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Monoidal (Monoidal)
 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.Algebraic.Exponential ((!.), (%))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Primary.Algebraic (point)
 
 newtype Continuation r t a = Continuation ((->) ::|:. a :. t := r)
 
@@ -19,18 +21,15 @@
 	run ~(Continuation x) = x
 	unite = Continuation
 
-instance Covariant t (->) (->) => Covariant (Continuation r t) (->) (->) where
+instance Covariant (->) (->) t => Covariant (->) (->) (Continuation r t) where
 	f -<$>- Continuation continuation = Continuation $ continuation . (. f)
 
-instance Covariant t (->) (->) => Pointable (Continuation r t) (->) where
-	point x = Continuation ($ x)
-
-instance Covariant t (->) (->) => Bindable (Continuation r t) (->) where
+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 Monad t => Monad (Continuation r t) where
 
-instance (forall u . Bindable u (->)) => Liftable (Continuation r) where
+instance (forall u . Bindable (->) u) => Liftable (->) (Continuation r) where
 	lift = Continuation . (%) (=<<)
 
 -- | Call with current continuation
@@ -38,12 +37,12 @@
 cwcc f = Continuation $ \g -> (run % g) . f $ Continuation . (!.) . g
 
 -- | Delimit the continuation of any 'shift'
-reset :: (forall u . Bindable u (->), Monad 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
-shift :: Pointable t (->) => ((a -> t r) -> Continuation r t r) -> Continuation r t a
+shift :: Monoidal (->) (->) (:*:) (:*:) t => ((a -> t r) -> Continuation r t r) -> Continuation r t a
 shift f = Continuation $ (run % point) . f
 
-interruptable :: Pointable t (->) => ((a -> Continuation a t a) -> Continuation a t a) -> t a
+interruptable :: Monoidal (->) (->) (:*:) (:*:) t => ((a -> Continuation a t a) -> Continuation a t a) -> t a
 interruptable = (run % point) . cwcc
diff --git a/Pandora/Paradigm/Primary/Transformer/Day.hs b/Pandora/Paradigm/Primary/Transformer/Day.hs
--- a/Pandora/Paradigm/Primary/Transformer/Day.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Day.hs
@@ -4,29 +4,17 @@
 
 import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((!..), (-.#..-))
 
 data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a)
 
-instance Covariant (Day t u) (->) (->) where
+instance Covariant (->) (->) (Day t u) where
 	f -<$>- Day tb uc g = Day tb uc # f -.#..- g
 
-instance (Pointable t (->), Pointable u (->)) => Pointable (Day t u) (->) where
-	point x = Day # point () # point () # (x !..)
-
-instance (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
+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
 
 instance Hoistable (Day t) where
 	g /|\ Day tb uc bca = Day tb # g uc # bca
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
@@ -5,8 +5,8 @@
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -15,39 +15,41 @@
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point)
 
 data Instruction t a = Enter a | Instruct (t :. Instruction t := a)
 
-instance Covariant t (->) (->) => Covariant (Instruction t) (->) (->) where
+instance Covariant (->) (->) t => Covariant (->) (->) (Instruction t) where
 	f -<$>- Enter x = Enter $ f x
 	f -<$>- Instruct xs = Instruct $ f -<$$>- xs
 
-instance Covariant t (->) (->) => Pointable (Instruction t) (->) where
-	point = Enter
+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Semimonoidal (->) (:*:) (:*:) (Instruction t) where
+	multiply (Enter x :*: Enter y) = Enter $ x :*: y
+	multiply (Enter x :*: Instruct y) = (x :*:) -<$>- Instruct y
+	multiply (Instruct x :*: Enter y) = (:*: y) -<$>- Instruct x
+	multiply (Instruct x :*: Instruct y) = Instruct $ multiply @(->) @(:*:) -<$>- multiply (x :*: y)
 
-instance (Covariant t (->) (->), Semimonoidal t (->) (:*:) (:*:)) => Semimonoidal (Instruction t) (->) (:*:) (:*:) where
-	multiply_ (Enter x :*: Enter y) = Enter $ x :*: y
-	multiply_ (Enter x :*: Instruct y) = (x :*:) -<$>- Instruct y
-	multiply_ (Instruct x :*: Enter y) = (:*: y) -<$>- Instruct x
-	multiply_ (Instruct x :*: Instruct y) = Instruct $ multiply_ @_ @(->) @(:*:) -<$>- multiply_ (x :*: y)
+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Monoidal (->) (->) (:*:) (:*:) (Instruction t) where
+	unit _ f = Enter $ f One
 
-instance Covariant t (->) (->) => Bindable (Instruction t) (->) where
+instance Covariant (->) (->) t => Bindable (->) (Instruction t) where
 	f =<< Enter x = f x
 	f =<< Instruct xs = Instruct $ (f =<<) -<$>- xs
 
 instance Monad t => Monad (Instruction t) where
 
-instance Traversable t (->) (->) => Traversable (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
+instance Liftable (->) Instruction where
 	lift x = Instruct $ Enter -<$>- x
 
-instance (forall t . Bindable t (->), forall t . Pointable t (->)) => Lowerable Instruction where
+instance (forall t . Bindable (->) t, forall t . Monoidal (->) (->) (:*:) (:*:) t) => Lowerable (->) Instruction where
 	lower (Enter x) = point x
 	lower (Instruct xs) = lower =<< xs
 
-instance (forall v . Covariant v (->) (->)) => Hoistable Instruction where
+instance (forall v . Covariant (->) (->) v) => Hoistable Instruction where
 	_ /|\ Enter x = Enter x
 	f /|\ Instruct xs = Instruct $ hoist f -<$>- f xs
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
@@ -5,8 +5,7 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -15,35 +14,30 @@
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Primary.Algebraic (point)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
 
 data Jack t a = It a | Other (t a)
 
-instance Covariant t (->) (->) => Covariant (Jack t) (->) (->) where
+instance Covariant (->) (->) t => Covariant (->) (->) (Jack t) where
 	f -<$>- It x = It $ f x
 	f -<$>- Other y = Other $ f -<$>- y
 
-instance Covariant t (->) (->) => Pointable (Jack t) (->) where
-	point = It
-
-instance Extractable t (->) => Extractable (Jack t) (->) where
-	extract (It x) = x
-	extract (Other y) = extract y
-
-instance Traversable t (->) (->) => Traversable (Jack t) (->) (->) where
+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
+instance (Monoidal (->) (->) (:*:) (:*:) 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
+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
+instance Liftable (->) Jack where
 	lift = Other
 
 instance Hoistable Jack where
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
@@ -3,17 +3,13 @@
 module Pandora.Paradigm.Primary.Transformer.Jet where
 
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
 
 data Jet t a = Jet a (Jet t (t a))
 
-instance Covariant t (->) (->) => Covariant (Jet t) (->) (->) where
+instance Covariant (->) (->) t => Covariant (->) (->) (Jet t) where
 	f -<$>- Jet x xs = Jet (f x) (f -<$$>- xs)
 
-instance Traversable t (->) (->) => Traversable (Jet t) (->) (->) where
+instance Traversable (->) (->) t => Traversable (->) (->) (Jet t) where
 	f <<- Jet x xs = Jet -<$>- f x -<*>- f -<<-<<- xs
-
-instance Covariant t (->) (->) => Extractable (Jet t) (->) where
-	extract (Jet x _) = x
diff --git a/Pandora/Paradigm/Primary/Transformer/Kan.hs b/Pandora/Paradigm/Primary/Transformer/Kan.hs
--- a/Pandora/Paradigm/Primary/Transformer/Kan.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Kan.hs
@@ -11,7 +11,7 @@
 
 data instance Kan Left t u b a = Lan ((t b -> a) -> u b)
 
-instance Contravariant (Kan Left t u b) (->) (->) where
+instance Contravariant (->) (->) (Kan Left t u b) where
 	f ->$<- Lan x = Lan $ x . (f .)
 
 instance Interpreted (Kan Left t u b) where
@@ -21,7 +21,7 @@
 
 data instance Kan Right t u b a = Ran ((a -> t b) -> u b)
 
-instance Covariant (Kan Right t u b) (->) (->) where
+instance Covariant (->) (->) (Kan Right t u b) where
 	f -<$>- Ran x = Ran $ x . (. f)
 
 instance Interpreted (Kan Right t u b) where
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
@@ -5,8 +5,6 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
@@ -15,18 +13,11 @@
 	Line :: a -> Outline t a
 	Outlined :: t a -> Outline t (a -> b) -> Outline t b
 
-instance Covariant (Outline t) (->) (->) where
+instance Covariant (->) (->) (Outline t) where
 	f -<$>- Line a = Line $ f a
 	f -<$>- Outlined x y = Outlined x # (.) f -<$>- y
 
-instance Pointable (Outline t) (->) where
-	point = Line
-
-instance Extractable t (->) => Extractable (Outline t) (->) where
-	extract (Line x) = x
-	extract (Outlined x y) = extract y # extract x
-
-instance Liftable Outline where
+instance Liftable (->) Outline where
 	lift t = Outlined t (Line identity)
 
 instance Hoistable Outline where
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
@@ -6,34 +6,48 @@
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point, extract)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype Reverse t a = Reverse (t a)
 
-instance Covariant t (->) (->) => Covariant (Reverse t) (->) (->) where
+instance Covariant (->) (->) t => Covariant (->) (->) (Reverse t) where
 	f -<$>- Reverse x = Reverse # f -<$>- x
 
-instance Pointable t (->) => Pointable (Reverse t) (->) where
-	point = Reverse . point
+instance (Semimonoidal (->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (->) (:*:) (:*:) (Reverse t) where
+	multiply (Reverse x :*: Reverse y) = Reverse # multiply (x :*: y)
 
-instance Extractable t (->) => Extractable (Reverse t) (->) where
-	extract (Reverse x) = extract x
+instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t) => Monoidal (->) (->) (:*:) (:*:) (Reverse t) where
+	unit _ f = Reverse . point $ f One
 
-instance Traversable t (->) (->) => Traversable (Reverse t) (->) (->) where
+instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Reverse t) where
+	multiply = Flip $ \(Reverse x) -> 
+		let Flip f = multiply @(<--) @(:*:) @(:*:) in
+		(Reverse <-> Reverse) $ f x
+
+instance (Covariant (->) (->) t, Monoidal (<--) (->) (:*:) (:*:) t) => Monoidal (<--) (->) (:*:) (:*:) (Reverse t) where
+	unit _ = Flip $ \(Reverse x) -> (\_ -> extract x)
+
+instance Traversable (->) (->) t => Traversable (->) (->) (Reverse t) where
 	f <<- Reverse x = Reverse -<$>- run (Backwards . f <<- x)
 
-instance Distributive t (->) (->) => Distributive (Reverse t) (->) (->) where
+instance Distributive (->) (->) t => Distributive (->) (->) (Reverse t) where
 	f -<< x = Reverse $ run . f -<< x
 
-instance Contravariant t (->) (->) => Contravariant (Reverse t) (->) (->) where
+instance Contravariant (->) (->) t => Contravariant (->) (->) (Reverse t) where
 	f ->$<- Reverse x = Reverse # f ->$<- x
 
 instance Interpreted (Reverse t) where
@@ -41,10 +55,10 @@
 	run ~(Reverse x) = x
 	unite = Reverse
 
-instance Liftable Reverse where
+instance Liftable (->) Reverse where
 	lift = Reverse
 
-instance Lowerable Reverse where
+instance Lowerable (->) Reverse where
 	lower = run
 
 instance Hoistable Reverse where
diff --git a/Pandora/Paradigm/Primary/Transformer/Tap.hs b/Pandora/Paradigm/Primary/Transformer/Tap.hs
--- a/Pandora/Paradigm/Primary/Transformer/Tap.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Tap.hs
@@ -6,8 +6,8 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
@@ -15,11 +15,12 @@
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) 
-import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
+import Pandora.Paradigm.Primary.Algebraic ((-<*>-), extract)
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), twosome)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), (%))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 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))
@@ -28,48 +29,53 @@
 
 data Tap t a = Tap a (t a)
 
-instance Covariant t (->) (->) => Covariant (Tap t) (->) (->) where
+instance Covariant (->) (->) t => Covariant (->) (->) (Tap t) where
 	f -<$>- Tap x xs = Tap # f x # f -<$>- xs
 
-instance (Covariant t (->) (->)) => Extractable (Tap t) (->) where
-	extract (Tap x _) = x
+instance Semimonoidal (->) (:*:) (:*:) t => Semimonoidal (->) (:*:) (:*:) (Tap t) where
+	multiply (Tap x xs :*: Tap y ys) = Tap (x :*: y) $ multiply $ xs :*: ys
 
-instance Semimonoidal t (->) (:*:) (:*:) => Semimonoidal (Tap t) (->) (:*:) (:*:) where
-	multiply_ (Tap x xs :*: Tap y ys) = Tap (x :*: y) $ multiply_ $ xs :*: ys
+instance Semimonoidal (<--) (:*:) (:*:) t => Semimonoidal (<--) (:*:) (:*:) (Tap t) where
+	multiply = Flip $ \(Tap (x :*: y) xys) -> 
+		let Flip f = multiply @(<--) @(:*:) @(:*:) in
+		let (xs :*: ys) = f xys in Tap x xs :*: Tap y ys
 
-instance Traversable t (->) (->) => Traversable (Tap t) (->) (->) where
+instance Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (->) (:*:) (:*:) (Tap t) where
+	unit _ = Flip $ \(Tap x _) -> (\_ -> x)
+
+instance Traversable (->) (->) t => Traversable (->) (->) (Tap t) where
 	f <<- Tap x xs = Tap -<$>- f x -<*>- f <<- xs
 
-instance (Extendable t (->), Covariant t (->) (->)) => Extendable (Tap t) (->) where
+instance (Semimonoidal (<--) (:*:) (:*:) t, Extendable (->) t, Covariant (->) (->) t) => Extendable (->) (Tap t) where
 	f <<= x = Tap # f x $ f . Tap (extract x) <<= lower x
 
-instance Lowerable Tap where
+instance Lowerable (->) Tap where
 	lower (Tap _ xs) = xs
 
 instance Hoistable Tap where
 	f /|\ Tap x xs = Tap x # f xs
 
-instance Semimonoidal t (->) (:*:) (:*:) => Semimonoidal (Tap (t <:.:> t := (:*:))) (->) (:*:) (:*:) where
-	multiply_ (Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) = Tap (x :*: y)
-		$ T_U $ multiply_ (xls :*: yls) :*: multiply_ (xrs :*: yrs)
+instance {-# OVERLAPS #-} Semimonoidal (->) (:*:) (:*:) t => Semimonoidal (->) (:*:) (:*:) (Tap (t <:.:> t := (:*:))) where
+	multiply (Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) = Tap (x :*: y)
+		$ T_U $ multiply (xls :*: yls) :*: multiply (xrs :*: yrs)
 
-instance {-# OVERLAPS #-} Traversable t (->) (->) => Traversable (Tap (t <:.:> t := (:*:))) (->) (->) where
+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 (->) (->)) => Substructure Root (Tap (t <:.:> t := (:*:))) where
+instance (Covariant (->) (->) t) => Substructure Root (Tap (t <:.:> t := (:*:))) where
 	type Available Root (Tap (t <:.:> t := (:*:))) = Identity
 	type Substance Root (Tap (t <:.:> t := (:*:))) = Identity
 	substructure = P_Q_T $ \zipper -> case lower zipper of
 		Tap x xs -> Store $ Identity (Identity x) :*: lift . (Tap % xs) . extract . extract
 
-instance (Covariant t (->) (->)) => Substructure Left (Tap (t <:.:> t := (:*:))) where
+instance (Covariant (->) (->) t) => Substructure Left (Tap (t <:.:> t := (:*:))) where
 	type Available Left (Tap (t <:.:> t := (:*:))) = Identity
 	type Substance Left (Tap (t <:.:> t := (:*:))) = t
 	substructure = P_Q_T $ \zipper -> case lower zipper of
 		Tap x (T_U (future :*: past)) -> Store $ Identity future :*: lift . Tap x . T_U . (:*: past) . extract
 
-instance (Covariant t (->) (->)) => Substructure Right (Tap (t <:.:> t := (:*:))) where
+instance (Covariant (->) (->) t) => Substructure Right (Tap (t <:.:> t := (:*:))) where
 	type Available Right (Tap (t <:.:> t := (:*:))) = Identity
 	type Substance Right (Tap (t <:.:> t := (:*:))) = t
 	substructure = P_Q_T $ \zipper -> case lower zipper of
diff --git a/Pandora/Paradigm/Primary/Transformer/Yoneda.hs b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
--- a/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
@@ -3,29 +3,15 @@
 module Pandora.Paradigm.Primary.Transformer.Yoneda where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (identity, ($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 newtype Yoneda t a = Yoneda
 	{ yoneda :: forall b . (a -> b) -> t b }
 
-instance Covariant (Yoneda t) (->) (->) where
+instance Covariant (->) (->) (Yoneda t) where
 	f -<$>- x = Yoneda (\k -> yoneda x (k . f))
 
-instance Pointable t (->) => Pointable (Yoneda t) (->) where
-	point x = Yoneda (\f -> point $ f x)
-
-instance Extractable t (->) => Extractable (Yoneda t) (->) where
-	extract (Yoneda f) = extract $ f identity
-
-instance Liftable Yoneda where
+instance Liftable (->) Yoneda where
 	lift x = Yoneda (-<$>- 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
@@ -20,29 +20,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 (->) (->))
+instance (Covariant (->) (->) (v <:.> t), Covariant (->) (->) (u <:.> w), Adjoint (->) (->) t u, Adjoint (->) (->) v w)
 
-	=> Adjoint (v <:.> t) (u <:.> w) (->) (->) where
+	=> 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
+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
+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
+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
+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
 		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
@@ -5,17 +5,22 @@
 import Pandora.Pattern.Category (($), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption), sum)
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (empty, point, extract)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 newtype TU ct cu t u a = TU (t :. u := a)
 
@@ -31,32 +36,44 @@
 	run ~(TU x) = x
 	unite = TU
 
-instance (Covariant t (->) (->), Covariant u (->) (->)) => Covariant (t <:.> u) (->) (->) where
+instance (Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <:.> u) where
 	f -<$>- x = TU $ f -<$$>- run x
 
-instance (Covariant t (->) (->), Semimonoidal t (->) (:*:) (:*:), Semimonoidal u (->) (:*:) (:*:)) => Semimonoidal (t <:.> u) (->) (:*:) (:*:) where
-	multiply_ (TU x :*: TU y) = TU $ multiply_ @_ @(->) @(:*:) -<$>- multiply_ (x :*: y)
+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) u) => Semimonoidal (->) (:*:) (:*:) (t <:.> u) where
+	multiply (TU x :*: TU y) = TU $ multiply @(->) @(:*:) -<$>- multiply (x :*: y)
 
-instance (Pointable t (->), Pointable u (->)) => Pointable (t <:.> u) (->) where
-	point = TU . point . point
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) u, Monoidal (->) (->) (:*:) (:*:) t, Monoidal (->) (->) (:*:) (:*:) u) => Monoidal (->) (->) (:*:) (:*:) (t <:.> u) where
+	unit _ f = TU . point . point $ f One
 
-instance (Extractable t (->), Extractable u (->)) => Extractable (t <:.> u) (->) where
-	extract = extract . extract . run
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (->) (:*:) (:+:) t) => Semimonoidal (->) (:*:) (:+:) (t <:.> u) where
+	multiply (TU x :*: TU y) = TU $ sum (Option -<$>-) (Adoption -<$>-) -<$>- multiply @(->) @(:*:) @(:+:) (x :*: y)
 
-instance (Traversable t (->) (->), Traversable u (->) (->)) => Traversable (t <:.> u) (->) (->) where
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Monoidal (->) (->) (:*:) (:+:) t) => Monoidal (->) (->) (:*:) (:+:) (t <:.> u) where
+	unit _ _ = TU empty
+
+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:.> u) where
+	multiply = Flip $ \(TU xys) ->
+		let Flip f = multiply @(<--) @(:*:) @(:*:) in
+		let Flip g = multiply @(<--) @(:*:) @(:*:) in
+		(TU <-> TU) $ g (f -<$>- xys) where
+
+instance (Covariant (->) (->) t, Monoidal (<--) (->) (:*:) (:*:) t, Monoidal (<--) (->) (:*:) (:*:) u) => Monoidal (<--) (->) (:*:) (:*:) (t <:.> u) where
+	unit _ = Flip $ \(TU x) -> (\_ -> extract $ extract x)
+
+instance (Traversable (->) (->) t, Traversable (->) (->) u) => Traversable (->) (->) (t <:.> u) where
 	f <<- x = TU -<$>- f -<<-<<- run x
 
-instance (Bindable t (->), Distributive t (->) (->), Covariant u (->) (->), Bindable u (->)) => Bindable (t <:.> u) (->) where
+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
+instance Monoidal (->) (->) (:*:) (:*:) t => Liftable (->) (TU Covariant Covariant t) where
+	lift :: Covariant (->) (->) u => u ~> t <:.> u
 	lift = TU . point
 
-instance Extractable t (->) => Lowerable (TU Covariant Covariant t) where
+instance Monoidal (<--) (->) (:*:) (:*:) t => Lowerable (->) (TU Covariant Covariant t) where
 	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
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
@@ -5,15 +5,20 @@
 import Pandora.Pattern.Category (identity, ($))
 import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-), (-<$$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point, extract)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a)
@@ -34,25 +39,35 @@
 	run ~(TUT x) = x
 	unite = TUT
 
-instance (Covariant t (->) (->), Covariant t' (->) (->), Covariant u (->) (->)) => Covariant (t <:<.>:> t' := u) (->) (->) where
+instance (Covariant (->) (->) t, Covariant (->) (->) t', Covariant (->) (->) u) => Covariant (->) (->) (t <:<.>:> t' := u) where
 	f -<$>- TUT x = TUT $ f -<$$$>- x
 
-instance (Covariant t (->) (->), Covariant t' (->) (->), Covariant u (->) (->), Semimonoidal t (->) (:*:) (:*:), Semimonoidal u (->) (:*:) (:*:), Semimonoidal t' (->) (:*:) (:*:)) => Semimonoidal (t <:<.>:> t' := u) (->) (:*:) (:*:) where
-	multiply_ (TUT x :*: TUT y) = TUT $ multiply_ @_ @(->) @(:*:) -<$$>- multiply_ @_ @(->) @(:*:) -<$>- multiply_ (x :*: y)
+instance (Covariant (->) (->) t, Covariant (->) (->) t', Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) u, Semimonoidal (->) (:*:) (:*:) t') => Semimonoidal (->) (:*:) (:*:) (t <:<.>:> t' := u) where
+	multiply (TUT x :*: TUT y) = TUT $ multiply @(->) @(:*:) -<$$>- multiply @(->) @(:*:) -<$>- multiply (x :*: y)
 
-instance (Covariant t (->) (->), Covariant t' (->) (->), Pointable u (->), Adjoint t' t (->) (->)) => Pointable (t <:<.>:> t' := u) (->) where
-	point = unite . (point @_ @(->) -|)
+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <:<.>:> t' := u) where
+	multiply = Flip $ \(TUT xys) ->
+		let Flip f = multiply @(<--) @(:*:) @(:*:) in
+		let Flip g = multiply @(<--) @(:*:) @(:*:) in
+		let Flip h = multiply @(<--) @(:*:) @(:*:) in
+		(TUT <-> TUT) $ f (g -<$>- (h -<$$>- xys)) where
 
-instance (Adjoint t' t (->) (->), Extendable u (->)) => Extendable (t' <:<.>:> t := u) (->) where
-	f <<= x = TUT $ ((f . unite -|) <<=) -<$>- run x
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t', Monoidal (<--) (->) (:*:) (:*:) u, Adjoint (->) (->) t t') => Monoidal (<--) (->) (:*:) (:*:) (t <:<.>:> t' := u) where
+	unit _ = Flip $ \(TUT xys) -> (\_ -> (extract |-) xys)
 
-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, Bindable (->) u) => Bindable (->) (t <:<.>:> t' := u) where
+	f =<< x = TUT $ ((run . f |-) =<<) -<$>- run x
 
-instance (Adjoint t' t (->) (->), Distributive t(->) (->) ) => Liftable (t <:<.>:> t') where
-	lift :: Covariant u (->) (->) => u ~> t <:<.>:> t' := u
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Covariant (->) (->) t', Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) t', Monoidal (->) (->) (:*:) (:*:) u, Adjoint (->) (->) t' t) => Monoidal (->) (->) (:*:) (:*:) (t <:<.>:> t' := u) where
+	unit _ f = unite . (point -|) . f $ One
+
+instance (Adjoint (->) (->) t' t, Extendable (->) u) => Extendable (->) (t' <:<.>:> t := u) where
+	f <<= x = TUT $ ((f . unite -|) <<=) -<$>- run x
+
+instance (Adjoint (->) (->) t' t, Distributive (->) (->) t) => Liftable (->) (t <:<.>:> t') where
+	lift :: Covariant (->) (->) u => u ~> t <:<.>:> t' := u
 	lift x = TUT $ (identity @(->) -|) -<< x
 
-instance (Adjoint t t' (->) (->), Distributive t'(->) (->) ) => Lowerable (t <:<.>:> t') where
-	lower :: Covariant u (->) (->) => (t <:<.>:> t' := u) ~> u
+instance (Adjoint (->) (->) t t', Distributive (->) (->) t') => Lowerable (->) (t <:<.>:> t') where
+	lower :: Covariant (->) (->) u => (t <:<.>:> t' := u) ~> u
 	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
@@ -21,11 +21,11 @@
 	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 (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
@@ -5,15 +5,18 @@
 import Pandora.Pattern.Category (($), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
 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 ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), point, extract)
+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 newtype UT ct cu t u a = UT (u :. t := a)
 
@@ -29,25 +32,31 @@
 	run ~(UT x) = x
 	unite = UT
 
-instance (Covariant t (->) (->), Covariant u (->) (->)) => Covariant (t <.:> u) (->) (->) where
+instance (Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <.:> u) where
 	f -<$>- x = UT $ f -<$$>- run x
 
-instance (Covariant u (->) (->), Semimonoidal t (->) (:*:) (:*:), Semimonoidal u (->) (:*:) (:*:)) => Semimonoidal (t <.:> u) (->) (:*:) (:*:) where
-	multiply_ (UT x :*: UT y) = UT $ multiply_ @_ @(->) @(:*:) -<$>- multiply_ (x :*: y)
+instance (Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) u) => Semimonoidal (->) (:*:) (:*:) (t <.:> u) where
+	multiply (UT x :*: UT y) = UT $ multiply @(->) @(:*:) -<$>- multiply (x :*: y)
 
-instance (Pointable t (->), Pointable u (->)) => Pointable (t <.:> u) (->) where
-	point = UT . point . point
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) u, Monoidal (->) (->) (:*:) (:*:) t, Monoidal (->) (->) (:*:) (:*:) u) => Monoidal (->) (->) (:*:) (:*:) (t <.:> u) where
+	unit _ f = UT . point . point $ f One
 
-instance (Traversable t (->) (->), Bindable t (->), Semimonoidal u (->) (:*:) (:*:), Pointable u (->), Bindable u (->)) => Bindable (t <.:> u) (->) where
+instance (Traversable (->) (->) t, Bindable (->) t, Semimonoidal (->) (:*:) (:*:) u, Monoidal (->) (->) (:*:) (:*:) 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
+instance (Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <.:> u) where
+	multiply = Flip $ \(UT xys) ->
+		let Flip f = multiply @(<--) @(:*:) @(:*:) in
+		let Flip g = multiply @(<--) @(:*:) @(:*:) in
+		(UT <-> UT) $ f (g -<$>- xys) where
 
-instance Pointable t (->) => Liftable (UT Covariant Covariant t) where
-	lift :: Covariant u (->) (->) => u ~> t <.:> u
-	lift x = UT $ point @_ @(->) -<$>- x
+instance (Covariant (->) (->) u, Monoidal (<--) (->) (:*:) (:*:) t, Monoidal (<--) (->) (:*:) (:*:) u) => Monoidal (<--) (->) (:*:) (:*:) (t <.:> u) where
+	unit _ = Flip $ \(UT x) -> (\_ -> extract $ extract x)
 
-instance Extractable t (->) => Lowerable (UT Covariant Covariant t) where
-	lower :: Covariant u (->) (->) => t <.:> u ~> u
-	lower (UT x) = extract @_ @(->) -<$>- x
+instance Monoidal (->) (->) (:*:) (:*:) t => Liftable (->) (UT Covariant Covariant t) where
+	lift :: Covariant (->) (->) u => u ~> t <.:> u
+	lift x = UT $ point -<$>- x
+
+instance Monoidal (<--) (->) (:*:) (:*:) t => Lowerable (->) (UT Covariant Covariant t) where
+	lower :: Covariant (->) (->) u => t <.:> u ~> u
+	lower (UT x) = extract -<$>- x
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -11,7 +11,6 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Semigroup ((+))
@@ -20,6 +19,7 @@
 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.Algebraic (extract)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
@@ -38,7 +38,7 @@
 instance Nullable Maybe where
 	null = Predicate $ \case { Just _ -> True ; _ -> False }
 
-instance (Covariant t (->) (->)) => Substructure Tail (Tap t) where
+instance (Covariant (->) (->) t) => Substructure Tail (Tap t) where
 	type Available Tail (Tap t) = Identity
 	type Substance Tail (Tap t) = t
 	substructure = P_Q_T $ \tap -> case extract # run tap of
@@ -90,13 +90,13 @@
 instance {-# OVERLAPS #-} Accessible b a => Accessible b (s :*: a) where
 	access = access @b . access @a
 
-instance (Covariant t (->) (->)) => Substructure Left (t <:.:> t := (:*:)) where
+instance (Covariant (->) (->) t) => Substructure Left (t <:.:> t := (:*:)) where
 	type Available Left (t <:.:> t := (:*:)) = Identity
 	type Substance Left (t <:.:> t := (:*:)) = t
 	substructure = P_Q_T $ \x -> case run # lower x of
 		ls :*: rs -> Store $ Identity ls :*: lift . (twosome % rs) . extract
 
-instance (Covariant t (->) (->)) => Substructure Right (t <:.:> t := (:*:)) where
+instance (Covariant (->) (->) t) => Substructure Right (t <:.:> t := (:*:)) where
 	type Available Right (t <:.:> t := (:*:)) = Identity
 	type Substance Right (t <:.:> t := (:*:)) = t
 	substructure = P_Q_T $ \x -> case run # lower x of
diff --git a/Pandora/Paradigm/Structure/Ability/Morphable.hs b/Pandora/Paradigm/Structure/Ability/Morphable.hs
--- a/Pandora/Paradigm/Structure/Ability/Morphable.hs
+++ b/Pandora/Paradigm/Structure/Ability/Morphable.hs
@@ -5,10 +5,10 @@
 import Pandora.Core.Functor (type (:=), type (~>), type (:=:=>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((#))
-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.Algebraic (extract)
 import Pandora.Paradigm.Primary.Functor (Comparison)
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
diff --git a/Pandora/Paradigm/Structure/Ability/Substructure.hs b/Pandora/Paradigm/Structure/Ability/Substructure.hs
--- a/Pandora/Paradigm/Structure/Ability/Substructure.hs
+++ b/Pandora/Paradigm/Structure/Ability/Substructure.hs
@@ -23,5 +23,5 @@
 	type Substance segment structure :: * -> *
 	substructure :: (Tagged segment <:.> structure) #=@ Substance segment structure := Available segment structure
 
-	sub :: (Covariant structure (->) (->)) => structure #=@ Substance segment structure := Available segment structure
-	sub = lift >-> (lower -<$>-) ||= substructure @segment @structure
+	sub :: (Covariant (->) (->) structure) => structure #=@ Substance segment structure := Available segment structure
+	sub = lift @(->) >-> (lower @(->) -<$>-) ||= substructure @segment @structure
diff --git a/Pandora/Paradigm/Structure/Interface/Set.hs b/Pandora/Paradigm/Structure/Interface/Set.hs
--- a/Pandora/Paradigm/Structure/Interface/Set.hs
+++ b/Pandora/Paradigm/Structure/Interface/Set.hs
@@ -22,10 +22,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 != (find @f @t @Maybe % s) . equate <<- ss
 
-cardinality :: Traversable t (->) (->) => t a -> Numerator
+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
@@ -8,8 +8,8 @@
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Contravariant ((->$<-))
-import Pandora.Pattern.Functor.Pointable (Pointable)
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
@@ -23,7 +23,9 @@
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Push), premorph)
 import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))
+import Pandora.Paradigm.Primary.Algebraic (empty)
 
 newtype Comprehension t a = Comprehension (t <:.> Construction t := a)
 
@@ -32,16 +34,22 @@
 	run ~(Comprehension x) = x
 	unite = Comprehension
 
-instance Covariant (t <:.> Construction t) (->) (->) => Covariant (Comprehension t) (->) (->) where
+instance Covariant (->) (->) (t <:.> Construction t) => Covariant (->) (->) (Comprehension t) where
 	f -<$>- Comprehension x = Comprehension $ f -<$>- x
 
-instance Traversable (t <:.> Construction t) (->) (->) => Traversable (Comprehension t) (->) (->) where
+instance Traversable (->) (->) (t <:.> Construction t) => Traversable (->) (->) (Comprehension t) where
 	f <<- Comprehension x = Comprehension -<$>- f <<- x
 
-instance (Covariant t (->) (->), Semimonoidal t (->) (:*:) (:*:)) => Semimonoidal (Comprehension t) (->) (:*:) (:*:) where
-	multiply_ (Comprehension x :*: Comprehension y) = Comprehension $ multiply_ (x :*: y)
+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Semimonoidal (->) (:*:) (:*:) (Comprehension t) where
+	multiply (Comprehension x :*: Comprehension y) = Comprehension $ multiply (x :*: y)
 
-instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t (->)) => Bindable (Comprehension t) (->) where
+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:+:) t) => Semimonoidal (->) (:*:) (:+:) (Comprehension t) where
+	multiply (Comprehension x :*: Comprehension y) = Comprehension $ multiply (x :*: y)
+
+instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:+:) t) => Monoidal (->) (->) (:*:) (:+:) (Comprehension t) where
+	unit _ _ = Comprehension empty
+
+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
 
 instance Setoid (t <:.> Construction t := a) => Setoid (Comprehension t a) where
@@ -53,7 +61,7 @@
 instance Monoid (t <:.> Construction t := a) => Monoid (Comprehension t a) where
 	zero = Comprehension zero
 
-instance (Covariant t (->) (->), Pointable t (->)) => Morphable Push (Comprehension t) where
+instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t)  => Morphable Push (Comprehension t) where
 	type Morphing Push (Comprehension t) = Identity <:.:> Comprehension t := (->)
 	morphing (run . premorph -> xs) = T_U $ \(Identity x) -> Comprehension . lift . Construct x . run $ xs
 
diff --git a/Pandora/Paradigm/Structure/Modification/Prefixed.hs b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
--- a/Pandora/Paradigm/Structure/Modification/Prefixed.hs
+++ b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
@@ -7,12 +7,9 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
-import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Primary.Algebraic ()
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic (extract)
+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)
@@ -24,17 +21,14 @@
 	run ~(Prefixed x) = x
 	unite = Prefixed
 
-instance Covariant t (->) (->) => Covariant (Prefixed t k) (->) (->) where
+instance Covariant (->) (->) t => Covariant (->) (->) (Prefixed t k) where
 	f -<$>- Prefixed x = Prefixed $ f -<$$>- x
 
-instance Traversable t (->) (->) => Traversable (Prefixed t k) (->) (->) where
+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
-
-instance Covariant t (->) (->) => Morphable (Into t) (Prefixed t k) where
+instance Covariant (->) (->) t => Morphable (Into t) (Prefixed t k) where
 	type Morphing (Into t) (Prefixed t k) = t
-	morphing (run . premorph -> prefixed) = extract @_ @(->) -<$>- prefixed
+	morphing (run . premorph -> prefixed) = extract -<$>- prefixed
 
 type instance Nonempty (Prefixed t k) = Prefixed (Nonempty t) k
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
@@ -6,7 +6,6 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Bindable ((=<<))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
@@ -15,11 +14,11 @@
 import Pandora.Paradigm.Primary ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), type (:*:), attached, twosome)
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), (&))
-import Pandora.Paradigm.Primary.Algebraic (($$$>-))
+import Pandora.Paradigm.Primary.Algebraic (($$$>-), extract)
 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.Object.Denumerator (Denumerator (Single))
 import Pandora.Paradigm.Primary.Functor (Comparison)
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
@@ -72,14 +71,14 @@
 	type Substance Left Binary = Construction Wye
 	substructure = P_Q_T $ \bintree -> case run . lower # bintree of
 		Nothing -> Store $ Nothing :*: lift . TU
-		Just tree -> lift . lift -<$>- run (sub @Left) tree
+		Just tree -> lift . lift @(->) -<$>- run (sub @Left) tree
 
 instance Substructure Right Binary where
 	type Available Right Binary = Maybe
 	type Substance Right Binary = Construction Wye
 	substructure = P_Q_T $ \bintree -> case run . extract . run # bintree of
 		Nothing -> Store $ Nothing :*: lift . TU
-		Just tree -> lift . lift -<$>- run (sub @Right) tree
+		Just tree -> lift . lift @(->) -<$>- run (sub @Right) tree
 
 -------------------------------------- Non-empty binary tree ---------------------------------------
 
@@ -101,10 +100,10 @@
 
 instance Measurable Heighth (Construction Wye) where
 	type Measural Heighth (Construction Wye) a = Denumerator
-	measurement (deconstruct . extract -> End) = One
-	measurement (deconstruct . extract -> Left lst) = One + measure @Heighth lst
-	measurement (deconstruct . extract -> Right rst) = One + measure @Heighth rst
-	measurement (deconstruct . extract -> Both lst rst) = One +
+	measurement (deconstruct . extract -> End) = Single
+	measurement (deconstruct . extract -> Left lst) = Single + measure @Heighth lst
+	measurement (deconstruct . extract -> Right rst) = Single + measure @Heighth rst
+	measurement (deconstruct . extract -> Both lst rst) = Single +
 		let (lm :*: rm) = measure @Heighth lst :*: measure @Heighth rst
 		in lm <=> rm & order lm rm lm
 
@@ -136,7 +135,7 @@
 
 instance Chain k => Morphable (Lookup Key) (Prefixed Binary k) where
 	type Morphing (Lookup Key) (Prefixed Binary k) = (->) k <:.> Maybe
-	morphing (run . run . premorph -> Nothing) = lift Nothing
+	morphing (run . run . premorph -> Nothing) = TU $ \_ -> Nothing
 	morphing (run . run . premorph -> Just tree) = TU $ \key ->
 		let root = extract tree in key <=> attached root & order (Just # extract root)
 			(lookup @Key key . Prefixed =<< view # sub @Left # tree)
@@ -165,7 +164,7 @@
 
 data Biforked a = Top | Leftward a | Rightward a
 
-instance Covariant Biforked (->) (->) where
+instance Covariant (->) (->) Biforked where
 	_ -<$>- Top = Top
 	f -<$>- Leftward l = Leftward $ f l
 	f -<$>- Rightward r = Rightward $ f r
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
@@ -7,8 +7,6 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
-import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -21,8 +19,8 @@
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 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.Algebraic ((-<*>-), (-.#..-))
+import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (Single))
+import Pandora.Paradigm.Primary.Algebraic ((-<*>-), (-.#..-), extract)
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached, twosome)
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
@@ -114,11 +112,11 @@
 	type Available Tail List = Identity
 	type Substance Tail List = List
 	substructure = P_Q_T $ \x -> case run . extract . run $ x of
-		Just ns -> lift . lift -<$>- run (sub @Tail) ns
+		Just ns -> lift . lift @(->) -<$>- run (sub @Tail) ns
 		Nothing -> Store $ Identity zero :*: 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 -------------------------------------------
@@ -144,8 +142,8 @@
 
 instance Measurable Length (Construction Maybe) where
 	type Measural Length (Construction Maybe) a = Denumerator
-	measurement (deconstruct . extract -> Nothing) = One
-	measurement (deconstruct . extract -> Just xs) = One + measure @Length xs
+	measurement (deconstruct . extract -> Nothing) = Single
+	measurement (deconstruct . extract -> Just xs) = Single + measure @Length xs
 
 instance Substructure Root (Construction Maybe) where
 	type Available Root (Construction Maybe) = Identity
@@ -167,11 +165,11 @@
 
 type instance Zipper List (Left ::: Right) = Tap (List <:.:> List := (:*:))
 
-instance {-# OVERLAPS #-} Traversable (Tap (List <:.:> List := (:*:))) (->) (->) where
+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
+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)
 
@@ -223,7 +221,7 @@
 
 instance Morphable (Into (Tap (List <:.:> List := (:*:)))) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
 	type Morphing (Into (Tap (List <:.:> List := (:*:)))) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = Tap (List <:.:> List := (:*:))
-	morphing (premorph -> zipper) = Tap # extract zipper $ lift <-> lift ||= lower zipper
+	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 := (:*:))) =
@@ -247,10 +245,6 @@
 
 type instance Zipper (Comprehension Maybe) (Left ::: Right) = Tap (Comprehension Maybe <:.:> Comprehension Maybe := (:*:))
 
-instance Semimonoidal (Tap (Comprehension Maybe <:.:> Comprehension Maybe := (:*:))) (->) (:*:) (:*:) where
-	multiply_ (Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) = Tap (x :*: y)
-		$ T_U $ multiply_ (xls :*: yls) :*: multiply_ (xrs :*: yrs)
-
 ----------------------------------------- Prefixed list --------------------------------------------
 
 instance Setoid key => Morphable (Lookup Key) (Prefixed List key) where
@@ -261,5 +255,5 @@
 
 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
+	morphing (run . premorph -> Construct x xs) = TU $ \key -> extract -<$>- search key where
 		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
@@ -6,7 +6,6 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Contravariant ((->$<-))
-import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
@@ -14,6 +13,7 @@
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Primary.Algebraic (extract)
 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)
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
@@ -7,10 +7,9 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Paradigm.Primary ()
-import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
+import Pandora.Paradigm.Primary.Algebraic ((-<*>-), extract)
 import Pandora.Paradigm.Primary.Algebraic.Product (twosome)
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
 import Pandora.Paradigm.Primary.Functor.Tagged (type (:#))
@@ -63,7 +62,7 @@
 				(branch @Right =<< deconstruct -<$>- branch @Right xs)
 
 		parent :: Maybe a
-		parent = extract @_ @(->) -<$>- branch @Right xs
+		parent = extract -<$>- branch @Right xs
 
 instance Morphable (Rotate (Right Zig)) (Construction Wye) where
 	type Morphing (Rotate (Right Zig)) (Construction Wye) = Binary
@@ -75,7 +74,7 @@
 			. into @Wye $ twosome (branch @Right =<< deconstruct -<$>- branch @Left xs) # branch @Right xs
 
 		parent :: Maybe a
-		parent = extract @_ @(->) -<$>- branch @Left xs
+		parent = extract -<$>- branch @Left xs
 
 -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary
 instance Morphable (Rotate (Left (Zig Zig))) (Construction Wye) where
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
@@ -6,10 +6,9 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
 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.Algebraic.Product ((:*:) ((:*:)), twosome)
+import Pandora.Paradigm.Primary.Algebraic (extract)
 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, (.-+))
@@ -17,6 +16,7 @@
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate), premorph, rotate)
 import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
+import Pandora.Paradigm.Primary.Algebraic (point)
 
 type Stream = Construction Identity
 
@@ -32,7 +32,7 @@
 	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
+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))
 
diff --git a/Pandora/Pattern/Functor.hs b/Pandora/Pattern/Functor.hs
--- a/Pandora/Pattern/Functor.hs
+++ b/Pandora/Pattern/Functor.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor (module Exports, Endofunctor) where
+module Pandora.Pattern.Functor (module Exports) where
 
 import Pandora.Pattern.Functor.Bivariant as Exports
 import Pandora.Pattern.Functor.Divariant as Exports
@@ -10,15 +10,14 @@
 import Pandora.Pattern.Functor.Bindable as Exports
 import Pandora.Pattern.Functor.Distributive as Exports
 import Pandora.Pattern.Functor.Traversable as Exports
-import Pandora.Pattern.Functor.Extractable as Exports
-import Pandora.Pattern.Functor.Pointable as Exports
+import Pandora.Pattern.Functor.Monoidal as Exports
 import Pandora.Pattern.Functor.Semimonoidal as Exports
 import Pandora.Pattern.Functor.Invariant as Exports
 import Pandora.Pattern.Functor.Contravariant as Exports
 import Pandora.Pattern.Functor.Covariant as Exports
 
-type family Endofunctor constraint functor category where
-	Endofunctor Covariant t category = Covariant t category category
-	Endofunctor Contravariant t category = Contravariant t category category
-	Endofunctor Traversable t category = Traversable t category category
-	Endofunctor Distributive t category = Distributive t category category
+--type family Endofunctor constraint functor category where
+	--Endofunctor Covariant t category = Covariant category category t
+	--Endofunctor Contravariant t category = Contravariant t category category
+	--Endofunctor Traversable t category = Traversable t category category
+	--Endofunctor Distributive t category = Distributive t category category
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
@@ -14,6 +14,6 @@
 > * Right adjunction interchange: psi f ≡ epsilon . comap f
 -}
 
-class (Covariant t target source, Covariant u source target) => Adjoint t u source target where
+class (Covariant target source t, Covariant source target u) => Adjoint source target t u where
 	(-|) :: source (t a) b -> target a (u b)
 	(|-) :: target a (u b) -> source (t a) b
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
@@ -9,5 +9,5 @@
 > * Interchange: t >>= f = join (f <$> t)
 -}
 
-class Covariant t source source => Bindable t source where
+class Covariant source source t => Bindable source t 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
@@ -11,6 +11,6 @@
 > * Parametricity: (f . g) <-> (h . i) ≡ f <-> h . g <-> i
 -}
 
-class (forall i . Covariant (v i) left target, forall i . Covariant (Flip v i) right target)
-	=> Bivariant v left right target where
+class (forall i . Covariant left target (v i), forall i . Covariant right target (Flip v i))
+	=> Bivariant left right target v 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
@@ -1,11 +1,13 @@
 module Pandora.Pattern.Functor.Comonad where
 
-import Pandora.Pattern.Functor.Extractable (Extractable)
+import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Extendable (Extendable)
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 
 {- |
-> Let f :: (Pointable t, Bindable t) => t a -> b
-> Let g :: (Pointable t, Bindable t) => t a -> b
+> Let f :: (Extendable t, Extractable t) => t a -> b
+> Let g :: (Extendable t, Extractable t) => t a -> b
 
 > When providing a new instance, you should ensure it satisfies:
 > * Left identity: extend extract ≡ identity
@@ -13,4 +15,4 @@
 > * Associativity: extend f . extend g ≡ extend (f . extend g)
 -}
 
-class (Extractable t source, Extendable t (->)) => Comonad t source
+class (Monoidal (<--) source (:*:) (:*:) t, Extendable source t) => Comonad t source
diff --git a/Pandora/Pattern/Functor/Contravariant.hs b/Pandora/Pattern/Functor/Contravariant.hs
--- a/Pandora/Pattern/Functor/Contravariant.hs
+++ b/Pandora/Pattern/Functor/Contravariant.hs
@@ -4,12 +4,11 @@
 
 infixl 4 ->$<-
 
--- TODO: use ->$<- instead of contramap here
 {- |
 > When providing a new instance, you should ensure it satisfies:
-> * Identity morphism: contramap identity ≡ identity
-> * Interpreted of morphisms: contramap f . contramap g ≡ contramap (g . f)
+> * Identity morphism: (identity ->$<-) ≡ identity
+> * Interpreted of morphisms: (f ->$<-) . (g ->$<-) ≡ (g . f ->$<-)
 -}
 
-class (Category source, Category target) => Contravariant t source target where
+class (Category source, Category target) => Contravariant source target t where
 	(->$<-) :: source a b -> target (t b) (t a)
diff --git a/Pandora/Pattern/Functor/Covariant.hs b/Pandora/Pattern/Functor/Covariant.hs
--- a/Pandora/Pattern/Functor/Covariant.hs
+++ b/Pandora/Pattern/Functor/Covariant.hs
@@ -5,40 +5,39 @@
 infixl 4 -<$>-
 infixl 3 -<<$$>-, -<$$>>-
 
--- TODO: use -<$>- instead of comap here
 {- |
 > When providing a new instance, you should ensure it satisfies:
-> * Identity morphism: comap identity ≡ identity
-> * Interpreted of morphisms: comap (f . g) ≡ comap f . comap g
+> * Identity morphism: (identity -<$>-) ≡ identity
+> * Interpreted of morphisms: (f . g -<$>-) ≡ (f -<$>-) . (g -<$>-)
 -}
 
-class (Semigroupoid source, Semigroupoid target) => Covariant t source target where
+class (Semigroupoid source, Semigroupoid target) => Covariant source target t where
 	(-<$>-) :: source a b -> target (t a) (t b)
 	
 (-<$$>-) :: forall t u category a b 
-	. (Covariant u category category, Covariant t category category) 
+	. (Covariant category category u, Covariant category category t) 
 	=> category a b -> category (t (u a)) (t (u b))
-(-<$$>-) s = ((-<$>-) ((-<$>-) @u @category @category s))
+(-<$$>-) s = ((-<$>-) ((-<$>-) @category @category @u s))
 
 (-<<$$>-) :: forall t u source target a b 
-	. (Covariant u source source, Covariant t source target) 
+	. (Covariant source source u, Covariant source target t) 
 	=> source a b -> target (t (u a)) (t (u b))
-(-<<$$>-) s = ((-<$>-) ((-<$>-) @u @source @source s))
+(-<<$$>-) s = ((-<$>-) ((-<$>-) @source @source @u s))
 
-(-<$$>>-) :: forall t u source target a b 
-	. (Covariant u source target, Covariant t target target) 
+(-<$$>>-) :: forall source target t u a b 
+	. (Covariant source target u, Covariant target target t) 
 	=> source a b -> target (t (u a)) (t (u b))
-(-<$$>>-) s = ((-<$>-) ((-<$>-) @u @source @target s))
+(-<$$>>-) s = ((-<$>-) ((-<$>-) @source @target @u s))
 
 -- TODO: Figure out how to work with hidden type variables
 -- to put intermediate category `between`
 
 (-<$$$>-) :: forall t u v category a b
-	. (Covariant t category category, Covariant u category category, Covariant v category category) 
+	. (Covariant category category t, Covariant category category u, Covariant category category v) 
 	=> category a b -> category (t (u (v a))) (t (u (v b)))
-(-<$$$>-) s = ((-<$>-) @t @category @category ((-<$>-) @u @category @category ((-<$>-) @v @category @category s)))
+(-<$$$>-) s = ((-<$>-) @category @category @t ((-<$>-) @category @category @u ((-<$>-) @category @category @v s)))
 
-(-<$$$$>-) :: forall t u v w category a b
-	. (Covariant t category category, Covariant u category category, Covariant v category category, Covariant w category category) 
+(-<$$$$>-) :: forall category t u v w a b
+	. (Covariant category category t, Covariant category category u, Covariant category category v, Covariant category category w) 
 	=> category a b -> category (t (u (v (w a)))) (t (u (v (w b))))
-(-<$$$$>-) s = ((-<$>-) @t @category @category ((-<$>-) @u @category @category ((-<$>-) @v @category @category ((-<$>-) @w @category @category s))))
+(-<$$$$>-) s = ((-<$>-) @category @category @t ((-<$>-) @category @category @u ((-<$>-) @category @category @v ((-<$>-) @category @category @w s))))
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
@@ -12,5 +12,5 @@
 
 infixl 5 -<<
 
-class Covariant t source target => Distributive t source target where
-	(-<<) :: Covariant u source target => source a (t b) -> target (u a) (t (u b))
+class Covariant source target t => Distributive source target t where
+	(-<<) :: Covariant source target u => 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
@@ -12,6 +12,6 @@
 > * Interpreted: f . g >-> h . i ≡ g >-> h . f >-> i
 -}
 
-class (forall i . Contravariant (Flip v i) left target, forall i . Covariant (v i) right target) 
-	=> Divariant v left right target where
+class (forall i . Contravariant left target (Flip v i), forall i . Covariant right target (v i)) 
+	=> Divariant left right target v where
 	(>->) :: left a b -> right c d -> target (v b c) (v a d)
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
@@ -10,5 +10,5 @@
 > * Extension interchange: (f <<=) ≡ (f -<$>-) . (identity <<=)
 -}
 
-class Covariant t source source => Extendable t source where
+class Covariant source source t => Extendable source t where
 	(<<=) :: source (t a) b -> source (t a) (t b)
diff --git a/Pandora/Pattern/Functor/Extractable.hs b/Pandora/Pattern/Functor/Extractable.hs
deleted file mode 100644
--- a/Pandora/Pattern/Functor/Extractable.hs
+++ /dev/null
@@ -1,7 +0,0 @@
-module Pandora.Pattern.Functor.Extractable where
-
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-class Covariant t source source => Extractable t source where
-	{-# MINIMAL extract #-}
-	extract :: source (t a) a
diff --git a/Pandora/Pattern/Functor/Monad.hs b/Pandora/Pattern/Functor/Monad.hs
--- a/Pandora/Pattern/Functor/Monad.hs
+++ b/Pandora/Pattern/Functor/Monad.hs
@@ -2,12 +2,13 @@
 
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Bindable (Bindable)
-import Pandora.Pattern.Functor.Pointable (Pointable)
+import Pandora.Pattern.Functor.Monoidal (Monoidal)
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 
 {- |
-> Let f :: (Pointable t, Bindable t) => a -> t a
-> Let g :: (Pointable t, Bindable t) => a -> t a
-> Let h :: (Pointable t, Bindable t) => t a
+> Let f :: (Monoidal t (->) (->) (:*:) (:*:), Bindable t) => a -> t a
+> Let g :: (Monoidal t (->) (->) (:*:) (:*:), Bindable t) => a -> t a
+> Let h :: (Monoidal t (->) (->) (:*:) (:*:), Bindable t) => t a
 
 > When providing a new instance, you should ensure it satisfies:
 > * Left identity: point a >>= f ≡ f a
@@ -18,7 +19,7 @@
 --infixl 1 >>=-, ->>=
 --infixr 1 -=<<, =<<-
 
-class (Covariant t (->) (->), Pointable t (->), Bindable t (->)) => Monad t where
+class (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t, Bindable (->) t) => Monad t where
 	--(>>=-) :: t a -> t b -> t a
 	--(>>=-) x y = x >>= \r -> y >>= \_ -> point r
 	--(->>=) :: t a -> t b -> t b
diff --git a/Pandora/Pattern/Functor/Monoidal.hs b/Pandora/Pattern/Functor/Monoidal.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Functor/Monoidal.hs
@@ -0,0 +1,9 @@
+module Pandora.Pattern.Functor.Monoidal where
+
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal)
+import Pandora.Paradigm.Primary.Functor.Proxy (Proxy)
+
+type family Unit (p :: * -> * -> *) = r | r -> p
+
+class Semimonoidal p source target t => Monoidal p q source target t where
+	unit :: Proxy source -> p (q (Unit target) a) (t a)
diff --git a/Pandora/Pattern/Functor/Pointable.hs b/Pandora/Pattern/Functor/Pointable.hs
deleted file mode 100644
--- a/Pandora/Pattern/Functor/Pointable.hs
+++ /dev/null
@@ -1,7 +0,0 @@
-module Pandora.Pattern.Functor.Pointable where
-
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-class Covariant t source source => Pointable t source where
-	{-# MINIMAL point #-}
-	point :: source a (t a)
diff --git a/Pandora/Pattern/Functor/Representable.hs b/Pandora/Pattern/Functor/Representable.hs
--- a/Pandora/Pattern/Functor/Representable.hs
+++ b/Pandora/Pattern/Functor/Representable.hs
@@ -1,7 +1,6 @@
 module Pandora.Pattern.Functor.Representable where
 
 import Pandora.Core.Functor (type (<:=))
-import Pandora.Pattern.Functor.Pointable (Pointable)
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -13,7 +12,7 @@
 
 infixr 6 <#>
 
-class Pointable t (->) => Representable t where
+class Representable t where
 	{-# MINIMAL (<#>), tabulate #-}
 	type Representation t :: *
 	-- | Infix and flipped version of 'index'
diff --git a/Pandora/Pattern/Functor/Semimonoidal.hs b/Pandora/Pattern/Functor/Semimonoidal.hs
--- a/Pandora/Pattern/Functor/Semimonoidal.hs
+++ b/Pandora/Pattern/Functor/Semimonoidal.hs
@@ -2,5 +2,5 @@
 
 import Pandora.Pattern.Semigroupoid (Semigroupoid)
 
-class Semigroupoid p => Semimonoidal t p source target where
-	multiply_ :: p (source (t a) (t b)) (t (target a b))
+class Semigroupoid p => Semimonoidal p source target t where
+	multiply :: p (source (t a) (t b)) (t (target a b))
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,13 +1,12 @@
 module Pandora.Pattern.Functor.Traversable where
 
 import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal)
-import Pandora.Pattern.Functor.Pointable (Pointable)
+import Pandora.Pattern.Functor.Monoidal (Monoidal)
 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
+> Let p :: (Monoidal u category category (:*:) (:*:), Monoidal u category category (:*:) (:*:)) => t a -> u a
 
 > When providing a new instance, you should ensure it satisfies:
 > * Numeratority of traversing: g . (f <<--) ≡ (g . f <<--)
@@ -18,10 +17,10 @@
 
 infixl 5 <<-, -<<-<<-
 
-class Covariant t source target => Traversable t source target where
-	(<<-) :: (Covariant u source target, Pointable u target, Semimonoidal u target (:*:) (:*:)) => source a (u b) -> target (t a) (u (t b))
+class Covariant source target t => Traversable source target t where
+	(<<-) :: (Covariant source target u, Monoidal source target (:*:) (:*:) u) => source a (u b) -> target (t a) (u (t b))
 
 (-<<-<<-) :: forall t u v category a b .
-	(Traversable t category category, Covariant u category category, Pointable u category, Semimonoidal u category (:*:) (:*:), Traversable v category category)
+	(Traversable category category t, Covariant category category u, Monoidal category category (:*:) (:*:) u, Traversable category category v) 
 	=> category a (u b) -> category (v (t a)) (u (v (t b)))
-(-<<-<<-) f = ((<<-) ((<<-) @t @category @category f))
+(-<<-<<-) f = ((<<-) ((<<-) @category @category @t f))
diff --git a/Pandora/Pattern/Transformer/Hoistable.hs b/Pandora/Pattern/Transformer/Hoistable.hs
--- a/Pandora/Pattern/Transformer/Hoistable.hs
+++ b/Pandora/Pattern/Transformer/Hoistable.hs
@@ -13,7 +13,7 @@
 
 class Hoistable t where
 	{-# MINIMAL (/|\) #-}
-	(/|\) :: (Covariant u (->) (->)) => u ~> v -> t u ~> t v
+	(/|\) :: (Covariant (->) (->) u) => u ~> v -> t u ~> t v
 
-	hoist :: (Covariant u (->) (->)) => u ~> v -> t u ~> t v
+	hoist :: (Covariant (->) (->) u) => u ~> v -> t u ~> t v
 	hoist = (/|\)
diff --git a/Pandora/Pattern/Transformer/Liftable.hs b/Pandora/Pattern/Transformer/Liftable.hs
--- a/Pandora/Pattern/Transformer/Liftable.hs
+++ b/Pandora/Pattern/Transformer/Liftable.hs
@@ -1,6 +1,5 @@
 module Pandora.Pattern.Transformer.Liftable (Liftable (..)) where
 
-import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 {- |
@@ -8,5 +7,5 @@
 > * Interchange: lift . point ≡ point
 -}
 
-class Liftable t where
-	lift :: (Covariant u (->) (->)) => u ~> t u
+class Liftable cat t where
+	lift :: Covariant cat cat u => cat (u a) (t u a)
diff --git a/Pandora/Pattern/Transformer/Lowerable.hs b/Pandora/Pattern/Transformer/Lowerable.hs
--- a/Pandora/Pattern/Transformer/Lowerable.hs
+++ b/Pandora/Pattern/Transformer/Lowerable.hs
@@ -8,5 +8,5 @@
 > * Interchange: extract . lower ≡ extract
 -}
 
-class Lowerable t where
-	lower :: (Covariant u (->) (->)) => t u ~> u
+class Lowerable cat t where
+	lower :: Covariant cat cat u => cat (t u a) (u a)
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.4.5
+version:             0.4.6
 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
@@ -32,6 +32,8 @@
     Pandora.Paradigm.Primary.Algebraic.Exponential
     Pandora.Paradigm.Primary.Algebraic.Product
     Pandora.Paradigm.Primary.Algebraic.Sum
+    Pandora.Paradigm.Primary.Algebraic.Zero
+    Pandora.Paradigm.Primary.Algebraic.One
     Pandora.Paradigm.Primary.Object.Boolean
     Pandora.Paradigm.Primary.Object.Ordering
     Pandora.Paradigm.Primary.Object.Numerator
@@ -137,16 +139,15 @@
     Pandora.Pattern.Functor
     Pandora.Pattern.Functor.Adjoint
     Pandora.Pattern.Functor.Semimonoidal
+    Pandora.Pattern.Functor.Monoidal
     Pandora.Pattern.Functor.Bindable
     Pandora.Pattern.Functor.Comonad
     Pandora.Pattern.Functor.Contravariant
     Pandora.Pattern.Functor.Covariant
     Pandora.Pattern.Functor.Distributive
     Pandora.Pattern.Functor.Extendable
-    Pandora.Pattern.Functor.Extractable
     Pandora.Pattern.Functor.Invariant
     Pandora.Pattern.Functor.Monad
-    Pandora.Pattern.Functor.Pointable
     Pandora.Pattern.Functor.Representable
     Pandora.Pattern.Functor.Traversable
     Pandora.Pattern.Functor.Divariant