diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -517,3 +517,35 @@
 * Rename experimental `Applicative_` to `Semimonoidal`
 
 # 0.4.5
+* Define `Endofunctor` type family
+* Define `Sum` module in `Algebraic` with `:+:` type
+* Define experimental `Day_` transformer
+* Define experimental `Semimonoidal_` typeclass
+* Define `Semigroupoid` typeclass as generalization of `Category`
+* Define `Applicative_` and `Alternative_` type class aliases of `Semimonoidal_`
+* Define experimental `-*-` method of `Semonoidal_` typeclass
+* Define experimental `-+-` method of `Semonoidal_` typeclass
+* Use experimental `Semimonoidal_` as superclass of `Traversable`
+* Remove `-<*>-` method of `Semimonoidal` typeclass
+* Remove `Semimonoidal` typeclass
+* Rename `Semimonoidal_` typeclass to `Semimonoidal`
+* Rename `-*-` method of `Semimonoidal` to `-<*>-`
+* Use `Semigroupoid` as superclass for `Semimonoidal`
+* Define `*>-` and `forever_` methods of `Applicative_` typeclass
+* Remove `<+*>`, `<**+>`, `<***+>` methods
+* Remove `Applicative` typeclass
+* Remove `satisfy` method of `Predicate`
+* Remove `Alternative` typeclass
+* Remove `Avoidable` typeclass
+* Change `-<$$$>-`: works with endofunctors
+* Define `-<$$$$>-` operator of `Covariant_` typeclass
+* Use experimental `Covariant_` in `Interpreted`
+* Define `$>-`, `$$>-`, `$$$>-` methods of `Covariant_` typeclass
+* Remove `Covariant` typeclass
+* Rename experimental `Covariant_` to `Covariant`
+* Remove `Determinable` typeclass
+* Remove `Divisible_` typeclass
+* Remove `Contravariant` typeclass
+* Rename experimental `Contravariant_` to `Contravariant`
+
+# 0.4.6
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
@@ -3,8 +3,9 @@
 module Pandora.Paradigm.Controlflow.Effect.Adaptable where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category (identity, (.))
-import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)
+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.Comonad (Comonad)
@@ -17,8 +18,8 @@
 	{-# 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 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 (->))
 
@@ -39,7 +40,7 @@
 
 instance
 	( Liftable (Schematic Monad t)
-	, Covariant_ (Schematic Monad u v) (->) (->)
+	, Covariant (Schematic Monad u v) (->) (->)
 	, Wrappable u v
 	) => Adaptable u (t :> u :> v) where
 	adapt = lift . wrap
@@ -293,12 +294,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, 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)
@@ -307,12 +308,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)
@@ -322,10 +323,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)
@@ -336,11 +337,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)
@@ -352,12 +353,12 @@
 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))
 
 instance
-	( Covariant 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) (->) (->)
+	( 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)
@@ -371,32 +372,13 @@
 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))
 
 instance
-	( Covariant f, Covariant_ f (->) (->)
-	, Covariant (Schematic Monad u v)
-	, Covariant (Schematic Monad u (v :> w))
-	, Covariant (Schematic Monad u (v :> (w :> x)))
-	, Covariant (Schematic Monad u (v :> (w :> (x :> y))))
-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z)))))
-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f))))))
-	, Covariant_ (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f)))))) (->) (->)
-	, Covariant (Schematic Monad v (w :> x))
-	, Covariant (Schematic Monad v (w :> (x :> y)))
-	, Covariant (Schematic Monad v (w :> (x :> (y :> z))))
-	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> f)))))
-	, Covariant_ (Schematic Monad v (w :> (x :> (y :> (z :> f))))) (->) (->)
-	, Covariant (Schematic Monad w (x :> y))
-	, Covariant (Schematic Monad w (x :> (y :> z)))
-	, Covariant (Schematic Monad w (x :> (y :> (z :> f))))
-	, Covariant_ (Schematic Monad w (x :> (y :> (z :> f)))) (->) (->)
-	, Covariant (Schematic Monad x y)
-	, Covariant (Schematic Monad x (y :> z))
-	, Covariant (Schematic Monad x (y :> (z :> f)))
-	, Covariant_ (Schematic Monad x (y :> (z :> f))) (->) (->)
-	, Covariant (Schematic Monad y z)
-	, Covariant (Schematic Monad y (z :> f))
-	, Covariant_ (Schematic Monad y (z :> f)) (->) (->)
-	, Covariant (Schematic Monad z f)
-	, Covariant_ (Schematic Monad z f) (->) (->)
+	( 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)
@@ -411,24 +393,14 @@
 	adapt = hoist (hoist (hoist (hoist (hoist (hoist adapt)))))
 
 instance
-	( Covariant 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)
-	, Covariant (Schematic Monad x (y :> z))
-	, Covariant (Schematic Monad x (y :> (z :> f)))
-	, Covariant (Schematic Monad x (y :> (z :> (f :> h))))
-	, Covariant_ (Schematic Monad x (y :> (z :> (f :> h)))) (->) (->)
-	, Covariant (Schematic Monad y z)
-	, Covariant (Schematic Monad y (z :> f))
-	, Covariant (Schematic Monad y (z :> (f :> h)))
-	, Covariant_ (Schematic Monad y (z :> (f :> h))) (->) (->)
-	, Covariant (Schematic Monad z f)
-	, Covariant (Schematic Monad z (f :> h))
-	, Covariant_ (Schematic Monad z (f :> h)) (->) (->)
-	, Covariant (Schematic Monad f h)
-	, Covariant_ (Schematic Monad f h) (->) (->)
+	( 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
@@ -1,8 +1,8 @@
 module Pandora.Paradigm.Controlflow.Effect.Interpreted where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)), Covariant_)
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-), (-<$$$>-), (-<$$$$>-))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
@@ -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
+	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
+	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
+	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
+	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
+	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
+	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
+	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
+	f =||$$$$> x = (f =||) -<$$$$>- x
 
-(-=:) :: (Liftable t, Interpreted (t u), Interpreted (t v), Covariant u, 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
@@ -3,12 +3,12 @@
 module Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (..), (:<) (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -16,6 +16,7 @@
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 
 class Interpreted t => Comonadic t where
@@ -25,10 +26,7 @@
 infixr 3 :<
 newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }
 
-instance Covariant (Schematic Comonad t u) => Covariant (t :< u) where
-	f <$> TC x = TC $ f <$> x
-
-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
@@ -37,11 +35,8 @@
 instance Extractable (Schematic Comonad t u) (->) => Extractable (t :< u) (->) where
 	extract = extract . tc
 
-instance Applicative (Schematic Comonad t u) => Applicative (t :< u) where
-	TC f <*> TC x = TC $ f <*> x
-
-instance Alternative (Schematic Comonad t u) => Alternative (t :< u) where
-	TC x <+> TC y = TC $ x <+> y
+instance Semimonoidal (Schematic Comonad t u) (->) (:*:) (:*:) => Semimonoidal (t :< u) (->) (:*:) (:*:) where
+	multiply_ (TC f :*: TC x) = TC $ multiply_ $ f :*: x
 
 instance Traversable (Schematic Comonad t u) (->) (->) => Traversable (t :< u) (->) (->) where
 	f <<- TC x = TC -<$>- f <<- x
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
@@ -3,13 +3,12 @@
 module Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (..), (:>) (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -17,6 +16,7 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 
 class Interpreted t => Monadic t where
@@ -26,10 +26,7 @@
 infixr 3 :>
 newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
 
-instance Covariant (Schematic Monad t u) => Covariant (t :> u) where
-	f <$> TM x = TM $ f <$> x
-
-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
@@ -38,14 +35,8 @@
 instance Extractable (Schematic Monad t u) (->) => Extractable (t :> u) (->) where
 	extract = extract . tm
 
-instance Applicative (Schematic Monad t u) => Applicative (t :> u) where
-	TM f <*> TM x = TM $ f <*> x
-
-instance Alternative (Schematic Monad t u) => Alternative (t :> u) where
-	TM x <+> TM y = TM $ x <+> y
-
-instance Avoidable (Schematic Monad t u) => Avoidable (t :> u) where
-	empty = TM empty
+instance Semimonoidal (Schematic Monad t u) (->) (:*:) (:*:) => Semimonoidal (t :> u) (->) (:*:) (:*:) where
+	multiply_ (TM f :*: TM x) = TM $ multiply_ $ f :*: x
 
 instance Traversable (Schematic Monad t u) (->) (->) => Traversable (t :> u) (->) (->) where
 	f <<- TM x = TM -<$>- f <<- x
@@ -59,7 +50,7 @@
 instance Extendable (Schematic Monad t u) (->) => Extendable (t :> u) (->) where
 	f <<= TM x = TM $ f . TM <<= x
 
-instance (Covariant_ (Schematic Monad t u) (->) (->), Pointable (t :> u) (->), Bindable (t :> u) (->)) => Monad (t :> u) where
+instance (Covariant (Schematic Monad t u) (->) (->), Pointable (t :> u) (->), Bindable (t :> u) (->)) => Monad (t :> u) where
 
 instance Liftable (Schematic Monad t) => Liftable ((:>) t) where
 	lift = TM . lift
diff --git a/Pandora/Paradigm/Controlflow/Observable.hs b/Pandora/Paradigm/Controlflow/Observable.hs
--- a/Pandora/Paradigm/Controlflow/Observable.hs
+++ b/Pandora/Paradigm/Controlflow/Observable.hs
@@ -1,8 +1,9 @@
 module Pandora.Paradigm.Controlflow.Observable (Observable, observe,
 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where
 
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Applicative (Applicative (forever))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($), (#))
+import Pandora.Paradigm.Primary.Algebraic (Applicative_, forever_)
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 
@@ -22,26 +23,26 @@
 (.:~.) :: Observable t a r -> (a -> t r) -> t r
 (.:~.) = notify
 
--- | Listen only first event, call back forever
-follow :: Applicative t => Observable t a r -> (a -> t r) -> t r
-follow r action = captured $ run r # Capture . forever . action
+-- | Listen only first event, call back forever_
+follow :: Applicative_ t => Observable t a r -> (a -> t r) -> t r
+follow r action = captured $ run r # Capture . forever_ . action
 
 -- | Infix version of 'follow'
-(.:~*) :: Applicative t => Observable t a r -> (a -> t r) -> t r
+(.:~*) :: Applicative_ t => Observable t a r -> (a -> t r) -> t r
 (.:~*) = follow
 
 -- | Listen all events from action, call back just once
-subscribe :: Applicative t => Observable t a r -> (a -> t r) -> t r
-subscribe r action = forever $ captured $ run r # Capture . action
+subscribe :: Applicative_ t => Observable t a r -> (a -> t r) -> t r
+subscribe r action = forever_ $ captured $ run r # Capture . action
 
 -- | Infix version of 'subscribe'
-(*:~.) :: Applicative t => Observable t a r -> (a -> t r) -> t r
+(*:~.) :: Applicative_ t => Observable t a r -> (a -> t r) -> t r
 (*:~.) = subscribe
 
--- | Listen all events from action, call back forever
-watch :: Applicative t => Observable t a r -> (a -> t r) -> t r
-watch r action = forever $ captured $ run r # Capture . forever . action
+-- | Listen all events from action, call back forever_
+watch :: Applicative_ t => Observable t a r -> (a -> t r) -> t r
+watch r action = forever_ $ captured $ run r # Capture . forever_ . action
 
 -- | Infix version of 'watch'
-(*:~*) :: Applicative t => Observable t a r -> (a -> t r) -> t r
+(*:~*) :: Applicative_ t => Observable t a r -> (a -> t r) -> t r
 (*:~*) = watch
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
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Controlflow.Pipeline (Pipeline, await, yield, finish, impact, (=*=), pipeline) where
 
-import Pandora.Pattern.Category (($), (.), (#))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (!..))
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -12,8 +12,8 @@
 import Pandora.Paradigm.Inventory.Accumulator as Exports
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category ((.), ($), (#), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant)
+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 ((<->))
@@ -45,7 +45,7 @@
 (=<>) :: Stateful src t => Lens mode src tgt -> mode tgt -> t src
 lens =<> new = modify $ set lens new
 
-(~<>) :: Covariant mode => Stateful src t => Lens mode src tgt -> (mode tgt -> mode tgt) -> t src
+(~<>) :: Stateful src t => Lens mode src tgt -> (mode tgt -> mode tgt) -> t src
 lens ~<> f = modify $ over lens f
 
 magnify :: forall bg ls t . (Accessible ls bg, Stateful bg t) => t ls
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
@@ -2,10 +2,11 @@
 
 module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where
 
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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.Applicative (Applicative ((<*>)))
+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))
@@ -18,15 +19,12 @@
 
 newtype Accumulator e a = Accumulator (e :*: a)
 
-instance Covariant (Accumulator e) where
-	f <$> Accumulator x = Accumulator $ f <$> x
-
-instance Covariant_ (Accumulator e) (->) (->) where
+instance Covariant (Accumulator e) (->) (->) where
 	f -<$>- Accumulator x = Accumulator $ f -<$>- x
 
-instance Semigroup e => Applicative (Accumulator e) where
-	f <*> v = Accumulator $ k # run f # run v where
-		k ~(e :*: g) ~(e' :*: w) = e + e' :*: g w
+instance 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 :*:)
@@ -46,10 +44,6 @@
 	wrap = TM . UT . point . run
 
 type Accumulated e t = Adaptable (Accumulator e) t
-
-instance {-# OVERLAPS #-} (Semigroup e, Applicative u) => Applicative ((:*:) e <.:> u) where
-	UT f <*> UT x = UT $ k <$> f <*> x where
-		k ~(u :*: g) ~(v :*: y) = u + v :*: g y
 
 instance {-# OVERLAPS #-} (Pointable u (->), Monoid e) => Pointable ((:*:) e <.:> u) (->) where
 	point = UT . point . (zero :*:)
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
@@ -2,16 +2,19 @@
 
 module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where
 
-import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))
+import Pandora.Pattern.Semigroupoid ((.))
+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.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 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 ()
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
@@ -20,20 +23,17 @@
 
 newtype Environment e a = Environment (e -> a)
 
-instance Covariant (Environment e) where
-	f <$> Environment x = Environment $ f . x
-
-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 Applicative (Environment e) where
-	f <*> x = Environment $ run f <*> run x
+instance Semimonoidal (Environment e) (->) (:*:) (:*:) where
+	multiply_ (x :*: y) = unite $ multiply_ $ run x :*: run y
 
 instance Distributive (Environment e) (->) (->) where
 	f -<< g = Environment $ (run -<$>- f) -<< g
@@ -54,7 +54,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
@@ -2,8 +2,9 @@
 
 module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where
 
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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 ((<<=)))
@@ -17,10 +18,7 @@
 
 newtype Equipment e a = Equipment (e :*: a)
 
-instance Covariant (Equipment e) where
-	f <$> Equipment x = Equipment $ f <$> x
-
-instance Covariant_ (Equipment e) (->) (->) where
+instance Covariant (Equipment e) (->) (->) where
 	f -<$>- Equipment x = Equipment $ f -<$>- x
 
 instance Extractable (Equipment e) (->) where
@@ -40,7 +38,7 @@
 type instance Schematic Comonad (Equipment e) = (<:.>) ((:*:) e)
 
 instance Comonadic (Equipment e) where
-	bring (TC (TU x)) = Equipment $ extract <$> x
+	bring (TC (TU x)) = Equipment $ extract @_ @(->) -<$>- x
 
 type Equipped e t = Adaptable t (Equipment e)
 
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
@@ -2,9 +2,10 @@
 
 module Pandora.Paradigm.Inventory.Imprint (Imprint (..), Traceable) where
 
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))
+import Pandora.Pattern.Semigroupoid ((.))
+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 ((<<=)))
@@ -21,13 +22,10 @@
 
 newtype Imprint e a = Imprint (e -> a)
 
-instance Covariant (Imprint e) where
-	f <$> Imprint x = Imprint $ f . x
-
-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
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
@@ -3,8 +3,9 @@
 module Pandora.Paradigm.Inventory.Optics where
 
 import Pandora.Core.Impliable (Impliable (Arguments, imply))
-import Pandora.Pattern.Category (Category (identity, (.), ($), (#)))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)))
+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 ((>->))
@@ -13,6 +14,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.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
@@ -26,14 +28,16 @@
 type Lens = P_Q_T (->) Store
 
 instance Invariant (Flip (Lens available) tgt) where
-	f <$< g = \(Flip (P_Q_T lens)) -> Flip . P_Q_T $ g >-> (f <$>) $ lens
+	f <$< g = \(Flip (P_Q_T lens)) -> Flip . P_Q_T $ g >-> (f -<$>-) $ lens
 
 type family Convex lens where
 	Convex Lens = Lens Identity
 
+instance Semigroupoid (Lens Identity) where
+	P_Q_T to . P_Q_T from = P_Q_T $ \source -> (to . extract @Identity . position $ from source) $>- source
+
 instance Category (Lens Identity) where
 	identity = imply @(Convex Lens _ _) identity ((%) (!.))
-	P_Q_T to . P_Q_T from = P_Q_T $ \source -> source <$ (to . extract @Identity . position $ from source)
 
 instance Impliable (P_Q_T (->) Store Identity source target) where
 	type Arguments (P_Q_T (->) Store Identity source target) =
@@ -48,12 +52,14 @@
 		(source -> Maybe target) -> (source -> Maybe target -> source) -> Lens Maybe source target
 	imply getter setter = P_Q_T $ \source -> Store $ getter source :*: setter source
 
-instance Category (Lens Maybe) where
-	identity = imply @(Obscure Lens _ _) # Just # resolve identity
+instance Semigroupoid (Lens Maybe) where
 	P_Q_T to . P_Q_T from = P_Q_T $ \source -> case position # from source of
 		Nothing -> Store $ Nothing :*: (source !.)
-		Just between -> source <$ to between
+		Just between -> to between $>- source
 
+instance Category (Lens Maybe) where
+	identity = imply @(Obscure Lens _ _) # Just # resolve identity
+
 -- Lens as natural transformation
 type (#=@) source target available = forall a . Lens available (source a) (target a)
 
@@ -66,7 +72,7 @@
 set lens new = look new . run lens
 
 -- | Modify focused target value
-over :: Covariant available => Lens available source target -> (available target -> available target) -> source -> source
+over :: Lens available source target -> (available target -> available target) -> source -> source
 over lens f = extract . retrofit f . run lens
 
 -- | Representable based lens
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
@@ -3,11 +3,12 @@
 module Pandora.Paradigm.Inventory.State where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Semigroupoid ((.))
+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.Applicative (Applicative ((<*>)), Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -19,25 +20,19 @@
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))
-import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (%), (!.), (-<*>-), delta)
+import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (*>-), delta)
 
 -- | Effectful computation with a variable
 newtype State s a = State ((->) s :. (:*:) s := a)
 
-instance Covariant (State s) where
-	f <$> x = State $ (<$>) f . run x
-
-instance Covariant_ (State s) (->) (->) where
+instance Covariant (State s) (->) (->) where
 	f -<$>- x = State $ (-<$>-) f . run x
 
-instance Applicative (State s) where
-	f <*> x = State $ ((<$>) |-) . (run x <-> identity @(->)) . run f
-
-instance Semimonoidal (State s) (:*:) (->) (->) where
-	multiply f (State g :*: State h) = State $ \s -> 
-		let old :*: x = g s in
-		let new :*: y = h old in
-		new :*: f (x :*: y)
+instance 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 @(->) -|)
@@ -58,7 +53,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)
 
@@ -77,7 +72,7 @@
 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 = (Pointable t (->), Semimonoidal t (->) (:*:) (:*:), Stateful s t)
 
 fold :: (Traversable t (->) (->), Memorable s u) => (a -> s -> s) -> t a -> u s
-fold op struct = ((!.) %) -<$>- (modify . op <<- struct) -<*>- current
+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
@@ -3,8 +3,9 @@
 module Pandora.Paradigm.Inventory.Store where
 
 import Pandora.Core (type (:.), type (:=), type (<:=), type (~>))
-import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (.#..)), Covariant_ ((-<$>-)), (-<$$>-))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (identity, ($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -12,7 +13,7 @@
 import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), (-.#..-))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
 import Pandora.Paradigm.Primary.Algebraic ()
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
@@ -24,17 +25,14 @@
 -- | Context based computation on value
 newtype Store s a = Store ((:*:) s :. (->) s := a)
 
-instance Covariant (Store s) where
-	f <$> Store x = Store $ f <$$> x
-
-instance Covariant_ (Store s) (->) (->) where
+instance Covariant (Store s) (->) (->) where
 	f -<$>- Store x = Store $ f -<$$>- x
 
 instance Extractable (Store s) (->) where
 	extract = (($) |-) . run
 
 instance Extendable (Store s) (->) where
-	f <<= Store x = Store $ f -<$$>- (Store .#.. (identity @(->) -|) -<$>- x)
+	f <<= Store x = Store $ f -<$$>- (Store -.#..- (identity @(->) -|) -<$>- x)
 
 instance Comonad (Store s) (->) where
 
diff --git a/Pandora/Paradigm/Primary.hs b/Pandora/Paradigm/Primary.hs
--- a/Pandora/Paradigm/Primary.hs
+++ b/Pandora/Paradigm/Primary.hs
@@ -9,29 +9,25 @@
 import Pandora.Paradigm.Primary.Algebraic as Exports
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Category (Category ((.), ($), (#), identity))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
+import Pandora.Pattern.Category (Category (($), (#), identity))
+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, (||=))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Schemes (TU (TU), P_Q_T (P_Q_T), type (<:.>), type (<:.:>))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (resolve))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into), premorph)
 import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Available, Substance, substructure))
 
-instance Category (Flip (->)) where
-	identity = Flip identity
+instance Semigroupoid (Flip (->)) where
 	Flip f . Flip g = Flip $ \x -> g (f x)
 
-instance Contravariant (Flip (->) r) where
-	f >$< g = (<$> f) ||= g
-
-instance Covariant (Flip (:*:) a) where
-	f <$> (Flip (x :*: y)) = Flip $ f x :*: y
+instance Category (Flip (->)) where
+	identity = Flip identity
 
 instance Extractable (Flip (:*:) a) (->) where
 	extract (Flip (x :*: _)) = x
@@ -103,16 +99,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,22 +1,30 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Primary.Algebraic (module Exports, (-<*>-)) where
+module Pandora.Paradigm.Primary.Algebraic (module Exports, Applicative_, Alternative_, ($>-), ($$>-), ($$$>-), (-<*>-), (*>-), forever_, (-+-)) 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.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor (Endofunctor)
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-), (-<$$$>-))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 
 infixl 4 -<*>-
 
-instance Semimonoidal ((->) e) (:*:) (->) (->) where
-	multiply f (g :*: h) = \x -> f $ g x :*: h x
+($>-) :: Covariant t (->) (->) => t a -> b -> t b
+x $>- r = (r !.) -<$>- x
 
+($$>-) :: (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))
+x $$$>- r = (r !.) -<$$$>- x
+
 instance Traversable ((:*:) s) (->) (->) where
 	f <<- x = (attached x :*:) -<$>- f (extract x)
 
@@ -26,5 +34,27 @@
 	(|-) :: (a -> s -> b) -> (s :*: a) -> b
 	f |- ~(s :*: x) = f x s
 
-(-<*>-) :: forall a b t . (Semimonoidal t (:*:) (->) (->)) => t (a -> b) -> t a -> t b
-(-<*>-) = (%) ((-|) @((:*:) (t (a -> b))) (multiply @t @(:*:) @(->) @(->) ((&) |-)))
+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
+
+type Applicative_ t = (Endofunctor Covariant t (->), Semimonoidal t (->) (:*:) (:*:))
+type Alternative_ t = (Endofunctor Covariant t (->), Semimonoidal t (->) (:*:) (:+:))
+
+(-<*>-) :: Applicative_ t => t (a -> b) -> t a -> t b
+f -<*>- x = (|-) @_ @_ @(->) @(->) (&) -<$>- multiply_ @_ @_ @_ @(:*:) (f :*: x)
+
+forever_ :: Applicative_ t => t a -> t b
+forever_ x = let r = x *>- r in r
+
+(*>-) :: Applicative_ 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)
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
@@ -2,10 +2,10 @@
 
 module Pandora.Paradigm.Primary.Algebraic.Exponential where
 
-import Pandora.Pattern.Category (Category ((.), ($), (#), identity))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
+import Pandora.Pattern.Category (Category (($), (#), identity))
+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 ((=<<)))
@@ -16,25 +16,22 @@
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 infixr 2 !.
+infixr 7 -.#..-
 infixr 9 %
 infixl 1 &
 
-instance Category (->) where
-	identity x = x
+instance Semigroupoid (->) where
 	f . g = \x -> f (g x)
 
-instance Covariant ((->) a) where
-	(<$>) = (.)
+instance Category (->) where
+	identity x = x
 
-instance Covariant_ ((->) a) (->) (->) where
+instance Covariant ((->) a) (->) (->) where
 	(-<$>-) = (.)
 
-instance Contravariant_ (Flip (->) a) (->) (->) where
+instance Contravariant (Flip (->) a) (->) (->) where
 	f ->$<- Flip g = Flip $ g . f
 
-instance Applicative ((->) e) where
-	(<*>) f g x = f x $ g x
-
 instance Distributive ((->) e) (->) (->) where
 	f -<< g = \e -> (f % e) -<$>- g
 
@@ -58,7 +55,7 @@
 instance Ringoid r => Ringoid (e -> r) where
 	f * g = \e -> f e * g e
 
-(-.#..-) :: (Covariant_ (v a) (->) target, Category v) => v c d -> target (v a (v b c)) (v a (v b d))
+(-.#..-) :: (Covariant (v a) (->) target, 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/Product.hs b/Pandora/Paradigm/Primary/Algebraic/Product.hs
--- a/Pandora/Paradigm/Primary/Algebraic/Product.hs
+++ b/Pandora/Paradigm/Primary/Algebraic/Product.hs
@@ -2,8 +2,8 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
@@ -23,13 +23,10 @@
 
 data (:*:) s a = s :*: a
 
-instance Covariant ((:*:) s) where
-	f <$> x = attached x :*: f # extract x
-
-instance Covariant_ ((:*:) s) (->) (->) where
+instance Covariant ((:*:) s) (->) (->) where
 	f -<$>- x = attached x :*: f # extract x
 
-instance Covariant_ (Flip (:*:) a) (->) (->) where
+instance Covariant (Flip (:*:) a) (->) (->) where
 	f -<$>- (Flip (x :*: y)) = Flip $ f x :*: y
 
 instance Extractable ((:*:) a) (->) where
@@ -69,8 +66,8 @@
 instance (Group s, Group a) => Group (s :*: a) where
 	invert x = invert # attached x :*: invert # extract x
 
-instance {-# OVERLAPS #-} Applicative t => Applicative (t <:.:> t := (:*:)) where
-	T_U (lfs :*: rfs) <*> T_U (ls :*: rs) = T_U $ lfs <*> ls :*: rfs <*> rs
+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)
 
 delta :: a -> a :*: a
 delta x = x :*: x
diff --git a/Pandora/Paradigm/Primary/Algebraic/Sum.hs b/Pandora/Paradigm/Primary/Algebraic/Sum.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Algebraic/Sum.hs
@@ -0,0 +1,29 @@
+module Pandora.Paradigm.Primary.Algebraic.Sum where
+
+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))
+
+infixr 0 :+:
+
+data (:+:) s a = Option s | Adoption a
+
+instance Covariant ((:+:) s) (->) (->) where
+	_ -<$>- Option s = Option s
+	f -<$>- Adoption x = Adoption $ f x
+
+instance Pointable ((:+:) e) (->) where
+	point = Adoption
+
+instance Bivariant (:+:) (->) (->) (->) where
+	f <-> g = \case
+		Option s -> Option $ f s
+		Adoption x -> Adoption $ g x
+
+instance Covariant (Flip (:+:) a) (->) (->) where
+	_ -<$>- Flip (Adoption x) = Flip $ Adoption x
+	f -<$>- Flip (Option y) = Flip . Option $ f y
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
@@ -1,11 +1,12 @@
 module Pandora.Paradigm.Primary.Functor.Conclusion where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category (identity, (.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (identity, ($), (#))
+import Pandora.Pattern.Functor (Endofunctor)
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -16,6 +17,7 @@
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
 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))
@@ -24,38 +26,28 @@
 
 data Conclusion e a = Failure e | Success a
 
-instance Covariant (Conclusion e) where
-	f <$> Success x = Success $ f x
-	_ <$> Failure y = Failure y
-
-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 f (Success x :*: Success y) = Success . f $ x :*: y
-	multiply _ (Failure x :*: _) = Failure x
-	multiply _ (_ :*: Failure x) = Failure x
-
-instance Semimonoidal (Conclusion e) Conclusion (->) (->) where
-	multiply f (Failure (Success x)) = Success . f $ Failure x
-	multiply f (Success (Success y)) = Success . f $ Success y
-	multiply _ (Failure (Failure e)) = Failure e
-	multiply _ (Success (Failure e)) = Failure e
+instance Semimonoidal (Conclusion e) (->) (:*:) (:*:) where
+	multiply_ (Success x :*: Success y) = Success $ x :*: y
+	multiply_ (Failure x :*: _) = Failure x
+	multiply_ (_ :*: Failure x) = Failure x
 
-instance Alternative (Conclusion e) where
-	Failure _ <+> x = x
-	Success x <+> _ = 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
-	(<<-) :: (Covariant_ u (->) (->), Pointable u (->), Semimonoidal u (:*:) (->) (->))
+	(<<-) :: (Endofunctor Covariant u (->), Pointable u (->), Semimonoidal u (->) (:*:) (:*:))
 		 => (a -> u b) -> Conclusion e a -> u (Conclusion e b)
 	_ <<- Failure y = point $ Failure y
 	f <<- Success x = Success -<$>- f x
diff --git a/Pandora/Paradigm/Primary/Functor/Constant.hs b/Pandora/Paradigm/Primary/Functor/Constant.hs
--- a/Pandora/Paradigm/Primary/Functor/Constant.hs
+++ b/Pandora/Paradigm/Primary/Functor/Constant.hs
@@ -1,8 +1,9 @@
 module Pandora.Paradigm.Primary.Functor.Constant where
 
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
@@ -19,17 +20,14 @@
 
 newtype Constant a b = Constant a
 
-instance Covariant (Constant a) where
-	_ <$> Constant x = Constant x
-
-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
-	_ >$< Constant x = Constant x
+instance Contravariant (Constant a) (->) (->) where
+	_ ->$<- Constant x = Constant x
 
 instance Invariant (Constant a) where
 	_ <$< _ = \(Constant x) -> Constant x
diff --git a/Pandora/Paradigm/Primary/Functor/Convergence.hs b/Pandora/Paradigm/Primary/Functor/Convergence.hs
--- a/Pandora/Paradigm/Primary/Functor/Convergence.hs
+++ b/Pandora/Paradigm/Primary/Functor/Convergence.hs
@@ -1,19 +1,10 @@
 module Pandora.Paradigm.Primary.Functor.Convergence where
 
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)), Contravariant_ ((->$<-)))
-import Pandora.Pattern.Functor.Divisible (Divisible ((>*<)))
-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
+import Pandora.Paradigm.Primary.Algebraic ()
 
 data Convergence r a = Convergence (a -> a -> r)
 
-instance Contravariant (Convergence r) where
-	f >$< Convergence g = Convergence $ \x y -> g # f x # f y
-
-instance Contravariant_ (Convergence r) (->) (->) where
+instance Contravariant (Convergence r) (->) (->) where
 	f ->$<- Convergence g = Convergence $ \x y -> g # f x # f y
-
-instance Ringoid r => Divisible (Convergence r) where
-	Convergence g >*< Convergence h = Convergence $
-		\(x :*: x') (y :*: y') -> g x y * h x' 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
@@ -1,20 +1,14 @@
 module Pandora.Paradigm.Primary.Functor.Edges where
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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 ()
 
 data Edges a = Empty | Leap a | Connect a | Overlay a
 
-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 Covariant_ Edges (->) (->) where
+instance Covariant Edges (->) (->) where
 	_ -<$>- Empty = Empty
 	f -<$>- Connect x = Connect $ f x
 	f -<$>- Overlay x = Overlay $ f x
diff --git a/Pandora/Paradigm/Primary/Functor/Endo.hs b/Pandora/Paradigm/Primary/Functor/Endo.hs
--- a/Pandora/Paradigm/Primary/Functor/Endo.hs
+++ b/Pandora/Paradigm/Primary/Functor/Endo.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Endo where
 
-import Pandora.Pattern.Category (identity, (.), (#))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (identity, (#))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
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
@@ -1,17 +1,17 @@
 module Pandora.Paradigm.Primary.Functor.Fix where
 
 import Pandora.Core.Functor (type (<:=), type (:=>))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant (comap))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 newtype Fix t = Fix { unfix :: t (Fix t) }
 
-cata :: Covariant t => (a <:= t) -> Fix t -> a
-cata f = f . comap (cata f) . unfix
+cata :: Covariant t (->) (->) => (a <:= t) -> Fix t -> a
+cata f = f . (cata f -<$>-) . unfix
 
-ana :: Covariant t => (a :=> t) -> a -> Fix t
-ana f = Fix . comap (ana f) . f
+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
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Primary.Functor.Identity where
 
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap), Covariant_ ((-<$>-)))
+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.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -25,10 +25,7 @@
 
 newtype Identity a = Identity a
 
-instance Covariant Identity where
-	f <$> Identity x = Identity $ f x
-
-instance Covariant_ Identity (->) (->) where
+instance Covariant Identity (->) (->) where
 	f -<$>- Identity x = Identity $ f x
 
 instance Pointable Identity (->) where
@@ -37,9 +34,6 @@
 instance Extractable Identity (->) where
 	extract (Identity x) = x
 
-instance Applicative Identity where
-	Identity f <*> Identity x = Identity $ f x
-
 instance Traversable Identity (->) (->) where
 	f <<- Identity x = Identity -<$>- f x
 
@@ -60,7 +54,7 @@
 
 instance Adjoint Identity Identity (->) (->) where
 	f -| x = Identity . f . Identity $ x
-	g |- x = extract . extract . comap g $ x
+	g |- x = extract . extract . (g -<$>-) $ x
 
 instance Setoid a => Setoid (Identity a) where
 	Identity x == Identity y = x == y
diff --git a/Pandora/Paradigm/Primary/Functor/Maybe.hs b/Pandora/Paradigm/Primary/Functor/Maybe.hs
--- a/Pandora/Paradigm/Primary/Functor/Maybe.hs
+++ b/Pandora/Paradigm/Primary/Functor/Maybe.hs
@@ -1,12 +1,11 @@
 module Pandora.Paradigm.Primary.Functor.Maybe where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+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.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -25,38 +24,26 @@
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (Failure, Success))
+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
 
 data Maybe a = Nothing | Just a
 
-instance Covariant Maybe where
-	f <$> Just x = Just $ f x
-	_ <$> Nothing = Nothing
-
-instance Covariant_ Maybe (->) (->) where
+instance Covariant Maybe (->) (->) where
 	f -<$>- Just x = Just $ f x
 	_ -<$>- Nothing = Nothing
 
 instance Pointable Maybe (->) where
 	point = Just
 
-instance Avoidable Maybe where
-	empty = Nothing
-
-instance Semimonoidal Maybe (:*:) (->) (->) where
-	multiply f (Just x :*: Just y) = Just . f $ x :*: y
-	multiply _ (Nothing :*: _) = Nothing
-	multiply _ (_ :*: Nothing) = Nothing
-
-instance Semimonoidal Maybe Conclusion (->) (->) where
-	multiply f (Failure (Just x)) = Just . f $ Failure x
-	multiply f (Success (Just y)) = Just . f $ Success y
-	multiply _ (Failure Nothing) = Nothing
-	multiply _ (Success Nothing) = Nothing
+instance Semimonoidal Maybe (->) (:*:) (:*:) where
+	multiply_ (Just x :*: Just y) = Just $ x :*: y
+	multiply_ (Nothing :*: _) = Nothing
+	multiply_ (_ :*: Nothing) = Nothing
 
-instance Alternative Maybe where
-	Nothing <+> y = y
-	Just x <+> _ = Just x
+instance Semimonoidal Maybe (->) (:*:) (:+:) where
+	multiply_ (Just x :*: Just _) = Just $ Option x
+	multiply_ (Nothing :*: Just y) = Just $ Adoption y
+	multiply_ (Nothing :*: Nothing) = Nothing
 
 instance Traversable Maybe (->) (->) where
 	_ <<- Nothing = point Nothing
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
@@ -1,17 +1,11 @@
 module Pandora.Paradigm.Primary.Functor.Predicate where
 
 import Pandora.Core.Functor (type (~>), type (:=>))
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)), Contravariant_ ((->$<-)))
-import Pandora.Pattern.Functor.Divisible (Divisible ((>*<)), Divisible_ (divide))
-import Pandora.Pattern.Functor.Determinable (Determinable (determine))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
-import Pandora.Pattern.Object.Ringoid ((*))
-import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), bool, (?))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), bool)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype Predicate a = Predicate (a -> Boolean)
@@ -21,27 +15,11 @@
 	run ~(Predicate f) = f
 	unite = Predicate
 
-instance Contravariant Predicate where
-	f >$< Predicate g = Predicate $ g . f
-
-instance Contravariant_ Predicate (->) (->) where
+instance Contravariant Predicate (->) (->) where
 	f ->$<- Predicate g = Predicate $ g . f
 
-instance Divisible Predicate where
-	Predicate g >*< Predicate h = Predicate $ \(b :*: c) -> g b * h c
-
-instance Divisible_ Predicate (:*:) (->) (->) where
-	divide f (Predicate g :*: Predicate h) = Predicate $ \r -> case f r of
-		b :*: c -> g b * h c
-
-instance Determinable Predicate where
-	determine = Predicate (True !.)
-
 equate :: Setoid a => a :=> Predicate
 equate x = Predicate (== x)
-
-satisfy :: (Pointable t (->), Avoidable t) => Predicate a -> a -> t a
-satisfy p x = run p x ? point x $ empty
 
 not :: Predicate ~> Predicate
 not (Predicate p) = Predicate $ bool True False . p
diff --git a/Pandora/Paradigm/Primary/Functor/Proxy.hs b/Pandora/Paradigm/Primary/Functor/Proxy.hs
--- a/Pandora/Paradigm/Primary/Functor/Proxy.hs
+++ b/Pandora/Paradigm/Primary/Functor/Proxy.hs
@@ -1,10 +1,8 @@
 module Pandora.Paradigm.Primary.Functor.Proxy where
 
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -13,23 +11,14 @@
 
 data Proxy a = Proxy
 
-instance Covariant Proxy where
-	_ <$> Proxy = Proxy
-
-instance Covariant_ Proxy (->) (->) where
+instance Covariant Proxy (->) (->) where
 	_ -<$>- Proxy = Proxy
 
-instance Contravariant Proxy where
-	_ >$< _ = Proxy
+instance Contravariant Proxy (->) (->) where
+	_ ->$<- _ = Proxy
 
 instance Pointable Proxy (->) where
 	point _ = Proxy
-
-instance Applicative Proxy where
-	_ <*> _ = Proxy
-
-instance Alternative Proxy where
-	_ <+> _ = Proxy
 
 instance Distributive 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
@@ -1,11 +1,11 @@
 module Pandora.Paradigm.Primary.Functor.Tagged where
 
 import Pandora.Core.Functor (type (:=>), type (~>))
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -30,13 +30,10 @@
 infixr 0 :#
 type (:#) tag = Tagged tag
 
-instance Covariant (Tagged tag) where
-	f <$> Tag x = Tag $ f x
-
-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
@@ -44,9 +41,6 @@
 
 instance Extractable (Tagged tag) (->) where
 	extract (Tag x) = x
-
-instance Applicative (Tagged tag) where
-	Tag f <*> Tag x = Tag $ f x
 
 instance Traversable (Tagged tag) (->) (->) where
 	f <<- Tag x = Tag -<$>- f x
diff --git a/Pandora/Paradigm/Primary/Functor/These.hs b/Pandora/Paradigm/Primary/Functor/These.hs
--- a/Pandora/Paradigm/Primary/Functor/These.hs
+++ b/Pandora/Paradigm/Primary/Functor/These.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.These where
 
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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 ((+)))
@@ -9,12 +9,7 @@
 
 data These e a = This a | That e | These e a
 
-instance Covariant (These e) where
-	f <$> This x = This $ f x
-	_ <$> That y = That y
-	f <$> These y x = These y $ f x
-
-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
diff --git a/Pandora/Paradigm/Primary/Functor/Validation.hs b/Pandora/Paradigm/Primary/Functor/Validation.hs
--- a/Pandora/Paradigm/Primary/Functor/Validation.hs
+++ b/Pandora/Paradigm/Primary/Functor/Validation.hs
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Primary.Functor.Validation where
 
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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.Applicative (Applicative ((<*>)), Semimonoidal (multiply))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
@@ -12,17 +12,14 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
 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
-	_ <$> Flaws e = Flaws e
-	f <$> Validated x = Validated $ f x
-
-instance Covariant_ (Validation e) (->) (->) where
+instance Covariant (Validation e) (->) (->) where
 	_ -<$>- Flaws e = Flaws e
 	f -<$>- Validated x = Validated $ f x
 	_ -<$>- Flaws e = Flaws e
@@ -30,7 +27,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
@@ -41,21 +38,15 @@
 instance Pointable (Validation e) (->) where
 	point = Validated
 
-instance Semigroup e => Applicative (Validation e) where
-	Flaws e <*> Flaws e' = Flaws $ e + e'
-	Flaws e <*> Validated _ = Flaws e
-	Validated _ <*> Flaws e' = Flaws e'
-	Validated f <*> Validated x = Validated $ f x
-
-instance Semigroup e => Semimonoidal (Validation e) (:*:) (->) (->) where
-	multiply f (Validated x :*: Validated y) = Validated . f $ x :*: y
-	multiply _ (Flaws x :*: Flaws y) = Flaws $ x + y
-	multiply _ (Validated _ :*: Flaws y) = Flaws y
-	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 Alternative (Validation e) where
-	Flaws _ <+> x = x
-	Validated x <+> _ = 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
 	f <<- Validated x = Validated -<$>- f x
diff --git a/Pandora/Paradigm/Primary/Functor/Wedge.hs b/Pandora/Paradigm/Primary/Functor/Wedge.hs
--- a/Pandora/Paradigm/Primary/Functor/Wedge.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wedge.hs
@@ -1,19 +1,14 @@
 module Pandora.Paradigm.Primary.Functor.Wedge where
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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 ()
 
 data Wedge e a = Nowhere | Here e | There a
 
-instance Covariant (Wedge e) where
-	_ <$> Nowhere = Nowhere
-	_ <$> Here x = Here x
-	f <$> There x = There $ f x
-
-instance Covariant_ (Wedge e) (->) (->) where
+instance Covariant (Wedge e) (->) (->) where
 	_ -<$>- Nowhere = Nowhere
 	_ -<$>- Here x = 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
@@ -2,20 +2,14 @@
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 
 data Wye a = End | Left a | Right a | Both a a
 
-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 Covariant_ Wye (->) (->) where
+instance Covariant Wye (->) (->) where
 	_ -<$>- End = End
 	f -<$>- Left x = Left # f x
 	f -<$>- Right y = Right # f y
diff --git a/Pandora/Paradigm/Primary/Linear/Vector.hs b/Pandora/Paradigm/Primary/Linear/Vector.hs
--- a/Pandora/Paradigm/Primary/Linear/Vector.hs
+++ b/Pandora/Paradigm/Primary/Linear/Vector.hs
@@ -2,8 +2,8 @@
 
 module Pandora.Paradigm.Primary.Linear.Vector where
 
+import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Pointable (point)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
@@ -11,8 +11,9 @@
 import Pandora.Pattern.Object.Group (Group (invert))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)
-import Pandora.Paradigm.Primary.Transformer.Construction (Construction)
+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
+import Pandora.Paradigm.Schemes.TU (TU (TU))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into, Push), premorph, into, item)
@@ -66,12 +67,12 @@
 
 instance Morphable (Into List) (Vector r) where
 	type Morphing (Into List) (Vector r) = List
-	morphing (premorph -> Scalar x) = point x
+	morphing (premorph -> Scalar x) = TU . Just $ Construct x Nothing
 	morphing (premorph -> Vector x xs) = item @Push x $ into @List xs
 
 instance Morphable (Into (Construction Maybe)) (Vector r) where
 	type Morphing (Into (Construction Maybe)) (Vector r) = Construction Maybe
-	morphing (premorph -> Scalar x) = point x
+	morphing (premorph -> Scalar x) = Construct x Nothing
 	morphing (premorph -> Vector x xs) = item @Push x $ into @(Nonempty List) xs
 
 class Vectorize a r where
diff --git a/Pandora/Paradigm/Primary/Transformer/Backwards.hs b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
--- a/Pandora/Paradigm/Primary/Transformer/Backwards.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
@@ -1,11 +1,12 @@
 module Pandora.Paradigm.Primary.Transformer.Backwards where
 
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Semigroupoid ((.))
+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.Applicative (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
@@ -18,10 +19,7 @@
 
 newtype Backwards t a = Backwards (t a)
 
-instance Covariant t => Covariant (Backwards t) where
-	f <$> Backwards x = Backwards $ f <$> x
-
-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
@@ -31,9 +29,9 @@
 	extract (Backwards x) = extract x
 
 -- TODO: check that effects evaluation goes in opposite order
-instance Semimonoidal t (:*:) (->) (->) => Semimonoidal (Backwards t) (:*:) (->) (->) where
-	multiply f (Backwards x :*: Backwards y) = Backwards #
-		f .#.. ((:*:) %) -<$>- y -<*>- x
+instance (Semimonoidal t (->) (:*:) (:*:), Covariant t (->) (->)) => Semimonoidal (Backwards t) (->) (:*:) (:*:) where
+	multiply_ (Backwards x :*: Backwards y) = Backwards #
+		((:*:) %) -<$>- y -<*>- x
 
 instance Traversable t (->) (->) => Traversable (Backwards t) (->) (->) where
 	f <<- Backwards x = Backwards -<$>- f <<- x
@@ -41,8 +39,8 @@
 instance Distributive t (->) (->) => Distributive (Backwards t) (->) (->) where
 	f -<< x = Backwards $ run . f -<< x
 
-instance Contravariant t => Contravariant (Backwards t) where
-	f >$< Backwards x = Backwards $ f >$< x
+instance Contravariant t (->) (->) => Contravariant (Backwards t) (->) (->) where
+	f ->$<- Backwards x = Backwards $ f ->$<- x
 
 instance Interpreted (Backwards t) where
 	type Primary (Backwards t) a = t a
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
@@ -3,17 +3,13 @@
 module Pandora.Paradigm.Primary.Transformer.Construction where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (:=>), type (~>))
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+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.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
-import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
-import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist))
@@ -23,6 +19,7 @@
 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.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 import Pandora.Paradigm.Schemes (type (<:.>))
@@ -31,33 +28,22 @@
 
 data Construction t a = Construct a (t :. Construction t := a)
 
-instance Covariant t => Covariant (Construction t) where
-	f <$> ~(Construct x xs) = Construct # f x # f <$$> xs
-
-instance Covariant_ t (->) (->) => Covariant_ (Construction t) (->) (->) where
+instance Covariant t (->) (->) => Covariant (Construction t) (->) (->) where
 	f -<$>- ~(Construct x xs) = Construct # f x # f -<$$>- xs
 
-instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Construction t) (->) where
-	point x = Construct x empty
-
-instance Covariant_ t (->) (->) => Extractable (Construction t) (->) where
+instance Covariant t (->) (->) => Extractable (Construction t) (->) where
 	extract ~(Construct x _) = x
 
-instance Applicative t => Applicative (Construction t) where
-	~(Construct f fs) <*> ~(Construct x xs) = Construct # f x # fs <**> xs
+instance (Covariant t (->) (->), Semimonoidal t (->) (:*:) (:*:)) => Semimonoidal (Construction t) (->) (:*:) (:*:) where
+	multiply_ (Construct x xs :*: Construct y ys) = Construct (x :*: y) (multiply_ @_ @(->) @(:*:) -<$>- multiply_ (xs :*: ys))
 
 instance Traversable t (->) (->) => Traversable (Construction t) (->) (->) where
 	f <<- ~(Construct x xs) = Construct -<$>- f x -<*>- f -<<-<<- xs
 
-instance (Covariant_ t (->) (->), Alternative t) => Bindable (Construction t) (->) where
-	f =<< ~(Construct x xs) = Construct # extract (f x) # deconstruct (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 (Avoidable t, Alternative t, Covariant_ t (->) (->)) => Monad (Construction t) where
-
-instance (Covariant t, Covariant_ t (->) (->)) => Comonad (Construction t) (->) where
+instance (Covariant t (->) (->)) => Comonad (Construction t) (->) where
 
 instance Lowerable Construction where
 	lower x = extract @_ @(->) -<$>- deconstruct x
@@ -65,13 +51,13 @@
 instance 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, Covariant_ t (->) (->)) => Setoid (Construction t a) where
+instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant t (->) (->)) => Setoid (Construction t a) where
 	x == y = (extract x == extract y) * (deconstruct x == deconstruct y)
 
-instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant t, Covariant_ t (->) (->)) => Semigroup (Construction t a) where
+instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant t (->) (->)) => Semigroup (Construction t a) where
 	x + y = Construct # extract x + extract y # deconstruct x + deconstruct y
 
-instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant t, Covariant_ t (->) (->)) => Monoid (Construction t a) where
+instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant t (->) (->)) => Monoid (Construction t a) where
 	zero = Construct zero zero
 
 instance Monotonic a (t :. Construction t := a) => Monotonic a (Construction t a) where
@@ -84,8 +70,8 @@
 deconstruct ~(Construct _ xs) = xs
 
 -- Generate a construction from seed using effectful computation
-(.-+) :: Covariant t => a :=> t -> a :=> Construction t
-f .-+ x = Construct x $ (f .-+) <$> f x
+(.-+) :: Covariant t (->) (->) => a :=> t -> a :=> Construction t
+f .-+ x = Construct x $ (f .-+) -<$>- f x
 
 section :: Comonad 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
@@ -2,10 +2,10 @@
 module Pandora.Paradigm.Primary.Transformer.Continuation where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
@@ -19,19 +19,13 @@
 	run ~(Continuation x) = x
 	unite = Continuation
 
-instance Covariant t => Covariant (Continuation r t) where
-	f <$> Continuation continuation = Continuation $ continuation . (. f)
-
-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
+instance Covariant t (->) (->) => Pointable (Continuation r t) (->) where
 	point x = Continuation ($ x)
 
-instance Covariant t => Applicative (Continuation r t) where
-	f <*> x = Continuation $ \h -> run f $ \g -> run x # h . g
-
-instance Covariant_ t (->) (->) => Bindable (Continuation r t) (->) where
+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
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
@@ -2,32 +2,23 @@
 
 module Pandora.Paradigm.Primary.Transformer.Day where
 
-import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)), Covariant_ ((-<$>-)))
+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.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((!..), (-.#..-))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 
 data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a)
 
-instance Covariant (Day t u) where
-	f <$> Day tb uc g = Day tb uc # f .#.. g
-
-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 (Applicative t, Applicative u) => Applicative (Day t u) where
-	Day tb uc bcad <*> Day vb wc bca = Day # (:*:) <$> tb <*> vb # (:*:) <$> uc <*> wc
-		$ \(b :*: b') (c :*: c') -> bcad b c $ bca b' c'
-
 instance (Extractable t (->), Extractable u (->)) => Extractable (Day t u) (->) where
 	extract (Day tb uc bcad) = bcad # extract tb # extract uc
 
@@ -39,3 +30,6 @@
 
 instance Hoistable (Day t) where
 	g /|\ Day tb uc bca = Day tb # g uc # bca
+
+data Day_ category source target t u r = forall a b .
+	Day_ (target (category (source a b) r) (target (t a) (u b)))
diff --git a/Pandora/Paradigm/Primary/Transformer/Instruction.hs b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Instruction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
@@ -4,11 +4,9 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -16,34 +14,24 @@
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
 
 data Instruction t a = Enter a | Instruct (t :. Instruction t := a)
 
-instance Covariant t => Covariant (Instruction t) where
-	f <$> Enter x = Enter $ f x
-	f <$> Instruct xs = Instruct $ f <$$> xs
-
-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
+instance Covariant t (->) (->) => Pointable (Instruction t) (->) where
 	point = Enter
 
-instance Alternative t => Alternative (Instruction t) where
-	Enter x <+> _ = Enter x
-	_ <+> Enter y = Enter y
-	Instruct xs <+> Instruct ys = Instruct $ xs <+> ys
-
-instance Avoidable t => Avoidable (Instruction t) where
-	empty = Instruct empty
-
-instance Covariant t => Applicative (Instruction t) where
-	Enter f <*> Enter y = Enter $ f y
-	Enter f <*> Instruct y = Instruct $ f <$$> y
-	Instruct f <*> y = Instruct $ (<*> y) <$> f
+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 (->) (->) => Bindable (Instruction t) (->) where
+instance Covariant t (->) (->) => Bindable (Instruction t) (->) where
 	f =<< Enter x = f x
 	f =<< Instruct xs = Instruct $ (f =<<) -<$>- xs
 
@@ -60,6 +48,6 @@
 	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
+	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
@@ -2,13 +2,11 @@
 
 module Pandora.Paradigm.Primary.Transformer.Jack where
 
-import Pandora.Pattern.Category (identity, (.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -22,34 +20,16 @@
 
 data Jack t a = It a | Other (t a)
 
-instance Covariant t => Covariant (Jack t) where
-	f <$> It x = It $ f x
-	f <$> Other y = Other $ f <$> y
-
-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
+instance Covariant t (->) (->) => Pointable (Jack t) (->) where
 	point = It
 
-instance Alternative t => Alternative (Jack t) where
-	It x <+> _ = It x
-	Other _ <+> It y = It y
-	Other x <+> Other y = Other # x <+> y
-
-instance Avoidable t => Avoidable (Jack t) where
-	empty = Other empty
-
 instance Extractable t (->) => Extractable (Jack t) (->) where
 	extract (It x) = x
 	extract (Other y) = extract y
-
-instance Applicative t => Applicative (Jack t) where
-	It f <*> It x = It $ f x
-	It f <*> Other y = Other $ f <$> y
-	Other f <*> It x = Other $ ($ x) <$> f
-	Other f <*> Other y = Other $ f <*> y
 
 instance Traversable t (->) (->) => Traversable (Jack t) (->) (->) where
 	f <<- It x = It -<$>- f x
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
@@ -2,26 +2,18 @@
 
 module Pandora.Paradigm.Primary.Transformer.Jet where
 
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>), Covariant_ ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.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
-	f <$> Jet x xs = Jet (f x) (f <$$> xs)
-
-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
 	f <<- Jet x xs = Jet -<$>- f x -<*>- f -<<-<<- xs
 
-instance (forall u . Avoidable u, Covariant_ t (->) (->)) => Pointable (Jet t) (->) where
-	point x = Jet x empty
-
-instance Covariant_ t (->) (->) => Extractable (Jet t) (->) where
+instance Covariant t (->) (->) => Extractable (Jet t) (->) where
 	extract (Jet x _) = x
diff --git a/Pandora/Paradigm/Primary/Transformer/Kan.hs b/Pandora/Paradigm/Primary/Transformer/Kan.hs
--- a/Pandora/Paradigm/Primary/Transformer/Kan.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Kan.hs
@@ -1,8 +1,9 @@
 module Pandora.Paradigm.Primary.Transformer.Kan where
 
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))
-import Pandora.Pattern.Functor.Covariant (Covariant_ ((-<$>-)))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 
@@ -10,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
@@ -20,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
@@ -2,25 +2,20 @@
 
 module Pandora.Paradigm.Primary.Transformer.Outline where
 
-import Pandora.Pattern.Category (identity, (.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 data Outline t a where
 	Line :: a -> Outline t a
 	Outlined :: t a -> Outline t (a -> b) -> Outline t b
 
-instance Covariant (Outline t) where
-	f <$> Line a = Line $ f a
-	f <$> Outlined x y = Outlined x # (.) f <$> y
-
-instance Covariant_ (Outline t) (->) (->) where
+instance Covariant (Outline t) (->) (->) where
 	f -<$>- Line a = Line $ f a
 	f -<$>- Outlined x y = Outlined x # (.) f -<$>- y
 
@@ -31,19 +26,9 @@
 	extract (Line x) = x
 	extract (Outlined x y) = extract y # extract x
 
-instance Applicative (Outline f) where
-	Line f <*> y = f <$> y
-	Outlined x y <*> z = Outlined x # (%) <$> y <*> z
-
 instance Liftable Outline where
 	lift t = Outlined t (Line identity)
 
 instance Hoistable Outline where
 	_ /|\ Line x = Line x
 	f /|\ Outlined x y = Outlined # f x # f /|\ y
-
-instance (Extractable t (->), Pointable t (->), Applicative t) => Interpreted (Outline t) where
-	type Primary (Outline t) a = t a
-	run (Line x) = point x
-	run (Outlined t f) = run f <*> t
-	unite = Line . extract
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
@@ -2,27 +2,23 @@
 
 module Pandora.Paradigm.Primary.Transformer.Reverse where
 
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Semigroupoid ((.))
+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.Applicative (Semimonoidal (multiply))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype Reverse t a = Reverse (t a)
 
-instance Covariant t => Covariant (Reverse t) where
-	f <$> Reverse x = Reverse # f <$> x
-
-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
@@ -31,17 +27,14 @@
 instance Extractable t (->) => Extractable (Reverse t) (->) where
 	extract (Reverse x) = extract x
 
-instance Semimonoidal t (:*:) (->) (->) => Semimonoidal (Reverse t) (:*:) (->) (->) where
-	multiply f (Reverse x :*: Reverse y) = Reverse . multiply f $ x :*: y
-
 instance Traversable t (->) (->) => Traversable (Reverse t) (->) (->) where
 	f <<- Reverse x = Reverse -<$>- run (Backwards . f <<- x)
 
 instance Distributive t (->) (->) => Distributive (Reverse t) (->) (->) where
 	f -<< x = Reverse $ run . f -<< x
 
-instance Contravariant t => Contravariant (Reverse t) where
-	f >$< Reverse x = Reverse # f >$< x
+instance Contravariant t (->) (->) => Contravariant (Reverse t) (->) (->) where
+	f ->$<- Reverse x = Reverse # f ->$<- x
 
 instance Interpreted (Reverse t) where
 	type Primary (Reverse t) a = t a
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
@@ -3,16 +3,13 @@
 module Pandora.Paradigm.Primary.Transformer.Tap where
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
+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.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
@@ -31,28 +28,19 @@
 
 data Tap t a = Tap a (t a)
 
-instance Covariant t => Covariant (Tap t) where
-	f <$> Tap x xs = Tap # f x # f <$> xs
-
-instance Covariant_ t (->) (->) => Covariant_ (Tap t) (->) (->) where
+instance Covariant t (->) (->) => Covariant (Tap t) (->) (->) where
 	f -<$>- Tap x xs = Tap # f x # f -<$>- xs
 
-instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Tap t) (->) where
-	point = Tap % empty
-
-instance (Covariant_ t (->) (->)) => Extractable (Tap t) (->) where
+instance (Covariant t (->) (->)) => Extractable (Tap t) (->) where
 	extract (Tap x _) = x
 
-instance Applicative t => Applicative (Tap t) where
-	Tap f fs <*> Tap x xs = Tap # f x # fs <*> xs
+instance Semimonoidal t (->) (:*:) (:*:) => Semimonoidal (Tap t) (->) (:*:) (:*:) where
+	multiply_ (Tap x xs :*: Tap y ys) = Tap (x :*: y) $ multiply_ $ xs :*: ys
 
 instance Traversable t (->) (->) => Traversable (Tap t) (->) (->) where
 	f <<- Tap x xs = Tap -<$>- f x -<*>- f <<- xs
 
-instance (Extractable t (->), Alternative t, Bindable t (->)) => Bindable (Tap t) (->) where
-	f =<< Tap x xs = case f x of ~(Tap y ys) -> Tap y $ ys <+> (lower . f =<< xs)
-
-instance (Extendable t (->), Covariant_ t (->) (->)) => Extendable (Tap t) (->) where
+instance (Extendable t (->), Covariant t (->) (->)) => Extendable (Tap t) (->) where
 	f <<= x = Tap # f x $ f . Tap (extract x) <<= lower x
 
 instance Lowerable Tap where
@@ -61,26 +49,27 @@
 instance Hoistable Tap where
 	f /|\ Tap x xs = Tap x # f xs
 
-instance {-# OVERLAPS #-} Applicative t => Applicative (Tap (t <:.:> t := (:*:))) where
-	Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs)
+instance 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
 	f <<- Tap x (T_U (future :*: past)) = (\past' x' future' -> Tap x' $ twosome # future' # run past')
 		-<$>- f <<- Reverse past -<*>- f x -<*>- f <<- future
 
-instance (Covariant t, Covariant_ t (->) (->)) => Substructure Root (Tap (t <:.:> t := (:*:))) where
+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, 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, 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
@@ -2,36 +2,21 @@
 
 module Pandora.Paradigm.Primary.Transformer.Yoneda where
 
-import Pandora.Pattern.Category (identity, (.), ($), (#))
-import Pandora.Pattern.Functor ((<*+>))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+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 ((!.))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 newtype Yoneda t a = Yoneda
 	{ yoneda :: forall b . (a -> b) -> t b }
 
-instance Covariant (Yoneda t) where
-	f <$> x = Yoneda (\k -> yoneda x (k . f))
-
-instance Covariant_ (Yoneda t) (->) (->) where
+instance Covariant (Yoneda t) (->) (->) where
 	f -<$>- x = Yoneda (\k -> yoneda x (k . f))
 
-instance Alternative t => Alternative (Yoneda t) where
-	Yoneda f <+> Yoneda g = Yoneda (f <*+> g)
-
-instance Applicative t => Applicative (Yoneda t) where
-	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)
-
-instance Avoidable t => Avoidable (Yoneda t) where
-	empty = Yoneda (empty !.)
-
 instance Pointable t (->) => Pointable (Yoneda t) (->) where
 	point x = Yoneda (\f -> point $ f x)
 
@@ -43,4 +28,4 @@
 
 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
+	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
@@ -14,32 +14,34 @@
 import Pandora.Paradigm.Schemes.TUT as Exports
 import Pandora.Paradigm.Schemes.TU as Exports
 
-import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 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
 		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 (->) (->))
+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 (->) (->))
+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 (->) (->))
+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')
+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
diff --git a/Pandora/Paradigm/Schemes/TU.hs b/Pandora/Paradigm/Schemes/TU.hs
--- a/Pandora/Paradigm/Schemes/TU.hs
+++ b/Pandora/Paradigm/Schemes/TU.hs
@@ -1,13 +1,12 @@
 module Pandora.Paradigm.Schemes.TU where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
-import Pandora.Pattern.Category ((.), ($), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($), identity)
+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
@@ -16,6 +15,7 @@
 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 ((:*:)((:*:)))
 
 newtype TU ct cu t u a = TU (t :. u := a)
 
@@ -31,20 +31,11 @@
 	run ~(TU x) = x
 	unite = TU
 
-instance (Covariant t, Covariant u) => Covariant (t <:.> u) where
-	f <$> x = TU $ f <$$> run x
-
-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 (Applicative t, Applicative u) => Applicative (t <:.> u) where
-	TU f <*> TU x = TU $ f <**> x
-
-instance (Covariant u, Alternative t) => Alternative (t <:.> u) where
-	x <+> y = TU $ run x <+> run y
-
-instance (Covariant u, Avoidable t) => Avoidable (t <:.> u) where
-	empty = TU empty
+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
@@ -55,17 +46,17 @@
 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
+	lift :: Covariant u (->) (->) => u ~> t <:.> u
 	lift = TU . point
 
 instance Extractable 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
@@ -1,9 +1,11 @@
 module Pandora.Paradigm.Schemes.TUT where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
-import Pandora.Pattern.Category (identity, (.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$$>)), Covariant_ ((-<$>-)), (-<$$$>-))
+import Pandora.Pattern.Semigroupoid ((.))
+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.Extendable (Extendable ((<<=)))
@@ -11,6 +13,7 @@
 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.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a)
@@ -31,37 +34,25 @@
 	run ~(TUT x) = x
 	unite = TUT
 
-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 (->) (->)) => 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', Adjoint t' t (->) (->), Bindable u (->)) => Applicative (t <:<.>:> t' := u) where
---	f <*> x = TUT $ (>>= ((<$$$> run x) |-)) <$> run f
-
---instance (Applicative t, Covariant t', Alternative u) => Alternative (t <:<.>:> t' := u) where
---	x <+> y = TUT $ run x <*+> run y
-
---instance (Pointable t (->), Applicative t, Covariant t', Avoidable u) => Avoidable (t <:<.>:> t' := u) where
---	empty = TUT $ point empty
+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
+instance (Covariant t (->) (->), Covariant t' (->) (->), Pointable u (->), Adjoint t' t (->) (->)) => Pointable (t <:<.>:> t' := u) (->) where
 	point = unite . (point @_ @(->) -|)
 
---instance (Covariant t, Covariant t', Adjoint t' t (->) (->), Bindable u (->)) => Bindable (t <:<.>:> t' := u) (->) where
---	f =<< x = TUT $ ((run . f |-) =<<) -<$>- x
-
-instance (Covariant t', Covariant t, Adjoint t' t (->) (->), Extendable u (->)) => Extendable (t' <:<.>:> t := u) (->) where
+instance (Adjoint t' t (->) (->), Extendable u (->)) => Extendable (t' <:<.>:> t := u) (->) where
 	f <<= x = TUT $ ((f . unite -|) <<=) -<$>- run x
 
-instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Adjoint t t' (->) (->), Extractable u (->)) => Extractable (t <:<.>:> t' := u) (->) where
+instance (Covariant t (->) (->), Covariant t' (->) (->), Adjoint t t' (->) (->), Extractable u (->)) => Extractable (t <:<.>:> t' := u) (->) where
 	extract = (extract @_ @(->) |-) . run
 
-instance (forall u . Covariant u, Adjoint t' t (->) (->), Distributive t(->) (->) ) => Liftable (t <:<.>:> t') where
-	lift :: Covariant_ u (->) (->) => u ~> t <:<.>:> t' := u
+instance (Adjoint t' t (->) (->), Distributive t(->) (->) ) => Liftable (t <:<.>:> t') where
+	lift :: Covariant u (->) (->) => u ~> t <:<.>:> t' := u
 	lift x = TUT $ (identity @(->) -|) -<< x
 
-instance (forall u . Covariant u, 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
@@ -1,8 +1,8 @@
 module Pandora.Paradigm.Schemes.T_U where
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant, Contravariant ((->$<-)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))
@@ -21,14 +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
-	f <$> x = (f <$>) <-> (f <$>) ||= x
-
-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
-	f <$> x = (f >$<) >-> (f <$>) ||= x
+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
-	f >$< x = (f >$<) <-> (f >$<) ||= x
+instance (forall i . Covariant (p i) (->) (->), Bivariant p (->) (->) (->), Contravariant t (->) (->), Contravariant u (->) (->)) => Contravariant (t >:.:< u := p) (->) (->) where
+	f ->$<- x = (f ->$<-) <-> (f ->$<-) ||= x
diff --git a/Pandora/Paradigm/Schemes/UT.hs b/Pandora/Paradigm/Schemes/UT.hs
--- a/Pandora/Paradigm/Schemes/UT.hs
+++ b/Pandora/Paradigm/Schemes/UT.hs
@@ -1,10 +1,11 @@
 module Pandora.Paradigm.Schemes.UT where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
-import Pandora.Pattern.Category ((.), ($), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($), identity)
+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)), Semimonoidal)
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
@@ -12,7 +13,7 @@
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)))
 
 newtype UT ct cu t u a = UT (u :. t := a)
 
@@ -28,28 +29,25 @@
 	run ~(UT x) = x
 	unite = UT
 
-instance (Covariant t, Covariant u) => Covariant (t <.:> u) where
-	f <$> UT x = UT $ f <$$> x
-
-instance (Covariant_ t (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <.:> u) (->) (->) where
-	f -<$>- UT x = UT $ f -<$$>- x
+instance (Covariant t (->) (->), Covariant u (->) (->)) => Covariant (t <.:> u) (->) (->) where
+	f -<$>- x = UT $ f -<$$>- run x
 
-instance (Applicative t, Applicative u) => Applicative (t <.:> u) where
-	UT f <*> UT x = UT $ f <**> x
+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 (Traversable t (->) (->), Bindable t (->), Semimonoidal u (:*:) (->) (->), Pointable u (->), Bindable u (->)) => Bindable (t <.:> u) (->) where
+instance (Traversable t (->) (->), Bindable t (->), Semimonoidal u (->) (:*:) (:*:), Pointable u (->), Bindable u (->)) => Bindable (t <.:> u) (->) where
 	f =<< UT x = UT $ ((identity =<<) -<$>-) . (run . f <<-) =<< x
 
 instance (Extractable t (->), Extractable u (->)) => Extractable (t <.:> u) (->) where
 	extract = extract . extract . run
 
 instance Pointable t (->) => Liftable (UT Covariant Covariant t) where
-	lift :: Covariant_ u (->) (->) => u ~> t <.:> u
+	lift :: Covariant u (->) (->) => u ~> t <.:> u
 	lift x = UT $ point @_ @(->) -<$>- x
 
 instance Extractable t (->) => Lowerable (UT Covariant Covariant t) where
-	lower :: Covariant_ u (->) (->) => t <.:> u ~> u
+	lower :: 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
@@ -8,10 +8,10 @@
 import Pandora.Paradigm.Structure.Some as Exports
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Category (($), (.), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant (comap), Covariant_)
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Pattern.Functor.Pointable (point)
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Semigroup ((+))
@@ -38,7 +38,7 @@
 instance Nullable Maybe where
 	null = Predicate $ \case { Just _ -> True ; _ -> False }
 
-instance (Covariant t, 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
@@ -53,21 +53,21 @@
 
 instance Morphable (Into (Inorder (Construction Maybe))) (Construction Wye) where
 	type Morphing (Into (Inorder (Construction Maybe))) (Construction Wye) = Construction Maybe
-	morphing (premorph -> Construct x End) = point x
-	morphing (premorph -> Construct x (Left lst)) = into @(Inorder (Nonempty List)) lst + point x
-	morphing (premorph -> Construct x (Right rst)) = point x + into @(Inorder (Nonempty List)) rst
-	morphing (premorph -> Construct x (Both lst rst)) = into @(Inorder (Nonempty List)) lst + point x + into @(Inorder (Nonempty List)) rst
+	morphing (premorph -> Construct x End) = Construct x Nothing
+	morphing (premorph -> Construct x (Left lst)) = into @(Inorder (Nonempty List)) lst + Construct x Nothing
+	morphing (premorph -> Construct x (Right rst)) = Construct x Nothing + into @(Inorder (Nonempty List)) rst
+	morphing (premorph -> Construct x (Both lst rst)) = into @(Inorder (Nonempty List)) lst + Construct x Nothing + into @(Inorder (Nonempty List)) rst
 
 instance Morphable (Into (Postorder (Construction Maybe))) (Construction Wye) where
 	type Morphing (Into (Postorder (Construction Maybe))) (Construction Wye) = Construction Maybe
-	morphing (premorph -> Construct x End) = point x
-	morphing (premorph -> Construct x (Left lst)) = into @(Postorder (Nonempty List)) lst + point x
-	morphing (premorph -> Construct x (Right rst)) = into @(Postorder (Nonempty List)) rst + point x
-	morphing (premorph -> Construct x (Both lst rst)) = into @(Postorder (Nonempty List)) lst + into @(Postorder (Nonempty List)) rst + point x
+	morphing (premorph -> Construct x End) = Construct x Nothing
+	morphing (premorph -> Construct x (Left lst)) = into @(Postorder (Nonempty List)) lst + Construct x Nothing
+	morphing (premorph -> Construct x (Right rst)) = into @(Postorder (Nonempty List)) rst + Construct x Nothing
+	morphing (premorph -> Construct x (Both lst rst)) = into @(Postorder (Nonempty List)) lst + into @(Postorder (Nonempty List)) rst + Construct x Nothing
 
 instance Morphable (Into (o ds)) (Construction Wye) => Morphable (Into (o ds)) Binary where
 	type Morphing (Into (o ds)) Binary = Maybe <:.> Morphing (Into (o ds)) (Construction Wye)
-	morphing (premorph -> xs) = comap (into @(o ds)) ||= xs
+	morphing (premorph -> xs) = (into @(o ds) -<$>-) ||= xs
 
 instance Substructure Left (Flip (:*:) a) where
 	type Available Left (Flip (:*:) a) = Identity
@@ -90,13 +90,13 @@
 instance {-# OVERLAPS #-} Accessible b a => Accessible b (s :*: a) where
 	access = access @b . access @a
 
-instance (Covariant t, 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, 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/Measurable.hs b/Pandora/Paradigm/Structure/Ability/Measurable.hs
--- a/Pandora/Paradigm/Structure/Ability/Measurable.hs
+++ b/Pandora/Paradigm/Structure/Ability/Measurable.hs
@@ -2,7 +2,7 @@
 
 module Pandora.Paradigm.Structure.Ability.Measurable where
 
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 
 class Measurable f t where
diff --git a/Pandora/Paradigm/Structure/Ability/Monotonic.hs b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
--- a/Pandora/Paradigm/Structure/Ability/Monotonic.hs
+++ b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
@@ -1,8 +1,7 @@
 module Pandora.Paradigm.Structure.Ability.Monotonic where
 
 import Pandora.Pattern.Category ((#))
-import Pandora.Pattern.Functor.Covariant ((.#..))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (-.#..-))
 
 class Monotonic a e where
 	{-# MINIMAL reduce #-}
@@ -10,7 +9,7 @@
 
 	-- | Version of `reduce` which ignores accumulator
 	resolve :: (a -> r) -> r -> e -> r
-	resolve g = reduce # g .#.. (!.)
+	resolve g = reduce # g -.#..- (!.)
 
 instance Monotonic a a where
 	reduce f r x = f x r
diff --git a/Pandora/Paradigm/Structure/Ability/Morphable.hs b/Pandora/Paradigm/Structure/Ability/Morphable.hs
--- a/Pandora/Paradigm/Structure/Ability/Morphable.hs
+++ b/Pandora/Paradigm/Structure/Ability/Morphable.hs
@@ -3,7 +3,8 @@
 module Pandora.Paradigm.Structure.Ability.Morphable where
 
 import Pandora.Core.Functor (type (:=), type (~>), type (:=:=>))
-import Pandora.Pattern.Category ((.), (#))
+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)
diff --git a/Pandora/Paradigm/Structure/Ability/Substructure.hs b/Pandora/Paradigm/Structure/Ability/Substructure.hs
--- a/Pandora/Paradigm/Structure/Ability/Substructure.hs
+++ b/Pandora/Paradigm/Structure/Ability/Substructure.hs
@@ -4,7 +4,7 @@
 module Pandora.Paradigm.Structure.Ability.Substructure where
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
@@ -23,5 +23,5 @@
 	type Substance segment structure :: * -> *
 	substructure :: (Tagged segment <:.> structure) #=@ Substance segment structure := Available segment structure
 
-	sub :: (Covariant structure, 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
@@ -3,7 +3,8 @@
 module Pandora.Paradigm.Structure.Interface.Set where
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Category ((.), ($))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((!=)))
 import Pandora.Pattern.Object.Semigroup ((+))
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
@@ -4,28 +4,26 @@
 module Pandora.Paradigm.Structure.Modification.Comprehension where
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant ((>$<))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Semigroupoid ((.))
+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.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
-import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 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 ((:*:)((:*:)))
 
 newtype Comprehension t a = Comprehension (t <:.> Construction t := a)
 
@@ -34,33 +32,18 @@
 	run ~(Comprehension x) = x
 	unite = Comprehension
 
-instance Covariant (t <:.> Construction t) => Covariant (Comprehension t) where
-	f <$> Comprehension x = Comprehension $ f <$> x
-
-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 (Avoidable t, Pointable t (->)) => Pointable (Comprehension t) (->) where
-	point = Comprehension . TU . point . Construct % empty
-
-instance Alternative t => Alternative (Comprehension t) where
-	Comprehension x <+> Comprehension y = Comprehension $ x <+> y
-
-instance (Avoidable t, Alternative t) => Avoidable (Comprehension t) where
-	empty = Comprehension empty
-
 instance Traversable (t <:.> Construction t) (->) (->) => Traversable (Comprehension t) (->) (->) where
 	f <<- Comprehension x = Comprehension -<$>- f <<- x
 
-instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t (->), Pointable t (->), Avoidable t) => Applicative (Comprehension t) where
-	fs <*> xs = (\f -> Comprehension . TU . point . point . f =<< xs) =<< fs
+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
 	f =<< Comprehension (TU t) = Comprehension . TU $ (\(Construct x xs) -> run . run $ f x + (f =<< Comprehension (TU xs))) =<< t
-		-- t >>= \(Construct x xs) -> run . run $ f x + (Comprehension (TU xs) >>= f)
 
-instance (forall a . Semigroup (t <:.> Construction t := a), Pointable t (->), Avoidable t, Bindable t (->)) => Monad (Comprehension t) where
-
 instance Setoid (t <:.> Construction t := a) => Setoid (Comprehension t a) where
 	Comprehension ls == Comprehension rs = ls == rs
 
@@ -70,9 +53,9 @@
 instance Monoid (t <:.> Construction t := a) => Monoid (Comprehension t a) where
 	zero = Comprehension zero
 
-instance (Covariant t, Covariant_ t (->) (->), Pointable t (->)) => Morphable Push (Comprehension t) where
+instance (Covariant t (->) (->), Pointable t (->)) => Morphable Push (Comprehension t) where
 	type Morphing Push (Comprehension t) = Identity <:.:> Comprehension t := (->)
 	morphing (run . premorph -> xs) = T_U $ \(Identity x) -> Comprehension . lift . Construct x . run $ xs
 
 instance Nullable (t <:.> Construction t) => Nullable (Comprehension t) where
-	null = run >$< null
+	null = run ->$<- null
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
@@ -4,13 +4,12 @@
 module Pandora.Paradigm.Structure.Modification.Prefixed where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-))
+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.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Paradigm.Primary.Algebraic ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
@@ -25,10 +24,7 @@
 	run ~(Prefixed x) = x
 	unite = Prefixed
 
-instance Covariant t => Covariant (Prefixed t k) where
-	f <$> Prefixed x = Prefixed $ f <$$> x
-
-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
@@ -37,14 +33,8 @@
 instance (Monoid k, Pointable t (->)) => Pointable (Prefixed t k) (->) where
 	point = Prefixed . point . (:*:) zero
 
-instance Alternative t => Alternative (Prefixed t k) where
-	x <+> y = Prefixed $ run x <+> run y
-
-instance Avoidable t => Avoidable (Prefixed t k) where
-	empty = Prefixed empty
-
-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
@@ -3,10 +3,10 @@
 module Pandora.Paradigm.Structure.Some.Binary where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (:=>), type (:::))
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($$$>)), Covariant_ ((-<$>-)))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
 import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Pattern.Functor.Avoidable (empty)
 import Pandora.Pattern.Functor.Bindable ((=<<))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
@@ -15,6 +15,7 @@
 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.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (order)
 import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Numerator, Zero))
@@ -71,14 +72,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 ---------------------------------------
 
@@ -147,7 +148,7 @@
 	morphing (run . run . premorph -> Just tree) = T_U $ \(TU (key :*: Identity value)) ->
 		let continue = ((vary @Element @k @_ @(Prefixed Binary _) key value =||) =||)
 		in let root = extract tree in Prefixed . lift $ key <=> attached root & order
-			# over (sub @Root) ($$$> value) tree
+			# over (sub @Root) ($$$>- value) tree
 			# over (sub @Left) continue tree
 			# over (sub @Right) continue tree
 
@@ -164,12 +165,7 @@
 
 data Biforked a = Top | Leftward a | Rightward a
 
-instance Covariant Biforked where
-	_ <$> Top = Top
-	f <$> Leftward l = Leftward $ f l
-	f <$> Rightward r = Rightward $ f r
-
-instance Covariant_ Biforked (->) (->) where
+instance Covariant Biforked (->) (->) where
 	_ -<$>- Top = Top
 	f -<$>- Leftward l = Leftward $ f l
 	f -<$>- Rightward r = Rightward $ f r
@@ -188,27 +184,27 @@
 		lift $ twosome # Construct parent (resolve # Both focused # Left focused # run rest) # TU (TU next)
 	morphing (run . premorph -> focused :*: TU (TU (Rightward (Construct (T_U (Identity parent :*: rest)) next)))) =
 		lift $ twosome # Construct parent (resolve # Both % focused # Right focused # run rest) # TU (TU next)
-	morphing (premorph -> T_U (_ :*: TU (TU Top))) = empty
+	morphing (premorph -> T_U (_ :*: TU (TU Top))) = TU Nothing
 
 instance Morphable (Rotate (Down Left)) (Construction Wye <:.:> Bifurcation <:.> Bicursor := (:*:)) where
 	type Morphing (Rotate (Down Left)) (Construction Wye <:.:> Bifurcation <:.> Bicursor := (:*:))
 		= Maybe <:.> (Construction Wye <:.:> Bifurcation <:.> Bicursor := (:*:))
 	morphing (run . premorph -> Construct x (Left lst) :*: TU (TU next)) =
-		lift . twosome lst . TU . TU . Leftward $ Construct # twosome (Identity x) empty # next
+		lift . twosome lst . TU . TU . Leftward $ Construct # twosome (Identity x) (TU Nothing) # next
 	morphing (run . premorph -> Construct x (Both lst rst) :*: TU (TU next)) =
 		lift . twosome lst . TU . TU . Leftward $ Construct # twosome (Identity x) (lift rst) # next
-	morphing (run . premorph -> Construct _ (Right _) :*: _) = empty
-	morphing (run . premorph -> Construct _ End :*: _) = empty
+	morphing (run . premorph -> Construct _ (Right _) :*: _) = TU Nothing
+	morphing (run . premorph -> Construct _ End :*: _) = TU Nothing
 
 instance Morphable (Rotate (Down Right)) (Construction Wye <:.:> Bifurcation <:.> Bicursor := (:*:)) where
 	type Morphing (Rotate (Down Right)) (Construction Wye <:.:> Bifurcation <:.> Bicursor := (:*:))
 		= Maybe <:.> (Construction Wye <:.:> Bifurcation <:.> Bicursor := (:*:))
 	morphing (run . premorph -> Construct x (Right rst) :*: TU (TU next)) =
-		lift . twosome rst . TU . TU . Rightward $ Construct # twosome (Identity x) empty # next
+		lift . twosome rst . TU . TU . Rightward $ Construct # twosome (Identity x) (TU Nothing) # next
 	morphing (run . premorph -> Construct x (Both lst rst) :*: TU (TU next)) =
 		lift . twosome rst . TU . TU . Rightward $ Construct # twosome (Identity x) (lift lst) # next
-	morphing (run . premorph -> Construct _ (Left _) :*: _) = empty
-	morphing (run . premorph -> Construct _ End :*: _) = empty
+	morphing (run . premorph -> Construct _ (Left _) :*: _) = TU Nothing
+	morphing (run . premorph -> Construct _ End :*: _) = TU Nothing
 
 leaf :: a :=> Nonempty Binary
 leaf x = Construct x End
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
@@ -4,15 +4,16 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (:::))
 import Pandora.Core.Impliable (imply)
-import Pandora.Pattern.Category ((.), ($), (#), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)), Covariant_ ((-<$>-)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+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.Avoidable (empty)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Bivariant ((<->))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
@@ -21,7 +22,7 @@
 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.Algebraic ((-<*>-), (-.#..-))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached, twosome)
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
@@ -64,7 +65,7 @@
 		$ TU @Covariant @Covariant xs + TU @Covariant @Covariant ys
 
 instance Monoid (List a) where
-	zero = empty
+	zero = TU Nothing
 
 instance Morphable Push List where
 	type Morphing Push List = Identity <:.:> List := (->)
@@ -106,19 +107,19 @@
 	type Available Root List = Maybe
 	type Substance Root List = Identity
 	substructure = P_Q_T $ \zipper -> case run # lower zipper of
-		Just (Construct x xs) -> Store $ Just (Identity x) :*: lift . resolve (lift . (Construct % xs) . extract @Identity) empty
-		Nothing -> Store $ Nothing :*: lift . resolve (lift . (Construct % empty) . extract @Identity) empty
+		Just (Construct x xs) -> Store $ Just (Identity x) :*: lift . resolve (lift . (Construct % xs) . extract @Identity) zero
+		Nothing -> Store $ Nothing :*: lift . resolve (lift . (Construct % Nothing) . extract @Identity) zero
 
 instance Substructure Tail List where
 	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
-		Nothing -> Store $ Identity empty :*: lift . identity . extract
+		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 = TU . extract . (run @(State (Maybe :. Nonempty List := a)) % Nothing) . fold (Just .#.. Construct)
+linearize = TU . extract . (run @(State (Maybe :. Nonempty List := a)) % Nothing) . fold (Just -.#..- Construct)
 
 ----------------------------------------- Non-empty list -------------------------------------------
 
@@ -166,9 +167,6 @@
 
 type instance Zipper List (Left ::: Right) = Tap (List <:.:> List := (:*:))
 
---instance {-# OVERLAPS #-} Applicative (Tap (List <:.:> List := (:*:))) where
-	--Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs)
-
 instance {-# OVERLAPS #-} 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
@@ -181,17 +179,17 @@
 	type Morphing (Rotate Left) (Tap (List <:.:> List := (:*:))) = Maybe <:.> Tap (List <:.:> List := (:*:))
 	morphing (premorph -> Tap x (T_U (future :*: past))) =
 		let subtree = twosome # extract (view (sub @Tail) future) # item @Push x past in
-		TU $ (Tap . extract) % subtree <$> view (sub @Root) future
+		TU $ (Tap . extract) % subtree -<$>- view (sub @Root) future
 
 instance Morphable (Rotate Right) (Tap (List <:.:> List := (:*:))) where
 	type Morphing (Rotate Right) (Tap (List <:.:> List := (:*:))) = Maybe <:.> Tap (List <:.:> List := (:*:))
 	morphing (premorph -> Tap x (T_U (future :*: past))) =
 		let subtree = twosome # item @Push x future # extract (view (sub @Tail) past) in
-		TU $ (Tap . extract) % subtree <$> view (sub @Root) past
+		TU $ (Tap . extract) % subtree -<$>- view (sub @Root) past
 
 instance Morphable (Into (Tap (List <:.:> List := (:*:)))) List where
 	type Morphing (Into (Tap (List <:.:> List := (:*:)))) List = Maybe <:.> Tap (List <:.:> List := (:*:))
-	morphing (premorph -> list) = (into @(Zipper List (Left ::: Right)) <$>) ||= list
+	morphing (premorph -> list) = (into @(Zipper List (Left ::: Right)) -<$>-) ||= list
 
 instance Morphable (Into List) (Tap (List <:.:> List := (:*:))) where
 	type Morphing (Into List) (Tap (List <:.:> List := (:*:))) = List
@@ -212,26 +210,26 @@
 instance Morphable (Rotate Left) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
 	type Morphing (Rotate Left) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) =
 		Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))
-	morphing (premorph -> Tap x (T_U (future :*: past))) = TU $ Tap (extract future) . twosome % item @Push x past <$> deconstruct future
+	morphing (premorph -> Tap x (T_U (future :*: past))) = TU $ Tap (extract future) . twosome % item @Push x past -<$>- deconstruct future
 
 instance Morphable (Rotate Right) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
 	type Morphing (Rotate Right) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) =
 		Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))
-	morphing (premorph -> Tap x (T_U (future :*: past))) = TU $ Tap (extract past) . twosome (item @Push x future) <$> deconstruct past
+	morphing (premorph -> Tap x (T_U (future :*: past))) = TU $ Tap (extract past) . twosome (item @Push x future) -<$>- deconstruct past
 
 instance Morphable (Into (Tap (List <:.:> List := (:*:)))) (Construction Maybe) where
 	type Morphing (Into (Tap (List <:.:> List := (:*:)))) (Construction Maybe) = Tap (List <:.:> List := (:*:))
-	morphing (premorph -> ne) = Tap # extract ne $ twosome # extract (view # sub @Tail # ne) # empty
+	morphing (premorph -> ne) = Tap # extract ne $ twosome # extract (view # sub @Tail # ne) # zero
 
 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
 
---instance Morphable (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) where
-	--type Morphing (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) =
-		--Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))
-	--morphing (premorph -> zipper) = let spread x y = (:*:) -<$>- x -<*>- y in TU $
-		--Tap (extract zipper) . T_U -<$>- ((spread |-) . (run <-> run) . run $ lower zipper)
+instance Morphable (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) where
+	type Morphing (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) =
+		Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))
+	morphing (premorph -> zipper) = let spread x y = (:*:) -<$>- x -<*>- y in TU $
+		Tap (extract zipper) . T_U -<$>- ((spread |-) . (run <-> run) . run $ lower zipper)
 
 instance Morphable (Into (Construction Maybe)) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
 	type Morphing (Into (Construction Maybe)) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = Construction Maybe
@@ -249,8 +247,9 @@
 
 type instance Zipper (Comprehension Maybe) (Left ::: Right) = Tap (Comprehension Maybe <:.:> Comprehension Maybe := (:*:))
 
-instance {-# OVERLAPS #-} Applicative (Tap (Comprehension Maybe <:.:> Comprehension Maybe := (:*:))) where
-	Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs)
+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 --------------------------------------------
 
@@ -262,5 +261,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
@@ -3,32 +3,30 @@
 module Pandora.Paradigm.Structure.Some.Rose where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Contravariant ((>$<))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Functor.Contravariant ((->$<-))
 import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Setoid (Setoid ((==), (!=)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate), equate)
-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
-import Pandora.Paradigm.Schemes (TU (TU), T_U (T_U), P_Q_T (P_Q_T), type (<:.>), type (<:.:>))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (=||$>))
+import Pandora.Paradigm.Schemes (TU (TU), P_Q_T (P_Q_T), type (<:.>))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing)
-	, Morph (Lookup, Vary, Element, Key), premorph, find, vary)
+	, Morph (Lookup, Element, Key), premorph, find)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null))
 import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Available, Substance, substructure), Segment (Root, Tail))
-import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed (Prefixed))
+import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed)
 import Pandora.Paradigm.Structure.Some.List (List)
 
 type Rose = Maybe <:.> Construction List
@@ -37,21 +35,21 @@
 	null = Predicate $ \case { TU Nothing -> True ; _ -> False }
 
 -- FIXME: If we want to remove root node, we ruin the whole tree
-instance Substructure Root Rose where
-	type Available Root Rose = Maybe
-	type Substance Root Rose = Identity
-	substructure = P_Q_T $ \rose -> case run # lower rose of
-		Nothing -> Store $ Nothing :*: TU . Tag . TU . ((Construct % empty) . extract <$>)
-		Just nonempty_rose -> Store $ Just (Identity # extract nonempty_rose) :*: \case
-			Just (Identity new) -> lift . TU . Just . Construct new $ deconstruct nonempty_rose
-			Nothing -> lift empty
+--instance Substructure Root Rose where
+--	type Available Root Rose = Maybe
+--	type Substance Root Rose = Identity
+--	substructure = P_Q_T $ \rose -> case run # lower rose of
+--		Nothing -> Store $ Nothing :*: TU . Tag . TU . ((Construct % empty) . extract <$>)
+--		Just nonempty_rose -> Store $ Just (Identity # extract nonempty_rose) :*: \case
+--			Just (Identity new) -> lift . TU . Just . Construct new $ deconstruct nonempty_rose
+--			Nothing -> lift empty
 
-instance Substructure Just Rose where
-	type Available Just Rose = Identity
-	type Substance Just Rose = List <:.> Construction List
-	substructure = P_Q_T $ \rose -> case run . extract . run # rose of
-		Nothing -> Store $ Identity empty :*: (lift empty !.)
-		Just (Construct x xs) -> Store $ Identity (TU xs) :*: lift . lift . Construct x . run . extract
+--instance Substructure Just Rose where
+--	type Available Just Rose = Identity
+--	type Substance Just Rose = List <:.> Construction List
+--	substructure = P_Q_T $ \rose -> case run . extract . run # rose of
+--		Nothing -> Store $ Identity empty :*: (lift empty !.)
+--		Just (Construct x xs) -> Store $ Identity (TU xs) :*: lift . lift . Construct x . run . extract
 
 --------------------------------------- Non-empty rose tree ----------------------------------------
 
@@ -76,32 +74,32 @@
 	morphing (run . premorph -> TU (Just tree)) = TU $ find_rose_sub_tree % tree
 
 -- TODO: Ineffiecient - we iterate over all branches in subtree, but we need to short-circuit on the first matching part of
-instance Setoid k => Morphable (Vary Element) (Prefixed Rose k) where
-	type Morphing (Vary Element) (Prefixed Rose k) = ((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed Rose k := (->)
-	morphing (run . run . premorph -> Nothing) = T_U $ \(TU (Construct key _ :*: Identity value)) -> Prefixed . lift $ Construct (key :*: value) empty
-	morphing (run . run . premorph -> Just (Construct focused subtree)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
-		Construct key Nothing -> Prefixed . lift $ attached focused == key ? Construct (key :*: value) subtree $ Construct focused subtree
-		Construct key (Just keys) -> Prefixed . lift $ attached focused != key ? Construct focused subtree
-			$ Construct focused $ vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value =||$> subtree
+--instance Setoid k => Morphable (Vary Element) (Prefixed Rose k) where
+--	type Morphing (Vary Element) (Prefixed Rose k) = ((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed Rose k := (->)
+--	morphing (run . run . premorph -> Nothing) = T_U $ \(TU (Construct key _ :*: Identity value)) -> Prefixed . lift $ Construct (key :*: value) empty
+--	morphing (run . run . premorph -> Just (Construct focused subtree)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
+--		Construct key Nothing -> Prefixed . lift $ attached focused == key ? Construct (key :*: value) subtree $ Construct focused subtree
+--		Construct key (Just keys) -> Prefixed . lift $ attached focused != key ? Construct focused subtree
+--			$ Construct focused $ vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value =||$> subtree
 
 ---------------------------------- Non-empty prefixed rose tree ------------------------------------
 
 -- TODO: Ineffiecient - we iterate over all branches in subtree, but we need to short-circuit on the first matching part of
-instance Setoid k => Morphable (Vary Element) (Prefixed (Construction List) k) where
-	type Morphing (Vary Element) (Prefixed (Construction List) k) =
-		((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed (Construction List) k := (->)
-	morphing (run . premorph -> Construct x (TU Nothing)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
-		Construct key Nothing -> Prefixed $ attached x == key ? Construct (key :*: value) empty $ Construct x empty
-		Construct _ (Just _) -> Prefixed $ Construct x (TU Nothing)
-	morphing (run . premorph -> Construct x (TU (Just subtree))) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
-		Construct key Nothing -> Prefixed $ attached x != key ? Construct x # lift subtree
-			$ Construct (key :*: value) (lift subtree)
-		Construct key (Just keys) -> Prefixed $ attached x != key ? Construct x # lift subtree
-			$ Construct (key :*: value) . lift $ vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value =||$> subtree
+--instance Setoid k => Morphable (Vary Element) (Prefixed (Construction List) k) where
+--	type Morphing (Vary Element) (Prefixed (Construction List) k) =
+--		((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed (Construction List) k := (->)
+--	morphing (run . premorph -> Construct x (TU Nothing)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
+--		Construct key Nothing -> Prefixed $ attached x == key ? Construct (key :*: value) empty $ Construct x empty
+--		Construct _ (Just _) -> Prefixed $ Construct x (TU Nothing)
+--	morphing (run . premorph -> Construct x (TU (Just subtree))) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
+--		Construct key Nothing -> Prefixed $ attached x != key ? Construct x # lift subtree
+--			$ Construct (key :*: value) (lift subtree)
+--		Construct key (Just keys) -> Prefixed $ attached x != key ? Construct x # lift subtree
+--			$ Construct (key :*: value) . lift $ vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value =||$> subtree
 
 find_rose_sub_tree :: forall k a . Setoid k => Nonempty List k -> Nonempty Rose := k :*: a -> Maybe a
 find_rose_sub_tree (Construct k Nothing) tree = k == attached (extract tree) ? Just (extract $ extract tree) $ Nothing
 find_rose_sub_tree (Construct k (Just ks)) tree = k != attached (extract tree) ? Nothing $ find_rose_sub_tree ks =<< subtree where
 
 	subtree :: Maybe :. Nonempty Rose := k :*: a
-	subtree = find @Element # attached . extract >$< equate (extract ks) # deconstruct tree
+	subtree = find @Element # attached . extract ->$<- equate (extract ks) # deconstruct tree
diff --git a/Pandora/Paradigm/Structure/Some/Splay.hs b/Pandora/Paradigm/Structure/Some/Splay.hs
--- a/Pandora/Paradigm/Structure/Some/Splay.hs
+++ b/Pandora/Paradigm/Structure/Some/Splay.hs
@@ -4,8 +4,9 @@
 module Pandora.Paradigm.Structure.Some.Splay where
 
 import Pandora.Core.Functor (type (~>), type (:.), type (:=))
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))
+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 ()
@@ -58,11 +59,11 @@
 
 		nodes :: Wye :. Nonempty Binary := a
 		nodes = into @Wye . twosome (branch @Left xs) . Just . Construct x
-			. into @Wye $ twosome (branch @Left =<< deconstruct <$> branch @Right xs)
-				(branch @Right =<< deconstruct <$> branch @Right xs)
+			. into @Wye $ twosome (branch @Left =<< deconstruct -<$>- branch @Right xs)
+				(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
@@ -70,11 +71,11 @@
 	morphing (premorph -> Construct x xs) = TU $ Construct -<$>- parent -<*>- Just nodes where
 
 		nodes :: Wye :. Nonempty Binary := a
-		nodes = into @Wye . twosome (branch @Left =<< deconstruct <$> branch @Left xs) . Just . Construct x
-			. into @Wye $ twosome (branch @Right =<< deconstruct <$> branch @Left xs) # branch @Right xs
+		nodes = into @Wye . twosome (branch @Left =<< deconstruct -<$>- branch @Left xs) . Just . Construct x
+			. into @Wye $ twosome (branch @Right =<< deconstruct -<$>- branch @Left xs) # branch @Right xs
 
 		parent :: Maybe a
-		parent = extract <$> branch @Left xs
+		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
@@ -3,8 +3,9 @@
 module Pandora.Paradigm.Structure.Some.Stream where
 
 import Pandora.Core.Functor (type (:=), type (:=>), type (:::))
-import Pandora.Pattern.Category ((.), ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+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 ((<<=)))
@@ -33,7 +34,7 @@
 
 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))
+		in f -<$>- Tap z (twosome # (move $ rotate @Left) # (move $ rotate @Right))
 
 repeat :: a :=> Stream
 repeat x = Construct x . Identity $ repeat x
diff --git a/Pandora/Pattern.hs b/Pandora/Pattern.hs
--- a/Pandora/Pattern.hs
+++ b/Pandora/Pattern.hs
@@ -4,3 +4,4 @@
 import Pandora.Pattern.Transformer as Exports
 import Pandora.Pattern.Functor as Exports
 import Pandora.Pattern.Category as Exports
+import Pandora.Pattern.Semigroupoid as Exports
diff --git a/Pandora/Pattern/Category.hs b/Pandora/Pattern/Category.hs
--- a/Pandora/Pattern/Category.hs
+++ b/Pandora/Pattern/Category.hs
@@ -1,19 +1,18 @@
 module Pandora.Pattern.Category (Category (..)) where
 
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) 
+
 infixl 2 #
 infixr 0 $
-infixr 9 .
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
 > * Left identity: identity . f ≡ f
 > * Right identity: f . identity ≡ f
-> * Associativity: f . (g . h) ≡ (f . g) . h
 -}
 
-class Category (m :: * -> * -> *) where
+class Semigroupoid m => Category m where
 	identity :: m a a
-	(.) :: m b c -> m a b -> m a c
 
 	($) :: m (m a b) (m a b)
 	($) = identity . identity
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, (<*+>), (<**+>), (<***+>)) where
+module Pandora.Pattern.Functor (module Exports, Endofunctor) where
 
 import Pandora.Pattern.Functor.Bivariant as Exports
 import Pandora.Pattern.Functor.Divariant as Exports
@@ -10,25 +10,15 @@
 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.Determinable as Exports
 import Pandora.Pattern.Functor.Extractable as Exports
 import Pandora.Pattern.Functor.Pointable as Exports
-import Pandora.Pattern.Functor.Avoidable as Exports
-import Pandora.Pattern.Functor.Applicative as Exports
-import Pandora.Pattern.Functor.Alternative 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
 
-import Pandora.Core.Functor (type (:.), type (:=))
-
-(<*+>) :: (Applicative t, Alternative u) => t :. u := a -> t :. u := a -> t :. u := a
-x <*+> y = (<+>) <$> x <*> y
-
-(<**+>) :: (Applicative t, Applicative u, Alternative v)
-	=> t :. u :. v := a -> t :. u :. v := a -> t :. u :. v := a
-x <**+> y = (<+>) <$$> x <**> y
-
-(<***+>) :: (Applicative t, Applicative u, Applicative v, Alternative w)
-	=> t :. u :. v :. w := a -> t :. u :. v :. w := a -> t :. u :. v :. w := a
-x <***+> y = (<+>) <$$$> x <***> y
+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
diff --git a/Pandora/Pattern/Functor/Adjoint.hs b/Pandora/Pattern/Functor/Adjoint.hs
--- a/Pandora/Pattern/Functor/Adjoint.hs
+++ b/Pandora/Pattern/Functor/Adjoint.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Adjoint where
 
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
 type (-|) = Adjoint
 
@@ -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 t target source, Covariant u source target) => Adjoint t u source target where
 	(-|) :: source (t a) b -> target a (u b)
 	(|-) :: target a (u b) -> source (t a) b
diff --git a/Pandora/Pattern/Functor/Alternative.hs b/Pandora/Pattern/Functor/Alternative.hs
deleted file mode 100644
--- a/Pandora/Pattern/Functor/Alternative.hs
+++ /dev/null
@@ -1,20 +0,0 @@
-module Pandora.Pattern.Functor.Alternative where
-
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-infixl 3 <+>
-
-{- |
-> When providing a new instance, you should ensure it satisfies:
-> * Associativity of <+>: (x <+> y) <+> z ≡ x <+> (y <+> z)
-> * Left-distributes <$> over <+>: f <$> (x <+> y) ≡ (f <$> x) <+> (f <$> y)
--}
-
-class Covariant t => Alternative t where
-	{-# MINIMAL (<+>) #-}
-	-- | Infix version of 'alter'
-
-	(<+>) :: t a -> t a -> t a
-	-- | Prefix version of '<+>'
-	alter :: t a -> t a -> t a
-	alter f g = f <+> g
diff --git a/Pandora/Pattern/Functor/Applicative.hs b/Pandora/Pattern/Functor/Applicative.hs
deleted file mode 100644
--- a/Pandora/Pattern/Functor/Applicative.hs
+++ /dev/null
@@ -1,51 +0,0 @@
-module Pandora.Pattern.Functor.Applicative where
-
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)), Covariant_)
-import Pandora.Pattern.Functor.Bivariant (Bivariant)
-
-infixl 4 <*>, <*, *>
-infixl 3 <**>
-infixl 2 <***>
-infixl 1 <****>
-
-{- |
-> When providing a new instance, you should ensure it satisfies:
-> * Interpreted: (.) <$> u <*> v <*> w ≡ u <*> (v <*> w)
-> * Left interchange: x <*> (f <$> y) ≡ (. f) <$> x <*> y
-> * Right interchange: f <$> (x <*> y) ≡ (f .) <$> x <*> y
--}
-
-class Covariant t => Applicative t where
-	{-# MINIMAL (<*>) #-}
-	-- | Infix version of 'apply'
-	(<*>) :: t (a -> b) -> t a -> t b
-	-- | Prefix version of '<*>'
-	apply :: t (a -> b) -> t a -> t b
-	apply f x = f <*> x
-	-- | Sequence actions, discarding the value of the first argument
-	(*>) :: t a -> t b -> t b
-	x *> y = ((\z -> z) <$ x) <*> y
-	-- | Sequence actions, discarding the value of the second argument
-	(<*) :: t a -> t b -> t a
-	x <* y = y *> x
-	-- | Repeat an action indefinitely
-	forever :: t a -> t b
-	forever x = x *> forever x
-	-- | Flipped version of '<*>'
-	(<%>) :: t a -> t (a -> b) -> t b
-	x <%> f = (\x' f' -> f' x') <$> x <*> f
-	-- | Infix versions of `apply` with various nesting levels
-	(<**>) :: Applicative u => t :. u := (a -> b) -> t :. u := a -> t :. u := b
-	f <**> x = (<*>) <$> f <*> x
-	(<***>) :: (Applicative u, Applicative v) => t :. u :. v := (a -> b)
-		-> t :. u :. v := a -> t :. u :. v := b
-	f <***> x = (<**>) <$> f <*> x
-	(<****>) :: (Applicative u, Applicative v, Applicative w)
-		=> t :. u :. v :. w := (a -> b)
-		-> t :. u :. v :. w := a
-		-> t :. u :. v :. w := b
-	f <****> x = (<***>) <$> f <*> x
-
-class (Covariant_ t source target, Bivariant v source source target) => Semimonoidal t v source target where
-	multiply :: source (v a b) r -> target (v (t a) (t b)) (t r)
diff --git a/Pandora/Pattern/Functor/Avoidable.hs b/Pandora/Pattern/Functor/Avoidable.hs
deleted file mode 100644
--- a/Pandora/Pattern/Functor/Avoidable.hs
+++ /dev/null
@@ -1,13 +0,0 @@
-module Pandora.Pattern.Functor.Avoidable where
-
-import Pandora.Pattern.Functor.Alternative (Alternative)
-
-{- |
-> When providing a new instance, you should ensure it satisfies:
-> * Left absorption: x <+> empty ≡ x
-> * Right absorption: empty <+> x ≡ x
--}
-
-class Alternative t => Avoidable t where
-	{-# MINIMAL empty #-}
-	empty :: t a
diff --git a/Pandora/Pattern/Functor/Bindable.hs b/Pandora/Pattern/Functor/Bindable.hs
--- a/Pandora/Pattern/Functor/Bindable.hs
+++ b/Pandora/Pattern/Functor/Bindable.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Bindable where
 
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
 infixr 1 =<<
 
@@ -9,5 +9,5 @@
 > * Interchange: t >>= f = join (f <$> t)
 -}
 
-class Covariant_ t source source => Bindable t source where
+class Covariant t source source => Bindable t source where
 	(=<<) :: source a (t b) -> source (t a) (t b)
diff --git a/Pandora/Pattern/Functor/Bivariant.hs b/Pandora/Pattern/Functor/Bivariant.hs
--- a/Pandora/Pattern/Functor/Bivariant.hs
+++ b/Pandora/Pattern/Functor/Bivariant.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Bivariant where
 
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip)
 
 infixl 4 <->
@@ -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)
+class (forall i . Covariant (v i) left target, forall i . Covariant (Flip v i) right target)
 	=> Bivariant v left right target where
 	(<->) :: left a b -> right c d -> target (v a c) (v b d) 
diff --git a/Pandora/Pattern/Functor/Contravariant.hs b/Pandora/Pattern/Functor/Contravariant.hs
--- a/Pandora/Pattern/Functor/Contravariant.hs
+++ b/Pandora/Pattern/Functor/Contravariant.hs
@@ -1,56 +1,15 @@
 module Pandora.Pattern.Functor.Contravariant where
 
-import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category (Category)
 
-infixl 4 >$<, ->$<-, $<, >$
+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)
 -}
 
-class Contravariant (t :: * -> *) where
-	{-# MINIMAL (>$<) #-}
-	-- | Infix version of 'contramap'
-	(>$<) :: (a -> b) -> t b -> t a
-
-	-- | Prefix version of '>$<'
-	contramap :: (a -> b) -> t b -> t a
-	contramap f x = f >$< x
-	-- | Replace all locations in the output with the same value
-	(>$) :: b -> t b -> t a
-	x >$ z = (\_ -> x) >$< z
-	-- | Flipped version of '>$'
-	($<) :: t b -> b -> t a
-	x $< v = v >$ x
-	-- | Fill the input of evaluation
-	full :: t () -> t a
-	full x = () >$ x
-	-- | Flipped infix version of 'contramap'
-	(>&<) :: t b -> (a -> b) -> t a
-	x >&< f = f >$< x
-
-	-- | Infix versions of `contramap` with various nesting levels
-	(>$$<) :: Contravariant u => (a -> b) -> t :. u := a -> t :. u := b
-	f >$$< x = ((f >$<) >$<) x
-	(>$$$<) :: (Contravariant u, Contravariant v)
-		=> (a -> b) -> t :. u :. v := b -> t :. u :. v := a
-	f >$$$< x = (((f >$<) >$<) >$<) x
-	(>$$$$<) :: (Contravariant u, Contravariant v, Contravariant w)
-		=> (a -> b) -> t :. u :. v :. w := a -> t :. u :. v :. w := b
-	f >$$$$< x = ((((f >$<) >$<) >$<) >$<) x
-
-	-- | Infix flipped versions of `contramap` with various nesting levels
-	(>&&<) :: Contravariant u => t :. u := a -> (a -> b) -> t :. u := b
-	x >&&< f = f >$$< x
-	(>&&&<) :: (Contravariant u, Contravariant v)
-		=> t :. u :. v := b -> (a -> b) -> t :. u :. v := a
-	x >&&&< f = f >$$$< x
-	(>&&&&<) :: (Contravariant u, Contravariant v, Contravariant w)
-		=> t :. u :. v :. w := a -> (a -> b) -> t :. u :. v :. w := b
-	x >&&&&< f = f >$$$$< x
-
-class (Category source, Category target) => Contravariant_ t source target where
+class (Category source, Category target) => Contravariant t source target where
 	(->$<-) :: source a b -> target (t b) (t a)
diff --git a/Pandora/Pattern/Functor/Covariant.hs b/Pandora/Pattern/Functor/Covariant.hs
--- a/Pandora/Pattern/Functor/Covariant.hs
+++ b/Pandora/Pattern/Functor/Covariant.hs
@@ -1,121 +1,44 @@
 module Pandora.Pattern.Functor.Covariant where
 
-import Pandora.Core.Functor (type (:.), type (:=), type (<:=))
-import Pandora.Pattern.Category (Category ((.)))
-
-infixl 4 <$>, -<$>-, <$, $>
-infixl 3 <$$>, -<<$$>-, -<$$>>-
-infixl 2 <$$$>
-infixl 1 <$$$$>
-
-infixl 1 <&>
-infixl 2 <&&>
-infixl 3 <&&&>
-infixl 4 <&&&&>
+import Pandora.Pattern.Semigroupoid (Semigroupoid)
 
-infixr 7 .#.., .#..., .#....
+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
 -}
 
-class Covariant (t :: * -> *) where
-	{-# MINIMAL (<$>) #-}
-	-- | Infix version of 'comap'
-	(<$>) :: (a -> b) -> t a -> t b
-
-	-- | Prefix version of '<$>'
-	comap :: (a -> b) -> t a -> t b
-	comap f x = f <$> x
-	-- | Replace all locations in the input with the same value
-	(<$) :: a -> t b -> t a
-	x <$ z = (\_-> x) <$> z
-	-- | Flipped version of '<$'
-	($>) :: t a -> b -> t b
-	x $> v = v <$ x
-	-- | Discards the result of evaluation
-	void :: t a -> t ()
-	void x = () <$ x
-	-- | Computing a value from a structure of values
-	loeb :: t (a <:= t) -> t a
-	loeb tt = let fix f = let x = f x in x in fix (\f -> (\g -> g f) <$> tt)
-	-- | Flipped infix version of 'comap'
-	(<&>) :: t a -> (a -> b) -> t b
-	x <&> f = f <$> x
-
-	-- | Infix versions of `comap` with various nesting levels
-	(<$$>) :: Covariant u => (a -> b) -> t :. u := a -> t :. u := b
-	f <$$> x = ((f <$>) <$>) x
-	(<$$$>) :: (Covariant u, Covariant v)
-		=> (a -> b) -> t :. u :. v := a -> t :. u :. v := b
-	f <$$$> x = (((f <$>) <$>) <$>) x
-	(<$$$$>) :: (Covariant u, Covariant v, Covariant w)
-		=> (a -> b) -> t :. u :. v :. w := a -> t :. u :. v :. w := b
-	f <$$$$> x = ((((f <$>) <$>) <$>) <$>) x
-
-	-- | Infix flipped versions of `comap` with various nesting levels
-	(<&&>) :: Covariant u => t :. u := a -> (a -> b) -> t :. u := b
-	x <&&> f = f <$$> x
-	(<&&&>) :: (Covariant u, Covariant v)
-		=> t :. u :. v := a -> (a -> b) -> t :. u :. v := b
-	x <&&&> f = f <$$$> x
-	(<&&&&>) :: (Covariant u, Covariant v, Covariant w)
-		=> t :. u :. v :. w := a -> (a -> b) -> t :. u :. v :. w := b
-	x <&&&&> f = f <$$$$> x
-
-	(.#..) :: (t ~ v a, Category v)
-		=> v c d -> v a :. v b := c -> v a :. v b := d
-	f .#.. g = (f .) <$> g
-
-	(.#...) :: (t ~ v a, t ~ v b, Category v, Covariant (v a), Covariant (v b))
-		=> v d e -> v a :. v b :. v c := d -> v a :. v b :. v c := e
-	f .#... g = (f .) <$$> g
-
-	(.#....) :: (t ~ v a, t ~ v b, t ~ v c, Category v, Covariant (v a), Covariant (v b), Covariant (v c))
-		=> v e f -> v a :. v b :. v c :. v d := e -> v a :. v b :. v c :. v d := f
-	f .#.... g = (f .) <$$$> g
-
-	(<$$) :: Covariant u => b -> t :. u := a -> t :. u := b
-	x <$$ s = (\_-> x) <$$> s
-
-	(<$$$) :: (Covariant u, Covariant v) => b -> t :. u :. v := a -> t :. u :. v := b
-	x <$$$ s = (\_-> x) <$$$> s
-
-	(<$$$$) :: (Covariant u, Covariant v, Covariant w) => b -> t :. u :. v :. w := a -> t :. u :. v :. w := b
-	x <$$$$ s = (\_-> x) <$$$$> s
-
-	($$>) :: Covariant u => t :. u := a -> b -> t :. u := b
-	s $$> x = (\_-> x) <$$> s
-
-	($$$>) :: (Covariant u, Covariant v) => t :. u :. v := a -> b -> t :. u :. v := b
-	s $$$> x = (\_-> x) <$$$> s
-
-	($$$$>) :: (Covariant u, Covariant v, Covariant w) => t :. u :. v :. w := a -> b -> t :. u :. v :. w := b
-	s $$$$> x = (\_-> x) <$$$$> s
-
-class (Category source, Category target) => Covariant_ t source target where
+class (Semigroupoid source, Semigroupoid target) => Covariant t source target where
 	(-<$>-) :: source a b -> target (t a) (t b)
 	
 (-<$$>-) :: forall t u category a b 
-	. (Covariant_ u category category, Covariant_ t category category) 
+	. (Covariant u category category, Covariant t category category) 
 	=> category a b -> category (t (u a)) (t (u b))
 (-<$$>-) s = ((-<$>-) ((-<$>-) @u @category @category s))
 
 (-<<$$>-) :: forall t u source target a b 
-	. (Covariant_ u source source, Covariant_ t source target) 
+	. (Covariant u source source, Covariant t source target) 
 	=> source a b -> target (t (u a)) (t (u b))
 (-<<$$>-) s = ((-<$>-) ((-<$>-) @u @source @source s))
 
 (-<$$>>-) :: forall t u source target a b 
-	. (Covariant_ u source target, Covariant_ t target target) 
+	. (Covariant u source target, Covariant t target target) 
 	=> source a b -> target (t (u a)) (t (u b))
 (-<$$>>-) s = ((-<$>-) ((-<$>-) @u @source @target s))
 
 -- TODO: Figure out how to work with hidden type variables
 -- to put intermediate category `between`
-(-<$$$>-) :: forall t u v source target a b
-	. (Covariant_ u source source, Covariant_ t source target, Covariant_ v target target) 
-	=> source a b -> target (v (t (u a))) (v (t (u b)))
-(-<$$$>-) s = ((-<$>-) ((-<$>-) @t @source @target ((-<$>-) @u @source @source s)))
+
+(-<$$$>-) :: forall t u v category a b
+	. (Covariant t category category, Covariant u category category, Covariant v category category) 
+	=> category a b -> category (t (u (v a))) (t (u (v b)))
+(-<$$$>-) s = ((-<$>-) @t @category @category ((-<$>-) @u @category @category ((-<$>-) @v @category @category 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) 
+	=> 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))))
diff --git a/Pandora/Pattern/Functor/Determinable.hs b/Pandora/Pattern/Functor/Determinable.hs
deleted file mode 100644
--- a/Pandora/Pattern/Functor/Determinable.hs
+++ /dev/null
@@ -1,7 +0,0 @@
-module Pandora.Pattern.Functor.Determinable where
-
-import Pandora.Pattern.Functor.Contravariant (Contravariant)
-
-class Contravariant t => Determinable t where
-	{-# MINIMAL determine #-}
-	determine :: t a
diff --git a/Pandora/Pattern/Functor/Distributive.hs b/Pandora/Pattern/Functor/Distributive.hs
--- a/Pandora/Pattern/Functor/Distributive.hs
+++ b/Pandora/Pattern/Functor/Distributive.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Distributive where
 
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
 {- |
 > Let f :: Distributive g => (a -> g b)
@@ -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 t source target => Distributive t source target where
+	(-<<) :: Covariant u source target => source a (t b) -> target (u a) (t (u b))
diff --git a/Pandora/Pattern/Functor/Divariant.hs b/Pandora/Pattern/Functor/Divariant.hs
--- a/Pandora/Pattern/Functor/Divariant.hs
+++ b/Pandora/Pattern/Functor/Divariant.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Divariant where
 
-import Pandora.Pattern.Functor.Covariant (Covariant_)
-import Pandora.Pattern.Functor.Contravariant (Contravariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Paradigm.Primary.Transformer.Flip (Flip)
 
 infixl 4 >->
@@ -12,13 +12,6 @@
 > * Interpreted: f . g >-> h . i ≡ g >-> h . f >-> i
 -}
 
---class (forall i . Covariant (v i)) => Divariant (v :: * -> * -> *) where
---	{-# MINIMAL (>->) #-}
---	(>->) :: (a -> b) -> (c -> d) -> v b c -> v a d
---	-- | Prefix version of '>->'
---	dimap :: (a -> b) -> (c -> d) -> v b c -> v a d
---	dimap f g x = (f >-> g) x
-
-class (forall i . Contravariant_ (Flip v i) left target, forall i . Covariant_ (v i) right target) 
+class (forall i . Contravariant (Flip v i) left target, forall i . Covariant (v i) right target) 
 	=> Divariant v left right target where
 	(>->) :: left a b -> right c d -> target (v b c) (v a d)
diff --git a/Pandora/Pattern/Functor/Divisible.hs b/Pandora/Pattern/Functor/Divisible.hs
deleted file mode 100644
--- a/Pandora/Pattern/Functor/Divisible.hs
+++ /dev/null
@@ -1,14 +0,0 @@
-module Pandora.Pattern.Functor.Divisible where
-
-import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Bivariant (Bivariant)
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
-
-infixr 5 >*<
-
-class Contravariant t => Divisible t where
-	{-# MINIMAL (>*<) #-}
-	(>*<) :: t b -> t c -> t (b :*: c)
-
-class Bivariant v source source target => Divisible_ t v source target where
-	divide :: source r (v a b) -> target (v (t a) (t b)) (t r)
diff --git a/Pandora/Pattern/Functor/Extendable.hs b/Pandora/Pattern/Functor/Extendable.hs
--- a/Pandora/Pattern/Functor/Extendable.hs
+++ b/Pandora/Pattern/Functor/Extendable.hs
@@ -1,7 +1,6 @@
 module Pandora.Pattern.Functor.Extendable where
 
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
 infixr 1 <<=
 
@@ -11,5 +10,5 @@
 > * Extension interchange: (f <<=) ≡ (f -<$>-) . (identity <<=)
 -}
 
-class Covariant_ t source source => Extendable t source where
+class Covariant t source source => Extendable t source where
 	(<<=) :: source (t a) b -> source (t a) (t b)
diff --git a/Pandora/Pattern/Functor/Extractable.hs b/Pandora/Pattern/Functor/Extractable.hs
--- a/Pandora/Pattern/Functor/Extractable.hs
+++ b/Pandora/Pattern/Functor/Extractable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Extractable where
 
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
-class Covariant_ t source source => Extractable t source where
+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
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Monad where
 
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Bindable (Bindable)
 import Pandora.Pattern.Functor.Pointable (Pointable)
 
@@ -18,7 +18,7 @@
 --infixl 1 >>=-, ->>=
 --infixr 1 -=<<, =<<-
 
-class (Covariant_ t (->) (->), Pointable t (->), Bindable t (->)) => Monad t where
+class (Covariant t (->) (->), Pointable t (->), Bindable t (->)) => Monad t where
 	--(>>=-) :: t a -> t b -> t a
 	--(>>=-) x y = x >>= \r -> y >>= \_ -> point r
 	--(->>=) :: t a -> t b -> t b
diff --git a/Pandora/Pattern/Functor/Pointable.hs b/Pandora/Pattern/Functor/Pointable.hs
--- a/Pandora/Pattern/Functor/Pointable.hs
+++ b/Pandora/Pattern/Functor/Pointable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Pointable where
 
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
-class Covariant_ t source source => Pointable t source where
+class Covariant t source source => Pointable t source where
 	{-# MINIMAL point #-}
 	point :: source a (t a)
diff --git a/Pandora/Pattern/Functor/Semimonoidal.hs b/Pandora/Pattern/Functor/Semimonoidal.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Functor/Semimonoidal.hs
@@ -0,0 +1,6 @@
+module Pandora.Pattern.Functor.Semimonoidal where
+
+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))
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,7 +1,7 @@
 module Pandora.Pattern.Functor.Traversable where
 
-import Pandora.Pattern.Functor.Covariant (Covariant_)
-import Pandora.Pattern.Functor.Applicative (Semimonoidal)
+import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal)
 import Pandora.Pattern.Functor.Pointable (Pointable)
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 
@@ -18,10 +18,10 @@
 
 infixl 5 <<-, -<<-<<-
 
-class Covariant_ t source target => Traversable t source target where
-	(<<-) :: (Covariant_ u source target, Pointable u target, Semimonoidal u (:*:) source target) => source a (u b) -> target (t a) (u (t b))
+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))
 
-(-<<-<<-) :: forall t u v category a b . 
-	(Traversable t category category, Covariant_ u category category, Pointable u category, Semimonoidal u (:*:) category category, Traversable v category category)
+(-<<-<<-) :: 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)
 	=> category a (u b) -> category (v (t a)) (u (v (t b)))
 (-<<-<<-) f = ((<<-) ((<<-) @t @category @category f))
diff --git a/Pandora/Pattern/Semigroupoid.hs b/Pandora/Pattern/Semigroupoid.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Semigroupoid.hs
@@ -0,0 +1,11 @@
+module Pandora.Pattern.Semigroupoid where
+
+infixr 9 .
+
+{- |
+> When providing a new instance, you should ensure it satisfies:
+> * Associativity: f . (g . h) ≡ (f . g) . h
+-}
+
+class Semigroupoid (m :: * -> * -> *) where
+	(.) :: m b c -> m a b -> m a c
diff --git a/Pandora/Pattern/Transformer/Hoistable.hs b/Pandora/Pattern/Transformer/Hoistable.hs
--- a/Pandora/Pattern/Transformer/Hoistable.hs
+++ b/Pandora/Pattern/Transformer/Hoistable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Transformer.Hoistable (Hoistable (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
 {- |
 > When providing a new instance, you should ensure it satisfies one law:
@@ -13,7 +13,7 @@
 
 class Hoistable t where
 	{-# MINIMAL (/|\) #-}
-	(/|\) :: (Covariant_ u (->) (->)) => u ~> v -> t u ~> t v
+	(/|\) :: (Covariant u (->) (->)) => u ~> v -> t u ~> t v
 
-	hoist :: (Covariant_ u (->) (->)) => u ~> v -> t u ~> t v
+	hoist :: (Covariant u (->) (->)) => u ~> v -> t u ~> t v
 	hoist = (/|\)
diff --git a/Pandora/Pattern/Transformer/Liftable.hs b/Pandora/Pattern/Transformer/Liftable.hs
--- a/Pandora/Pattern/Transformer/Liftable.hs
+++ b/Pandora/Pattern/Transformer/Liftable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Transformer.Liftable (Liftable (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
 {- |
 > When providing a new instance, you should ensure it satisfies one law:
@@ -9,4 +9,4 @@
 -}
 
 class Liftable t where
-	lift :: (Covariant_ u (->) (->)) => u ~> t u
+	lift :: (Covariant u (->) (->)) => u ~> t u
diff --git a/Pandora/Pattern/Transformer/Lowerable.hs b/Pandora/Pattern/Transformer/Lowerable.hs
--- a/Pandora/Pattern/Transformer/Lowerable.hs
+++ b/Pandora/Pattern/Transformer/Lowerable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Transformer.Lowerable (Lowerable (..)) where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Covariant (Covariant_)
+import Pandora.Pattern.Functor.Covariant (Covariant)
 
 {- |
 > When providing a new instance, you should ensure it satisfies one law:
@@ -9,4 +9,4 @@
 -}
 
 class Lowerable t where
-	lower :: (Covariant_ u (->) (->)) => t u ~> u
+	lower :: (Covariant u (->) (->)) => t u ~> u
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.4.4
+version:             0.4.5
 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
@@ -31,6 +31,7 @@
     Pandora.Paradigm.Primary.Algebraic
     Pandora.Paradigm.Primary.Algebraic.Exponential
     Pandora.Paradigm.Primary.Algebraic.Product
+    Pandora.Paradigm.Primary.Algebraic.Sum
     Pandora.Paradigm.Primary.Object.Boolean
     Pandora.Paradigm.Primary.Object.Ordering
     Pandora.Paradigm.Primary.Object.Numerator
@@ -129,21 +130,18 @@
     Pandora.Paradigm.Primary.Linear.Matrix
 
     Pandora.Pattern
-    -- Category typeclass
+	-- Algebra typeclasses
+    Pandora.Pattern.Semigroupoid
     Pandora.Pattern.Category
     -- Functor typeclassess
     Pandora.Pattern.Functor
     Pandora.Pattern.Functor.Adjoint
-    Pandora.Pattern.Functor.Alternative
-    Pandora.Pattern.Functor.Applicative
+    Pandora.Pattern.Functor.Semimonoidal
     Pandora.Pattern.Functor.Bindable
     Pandora.Pattern.Functor.Comonad
     Pandora.Pattern.Functor.Contravariant
     Pandora.Pattern.Functor.Covariant
-    Pandora.Pattern.Functor.Determinable
     Pandora.Pattern.Functor.Distributive
-    Pandora.Pattern.Functor.Avoidable
-    Pandora.Pattern.Functor.Divisible
     Pandora.Pattern.Functor.Extendable
     Pandora.Pattern.Functor.Extractable
     Pandora.Pattern.Functor.Invariant