diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -583,3 +583,25 @@
 * Rearrange type parameters in `Divariant` typeclass
 * Generalize `Liftable` typeclass
 * Generalize `Lowerable` typeclass
+
+# 0.4.7
+* Remove `hoist` method from `Hoistable` typeclass
+* Rename `-<$>-` method to `<$>` in `Covariant` typeclasss
+* Rename `->$<-` method to `>$<` in `Contravariant` typeclass
+* Define `Straight` transformer
+* Define `-->` type synonymous
+* Define `Opposite` type family
+* Define experimental `Appliable` typeclass
+* Rename `multiply` method to `mult` in `Semimonoidal` typeclass
+* Generalize `Interpreted` typeclass
+* Define `Groupoid` typeclass
+* Remove `Measurable` typeclass
+* Rename `Applicative_` typeclass to `Applicative`
+* Rename `Alternative_` typeclass to `Alternative`
+* Rename `-<*>-` method of Applicative to `<-*-`
+* Add functional dependencies to `Appliable` typeclass
+* Remove `-<$$>-`, `-<<$>-`, `-<$$>>-` in favor of `<$$>`
+* Remove `-<$$$>-` in favor of `<$$$>`
+* Remove `-<$$$$>-` in favor of `<$$$$>`
+
+# 0.4.8
diff --git a/Pandora/Core.hs b/Pandora/Core.hs
--- a/Pandora/Core.hs
+++ b/Pandora/Core.hs
@@ -1,4 +1,5 @@
 module Pandora.Core (module Exports) where
 
 import Pandora.Core.Impliable as Exports
+import Pandora.Core.Appliable as Exports
 import Pandora.Core.Functor as Exports
diff --git a/Pandora/Core/Appliable.hs b/Pandora/Core/Appliable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Core/Appliable.hs
@@ -0,0 +1,6 @@
+module Pandora.Core.Appliable where
+
+infixr 0 !
+
+class Appliable m a b n c d | m a b -> n c d where
+	(!) :: m a b -> n c d
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
@@ -9,9 +9,10 @@
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Transformer (Liftable (lift), Lowerable (lower), Hoistable (hoist))
+import Pandora.Pattern.Transformer (Liftable (lift), Lowerable (lower), Hoistable ((/|\)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
-import Pandora.Paradigm.Primary.Algebraic (Extractable_)
+import Pandora.Paradigm.Primary.Algebraic (Extractable)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer (Monadic, Comonadic, wrap, bring, (:>), (:<))
 
@@ -21,8 +22,8 @@
 
 type Lifting t u = (Monadic t, Liftable (->) (Schematic Monad t), Covariant (->) (->) u)
 type Lowering t u = (Comonadic t, Lowerable (->) (Schematic Comonad t), Covariant (->) (->) u)
-type Wrappable t u = (Monadic t, Monoidal (->) (->) (:*:) (:*:) u)
-type Bringable t u = (Comonadic t, Extractable_ u)
+type Wrappable t u = (Monadic t, Monoidal (-->) (->) (:*:) (:*:) u)
+type Bringable t u = (Comonadic t, Extractable u)
 
 instance Adaptable t t where
 	adapt = identity
@@ -296,7 +297,7 @@
 	adapt = bring . lower . lower . lower . lower . lower . lower . lower
 
 instance (Covariant (->) (->) u, Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where
-	adapt = hoist adapt
+	adapt = (adapt /|\)
 
 instance
 	( Covariant (->) (->) v
@@ -306,7 +307,7 @@
 	, Hoistable (Schematic Monad u)
 	, Adaptable v v'
 	) => Adaptable (t :> u :> v) (t :> u :> v') where
-	adapt = hoist (hoist adapt)
+	adapt = ((adapt /|\) /|\)
 
 instance
 	( Covariant (->) (->) u
@@ -321,7 +322,7 @@
 	, Hoistable (Schematic Monad v)
 	, Adaptable w w'
 	) => Adaptable (t :> u :> v :> w) (t :> u :> v :> w') where
-	adapt = hoist (hoist (hoist adapt))
+	adapt = (((adapt /|\) /|\) /|\)
 
 instance
 	( Covariant (->) (->) x
@@ -335,7 +336,7 @@
 	, Hoistable (Schematic Monad w)
 	, Adaptable x x'
 	) => Adaptable (t :> u :> v :> w :> x) (t :> u :> v :> w :> x') where
-	adapt = hoist (hoist (hoist (hoist adapt)))
+	adapt = (((adapt /|\) /|\) /|\)
 
 instance
 	( Covariant (->) (->) y
@@ -351,7 +352,7 @@
 	, Hoistable (Schematic Monad x)
 	, Adaptable y y'
 	) => Adaptable (t :> u :> v :> w :> x :> y) (t :> u :> v :> w :> x :> y') where
-	adapt = hoist (hoist (hoist (hoist (hoist adapt))))
+	adapt = ((((adapt /|\) /|\) /|\) /|\)
 
 instance
 	( Covariant (->) (->) z
@@ -370,7 +371,7 @@
 	, Adaptable z z'
 	) => Adaptable (t :> u :> v :> w :> x :> y :> z)
 		(t :> u :> v :> w :> x :> y :> z') where
-	adapt = hoist (hoist (hoist (hoist (hoist adapt))))
+	adapt = (((((adapt /|\) /|\) /|\) /|\) /|\)
 
 instance
 	( Covariant (->) (->) f
@@ -391,7 +392,7 @@
 	, Adaptable f f'
 	) => Adaptable (t :> u :> v :> w :> x :> y :> z :> f)
 		(t :> u :> v :> w :> x :> y :> z :> f') where
-	adapt = hoist (hoist (hoist (hoist (hoist (hoist adapt)))))
+	adapt = ((((((adapt /|\) /|\) /|\) /|\) /|\) /|\)
 
 instance
 	( Covariant (->) (->) h
@@ -414,4 +415,4 @@
 	, Adaptable h h'
 	) => Adaptable (t :> u :> v :> w :> x :> y :> z :> f :> h)
 		(t :> u :> v :> w :> x :> y :> z :> f :> h') where
-	adapt = hoist (hoist (hoist (hoist (hoist (hoist (hoist adapt))))))
+	adapt = (((((((adapt /|\) /|\) /|\) /|\) /|\) /|\) /|\)
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,59 +1,71 @@
 module Pandora.Paradigm.Controlflow.Effect.Interpreted where
 
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-), (-<$$$>-), (-<$$$$>-))
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>), (<$$$>), (<$$$$>))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
 infixr 2 ||=, =||
 
-type family Schematic (c :: (* -> *) -> k) (t :: * -> *) = (r :: (* -> *) -> * -> *) | r -> t
+type family Schematic (c :: (* -> * -> *) -> (* -> *) -> k) (t :: * -> *) = (r :: (* -> *) -> * -> *) | r -> t
 
-class Interpreted t where
+class Interpreted m t where
 	{-# MINIMAL run, unite #-}
 	type Primary t a :: *
-	run :: t a -> Primary t a
-	unite :: Primary t a -> t a
+	run :: m (t a) (Primary t a)
+	unite :: m (Primary t a) (t a)
 
-	(||=) :: Interpreted u => (Primary t a -> Primary u b) -> t a -> u b
+	(||=) :: (Semigroupoid m, Interpreted m u) => m (Primary t a) (Primary u b) -> m (t a) (u b)
 	(||=) f = unite . f . run
 
-	(=||) :: Interpreted u => (t a -> u b) -> Primary t a -> Primary u b
+	(=||) :: (Semigroupoid m, Interpreted m u) => m (t a) (u b) -> m (Primary t a) (Primary u b)
 	(=||) f = run . f . unite
 
-	(<$||=) :: (Covariant (->) (->) j, Interpreted u)
-		=> (Primary t a -> Primary u b) -> j := t a -> j := u b
-	f <$||= x = (f ||=) -<$>- x
+	(<$||=) :: (Semigroupoid m, Covariant m m j, Interpreted m u)
+                => m (Primary t a) (Primary u b) -> m (j := t a) (j := u b)
+	(<$||=) f = (<$>) ((||=) f)
 
-	(<$$||=) :: (Covariant (->) (->) j, Covariant (->) (->) k, Interpreted u)
-		=> (Primary t a -> Primary u b) -> j :. k := t a -> j :. k := u b
-	f <$$||= x = (f ||=) -<$$>- x
+	(<$$||=) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Interpreted m u)
+		=> m (Primary t a) (Primary u b) -> m (j :. k := t a) (j :. k := u b)
+	(<$$||=) f = (<$$>) @m @m ((||=) f)
 
-	(<$$$||=) :: (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
+	(<$$$||=) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)
+		=> m (Primary t a) (Primary u b) -> m (j :. k :. l := t a) (j :. k :. l := u b)
+	(<$$$||=) f = (<$$$>) @m @m @m ((||=) f)
 
-	(<$$$$||=) :: (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
+	(<$$$$||=) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Covariant m m l, Covariant m m n, Interpreted m u)
+		=> m (Primary t a) (Primary u b) -> m (j :. k :. l :. n := t a) (j :. k :. l :. n := u b)
+	(<$$$$||=) f = (<$$$$>) @m @m @m @m ((||=) f)
 
-	(=||$>) :: (Covariant (->) (->) j, Interpreted u)
-		=> (t a -> u b) -> j := Primary t a -> j := Primary u b
-	f =||$> x = (f =||) -<$>- x
+	(=||$>) :: (Covariant m m j, Interpreted m u)
+		=> m (t a) (u b) -> m (j := Primary t a) (j := Primary u b)
+	(=||$>) f = (<$>) ((=||) f)
 
-	(=||$$>) :: (Covariant (->) (->) j, Covariant (->) (->) k, Interpreted u)
-		=> (t a -> u b) -> j :. k := Primary t a -> j :. k := Primary u b
-	f =||$$> x = (f =||) -<$$>- x
+	(=||$$>) :: (Covariant m m j, Covariant m m k, Interpreted m u)
+		=> m (t a) (u b) -> m (j :. k := Primary t a) (j :. k := Primary u b)
+	(=||$$>) f = (<$$>) @m @m ((=||) f)
 
-	(=||$$$>) :: (Covariant (->) (->) j, Covariant (->) (->) k, Covariant (->) (->) l, Interpreted u)
-		=> (t a -> u b) -> j :. k :. l := Primary t a -> j :. k :. l := Primary u b
-	f =||$$$> x = (f =||) -<$$$>- x
+	(=||$$$>) :: (Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)
+		=> m (t a) (u b) -> m (j :. k :. l := Primary t a) (j :. k :. l := Primary u b)
+	(=||$$$>) f = (<$$$>) @m @m @m ((=||) f)
 
-	(=||$$$$>) :: (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
+	(=||$$$$>) :: (Covariant m m j, Covariant m m k, Covariant m m l, Covariant m m n, Interpreted m u)
+		=> m (t a) (u b) -> m (j :. k :. l :. n := Primary t a) (j :. k :. l :. n := Primary u b)
+	(=||$$$$>) f = (<$$$$>) @m @m @m @m ((=||) f)
 
-(-=:) :: (Liftable (->) t, Interpreted (t u), Interpreted (t v), Covariant (->) (->) u)
-	=> (t u a -> t v b) -> u a -> Primary (t v) b
+(-=:) :: (Liftable m t, Interpreted m (t u), Interpreted m (t v), Covariant m m u)
+	=> m (t u a) (t v b) -> m (u a) (Primary (t v) b)
 (-=:) f = run . f . lift
+
+instance Interpreted (->) (Flip v a) where
+	type Primary (Flip v a) e = v e a
+	run ~(Flip x) = x
+	unite = Flip
+
+instance Interpreted (->) (Straight v e) where
+	type Primary (Straight v e) a = v e a
+	run ~(Straight x) = x
+	unite = Straight
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer.hs
@@ -1,10 +1,10 @@
-module Pandora.Paradigm.Controlflow.Effect.Transformer (module Exports) where
+module Pandora.Paradigm.Controlflow.Effect.Transformer (module Exports, Transformer) where
 
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic as Exports
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic as Exports
 
---import Pandora.Pattern.Functor (Monad, Comonad)
+import Pandora.Pattern.Functor (Monad, Comonad)
 
---type family Transformer c t where
---	Transformer Monad t = Monadic t
---	Transformer Comonad t = Comonadic t
+type family Transformer c t where
+	Transformer Monad t = Monadic t
+	Transformer Comonad t = Comonadic t
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
@@ -2,11 +2,13 @@
 
 module Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (..), (:<) (..)) where
 
+import Pandora.Core.Appliable ((!))
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
@@ -15,29 +17,30 @@
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (Extractable_, point)
+import Pandora.Paradigm.Primary.Algebraic (Extractable, point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 
-class Interpreted t => Comonadic t where
+class Interpreted (->) t => Comonadic t where
 	{-# MINIMAL bring #-}
-	bring :: Extractable_ u => t :< u ~> t
+	bring :: Extractable u => t :< u ~> t
 
 infixr 3 :<
 newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }
 
 instance Covariant (->) (->) (Schematic Comonad t u) => Covariant (->) (->) (t :< u) where
-	f -<$>- TC x = TC $ f -<$>- x
+	f <$> TC x = TC $ f <$> x
 
-instance Semimonoidal (->) (:*:) (:*:) (Schematic Comonad t u) => Semimonoidal (->) (:*:) (:*:) (t :< u) where
-	multiply (TC f :*: TC x) = TC $ multiply $ f :*: x
+instance Semimonoidal (-->) (:*:) (:*:) (Schematic Comonad t u) => Semimonoidal (-->) (:*:) (:*:) (t :< u) where
+	mult = Straight $ \(TC f :*: TC x) -> TC $ mult @(-->) @(:*:) @(:*:) ! f :*: x
 
-instance Monoidal (->) (->) (:*:) (:*:) (Schematic Comonad t u) => Monoidal (->) (->) (:*:) (:*:) (t :< u) where
-	unit _ f = TC . point $ f One
+instance Monoidal (-->) (->) (:*:) (:*:) (Schematic Comonad t u) => Monoidal (-->) (->) (:*:) (:*:) (t :< u) where
+	unit _ = Straight $ TC . point . ($ One)
 
 instance Traversable (->) (->) (Schematic Comonad t u) => Traversable (->) (->) (t :< u) where
-	f <<- TC x = TC -<$>- f <<- x
+	f <<- TC x = TC <$> f <<- x
 
 instance Distributive (->) (->) (Schematic Comonad t u) => Distributive (->) (->) (t :< u) where
 	f -<< x = TC $ tc . f -<< x
@@ -48,7 +51,7 @@
 instance Extendable (->) (Schematic Comonad t u) => Extendable (->) (t :< u) where
 	f <<= TC x = TC $ f . TC <<= x
 
-instance (Extractable_ (t :< u), Extendable (->) (t :< u)) => Comonad (t :< u) (->) where
+instance (Extractable (t :< u), Extendable (->) (t :< u)) => Comonad (->) (t :< u) where
 
 instance Lowerable (->) (Schematic Comonad t) => Lowerable (->) ((:<) t) where
 	lower (TC x) = lower x
@@ -56,7 +59,7 @@
 instance Hoistable (Schematic Comonad t) => Hoistable ((:<) t) where
 	f /|\ TC x = TC $ f /|\ x
 
-instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where
+instance (Interpreted (->) (Schematic Comonad t u)) => Interpreted (->) (t :< u) where
 	type Primary (t :< u) a = Primary (Schematic Comonad t u) a
 	run ~(TC x) = run x
 	unite = TC . unite
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
@@ -2,11 +2,13 @@
 
 module Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (..), (:>) (..)) where
 
+import Pandora.Core.Appliable ((!))
 import Pandora.Core.Functor (type (~>))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
@@ -15,29 +17,30 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Primary.Algebraic (Pointable, point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 
-class Interpreted t => Monadic t where
+class Interpreted (->) t => Monadic t where
 	{-# MINIMAL wrap #-}
-	wrap :: Monoidal (->) (->) (:*:) (:*:) u => t ~> t :> u
+	wrap :: Pointable u => t ~> t :> u
 
 infixr 3 :>
 newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
 
 instance Covariant (->) (->) (Schematic Monad t u) => Covariant (->) (->) (t :> u) where
-	f -<$>- TM x = TM $ f -<$>- x
+	f <$> TM x = TM $ f <$> x
 
-instance Semimonoidal (->) (:*:) (:*:) (Schematic Monad t u) => Semimonoidal (->) (:*:) (:*:) (t :> u) where
-	multiply (TM f :*: TM x) = TM $ multiply $ f :*: x
+instance Semimonoidal (-->) (:*:) (:*:) (Schematic Monad t u) => Semimonoidal (-->) (:*:) (:*:) (t :> u) where
+	mult = Straight $ \(TM f :*: TM x) -> TM $ mult @(-->) @(:*:) @(:*:) ! f :*: x
 
-instance Monoidal (->) (->) (:*:) (:*:) (Schematic Monad t u) => Monoidal (->) (->) (:*:) (:*:) (t :> u) where
-	unit _ f = TM . point $ f One
+instance Monoidal (-->) (->) (:*:) (:*:) (Schematic Monad t u) => Monoidal (-->) (->) (:*:) (:*:) (t :> u) where
+	unit _ = Straight $ TM . point . ($ One)
 
 instance Traversable (->) (->) (Schematic Monad t u) => Traversable (->) (->) (t :> u) where
-	f <<- TM x = TM -<$>- f <<- x
+	f <<- TM x = TM <$> f <<- x
 
 instance Distributive (->) (->) (Schematic Monad t u) => Distributive (->) (->) (t :> u) where
 	f -<< x = TM $ tm . f -<< x
@@ -48,7 +51,7 @@
 instance Extendable (->) (Schematic Monad t u) => Extendable (->) (t :> u) where
 	f <<= TM x = TM $ f . TM <<= x
 
-instance (Covariant (->) (->) (Schematic Monad t u), Monoidal (->) (->) (:*:) (:*:) (Schematic Monad t u), Bindable (->) (t :> u)) => Monad (t :> u) where
+instance (Covariant (->) (->) (Schematic Monad t u), Monoidal (-->) (->) (:*:) (:*:) (Schematic Monad t u), Bindable (->) (t :> u)) => Monad (->) (t :> u) where
 
 instance Liftable (->) (Schematic Monad t) => Liftable (->) ((:>) t) where
 	lift = TM . lift
@@ -56,7 +59,7 @@
 instance Hoistable (Schematic Monad t) => Hoistable ((:>) t) where
 	f /|\ TM x = TM $ f /|\ x
 
-instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where
+instance (Interpreted (->) (Schematic Monad t u)) => Interpreted (->) (t :> u) where
 	type Primary (t :> u) a = Primary (Schematic Monad t u) a
 	run ~(TM x) = run x
 	unite = TM . unite
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
@@ -3,7 +3,7 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Paradigm.Primary.Algebraic (Applicative_, forever_)
+import Pandora.Paradigm.Primary.Algebraic (Applicative, forever_)
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 
@@ -24,25 +24,25 @@
 (.:~.) = notify
 
 -- | Listen only first event, call back forever_
-follow :: Applicative_ t => Observable t a r -> (a -> t r) -> t r
+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 :: 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 :: 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
@@ -4,7 +4,7 @@
 import Pandora.Pattern.Category (($), (#))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (!..))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (!..), type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 import Pandora.Paradigm.Primary.Algebraic (point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
@@ -12,14 +12,14 @@
 
 newtype Producer i t r = Producer { produce :: Consumer i t r -> t r }
 
-instance Interpreted (Producer i t) where
+instance Interpreted (->) (Producer i t) where
 	type Primary (Producer i t) a = Consumer i t a -> t a
 	run ~(Producer f) = f
 	unite = Producer
 
 newtype Consumer o t r = Consumer { consume :: o -> Producer o t r -> t r }
 
-instance Interpreted (Consumer o t) where
+instance Interpreted (->) (Consumer o t) where
 	type Primary (Consumer o t) a = o -> Producer o t a -> t a
 	run ~(Consumer f) = f
 	unite = Consumer
@@ -43,7 +43,7 @@
 yield v = Continuation $ \next -> Pipe $ \i (Consumer o) -> o v # pause next i
 
 -- | Pipeline that does nothing
-finish :: Monoidal (->) (->) (:*:) (:*:) t => Pipeline i o t () ()
+finish :: Monoidal (-->) (->) (:*:) (:*:) t => Pipeline i o t () ()
 finish = Continuation (Pipe (point () !..) !.)
 
 -- | Do some effectful computation within pipeline
@@ -51,14 +51,14 @@
 impact action = Continuation $ \next -> Pipe $ \i o -> (\x -> pipe (next x) i o) =<< action
 
 -- | Compose two pipelines into one
-(=*=) :: forall i e o t . Monoidal (->) (->) (:*:) (:*:) t => Pipeline i e t () () -> Pipeline e o t () () -> Pipeline i o t () ()
+(=*=) :: forall i e o t . Monoidal (-->) (->) (:*:) (:*:) t => Pipeline i e t () () -> Pipeline e o t () () -> Pipeline i o t () ()
 p =*= q = Continuation $ \_ -> Pipe $ \i -> pipe # run q end # pause (run p end !.) i where
 
 	end :: b -> Pipe c d () t ()
 	end _ = Pipe (point () !..)
 
 -- | Run pipeline and get result
-pipeline :: Monoidal (->) (->) (:*:) (:*:) t => Pipeline i o t () () -> t ()
+pipeline :: Monoidal (-->) (->) (:*:) (:*:) t => Pipeline i o t () () -> t ()
 pipeline p = pipe # run p (Pipe . (!..) . point) # i # o where
 
 	i :: Producer i t ()
diff --git a/Pandora/Paradigm/Inventory/Accumulator.hs b/Pandora/Paradigm/Inventory/Accumulator.hs
--- a/Pandora/Paradigm/Inventory/Accumulator.hs
+++ b/Pandora/Paradigm/Inventory/Accumulator.hs
@@ -2,14 +2,16 @@
 
 module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where
 
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Object.Monoid (Monoid)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic (point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
@@ -20,10 +22,10 @@
 newtype Accumulator e a = Accumulator (e :*: a)
 
 instance Covariant (->) (->) (Accumulator e) where
-	f -<$>- Accumulator x = Accumulator $ f -<$>- x
+	f <$> Accumulator x = Accumulator $ f <$> x
 
-instance Semigroup e => Semimonoidal (->) (:*:) (:*:) (Accumulator e) where
-	multiply (x :*: y) = Accumulator $ k # run x # run y where
+instance Semigroup e => Semimonoidal (-->) (:*:) (:*:) (Accumulator e) where
+	mult = Straight $ \(x :*: y) -> Accumulator $ k # run x # run y where
 		k ~(ex :*: x') ~(ey :*: y') = ex + ey :*: x' :*: y'
 
 instance Semigroup e => Bindable (->) (Accumulator e) where
@@ -32,7 +34,7 @@
 
 type instance Schematic Monad (Accumulator e) = (<.:>) ((:*:) e)
 
-instance Interpreted (Accumulator e) where
+instance Interpreted (->) (Accumulator e) where
 	type Primary (Accumulator e) a = e :*: a
 	run ~(Accumulator x) = x
 	unite = Accumulator
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,22 +2,25 @@
 
 module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where
 
+import Pandora.Core.Appliable ((!))
 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.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
+import Pandora.Pattern.Functor.Bivariant ((<->))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), (%))
 import Pandora.Paradigm.Primary.Algebraic ()
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (point)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
@@ -26,19 +29,19 @@
 newtype Environment e a = Environment (e -> a)
 
 instance Covariant (->) (->) (Environment e) where
-	f -<$>- Environment x = Environment $ f . x
+	f <$> Environment x = Environment $ f . x
 
 instance Contravariant (->) (->) (Flip Environment a) where
-	f ->$<- Flip (Environment g) = Flip . Environment $ g . f
+	f >$< Flip (Environment g) = Flip . Environment $ g . f
 
-instance Semimonoidal (->) (:*:) (:*:) (Environment e) where
-	multiply (x :*: y) = unite $ multiply $ run x :*: run y
+instance Semimonoidal (-->) (:*:) (:*:) (Environment e) where
+	mult = Straight $ Environment . (mult @(-->) !) . (run @(->) <-> run @(->))
 
-instance Monoidal (->) (->) (:*:) (:*:) (Environment e) where
-	unit _ f = Environment $ \_ -> f One
+instance Monoidal (-->) (->) (:*:) (:*:) (Environment e) where
+	unit _ = Straight $ \f -> Environment $ \_ -> f One
 
 instance Distributive (->) (->) (Environment e) where
-	f -<< g = Environment $ (run -<$>- f) -<< g
+	f -<< g = Environment $ (run @(->) <$> f) -<< g
 
 instance Bindable (->) (Environment e) where
 	f =<< Environment x = Environment $ \e -> (run % e) . f . x $ e
@@ -48,7 +51,7 @@
 instance Divariant (->) (->) (->) Environment where
 	(>->) ab cd bc = Environment $ ab >-> cd $ run bc
 
-instance Interpreted (Environment e) where
+instance Interpreted (->) (Environment e) where
 	type Primary (Environment e) a = (->) e a
 	run ~(Environment x) = x
 	unite = Environment
@@ -56,7 +59,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
@@ -4,7 +4,7 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
@@ -17,15 +17,15 @@
 newtype Equipment e a = Equipment (e :*: a)
 
 instance Covariant (->) (->) (Equipment e) where
-	f -<$>- Equipment x = Equipment $ f -<$>- x
+	f <$> Equipment x = Equipment $ f <$> x
 
 instance Traversable (->) (->) (Equipment e) where
-	f <<- Equipment x = Equipment -<$>- f <<- x
+	f <<- Equipment x = Equipment <$> f <<- x
 
 instance Extendable (->) (Equipment e) where
 	f <<= Equipment (e :*: x) = Equipment . (:*:) e . f . Equipment $ e :*: x
 
-instance Interpreted (Equipment e) where
+instance Interpreted (->) (Equipment e) where
 	type Primary (Equipment e) a = e :*: a
 	run ~(Equipment x) = x
 	unite = Equipment
@@ -38,4 +38,4 @@
 	f <<= TU (e :*: x) = TU . (:*:) e $ f . TU . (:*:) e <<= x
 
 retrieve :: Equipped e t => t a -> e
-retrieve = attached . run @(Equipment _) . adapt
+retrieve = attached . run @(->) @(Equipment _) . adapt
diff --git a/Pandora/Paradigm/Inventory/Imprint.hs b/Pandora/Paradigm/Inventory/Imprint.hs
--- a/Pandora/Paradigm/Inventory/Imprint.hs
+++ b/Pandora/Paradigm/Inventory/Imprint.hs
@@ -4,15 +4,15 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-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.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (||=)))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable)
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
@@ -20,13 +20,13 @@
 newtype Imprint e a = Imprint (e -> a)
 
 instance Covariant (->) (->) (Imprint e) where
-	f -<$>- Imprint g = Imprint $ f . g
+	f <$> Imprint g = Imprint $ f . g
 
 instance Contravariant (->) (->) (Flip Imprint a) where
-	f ->$<- Flip (Imprint g) = Flip . Imprint $ g . f
+	f >$< Flip (Imprint g) = Flip . Imprint $ g . f
 
 instance Distributive (->) (->) (Imprint e) where
-	f -<< g = Imprint $ (run -<$>- f) -<< g
+	f -<< g = Imprint $ (run @(->) <$> f) -<< g
 
 instance Divariant (->) (->) (->) Imprint where
 	(>->) ab cd bc = ab >-> cd ||= bc
@@ -34,7 +34,7 @@
 instance Semigroup e => Extendable (->) (Imprint e) where
 	f <<= Imprint x = Imprint $ \e -> f $ Imprint $ x . (e +)
 
-instance Interpreted (Imprint e) where
+instance Interpreted (->) (Imprint e) where
 	type Primary (Imprint e) a = (->) e a
 	run ~(Imprint x) = x
 	unite = Imprint
@@ -42,6 +42,6 @@
 type instance Schematic Comonad (Imprint e) = (<.:>) ((->) e)
 
 instance {-# OVERLAPS #-} (Semigroup e, Extendable (->) u) => Extendable (->) ((->) e <.:> u) where
-	f <<= UT x = UT $ (\x' e -> f . UT . (-<$>-) (. (e +)) $ x') <<= x
+	f <<= UT x = UT $ (\x' e -> f . UT . (<$>) (. (e +)) $ x') <<= x
 
 type Traceable e t = Adaptable t (Imprint e)
diff --git a/Pandora/Paradigm/Inventory/Optics.hs b/Pandora/Paradigm/Inventory/Optics.hs
--- a/Pandora/Paradigm/Inventory/Optics.hs
+++ b/Pandora/Paradigm/Inventory/Optics.hs
@@ -5,7 +5,7 @@
 import Pandora.Core.Impliable (Impliable (Arguments, imply))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (Category (identity, ($), (#)))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
@@ -16,7 +16,7 @@
 import Pandora.Paradigm.Primary.Algebraic (($>-), extract)
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Primary.Object.Boolean ((?))
 import Pandora.Paradigm.Inventory.Store (Store (Store), position, look, retrofit)
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
@@ -27,15 +27,17 @@
 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
+	(.) :: Convex Lens between target -> Convex Lens source between -> Convex Lens source target
 	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 :: Convex Lens source source
 	identity = imply @(Convex Lens _ _) identity ((%) (!.))
 
 instance Impliable (P_Q_T (->) Store Identity source target) where
@@ -52,11 +54,13 @@
 	imply getter setter = P_Q_T $ \source -> Store $ getter source :*: setter source
 
 instance Semigroupoid (Lens Maybe) where
+	(.) :: Obscure Lens between target -> Obscure Lens source between -> Obscure Lens source target
 	P_Q_T to . P_Q_T from = P_Q_T $ \source -> case position # from source of
 		Nothing -> Store $ Nothing :*: (source !.)
 		Just between -> to between $>- source
 
 instance Category (Lens Maybe) where
+	identity :: Obscure Lens source source
 	identity = imply @(Obscure Lens _ _) # Just # resolve identity
 
 -- Lens as natural transformation
diff --git a/Pandora/Paradigm/Inventory/State.hs b/Pandora/Paradigm/Inventory/State.hs
--- a/Pandora/Paradigm/Inventory/State.hs
+++ b/Pandora/Paradigm/Inventory/State.hs
@@ -2,12 +2,14 @@
 
 module Pandora.Paradigm.Inventory.State where
 
+import Pandora.Pattern.Morphism.Flip (Flip)
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -15,39 +17,39 @@
 import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
 import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Functor.Divariant ((>->))
-import Pandora.Paradigm.Primary.Transformer (Flip)
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (*>-), delta)
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Primary.Algebraic (Pointable, point)
 
 -- | Effectful computation with a variable
 newtype State s a = State ((->) s :. (:*:) s := a)
 
 instance Covariant (->) (->) (State s) where
-	f -<$>- x = State $ (-<$>-) f . run x
+	f <$> x = State $ (<$>) f . run x
 
-instance Semimonoidal (->) (:*:) (:*:) (State s) where
-	multiply (State g :*: State h) = State $ \s -> 
-		let old :*: x = g s in 
-	  	let new :*: y = h old in
+instance Semimonoidal (-->) (:*:) (:*:) (State s) where
+	mult = Straight $ \(State g :*: State h) -> State $ \s ->
+		let old :*: x = g s in
+		let new :*: y = h old in
 		new :*: x :*: y
 
-instance Monoidal (->) (->) (:*:) (:*:) (State s) where
-	unit _ f = State . (identity @(->) -|) $ f One
+instance Monoidal (-->) (->) (:*:) (:*:) (State s) where
+	unit _ = Straight $ State . (identity @(->) -|) . ($ One)
 
 instance Bindable (->) (State s) where
-	f =<< x = State $ (run . f |-) -<$>- run x
+	f =<< x = State $ (run . f |-) <$> run x
 
-instance Monad (State s) where
+instance Monad (->) (State s) where
 
 instance Invariant (Flip State r) where
 	f <$< g = ((g >-> ((<->) @_ @(->) @(->) f identity) ||=) ||=)
 
-instance Interpreted (State s) where
+instance Interpreted (->) (State s) where
 	type Primary (State s) a = (->) s :. (:*:) s := a
 	run ~(State x) = x
 	unite = State
@@ -55,7 +57,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)
 
@@ -74,7 +76,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 = (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t,  Stateful s t)
+type Memorable s t = (Covariant (->) (->) t, Pointable t,  Stateful s t)
 
 fold :: (Traversable (->) (->) t, Memorable s u) => (a -> s -> s) -> t a -> u s
 fold op struct = (modify . op <<- struct) *>- current
diff --git a/Pandora/Paradigm/Inventory/Store.hs b/Pandora/Paradigm/Inventory/Store.hs
--- a/Pandora/Paradigm/Inventory/Store.hs
+++ b/Pandora/Paradigm/Inventory/Store.hs
@@ -5,8 +5,8 @@
 import Pandora.Core (type (:.), type (:=), type (<:=), type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -17,7 +17,7 @@
 import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), (%), (!.), (-.#..-))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
 import Pandora.Paradigm.Primary.Algebraic (extract)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))
@@ -26,26 +26,28 @@
 -- | Context based computation on value
 newtype Store s a = Store ((:*:) s :. (->) s := a)
 
+-- TODO: Try to generalize (->) here
 instance Covariant (->) (->) (Store s) where
-	f -<$>- Store x = Store $ f -<$$>- x
+	(<$>) f = (||=) ((<$$>) @(->) @(->) f)
 
 instance Semimonoidal (<--) (:*:) (:*:) (Store s) where
-	multiply = Flip $ \(Store (s :*: f)) -> 
+	mult = Flip $ \(Store (s :*: f)) ->
 		let (x :*: y) = f s in
 		Store (s :*: (x !.)) :*: Store (s :*: (y !.))
 
 instance Monoidal (<--) (->) (:*:) (:*:) (Store s) where
 	unit _ = Flip $ \(Store (s :*: f)) -> (\_ -> f s)
 
+-- TODO: Try to generalize (->) here
 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
+instance Comonad (->) (Store s) where
 
 instance Invariant (Flip Store r) where
 	f <$< g = \(Flip x) -> Flip $ (<->) @_ @(->) f (g >-> identity @(->)) ||= x
 
-instance Interpreted (Store s) where
+instance Interpreted (->) (Store s) where
 	type Primary (Store s) a = (:*:) s :. (->) s := a
 	run ~(Store x) = x
 	unite = Store
@@ -59,11 +61,11 @@
 
 -- | Get current index
 position :: Storable s t => t a -> s
-position = attached . run @(Store _) . adapt
+position = attached . run @(->) @(Store _) . adapt
 
 -- | Given an index return value
 look :: Storable s t => s -> a <:= t
-look s = (extract % s) . run @(Store _) . adapt
+look s = (extract % s) . run @(->) @(Store _) . adapt
 
 -- | Change index with function
 retrofit :: (s -> s) -> Store s ~> Store s
diff --git a/Pandora/Paradigm/Primary.hs b/Pandora/Paradigm/Primary.hs
--- a/Pandora/Paradigm/Primary.hs
+++ b/Pandora/Paradigm/Primary.hs
@@ -8,10 +8,11 @@
 import Pandora.Paradigm.Primary.Object as Exports
 import Pandora.Paradigm.Primary.Algebraic as Exports
 
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (Category (($), (#)))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-), (-|)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
@@ -89,16 +90,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,6 +1,6 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Primary.Algebraic (module Exports, Applicative_, Alternative_, Extractable_, ($>-), ($$>-), ($$$>-), (-<*>-), (*>-), forever_, (-+-), void, empty, point, extract) where
+module Pandora.Paradigm.Primary.Algebraic (module Exports, Applicative, Alternative, Extractable, Pointable, ($>-), ($$>-), ($$$>-), (<-*-), (*>-), forever_, (-+-), void, empty, point, extract) where
 
 import Pandora.Paradigm.Primary.Algebraic.Exponential as Exports
 import Pandora.Paradigm.Primary.Algebraic.Product as Exports
@@ -8,35 +8,39 @@
 import Pandora.Paradigm.Primary.Algebraic.Zero as Exports
 import Pandora.Paradigm.Primary.Algebraic.One as Exports
 
+import Pandora.Core.Appliable ((!))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-), (-<$$$>-))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>), (<$$$>))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit), Unit)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Paradigm.Primary.Functor.Proxy (Proxy (Proxy))
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 
 type instance Unit (:*:) = One
 type instance Unit (:+:) = Zero
 
-infixl 4 -<*>-
+infixl 4 <-*-
 
 ($>-) :: Covariant (->) (->) t => t a -> b -> t b
-x $>- r = (r !.) -<$>- x
+x $>- r = (r !.) <$> x
 
 ($$>-) :: (Covariant (->) (->) t, Covariant (->) (->) u) => t (u a) -> b -> t (u b)
-x $$>- r = (r !.) -<$$>- x
+x $$>- r = (<$$>) @(->) @(->) (r !.) x
 
 ($$$>-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Covariant (->) (->) v) => t (u (v a)) -> b -> t (u (v b))
-x $$$>- r = (r !.) -<$$$>- x
+x $$$>- r = (<$$$>) @(->) @(->) @(->) (r !.) x
 
 void :: Covariant (->) (->) t => t a -> t ()
 void x = x $>- ()
 
 instance Traversable (->) (->) ((:*:) s) where
-	f <<- x = (attached x :*:) -<$>- f (extract x)
+	f <<- x = (attached x :*:) <$> f (extract x)
 
 instance Adjoint (->) (->) ((:*:) s) ((->) s) where
 	(-|) :: ((s :*: a) -> b) -> a -> (s -> b)
@@ -44,65 +48,72 @@
 	(|-) :: (a -> s -> b) -> (s :*: a) -> b
 	f |- ~(s :*: x) = f x s
 
-instance Semimonoidal (->) (:*:) (:*:) ((->) e) where
-	multiply :: ((e -> a) :*: (e -> b)) -> e -> (a :*: b)
-	multiply (g :*: h) = \x -> g x :*: h x
+instance Semimonoidal (-->) (:*:) (:*:) ((->) e) where
+	mult :: ((e -> a) :*: (e -> b)) --> (e -> (a :*: b))
+	mult = Straight $ \(g :*: h) -> \x -> g x :*: h x
 
 instance Semimonoidal (<--) (:*:) (:*:) ((->) e) where
-	multiply = Flip $ \f -> (\e -> attached $ f e) :*: (\e -> extract $ f e)
+	mult :: ((e -> a) :*: (e -> b)) <-- (e -> a :*: b)
+	mult = Flip $ \f -> attached . f :*: extract . f
 
-instance Semimonoidal (->) (:*:) (:+:) ((:+:) e) where
-	multiply :: ((e :+: a) :*: (e :+: b)) -> e :+: a :+: b
-	multiply (Option _ :*: Option e') = Option e'
-	multiply (Option _ :*: Adoption y) = Adoption $ Adoption y
-	multiply (Adoption x :*: _) = Adoption $ Option x
+instance Semimonoidal (-->) (:*:) (:+:) ((:+:) e) where
+	mult :: ((e :+: a) :*: (e :+: b)) --> (e :+: a :+: b)
+	mult = Straight $ \case
+		Option _ :*: Option e' -> Option e'
+		Option _ :*: Adoption y -> Adoption $ Adoption y
+		Adoption x :*: _ -> Adoption $ Option x
 
-instance Semimonoidal (->) (:*:) (:*:) ((:+:) e) where
-	multiply (Adoption x :*: Adoption y) = Adoption $ x :*: y
-	multiply (Option e :*: _) = Option e
-	multiply (_ :*: Option e) = Option e
+instance Semimonoidal (-->) (:*:) (:*:) ((:+:) e) where
+	mult = Straight $ \case
+		Adoption x :*: Adoption y -> Adoption $ x :*: y
+		Option e :*: _ -> Option e
+		_ :*: Option e -> Option e
 
-instance Monoidal (->) (->) (:*:) (:*:) ((:+:) e) where
-	unit _ f = Adoption $ f One
+instance Monoidal (-->) (->) (:*:) (:*:) ((:+:) e) where
+	unit _ = Straight $ Adoption . ($ One)
 
 instance Semimonoidal (<--) (:*:) (:*:) ((:*:) s) where
-	multiply = Flip $ \(s :*: x :*: y) -> (s :*: x) :*: (s :*: y)
+	mult = Flip $ \(s :*: x :*: y) -> (s :*: x) :*: (s :*: y)
 
 instance Monoidal (<--) (->) (:*:) (:*:) ((:*:) s) where
 	unit _ = Flip $ \(_ :*: x) -> (\_ -> x)
 
-instance Comonad ((:*:) s) (->) where
+instance Comonad (->) ((:*:) s) where
 
 instance Semimonoidal (<--) (:*:) (:*:) (Flip (:*:) a) where
-	multiply = Flip $ \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
+	mult = Flip $ \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
 
 instance Monoidal (<--) (->) (:*:) (:*:) (Flip (:*:) a) where
 	unit _ = Flip $ \(Flip (s :*: _)) -> (\_ -> s)
 
-type Applicative_ t = (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t, Monoidal (->) (->) (:*:) (:*:) t)
-type Alternative_ t = (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:+:) t, Monoidal (->) (->) (:*:) (:+:) t)
+type Applicative t = (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Monoidal (-->) (->) (:*:) (:*:) t)
+type Alternative t = (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t, Monoidal (-->) (->) (:*:) (:+:) t)
 
-(-<*>-) :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t)
-	=> t (a -> b) -> t a -> t b
-f -<*>- x = (|-) @(->) @(->) (&) -<$>- multiply @_ @_ @(:*:) (f :*: x)
+(<-*-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t (a -> b) -> t a -> t b
+f <-*- x = (|-) @(->) @(->) (&) <$> run (mult @(-->) @_ @(:*:)) (f :*: x)
 
-forever_ :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => t a -> t b
+forever_ :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t a -> t b
 forever_ x = let r = x *>- r in r
 
-(*>-) :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => t a -> t b -> t b
-x *>- y = ((!.) %) -<$>- x -<*>- y
+(*>-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t a -> t b -> t b
+x *>- y = ((!.) %) <$> x <-*- y
 
-(-+-) :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:+:) t)
-	  => t a -> t b -> (a :+: b -> r) -> t r
-x -+- y = \f -> f -<$>- multiply (x :*: y)
+(-+-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t)
+	=> t a -> t b -> (a :+: b -> r) -> t r
+x -+- y = \f -> f <$> (mult @(-->) ! (x :*: y))
 
-point :: Monoidal (->) (->) (:*:) (:*:) t => a -> t a
-point x = unit (Proxy @(:*:)) (\One -> x)
+type Extractable t = Monoidal (<--) (->) (:*:) (:*:) t
+type Pointable t = Monoidal (-->) (->) (:*:) (:*:) t
+type Emptiable t = Monoidal (-->) (->) (:*:) (:+:) t
 
-empty :: Monoidal (->) (->) (:*:) (:+:) t => t a
-empty = unit (Proxy @(:*:)) absurd
+extract :: Extractable t => t a -> a
+extract j = run (unit @(<--) Proxy) j One
 
-type Extractable_ t = Monoidal (<--) (->) (:*:) (:*:) t
+point :: Pointable t => a -> t a
+point x = run (unit @(-->) Proxy) (\One -> x)
 
-extract :: Extractable_ t => t a -> a
-extract j = let Flip f = unit @(<--) @(->) @(:*:) @(:*:) Proxy in f j $ One
+empty :: Emptiable t => t a
+empty = unit @(-->) (Proxy @(:*:)) ! absurd
+
+--instance Appliable (->) b c (->) e d => Appliable (->) a (b -> c) (->) (a :*: e) d where
+--	f ! (x :*: y) = f 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,16 +2,18 @@
 
 module Pandora.Paradigm.Primary.Algebraic.Exponential where
 
+import Pandora.Core.Appliable (Appliable ((!)))
 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.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
 infixr 2 !.
 infixr 7 -.#..-
@@ -25,10 +27,10 @@
 	identity x = x
 
 instance Covariant (->) (->) ((->) a) where
-	(-<$>-) = (.)
+	(<$>) = (.)
 
 instance Distributive (->) (->) ((->) e) where
-	f -<< g = \e -> (f % e) -<$>- g
+	f -<< g = \e -> (f % e) <$> g
 
 instance Bindable (->) ((->) e) where
 	f =<< g = \x -> f # g x # x
@@ -44,17 +46,23 @@
 
 type (<--) = Flip (->)
 
-instance Semigroupoid (<--) where
-	Flip f . Flip g = Flip $ \x -> g (f x)
+instance Contravariant (->) (->) ((<--) a) where
+	f >$< Flip g = Flip $ g . f
 
-instance Category (<--) where
-	identity = Flip identity
+type (-->) = Straight (->)
 
-instance Contravariant (->) (->) ((<--) a) where
-	f ->$<- Flip g = Flip $ g . f
+instance Covariant (->) (->) ((-->) b) where
+	f <$> Straight g = Straight $ f . g
 
+instance Appliable (->) c b (->) c b where
+	f ! x = f x
+
+-- TODO: Is it possible to generalize?
+instance Appliable (->) a (b -> c) (->) b (a -> c) where
+	(!) f = (%) f
+
 (-.#..-) :: (Covariant (->) target (v a), Semigroupoid v) => v c d -> target (v a (v b c)) (v a (v b d))
-(-.#..-) f = (-<$>-) (f .)
+(-.#..-) f = (<$>) (f .)
 
 {-# INLINE (!.) #-}
 (!.) :: a -> b -> a
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
@@ -1,9 +1,10 @@
 module Pandora.Paradigm.Primary.Algebraic.Product where
 
 import Pandora.Core.Functor (type (:=))
+import Pandora.Core.Appliable ((!))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
@@ -14,8 +15,9 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 
 infixr 0 :*:
@@ -23,10 +25,10 @@
 data (:*:) s a = s :*: a
 
 instance Covariant (->) (->) ((:*:) s) where
-	f -<$>- ~(s :*: x) = s :*: f x
+	f <$> ~(s :*: x) = s :*: f x
 
 instance Covariant (->) (->) (Flip (:*:) a) where
-	f -<$>- (Flip (x :*: y)) = Flip $ f x :*: y
+	f <$> (Flip (x :*: y)) = Flip $ f x :*: y
 
 instance Extendable (->) ((:*:) s) where
 	f <<= ~(s :*: x) = s :*: f (s :*: x)
@@ -60,16 +62,14 @@
 instance (Group s, Group a) => Group (s :*: a) where
 	invert ~(s :*: x) = invert # s :*: invert # x
 
-instance {-# OVERLAPS #-} Semimonoidal (->) (:*:) (:*:) t => Semimonoidal (->) (:*:) (:*:) (t <:.:> t := (:*:)) where
-	multiply (T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) = T_U $ multiply (xls :*: yls) :*: multiply (xrs :*: yrs)
+instance {-# OVERLAPS #-} Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (t <:.:> t := (:*:)) where
+	mult = Straight $ \(T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) -> T_U $ (mult @(-->) !) (xls :*: yls) :*: (mult @(-->) !) (xrs :*: yrs)
 
 -- TODO: Generalize (:*:) as Bivariant p
 instance (Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:.:> u := (:*:)) where
-	multiply = Flip $ \(T_U (lxys :*: rxys)) ->
-		let Flip f = multiply @(<--) @(:*:) @(:*:) in
-		let Flip g = multiply @(<--) @(:*:) @(:*:) in
-		let (lxs :*: lys) = f lxys in
-		let (rxs :*: rys) = g rxys in
+	mult = Flip $ \(T_U lrxys) ->
+		-- TODO: I need matrix transposing here
+		let ((lxs :*: lys) :*: (rxs :*: rys)) = ((mult @(<--) !) <-> (mult @(<--) !)) lrxys in
 		T_U (lxs :*: rxs) :*: T_U (lys :*: rys)
 
 delta :: a -> a :*: a
diff --git a/Pandora/Paradigm/Primary/Algebraic/Sum.hs b/Pandora/Paradigm/Primary/Algebraic/Sum.hs
--- a/Pandora/Paradigm/Primary/Algebraic/Sum.hs
+++ b/Pandora/Paradigm/Primary/Algebraic/Sum.hs
@@ -2,18 +2,18 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.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
+	_ <$> Option s = Option s
+	f <$> Adoption x = Adoption $ f x
 
 instance Bivariant (->) (->) (->) (:+:) where
 	f <-> g = \case
@@ -21,8 +21,8 @@
 		Adoption x -> Adoption $ g x
 
 instance Covariant (->) (->) (Flip (:+:) a) where
-	_ -<$>- Flip (Adoption x) = Flip $ Adoption x
-	f -<$>- Flip (Option y) = Flip . Option $ f y
+	_ <$> Flip (Adoption x) = Flip $ Adoption x
+	f <$> Flip (Option y) = Flip . Option $ f y
 
 sum :: (e -> r) -> (a -> r) -> e :+: a -> r
 sum f _ (Option x) = f x
diff --git a/Pandora/Paradigm/Primary/Functor/Conclusion.hs b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
--- a/Pandora/Paradigm/Primary/Functor/Conclusion.hs
+++ b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
@@ -2,10 +2,10 @@
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Category (identity, ($), (#))
---import Pandora.Pattern.Functor (Endofunctor)
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -18,41 +18,44 @@
 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.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (point)
 
 data Conclusion e a = Failure e | Success a
 
 instance Covariant (->) (->) (Conclusion e) where
-	f -<$>- Success x = Success $ f x
-	_ -<$>- Failure y = Failure y
+	f <$> Success x = Success $ f x
+	_ <$> Failure y = Failure y
 
 instance Covariant (->) (->) (Flip Conclusion e) where
-	_ -<$>- Flip (Success x) = Flip $ Success x
-	f -<$>- Flip (Failure y) = Flip . Failure $ f y
+	_ <$> Flip (Success x) = Flip $ Success x
+	f <$> Flip (Failure y) = Flip . Failure $ f y
 
-instance Semimonoidal (->) (:*:) (:*:) (Conclusion e) where
-	multiply (Success x :*: Success y) = Success $ x :*: y
-	multiply (Failure x :*: _) = Failure x
-	multiply (_ :*: Failure x) = Failure x
+instance Semimonoidal (-->) (:*:) (:*:) (Conclusion e) where
+	mult = Straight $ \case
+		Success x :*: Success y -> Success $ x :*: y
+		Failure x :*: _ -> Failure x
+		_ :*: Failure x -> Failure x
 
-instance Monoidal (->) (->) (:*:) (:*:) (Conclusion e) where
-	unit _ f = Success $ f One
+instance Monoidal (-->) (->) (:*:) (:*:) (Conclusion e) where
+	unit _ = Straight $ Success . ($ One)
 
-instance Semigroup e => Semimonoidal (->) (:*:) (:+:) (Conclusion e) where
-	multiply (Failure _ :*: x) = Adoption -<$>- x
-	multiply (Success x :*: _) = Option -<$>- Success x
+instance Semigroup e => Semimonoidal (-->) (:*:) (:+:) (Conclusion e) where
+	mult = Straight $ \case
+		Failure _ :*: x -> Adoption <$> x
+		Success x :*: _ -> Option <$> Success x
 
 instance Traversable (->) (->) (Conclusion e) where
-	(<<-) :: (Covariant (->) (->) u, Monoidal (->) (->) (:*:) (:*:) u, Semimonoidal (->) (:*:) (:*:)u)
+	(<<-) :: (Covariant (->) (->) u, Monoidal (-->) (->) (:*:) (:*:) u, Semimonoidal (-->) (:*:) (:*:) u)
 		 => (a -> u b) -> Conclusion e a -> u (Conclusion e b)
 	_ <<- Failure y = point $ Failure y
-	f <<- Success x = Success -<$>- f x
+	f <<- Success x = Success <$> f x
 
 instance Bindable (->) (Conclusion e) where
 	f =<< Success x = f x
@@ -88,7 +91,7 @@
 fail f (Failure x) = Failure $ f x
 fail _ (Success y) = Success y
 
-instance Interpreted (Conclusion e) where
+instance Interpreted (->) (Conclusion e) where
 	type Primary (Conclusion e) a = Conclusion e a
 	run = identity
 	unite = identity
@@ -110,6 +113,6 @@
 	catch (Failure e) handle = handle e
 	catch (Success x) _ = Success x
 
-instance (Monoidal (->) (->) (:*:) (:*:) u, Bindable (->) u) => Catchable e (Conclusion e <.:> u) where
+instance (Monoidal (-->) (->) (:*:) (:*:) u, Bindable (->) u) => Catchable e (Conclusion e <.:> u) where
 	catch (UT x) handle = let conclude = conclusion # run . handle # point . Success
 		in UT $ conclude =<< x
diff --git a/Pandora/Paradigm/Primary/Functor/Constant.hs b/Pandora/Paradigm/Primary/Functor/Constant.hs
--- a/Pandora/Paradigm/Primary/Functor/Constant.hs
+++ b/Pandora/Paradigm/Primary/Functor/Constant.hs
@@ -2,8 +2,8 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-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.Pattern.Functor.Invariant (Invariant ((<$<)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
@@ -16,18 +16,18 @@
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 
 newtype Constant a b = Constant a
 
 instance Covariant (->) (->) (Constant a) where
-	_ -<$>- Constant x = Constant x
+	_ <$> Constant x = Constant x
 
 instance Covariant (->) (->) (Flip Constant b) where
-	f -<$>- Flip (Constant x) = Flip . Constant $ f x
+	f <$> Flip (Constant x) = Flip . Constant $ f x
 
 instance Contravariant (->) (->) (Constant a) where
-	_ ->$<- Constant x = Constant x
+	_ >$< 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,10 +1,10 @@
 module Pandora.Paradigm.Primary.Functor.Convergence where
 
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
+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
+	f >$< Convergence g = Convergence $ \x y -> g # f x # f y
diff --git a/Pandora/Paradigm/Primary/Functor/Edges.hs b/Pandora/Paradigm/Primary/Functor/Edges.hs
--- a/Pandora/Paradigm/Primary/Functor/Edges.hs
+++ b/Pandora/Paradigm/Primary/Functor/Edges.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Edges where
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Algebraic (point)
@@ -9,16 +9,16 @@
 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
+	_ <$> Empty = Empty
+	f <$> Connect x = Connect $ f x
+	f <$> Overlay x = Overlay $ f x
+	f <$> Leap x = Leap $ f x
 
 instance Traversable (->) (->) Edges where
 	_ <<- Empty = point Empty
-	f <<- Connect x = Connect -<$>- f x
-	f <<- Overlay x = Overlay -<$>- f x
-	f <<- Leap x = Leap -<$>- f x
+	f <<- Connect x = Connect <$> f x
+	f <<- Overlay x = Overlay <$> f x
+	f <<- Leap x = Leap <$> f x
 
 edges :: r -> (a -> r) -> (a -> r) -> (a -> r) -> Edges a -> r
 edges r _ _ _ Empty = r
diff --git a/Pandora/Paradigm/Primary/Functor/Endo.hs b/Pandora/Paradigm/Primary/Functor/Endo.hs
--- a/Pandora/Paradigm/Primary/Functor/Endo.hs
+++ b/Pandora/Paradigm/Primary/Functor/Endo.hs
@@ -11,7 +11,7 @@
 
 newtype Endo a = Endo { endo :: a -> a }
 
-instance Interpreted Endo where
+instance Interpreted (->) Endo where
 	type Primary Endo a = a -> a
 	run ~(Endo x) = x
 	unite = Endo
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
@@ -2,16 +2,16 @@
 
 import Pandora.Core.Functor (type (<:=), type (:=>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+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 . (cata f -<$>-) . unfix
+cata f = f . (cata f <$>) . unfix
 
 ana :: Covariant (->) (->) t => (a :=> t) -> a -> Fix t
-ana f = Fix . (ana f -<$>-) . f
+ana f = Fix . (ana f <$>) . f
 
 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
@@ -2,12 +2,15 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 --import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
@@ -21,41 +24,40 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (extract)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 newtype Identity a = Identity a
 
 instance Covariant (->) (->) Identity where
-	f -<$>- Identity x = Identity $ f x
+	f <$> Identity x = Identity $ f x
 
-instance Semimonoidal (->) (:*:) (:*:) Identity where
-	multiply (Identity x :*: Identity y) = Identity $ x :*: y
+instance Semimonoidal (-->) (:*:) (:*:) Identity where
+	mult = Straight $ Identity . (extract <-> extract)
 
-instance Monoidal (->) (->) (:*:) (:*:) Identity where
-	unit _ f = Identity $ f One
+instance Monoidal (-->) (->) (:*:) (:*:) Identity where
+	unit _ = Straight $ Identity . ($ One)
 
 instance Semimonoidal (<--) (:*:) (:*:) Identity where
-	multiply = Flip $ \(Identity (x :*: y)) -> Identity x :*: Identity y
+	mult = Flip $ \(Identity (x :*: y)) -> Identity x :*: Identity y
 
 instance Monoidal (<--) (->) (:*:) (:*:) Identity where
 	unit _ = Flip $ \(Identity x) -> (\_ -> x)
 
 instance Traversable (->) (->) Identity where
-	f <<- Identity x = Identity -<$>- f x
+	f <<- Identity x = Identity <$> f x
 
 instance Bindable (->) Identity where
-	f =<< Identity x = f x	
+	f =<< Identity x = f x
 
-instance Monad Identity
+instance Monad (->) Identity
 
 instance Extendable (->) Identity where
 	f <<= x = Identity . f $ x
 
-instance Comonad Identity (->)
+instance Comonad (->) Identity
 
 --instance Representable Identity where
 	--type Representation Identity = ()
@@ -64,7 +66,7 @@
 
 instance Adjoint (->) (->) Identity Identity where
 	f -| x = Identity . f . Identity $ x
-	g |- x = extract . extract . (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
@@ -3,8 +3,10 @@
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -22,44 +24,45 @@
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (point)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 data Maybe a = Nothing | Just a
 
 instance Covariant (->) (->) Maybe where
-	f -<$>- Just x = Just $ f x
-	_ -<$>- Nothing = Nothing
+	f <$> Just x = Just $ f x
+	_ <$> Nothing = Nothing
 
-instance Semimonoidal (->) (:*:) (:*:) Maybe where
-	multiply (Just x :*: Just y) = Just $ x :*: y
-	multiply (Nothing :*: _) = Nothing
-	multiply (_ :*: Nothing) = Nothing
+instance Semimonoidal (-->) (:*:) (:*:) Maybe where
+	mult = Straight $ \case
+		Just x :*: Just y -> Just $ x :*: y
+		Nothing :*: _ -> Nothing
+		_ :*: Nothing -> Nothing
 
-instance Semimonoidal (->) (:*:) (:+:) Maybe where
-	multiply (Just x :*: _) = Just $ Option x
-	multiply (Nothing :*: Just y) = Just $ Adoption y
-	multiply (Nothing :*: Nothing) = Nothing
+instance Semimonoidal (-->) (:*:) (:+:) Maybe where
+	mult = Straight $ \case
+		Just x :*: _ -> Just $ Option x
+		Nothing :*: Just y -> Just $ Adoption y
+		Nothing :*: Nothing -> Nothing
 
-instance Monoidal (->) (->) (:*:) (:*:) Maybe where
-	unit _ f = Just $ f One
+instance Monoidal (-->) (->) (:*:) (:*:) Maybe where
+	unit _ = Straight $ Just . ($ One)
 
-instance Monoidal (->) (->) (:*:) (:+:) Maybe where
-	unit _ _ = Nothing
+instance Monoidal (-->) (->) (:*:) (:+:) Maybe where
+	unit _ = Straight $ \_ -> Nothing
 
 -- TODO: Check laws
 instance Semimonoidal (<--) (:*:) (:*:) Maybe where
-	multiply = Flip $ \case
+	mult = Flip $ \case
 		Just (x :*: y) -> Just x :*: Just y
 		Nothing -> Nothing :*: Nothing
 
 instance Traversable (->) (->) Maybe where
 	_ <<- Nothing = point Nothing
-	f <<- Just x = Just -<$>- f x
+	f <<- Just x = Just <$> f x
 
 instance Bindable (->) Maybe where
 	f =<< Just x = f x
@@ -100,7 +103,7 @@
 
 type instance Schematic Monad Maybe = (<.:>) Maybe
 
-instance Interpreted Maybe where
+instance Interpreted (->) Maybe where
 	type Primary Maybe a = Maybe a
 	run = identity
 	unite = identity
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
@@ -3,20 +3,20 @@
 import Pandora.Core.Functor (type (~>), type (:=>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 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)
 
-instance Interpreted Predicate where
+instance Interpreted (->) Predicate where
 	type Primary Predicate a = a -> Boolean
 	run ~(Predicate f) = f
 	unite = Predicate
 
 instance Contravariant (->) (->) Predicate where
-	f ->$<- Predicate g = Predicate $ g . f
+	f >$< Predicate g = Predicate $ g . f
 
 equate :: Setoid a => a :=> Predicate
 equate x = Predicate (== x)
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,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Proxy 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.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -11,10 +11,10 @@
 data Proxy a = Proxy
 
 instance Covariant (->) (->) Proxy where
-	_ -<$>- Proxy = Proxy
+	_ <$> Proxy = Proxy
 
 instance Contravariant (->) (->) Proxy where
-	_ ->$<- _ = Proxy
+	_ >$< _ = 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
@@ -2,9 +2,11 @@
 
 import Pandora.Core.Functor (type (:=>), type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
@@ -22,11 +24,10 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (extract)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
 
 newtype Tagged tag a = Tag a
 
@@ -34,38 +35,38 @@
 type (:#) tag = Tagged tag
 
 instance Covariant (->) (->) (Tagged tag) where
-	f -<$>- Tag x = Tag $ f x
+	f <$> Tag x = Tag $ f x
 
 instance Covariant (->) (->) (Flip Tagged a) where
-	_ -<$>- Flip (Tag x) = Flip $ Tag x
+	_ <$> Flip (Tag x) = Flip $ Tag x
 
-instance Semimonoidal (->) (:*:) (:*:) (Tagged tag) where
-	multiply (x :*: y) = Tag $ extract x :*: extract y
+instance Semimonoidal (-->) (:*:) (:*:) (Tagged tag) where
+	mult = Straight $ Tag . (extract <-> extract)
 
-instance Monoidal (->) (->) (:*:) (:*:) (Tagged tag) where
-	unit _ f = Tag $ f One
+instance Monoidal (-->) (->) (:*:) (:*:) (Tagged tag) where
+	unit _ = Straight $ Tag . ($ One)
 
 instance Semimonoidal (<--) (:*:) (:*:) (Tagged tag) where
-	multiply = Flip $ \(Tag (x :*: y)) -> Tag x :*: Tag y
+	mult = Flip $ \(Tag (x :*: y)) -> Tag x :*: Tag y
 
 instance Monoidal (<--) (->) (:*:) (:*:) (Tagged tag) where
 	unit _ = Flip $ \(Tag x) -> (\_ -> x)
 
 instance Traversable (->) (->) (Tagged tag) where
-	f <<- Tag x = Tag -<$>- f x
+	f <<- Tag x = Tag <$> f x
 
 instance Distributive (->) (->) (Tagged tag) where
-	f -<< x = Tag $ extract . f -<$>- x
+	f -<< x = Tag $ extract . f <$> x
 
 instance Bindable (->) (Tagged tag) where
 	f =<< Tag x = f x
 
-instance Monad (Tagged tag)
+instance Monad (->) (Tagged tag)
 
 instance Extendable (->) (Tagged tag) where
 	f <<= x = Tag . f $ x
 
-instance Comonad (Tagged tag) (->)
+instance Comonad (->) (Tagged tag)
 
 instance Bivariant (->) (->) (->) Tagged where
 	_ <-> g = \(Tag x) -> Tag $ g x
diff --git a/Pandora/Paradigm/Primary/Functor/These.hs b/Pandora/Paradigm/Primary/Functor/These.hs
--- a/Pandora/Paradigm/Primary/Functor/These.hs
+++ b/Pandora/Paradigm/Primary/Functor/These.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.These where
 
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
@@ -10,14 +10,14 @@
 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
+	f <$> This x = This $ f x
+	_ <$> That y = That y
+	f <$> These y x = These y $ f x
 
 instance Traversable (->) (->) (These e) where
-	f <<- This x = This -<$>- f x
+	f <<- This x = This <$> f x
 	_ <<- That y = point $ That y
-	f <<- These y x = These y -<$>- f x
+	f <<- These y x = These y <$> f x
 
 instance (Semigroup e, Semigroup a) => Semigroup (These e a) where
 	This x + This x' = This # x + x'
diff --git a/Pandora/Paradigm/Primary/Functor/Validation.hs b/Pandora/Paradigm/Primary/Functor/Validation.hs
--- a/Pandora/Paradigm/Primary/Functor/Validation.hs
+++ b/Pandora/Paradigm/Primary/Functor/Validation.hs
@@ -2,56 +2,59 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (point)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 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
-	_ -<$>- Flaws e = Flaws e
-	f -<$>- Validated x = Validated $ f x
-	_ -<$>- Flaws e = Flaws e
-	f -<$>- Validated x = Validated $ f x
+	_ <$> Flaws e = Flaws e
+	f <$> Validated x = Validated $ f x
+	_ <$> Flaws e = Flaws e
+	f <$> Validated x = Validated $ f x
+	_ <$> Flaws e = Flaws e
+	f <$> Validated x = Validated $ f x
 
 instance Covariant (->) (->) (Flip Validation a) where
-	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e
-	_ -<$>- Flip (Validated x) = Flip $ Validated x
-	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e
-	_ -<$>- Flip (Validated x) = Flip $ Validated x
-	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e
-	_ -<$>- Flip (Validated x) = Flip $ Validated x
+	f <$> Flip (Flaws e) = Flip . Flaws $ f e
+	_ <$> Flip (Validated x) = Flip $ Validated x
+	f <$> Flip (Flaws e) = Flip . Flaws $ f e
+	_ <$> Flip (Validated x) = Flip $ Validated x
+	f <$> Flip (Flaws e) = Flip . Flaws $ f e
+	_ <$> Flip (Validated x) = Flip $ Validated x
 
-instance Semigroup e => Semimonoidal (->) (:*:) (:*:) (Validation e) where
-	multiply (Validated x :*: Validated y) = Validated $ x :*: y
-	multiply (Flaws x :*: Flaws y) = Flaws $ x + y
-	multiply (Validated _ :*: Flaws y) = Flaws y
-	multiply (Flaws x :*: Validated _) = Flaws x
+instance Semigroup e => Semimonoidal (-->) (:*:) (:*:) (Validation e) where
+	mult = Straight $ \case
+		Validated x :*: Validated y -> Validated $ x :*: y
+		Flaws x :*: Flaws y -> Flaws $ x + y
+		Validated _ :*: Flaws y -> Flaws y
+		Flaws x :*: Validated _ -> Flaws x
 
-instance Semigroup e => Monoidal (->) (->) (:*:) (:*:) (Validation e) where
-	unit _ f = Validated $ f One
+instance Semigroup e => Monoidal (-->) (->) (:*:) (:*:) (Validation e) where
+	unit _ = Straight $ Validated . ($ One)
 
-instance Semigroup e => Semimonoidal (->) (:*:) (:+:) (Validation e) where
-	multiply (Flaws _ :*: y) = Adoption -<$>- y
-	multiply (Validated x :*: _) = Option -<$>- Validated x
+instance Semigroup e => Semimonoidal (-->) (:*:) (:+:) (Validation e) where
+	mult = Straight $ \case
+		Flaws _ :*: y -> Adoption <$> y
+		Validated x :*: _ -> Option <$> Validated x
 
 instance Traversable (->) (->) (Validation e) where
-	f <<- Validated x = Validated -<$>- f x
+	f <<- Validated x = Validated <$> f x
 	_ <<- Flaws e = point $ Flaws e
 
 instance Bivariant (->) (->) (->) Validation where
diff --git a/Pandora/Paradigm/Primary/Functor/Wedge.hs b/Pandora/Paradigm/Primary/Functor/Wedge.hs
--- a/Pandora/Paradigm/Primary/Functor/Wedge.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wedge.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Wedge where
 
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Algebraic (point)
@@ -9,14 +9,14 @@
 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
+	_ <$> Nowhere = Nowhere
+	_ <$> Here x = Here x
+	f <$> There x = There $ f x
 
 instance Traversable (->) (->) (Wedge e) where
 	_ <<- Nowhere = point Nowhere
 	_ <<- Here x = point $ Here x
-	f <<- There x = There -<$>- f x
+	f <<- There x = There <$> f x
 
 wedge :: (e -> r) -> (a -> r) -> r -> Wedge e a -> r
 wedge f _ _ (Here x) = f x
diff --git a/Pandora/Paradigm/Primary/Functor/Wye.hs b/Pandora/Paradigm/Primary/Functor/Wye.hs
--- a/Pandora/Paradigm/Primary/Functor/Wye.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wye.hs
@@ -2,25 +2,25 @@
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((#), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 
 data Wye a = End | Left a | Right a | Both a a
 
 instance Covariant (->) (->) Wye where
-	_ -<$>- End = End
-	f -<$>- Left x = Left # f x
-	f -<$>- Right y = Right # f y
-	f -<$>- Both x y = Both # f x # f y
+	_ <$> End = End
+	f <$> Left x = Left # f x
+	f <$> Right y = Right # f y
+	f <$> Both x y = Both # f x # f y
 
 instance Semimonoidal (<--) (:*:) (:*:) Wye where
-	multiply = Flip $ \case
+	mult = Flip $ \case
 		End -> End :*: End
 		Left (x :*: y) -> Left x :*: Left y
 		Right (x :*: y) -> Right x :*: Right y
diff --git a/Pandora/Paradigm/Primary/Transformer.hs b/Pandora/Paradigm/Primary/Transformer.hs
--- a/Pandora/Paradigm/Primary/Transformer.hs
+++ b/Pandora/Paradigm/Primary/Transformer.hs
@@ -14,11 +14,3 @@
 import Pandora.Paradigm.Primary.Transformer.Construction as Exports
 import Pandora.Paradigm.Primary.Transformer.Reverse as Exports
 import Pandora.Paradigm.Primary.Transformer.Backwards as Exports
-import Pandora.Paradigm.Primary.Transformer.Flip as Exports
-
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-
-instance Interpreted (Flip v a) where
-	type Primary (Flip v a) e = v e a
-	run ~(Flip x) = x
-	unite = Flip
diff --git a/Pandora/Paradigm/Primary/Transformer/Backwards.hs b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
--- a/Pandora/Paradigm/Primary/Transformer/Backwards.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
@@ -2,9 +2,9 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
@@ -12,45 +12,43 @@
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
+import Pandora.Paradigm.Primary.Algebraic ((<-*-))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), (%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->), (%))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (point, extract)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype Backwards t a = Backwards (t a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Backwards t) where
-	f -<$>- Backwards x = Backwards $ f -<$>- x
+	f <$> Backwards x = Backwards $ f <$> x
 
 -- TODO: check that effects evaluation goes in opposite order
-instance (Semimonoidal (->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (->) (:*:) (:*:) (Backwards t) where
-	multiply (Backwards x :*: Backwards y) = Backwards #
-		((:*:) %) -<$>- y -<*>- x
+instance (Semimonoidal (-->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (-->) (:*:) (:*:) (Backwards t) where
+	mult = Straight $ \(Backwards x :*: Backwards y) -> Backwards # ((:*:) %) <$> y <-*- x
 
-instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t) => Monoidal (->) (->) (:*:) (:*:) (Backwards t) where
-	unit _ f = Backwards . point $ f One
+instance (Covariant (->) (->) t, Monoidal (-->) (->) (:*:) (:*:) t) => Monoidal (-->) (->) (:*:) (:*:) (Backwards t) where
+	unit _ = Straight $ Backwards . point . ($ One)
 
 instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Backwards t) where
-	multiply = Flip $ \(Backwards x) -> 
-		let Flip f = multiply @(<--) @(:*:) @(:*:) in
-		(Backwards <-> Backwards) $ f x
+	mult = Flip $ (Backwards <-> Backwards) . run (mult @(<--)) . run
 
 instance (Covariant (->) (->) t, Monoidal (<--) (->) (:*:) (:*:) t) => Monoidal (<--) (->) (:*:) (:*:) (Backwards t) where
 	unit _ = Flip $ \(Backwards x) -> (\_ -> extract x)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Backwards t) where
-	f <<- Backwards x = Backwards -<$>- f <<- x
+	f <<- Backwards x = Backwards <$> f <<- x
 
 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
+	f >$< Backwards x = Backwards $ f >$< x
 
-instance Interpreted (Backwards t) where
+instance Interpreted (->) (Backwards t) where
 	type Primary (Backwards t) a = t a
 	run ~(Backwards x) = x
 	unite = Backwards
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,25 +3,30 @@
 module Pandora.Paradigm.Primary.Transformer.Construction where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (:=>), type (~>))
+import Pandora.Core.Appliable ((!))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist))
+import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid ((*))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Primary.Algebraic ((-<*>-), extract)
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic ((<-*-), extract)
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (empty)
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 import Pandora.Paradigm.Schemes (type (<:.>))
@@ -31,33 +36,34 @@
 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
+	f <$> ~(Construct x xs) = Construct # f x # (<$$>) @(->) @(->) f 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 (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Semimonoidal (-->) (:*:) (:*:) (Construction t) where
+	mult = Straight $ \(Construct x xs :*: Construct y ys) -> Construct (x :*: y) $ (mult @(-->) !) <$> (mult @(-->) ! xs :*: ys)
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Semimonoidal (<--) (:*:) (:*:) (Construction t) where
-	multiply = Flip $ \(Construct (x :*: y) xys) ->
-		let Flip f = multiply @(<--) @(:*:) @(:*:) in
-		let Flip g = multiply @(<--) @(:*:) @(:*:) in
-		(Construct x <-> Construct y) $ f $ g -<$>- xys
+	mult = Flip $ \(Construct (x :*: y) xys) -> (Construct x <-> Construct y)
+		$ (mult @(<--) !) $ (mult @(<--) !) <$> xys
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoidal (<--) (->) (:*:) (:*:) (Construction t) where
 	unit _ = Flip $ \(Construct x _) -> (\_ -> x)
 
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Monoidal (-->) (->) (:*:) (:+:) t) => Monoidal (-->) (->) (:*:) (:*:) (Construction t) where
+	unit _ = Straight $ \f -> Construct # f One # empty
+
 instance Traversable (->) (->) t => Traversable (->) (->) (Construction t) where
-	f <<- ~(Construct x xs) = Construct -<$>- f x -<*>- f -<<-<<- xs
+	f <<- ~(Construct x xs) = Construct <$> f x <-*- f -<<-<<- xs
 
 instance Covariant (->) (->) t => Extendable (->) (Construction t) where
-	f <<= x = Construct # f x # (f <<=) -<$>- deconstruct x
+	f <<= x = Construct # f x # (f <<=) <$> deconstruct x
 
-instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Comonad (Construction t) (->) where
+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Comonad (->) (Construction t) where
 
 instance (forall u . Semimonoidal (<--) (:*:) (:*:) u) => Lowerable (->) Construction where
-	lower x = extract -<$>- deconstruct x
+	lower x = extract <$> deconstruct x
 
 instance (forall u . Semimonoidal (<--) (:*:) (:*:) u) => Hoistable Construction where
-	f /|\ x = Construct # extract x $ f # hoist f -<$>- deconstruct x
+	f /|\ x = Construct # extract x $ f # (f /|\) <$> deconstruct x
 
 instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Setoid (Construction t a) where
 	x == y = (extract x == extract y) * (deconstruct x == deconstruct y)
@@ -79,7 +85,7 @@
 
 -- Generate a construction from seed using effectful computation
 (.-+) :: Covariant (->) (->) t => a :=> t -> a :=> Construction t
-f .-+ x = Construct x $ (f .-+) -<$>- f x
+f .-+ x = Construct x $ (f .-+) <$> f x
 
-section :: (Comonad t (->), Monoidal (<--) (->) (:*:) (:*:) t) => t ~> Construction t
+section :: (Comonad (->) t, Monoidal (<--) (->) (:*:) (:*:) t) => t ~> Construction t
 section xs = Construct # extract xs $ section <<= xs
diff --git a/Pandora/Paradigm/Primary/Transformer/Continuation.hs b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
--- a/Pandora/Paradigm/Primary/Transformer/Continuation.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
@@ -1,28 +1,29 @@
 {-# LANGUAGE UndecidableInstances #-}
+
 module Pandora.Paradigm.Primary.Transformer.Continuation where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 import Pandora.Paradigm.Primary.Algebraic (point)
 
 newtype Continuation r t a = Continuation ((->) ::|:. a :. t := r)
 
-instance Interpreted (Continuation r t) where
+instance Interpreted (->) (Continuation r t) where
 	type Primary (Continuation r t) a = (->) ::|:. a :. t := r
 	run ~(Continuation x) = x
 	unite = Continuation
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Continuation r t) where
-	f -<$>- Continuation continuation = Continuation $ continuation . (. f)
+	f <$> Continuation continuation = Continuation $ continuation . (. f)
 
 instance Covariant (->) (->) t => Bindable (->) (Continuation r t) where
 	f =<< x = Continuation $ \g -> run x $ \y -> run # f y # g
@@ -37,12 +38,12 @@
 cwcc f = Continuation $ \g -> (run % g) . f $ Continuation . (!.) . g
 
 -- | Delimit the continuation of any 'shift'
-reset :: (forall u . Bindable (->) u, Monad t) => Continuation r t r -> Continuation s t r
+reset :: (forall u . Bindable (->) u, Monad (->) t) => Continuation r t r -> Continuation s t r
 reset = lift . (run % point)
 
 -- | Capture the continuation up to the nearest enclosing 'reset' and pass it
-shift :: Monoidal (->) (->) (:*:) (:*:) t => ((a -> t r) -> Continuation r t r) -> Continuation r t a
+shift :: Monoidal (-->) (->) (:*:) (:*:) t => ((a -> t r) -> Continuation r t r) -> Continuation r t a
 shift f = Continuation $ (run % point) . f
 
-interruptable :: Monoidal (->) (->) (:*:) (:*:) t => ((a -> Continuation a t a) -> Continuation a t a) -> t a
+interruptable :: Monoidal (-->) (->) (:*:) (:*:) t => ((a -> Continuation a t a) -> Continuation a t a) -> t a
 interruptable = (run % point) . cwcc
diff --git a/Pandora/Paradigm/Primary/Transformer/Day.hs b/Pandora/Paradigm/Primary/Transformer/Day.hs
--- a/Pandora/Paradigm/Primary/Transformer/Day.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Day.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Primary.Transformer.Day where
 
 import Pandora.Pattern.Category ((#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((!..), (-.#..-))
@@ -11,7 +11,7 @@
 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
+	f <$> Day tb uc g = Day tb uc # f -.#..- g
 
 instance (Extendable (->) t, Extendable (->) u) => Extendable (->) (Day t u) where
 	f <<= day@(Day tb uc _) = Day tb uc (f day !..)
diff --git a/Pandora/Paradigm/Primary/Transformer/Flip.hs b/Pandora/Paradigm/Primary/Transformer/Flip.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Transformer/Flip.hs
+++ /dev/null
@@ -1,3 +0,0 @@
-module Pandora.Paradigm.Primary.Transformer.Flip where
-
-newtype Flip (v :: * -> * -> *) a e = Flip (v e a)
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
@@ -3,17 +3,20 @@
 module Pandora.Paradigm.Primary.Transformer.Instruction where
 
 import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Core.Appliable ((!))
+import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (point)
@@ -21,35 +24,36 @@
 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
+	f <$> Enter x = Enter $ f x
+	f <$> Instruct xs = Instruct $ (<$$>) @(->) @(->) f xs
 
-instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Semimonoidal (->) (:*:) (:*:) (Instruction t) where
-	multiply (Enter x :*: Enter y) = Enter $ x :*: y
-	multiply (Enter x :*: Instruct y) = (x :*:) -<$>- Instruct y
-	multiply (Instruct x :*: Enter y) = (:*: y) -<$>- Instruct x
-	multiply (Instruct x :*: Instruct y) = Instruct $ multiply @(->) @(:*:) -<$>- multiply (x :*: y)
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Semimonoidal (-->) (:*:) (:*:) (Instruction t) where
+	mult = Straight $ \case
+		Enter x :*: Enter y -> Enter $ x :*: y
+		Enter x :*: Instruct y -> (x :*:) <$> Instruct y
+		Instruct x :*: Enter y -> (:*: y) <$> Instruct x
+		Instruct x :*: Instruct y -> Instruct $ (mult @(-->) !) <$> (mult @(-->) ! x :*: y)
 
-instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Monoidal (->) (->) (:*:) (:*:) (Instruction t) where
-	unit _ f = Enter $ f One
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Monoidal (-->) (->) (:*:) (:*:) (Instruction t) where
+	unit _ = Straight $ Enter . ($ One)
 
 instance Covariant (->) (->) t => Bindable (->) (Instruction t) where
 	f =<< Enter x = f x
-	f =<< Instruct xs = Instruct $ (f =<<) -<$>- xs
+	f =<< Instruct xs = Instruct $ (f =<<) <$> xs
 
-instance Monad t => Monad (Instruction t) where
+instance Monad (->) t => Monad (->) (Instruction t) where
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Instruction t) where
-	f <<- Enter x = Enter -<$>- f x
-	f <<- Instruct xs = Instruct -<$>- f -<<-<<- xs
+	f <<- Enter x = Enter <$> f x
+	f <<- Instruct xs = Instruct <$> f -<<-<<- xs
 
 instance Liftable (->) Instruction where
-	lift x = Instruct $ Enter -<$>- x
+	lift x = Instruct $ Enter <$> x
 
-instance (forall t . Bindable (->) t, forall t . Monoidal (->) (->) (:*:) (:*:) t) => Lowerable (->) Instruction where
+instance (forall t . Bindable (->) t, forall t . Monoidal (-->) (->) (:*:) (:*:) t) => Lowerable (->) Instruction where
 	lower (Enter x) = point x
 	lower (Instruct xs) = lower =<< xs
 
 instance (forall v . Covariant (->) (->) v) => Hoistable Instruction where
 	_ /|\ Enter x = Enter x
-	f /|\ Instruct xs = Instruct $ hoist f -<$>- f xs
+	f /|\ Instruct xs = Instruct $ (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
@@ -4,7 +4,7 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -13,7 +13,7 @@
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 import Pandora.Paradigm.Primary.Algebraic (point)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
@@ -22,14 +22,14 @@
 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
+	f <$> It x = It $ f x
+	f <$> Other y = Other $ f <$> y
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Jack t) where
-	f <<- It x = It -<$>- f x
-	f <<- Other y = Other -<$>- f <<- y
+	f <<- It x = It <$> f x
+	f <<- Other y = Other <$> f <<- y
 
-instance (Monoidal (->) (->) (:*:) (:*:) t, Bindable (->) t) => Bindable (->) (Jack t) where
+instance (Monoidal (-->) (->) (:*:) (:*:) t, Bindable (->) t) => Bindable (->) (Jack t) where
 	f =<< It x = f x
 	f =<< Other x = Other $ jack point identity . f =<< x
 
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,14 +2,14 @@
 
 module Pandora.Paradigm.Primary.Transformer.Jet where
 
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
-import Pandora.Paradigm.Primary.Algebraic ((-<*>-))
+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)
+	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
+	f <<- Jet x xs = Jet <$> f x <-*- f -<<-<<- xs
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
@@ -2,8 +2,8 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 
@@ -12,9 +12,9 @@
 data instance Kan Left t u b a = Lan ((t b -> a) -> u b)
 
 instance Contravariant (->) (->) (Kan Left t u b) where
-	f ->$<- Lan x = Lan $ x . (f .)
+	f >$< Lan x = Lan $ x . (f .)
 
-instance Interpreted (Kan Left t u b) where
+instance Interpreted (->) (Kan Left t u b) where
 	type Primary (Kan Left t u b) a = (t b -> a) -> u b
 	run ~(Lan x) = x
 	unite = Lan
@@ -22,9 +22,9 @@
 data instance Kan Right t u b a = Ran ((a -> t b) -> u b)
 
 instance Covariant (->) (->) (Kan Right t u b) where
-	f -<$>- Ran x = Ran $ x . (. f)
+	f <$> Ran x = Ran $ x . (. f)
 
-instance Interpreted (Kan Right t u b) where
+instance Interpreted (->) (Kan Right t u b) where
 	type Primary (Kan Right t u b) a = (a -> t b) -> u b
 	run ~(Ran x) = x
 	unite = Ran
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
@@ -4,7 +4,7 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
@@ -14,8 +14,8 @@
 	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
+	f <$> Line a = Line $ f a
+	f <$> Outlined x y = Outlined x # (.) f <$> y
 
 instance Liftable (->) Outline where
 	lift t = Outlined t (Line identity)
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,11 +2,12 @@
 
 module Pandora.Paradigm.Primary.Transformer.Reverse where
 
+import Pandora.Core.Appliable ((!))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
@@ -15,42 +16,41 @@
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (point, extract)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 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
+	f <$> Reverse x = Reverse # f <$> x
 
-instance (Semimonoidal (->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (->) (:*:) (:*:) (Reverse t) where
-	multiply (Reverse x :*: Reverse y) = Reverse # multiply (x :*: y)
+instance (Semimonoidal (-->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (-->) (:*:) (:*:) (Reverse t) where
+	mult = Straight $ \(Reverse x :*: Reverse y) -> Reverse ! mult @(-->) ! (x :*: y)
 
-instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t) => Monoidal (->) (->) (:*:) (:*:) (Reverse t) where
-	unit _ f = Reverse . point $ f One
+instance (Covariant (->) (->) t, Monoidal (-->) (->) (:*:) (:*:) t) => Monoidal (-->) (->) (:*:) (:*:) (Reverse t) where
+	unit _ = Straight $ Reverse . point . ($ One)
 
 instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Reverse t) where
-	multiply = Flip $ \(Reverse x) -> 
-		let Flip f = multiply @(<--) @(:*:) @(:*:) in
-		(Reverse <-> Reverse) $ f x
+	mult = Flip $ (Reverse <-> Reverse) . run (mult @(<--)) . run
 
 instance (Covariant (->) (->) t, Monoidal (<--) (->) (:*:) (:*:) t) => Monoidal (<--) (->) (:*:) (:*:) (Reverse t) where
 	unit _ = Flip $ \(Reverse x) -> (\_ -> extract x)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Reverse t) where
-	f <<- Reverse x = Reverse -<$>- run (Backwards . f <<- x)
+	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
+	f >$< Reverse x = Reverse # f >$< x
 
-instance Interpreted (Reverse t) where
+instance Interpreted (->) (Reverse t) where
 	type Primary (Reverse t) a = t a
 	run ~(Reverse x) = x
 	unite = Reverse
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,24 +3,27 @@
 module Pandora.Paradigm.Primary.Transformer.Tap where
 
 import Pandora.Core.Functor (type (:=))
+import Pandora.Core.Appliable ((!))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Inventory.Store (Store (Store))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) 
-import Pandora.Paradigm.Primary.Algebraic ((-<*>-), extract)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Primary.Algebraic ((<-*-), extract)
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), twosome)
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), (%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->), (%))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
@@ -30,21 +33,20 @@
 data Tap t a = Tap a (t a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Tap t) where
-	f -<$>- Tap x xs = Tap # f x # f -<$>- xs
+	f <$> Tap x xs = Tap # f x # f <$> xs
 
-instance Semimonoidal (->) (:*:) (:*:) t => Semimonoidal (->) (:*:) (:*:) (Tap t) where
-	multiply (Tap x xs :*: Tap y ys) = Tap (x :*: y) $ multiply $ xs :*: ys
+instance Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (Tap t) where
+	mult = Straight $ \(Tap x xs :*: Tap y ys) -> Tap (x :*: y) $ mult @(-->) ! xs :*: ys
 
 instance Semimonoidal (<--) (:*:) (:*:) t => Semimonoidal (<--) (:*:) (:*:) (Tap t) where
-	multiply = Flip $ \(Tap (x :*: y) xys) -> 
-		let Flip f = multiply @(<--) @(:*:) @(:*:) in
-		let (xs :*: ys) = f xys in Tap x xs :*: Tap y ys
+	mult = Flip $ \(Tap (x :*: y) xys) ->
+		(Tap x <-> Tap y) $ mult @(<--) ! xys
 
 instance Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (->) (:*:) (:*:) (Tap t) where
 	unit _ = Flip $ \(Tap x _) -> (\_ -> x)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Tap t) where
-	f <<- Tap x xs = Tap -<$>- f x -<*>- f <<- xs
+	f <<- Tap x xs = Tap <$> f x <-*- f <<- xs
 
 instance (Semimonoidal (<--) (:*:) (:*:) t, Extendable (->) t, Covariant (->) (->) t) => Extendable (->) (Tap t) where
 	f <<= x = Tap # f x $ f . Tap (extract x) <<= lower x
@@ -55,13 +57,13 @@
 instance Hoistable Tap where
 	f /|\ Tap x xs = Tap x # f xs
 
-instance {-# OVERLAPS #-} Semimonoidal (->) (:*:) (:*:) t => Semimonoidal (->) (:*:) (:*:) (Tap (t <:.:> t := (:*:))) where
-	multiply (Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) = Tap (x :*: y)
-		$ T_U $ multiply (xls :*: yls) :*: multiply (xrs :*: yrs)
+instance {-# OVERLAPS #-} Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (Tap (t <:.:> t := (:*:))) where
+	mult = Straight $ \(Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) -> Tap (x :*: y)
+		$ T_U $ (mult @(-->) ! (xls :*: yls)) :*: (mult @(-->) ! (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
+		<$> f <<- Reverse past <-*- f x <-*- f <<- future
 
 instance (Covariant (->) (->) t) => Substructure Root (Tap (t <:.:> t := (:*:))) where
 	type Available Root (Tap (t <:.:> t := (:*:))) = Identity
diff --git a/Pandora/Paradigm/Primary/Transformer/Yoneda.hs b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
--- a/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Yoneda.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Primary.Transformer.Yoneda where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
@@ -11,7 +11,7 @@
 	{ yoneda :: forall b . (a -> b) -> t b }
 
 instance Covariant (->) (->) (Yoneda t) where
-	f -<$>- x = Yoneda (\k -> yoneda x (k . f))
+	f <$> x = Yoneda (\k -> yoneda x (k . f))
 
 instance Liftable (->) Yoneda where
-	lift x = Yoneda (-<$>- x)
+	lift x = Yoneda (<$> x)
diff --git a/Pandora/Paradigm/Schemes/PQ_.hs b/Pandora/Paradigm/Schemes/PQ_.hs
--- a/Pandora/Paradigm/Schemes/PQ_.hs
+++ b/Pandora/Paradigm/Schemes/PQ_.hs
@@ -4,7 +4,7 @@
 
 newtype PQ_ p q a b = PQ_ (p a (q b a))
 
-instance Interpreted (PQ_ p q a) where
+instance Interpreted (->) (PQ_ p q a) where
 	type Primary (PQ_ p q a) b = p a (q b a)
 	run ~(PQ_ x) = x
 	unite = PQ_
diff --git a/Pandora/Paradigm/Schemes/PTU.hs b/Pandora/Paradigm/Schemes/PTU.hs
--- a/Pandora/Paradigm/Schemes/PTU.hs
+++ b/Pandora/Paradigm/Schemes/PTU.hs
@@ -4,7 +4,7 @@
 
 newtype PTU p t u a b = PTU (p (t a) (u b))
 
-instance Interpreted (PTU p t u a) where
+instance Interpreted (->) (PTU p t u a) where
 	type Primary (PTU p t u a) b = p (t a) (u b)
 	run ~(PTU x) = x
 	unite = PTU
diff --git a/Pandora/Paradigm/Schemes/P_Q_T.hs b/Pandora/Paradigm/Schemes/P_Q_T.hs
--- a/Pandora/Paradigm/Schemes/P_Q_T.hs
+++ b/Pandora/Paradigm/Schemes/P_Q_T.hs
@@ -4,7 +4,7 @@
 
 newtype P_Q_T (p :: * -> * -> *) (q :: * -> * -> *) (t :: * -> *) (a :: *) (b :: *) = P_Q_T (p a (q (t b) a))
 
-instance Interpreted (P_Q_T p q t a) where
+instance Interpreted (->) (P_Q_T p q t a) where
 	type Primary (P_Q_T p q t a) b = (p a (q (t b) a))
 	run ~(P_Q_T x) = x
 	unite = P_Q_T
diff --git a/Pandora/Paradigm/Schemes/P_T.hs b/Pandora/Paradigm/Schemes/P_T.hs
--- a/Pandora/Paradigm/Schemes/P_T.hs
+++ b/Pandora/Paradigm/Schemes/P_T.hs
@@ -4,7 +4,7 @@
 
 newtype P_T p t a b = P_T (p (t a) b)
 
-instance Interpreted (P_T p t a) where
+instance Interpreted (->) (P_T p t a) where
 	type Primary (P_T p t a) b = p (t a) b
 	run ~(P_T x) = x
 	unite = P_T
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,11 +1,12 @@
 module Pandora.Paradigm.Schemes.TU where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
+import Pandora.Core.Appliable ((!))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
@@ -14,13 +15,14 @@
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption), sum)
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (empty, point, extract)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
 newtype TU ct cu t u a = TU (t :. u := a)
 
@@ -31,42 +33,39 @@
 type (<:.<) = TU Covariant Contravariant
 type (>:.<) = TU Contravariant Contravariant
 
-instance Interpreted (TU ct cu t u) where
+instance Interpreted (->) (TU ct cu t u) where
 	type Primary (TU ct cu t u) a = t :. u := a
 	run ~(TU x) = x
 	unite = TU
 
-instance (Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <:.> u) where
-	f -<$>- x = TU $ f -<$$>- run x
+instance (Covariant m m t, Covariant m m u, Interpreted m (t <:.> u)) => Covariant m m (t <:.> u) where
+	(<$>) f = (||=) ((<$$>) @m @m f)
 
-instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) u) => Semimonoidal (->) (:*:) (:*:) (t <:.> u) where
-	multiply (TU x :*: TU y) = TU $ multiply @(->) @(:*:) -<$>- multiply (x :*: y)
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <:.> u) where
+	mult = Straight $ TU . (<$>) (mult @(-->) !) . (mult @(-->) !) . (run @(->) <-> run @(->))
 
-instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) u, Monoidal (->) (->) (:*:) (:*:) t, Monoidal (->) (->) (:*:) (:*:) u) => Monoidal (->) (->) (:*:) (:*:) (t <:.> u) where
-	unit _ f = TU . point . point $ f One
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) u, Monoidal (-->) (->) (:*:) (:*:) t, Monoidal (-->) (->) (:*:) (:*:) u) => Monoidal (-->) (->) (:*:) (:*:) (t <:.> u) where
+	unit _ = Straight $ TU . point . point . ($ One)
 
-instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (->) (:*:) (:+:) t) => Semimonoidal (->) (:*:) (:+:) (t <:.> u) where
-	multiply (TU x :*: TU y) = TU $ sum (Option -<$>-) (Adoption -<$>-) -<$>- multiply @(->) @(:*:) @(:+:) (x :*: y)
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:+:) t) => Semimonoidal (-->) (:*:) (:+:) (t <:.> u) where
+	mult = Straight $ \(TU x :*: TU y) -> TU $ sum (Option <$>) (Adoption <$>) <$> (mult @(-->) ! x :*: y)
 
-instance (Covariant (->) (->) t, Covariant (->) (->) u, Monoidal (->) (->) (:*:) (:+:) t) => Monoidal (->) (->) (:*:) (:+:) (t <:.> u) where
-	unit _ _ = TU empty
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Monoidal (-->) (->) (:*:) (:+:) t) => Monoidal (-->) (->) (:*:) (:+:) (t <:.> u) where
+	unit _ = Straight $ \_ -> TU empty
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:.> u) where
-	multiply = Flip $ \(TU xys) ->
-		let Flip f = multiply @(<--) @(:*:) @(:*:) in
-		let Flip g = multiply @(<--) @(:*:) @(:*:) in
-		(TU <-> TU) $ g (f -<$>- xys) where
+	mult = Flip $ \(TU xys) -> (TU <-> TU) . (mult @(<--) !) $ (mult @(<--) !) <$> xys
 
 instance (Covariant (->) (->) t, Monoidal (<--) (->) (:*:) (:*:) t, Monoidal (<--) (->) (:*:) (:*:) u) => Monoidal (<--) (->) (:*:) (:*:) (t <:.> u) where
 	unit _ = Flip $ \(TU x) -> (\_ -> extract $ extract x)
 
 instance (Traversable (->) (->) t, Traversable (->) (->) u) => Traversable (->) (->) (t <:.> u) where
-	f <<- x = TU -<$>- f -<<-<<- run x
+	f <<- x = TU <$> f -<<-<<- run x
 
 instance (Bindable (->) t, Distributive (->) (->) t, Covariant (->) (->) u, Bindable (->) u) => Bindable (->) (t <:.> u) where
-	f =<< TU x = TU $ (\i -> (identity =<<) -<$>- run . f -<< i) =<< x
+	f =<< TU x = TU $ (\i -> (identity =<<) <$> run . f -<< i) =<< x
 
-instance Monoidal (->) (->) (:*:) (:*:) t => Liftable (->) (TU Covariant Covariant t) where
+instance Monoidal (-->) (->) (:*:) (:*:) t => Liftable (->) (TU Covariant Covariant t) where
 	lift :: Covariant (->) (->) u => u ~> t <:.> u
 	lift = TU . point
 
@@ -76,4 +75,4 @@
 
 instance Covariant (->) (->) t => Hoistable (TU Covariant Covariant t) where
 	(/|\) :: u ~> v -> (t <:.> u ~> t <:.> v)
-	f /|\ TU x = TU $ f -<$>- x
+	f /|\ TU x = TU $ f <$> x
diff --git a/Pandora/Paradigm/Schemes/TUT.hs b/Pandora/Paradigm/Schemes/TUT.hs
--- a/Pandora/Paradigm/Schemes/TUT.hs
+++ b/Pandora/Paradigm/Schemes/TUT.hs
@@ -1,11 +1,12 @@
 module Pandora.Paradigm.Schemes.TUT where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
+import Pandora.Core.Appliable ((!))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, ($))
-import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-), (-<$$$>-))
+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((<$>)), (<$$>), (<$$$>))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
@@ -14,12 +15,13 @@
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (point, extract)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))
 
 newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a)
 
@@ -34,35 +36,31 @@
 type (<:>.<:<) = TUT Covariant Contravariant Contravariant
 type (>:>.<:<) = TUT Contravariant Contravariant Contravariant
 
-instance Interpreted (TUT ct ct' cu t t' u) where
+instance Interpreted (->) (TUT ct ct' cu t t' u) where
 	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' := a
 	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 m m t, Covariant m m u, Covariant m m t', Interpreted m (t <:<.>:> t' := u)) => Covariant m m (t <:<.>:> t' := u) where
+	(<$>) f = (||=) ((<$$$>) @m @m @m f)
 
-instance (Covariant (->) (->) t, Covariant (->) (->) t', Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) u, Semimonoidal (->) (:*:) (:*:) t') => Semimonoidal (->) (:*:) (:*:) (t <:<.>:> t' := u) where
-	multiply (TUT x :*: TUT y) = TUT $ multiply @(->) @(:*:) -<$$>- multiply @(->) @(:*:) -<$>- multiply (x :*: y)
+instance (Covariant (->) (->) t, Covariant (->) (->) t', Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u, Semimonoidal (-->) (:*:) (:*:) t') => Semimonoidal (-->) (:*:) (:*:) (t <:<.>:> t' := u) where
+	mult = Straight $ TUT . (<$$>) @_ @(->) (mult @(-->) !) . (<$>) (mult @(-->) !) . (mult @(-->) !) . (run @(->) <-> run @(->))
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <:<.>:> t' := u) where
-	multiply = Flip $ \(TUT xys) ->
-		let Flip f = multiply @(<--) @(:*:) @(:*:) in
-		let Flip g = multiply @(<--) @(:*:) @(:*:) in
-		let Flip h = multiply @(<--) @(:*:) @(:*:) in
-		(TUT <-> TUT) $ f (g -<$>- (h -<$$>- xys)) where
+	mult = Flip $ (TUT <-> TUT) . (mult @(<--) !) . (<$>) (mult @(<--) !) . (<$$>) @_ @(->) (mult @(<--) !) . run
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t', Monoidal (<--) (->) (:*:) (:*:) u, Adjoint (->) (->) t t') => Monoidal (<--) (->) (:*:) (:*:) (t <:<.>:> t' := u) where
 	unit _ = Flip $ \(TUT xys) -> (\_ -> (extract |-) xys)
 
 instance (Covariant (->) (->) t, Covariant (->) (->) t', Adjoint (->) (->) t' t, Bindable (->) u) => Bindable (->) (t <:<.>:> t' := u) where
-	f =<< x = TUT $ ((run . f |-) =<<) -<$>- run x
+	f =<< x = TUT $ ((run . f |-) =<<) <$> run x
 
-instance (Covariant (->) (->) t, Covariant (->) (->) u, Covariant (->) (->) t', Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) t', Monoidal (->) (->) (:*:) (:*:) u, Adjoint (->) (->) t' t) => Monoidal (->) (->) (:*:) (:*:) (t <:<.>:> t' := u) where
-	unit _ f = unite . (point -|) . f $ One
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Covariant (->) (->) t', Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) t', Monoidal (-->) (->) (:*:) (:*:) u, Adjoint (->) (->) t' t) => Monoidal (-->) (->) (:*:) (:*:) (t <:<.>:> t' := u) where
+	unit _ = Straight $ unite . (point -|) . ($ One)
 
 instance (Adjoint (->) (->) t' t, Extendable (->) u) => Extendable (->) (t' <:<.>:> t := u) where
-	f <<= x = TUT $ ((f . unite -|) <<=) -<$>- run x
+	f <<= x = TUT $ ((f . unite -|) <<=) <$> run x
 
 instance (Adjoint (->) (->) t' t, Distributive (->) (->) t) => Liftable (->) (t <:<.>:> t') where
 	lift :: Covariant (->) (->) u => u ~> t <:<.>:> t' := u
diff --git a/Pandora/Paradigm/Schemes/TUVW.hs b/Pandora/Paradigm/Schemes/TUVW.hs
--- a/Pandora/Paradigm/Schemes/TUVW.hs
+++ b/Pandora/Paradigm/Schemes/TUVW.hs
@@ -5,7 +5,7 @@
 
 newtype TUVW ct cu cv cw t u v w a = TUVW (t :. u :. v :. w := a)
 
-instance Interpreted (TUVW ct cu cv cw t u v w) where
+instance Interpreted (->) (TUVW ct cu cv cw t u v w) where
 	type Primary (TUVW ct cu cv cw t u v w) a = t :. u :. v :. w := a
 	run ~(TUVW x) = x
 	unite = TUVW
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, 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, (||=)))
@@ -16,16 +16,16 @@
 type (<:.:<) t u p = T_U Covariant Contravariant p t u
 type (>:.:<) t u p = T_U Contravariant Contravariant p t u
 
-instance Interpreted (T_U ct cu p t u) where
+instance Interpreted (->) (T_U ct cu p t u) where
 	type Primary (T_U ct cu p t u) a = p (t a) (u a)
 	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
+	f <$> x = (f <$>) <-> (f <$>) ||= x
 
 instance (Divariant (->) (->) (->) p, Contravariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t >:.:> u := p) where
-	f -<$>- x = (f ->$<-) >-> (f -<$>-) ||= x
+	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
+	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,22 +1,24 @@
 module Pandora.Paradigm.Schemes.UT where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
+import Pandora.Core.Appliable ((!))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), point, extract)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 
 newtype UT ct cu t u a = UT (u :. t := a)
 
@@ -27,36 +29,33 @@
 type (<.:<) = UT Covariant Contravariant
 type (>.:<) = UT Contravariant Contravariant
 
-instance Interpreted (UT ct cu t u) where
+instance Interpreted (->) (UT ct cu t u) where
 	type Primary (UT ct cu t u) a = u :. t := a
 	run ~(UT x) = x
 	unite = UT
 
-instance (Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <.:> u) where
-	f -<$>- x = UT $ f -<$$>- run x
+instance (Covariant m m t, Covariant m m u, Interpreted m (t <.:> u)) => Covariant m m (t <.:> u) where
+	(<$>) f = (||=) ((<$$>) @m @m f)
 
-instance (Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) u) => Semimonoidal (->) (:*:) (:*:) (t <.:> u) where
-	multiply (UT x :*: UT y) = UT $ multiply @(->) @(:*:) -<$>- multiply (x :*: y)
+instance (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <.:> u) where
+	mult = Straight $ UT . (<$>) (mult @(-->) !) . (mult @(-->) !) . (run @(->) <-> run @(->))
 
-instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) u, Monoidal (->) (->) (:*:) (:*:) t, Monoidal (->) (->) (:*:) (:*:) u) => Monoidal (->) (->) (:*:) (:*:) (t <.:> u) where
-	unit _ f = UT . point . point $ f One
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) u, Monoidal (-->) (->) (:*:) (:*:) t, Monoidal (-->) (->) (:*:) (:*:) u) => Monoidal (-->) (->) (:*:) (:*:) (t <.:> u) where
+	unit _ = Straight $ UT . point . point . ($ One)
 
-instance (Traversable (->) (->) t, Bindable (->) t, Semimonoidal (->) (:*:) (:*:) u, Monoidal (->) (->) (:*:) (:*:) u, Bindable (->) u) => Bindable (->) (t <.:> u) where
-	f =<< UT x = UT $ ((identity =<<) -<$>-) . (run . f <<-) =<< x
+instance (Traversable (->) (->) t, Bindable (->) t, Semimonoidal (-->) (:*:) (:*:) u, Monoidal (-->) (->) (:*:) (:*:) u, Bindable (->) u) => Bindable (->) (t <.:> u) where
+	f =<< UT x = UT $ ((identity =<<) <$>) . (run . f <<-) =<< x
 
 instance (Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <.:> u) where
-	multiply = Flip $ \(UT xys) ->
-		let Flip f = multiply @(<--) @(:*:) @(:*:) in
-		let Flip g = multiply @(<--) @(:*:) @(:*:) in
-		(UT <-> UT) $ f (g -<$>- xys) where
+	mult = Flip $ \(UT xys) -> (UT <-> UT) . (mult @(<--) !) $ (mult @(<--) !) <$> xys
 
 instance (Covariant (->) (->) u, Monoidal (<--) (->) (:*:) (:*:) t, Monoidal (<--) (->) (:*:) (:*:) u) => Monoidal (<--) (->) (:*:) (:*:) (t <.:> u) where
 	unit _ = Flip $ \(UT x) -> (\_ -> extract $ extract x)
 
-instance Monoidal (->) (->) (:*:) (:*:) t => Liftable (->) (UT Covariant Covariant t) where
+instance Monoidal (-->) (->) (:*:) (:*:) t => Liftable (->) (UT Covariant Covariant t) where
 	lift :: Covariant (->) (->) u => u ~> t <.:> u
-	lift x = UT $ point -<$>- x
+	lift x = UT $ point <$> x
 
 instance Monoidal (<--) (->) (:*:) (:*:) t => Lowerable (->) (UT Covariant Covariant t) where
 	lower :: Covariant (->) (->) u => t <.:> u ~> u
-	lower (UT x) = extract -<$>- x
+	lower (UT x) = extract <$> x
diff --git a/Pandora/Paradigm/Schemes/UTU.hs b/Pandora/Paradigm/Schemes/UTU.hs
--- a/Pandora/Paradigm/Schemes/UTU.hs
+++ b/Pandora/Paradigm/Schemes/UTU.hs
@@ -16,7 +16,7 @@
 type (<.>:<.<) = UTU Covariant Contravariant Contravariant
 type (>.>:<.<) = UTU Contravariant Contravariant Contravariant
 
-instance Interpreted (UTU ct cu t u u') where
+instance Interpreted (->) (UTU ct cu t u u') where
 	type Primary (UTU ct cu t u u') a = u :. t :. u' := a
 	run ~(UTU x) = x
 	unite = UTU
diff --git a/Pandora/Paradigm/Schemes/U_T.hs b/Pandora/Paradigm/Schemes/U_T.hs
--- a/Pandora/Paradigm/Schemes/U_T.hs
+++ b/Pandora/Paradigm/Schemes/U_T.hs
@@ -4,7 +4,7 @@
 
 newtype U_T ct cu t p u a = U_T (p (u a) (t a))
 
-instance Interpreted (U_T ct cu t p u) where
+instance Interpreted (->) (U_T ct cu t p u) where
 	type Primary (U_T ct cu t p u) a = p (u a) (t a)
 	run ~(U_T x) = x
 	unite = U_T
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -10,7 +10,7 @@
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Semigroup ((+))
@@ -26,7 +26,7 @@
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Both, Left, Right, End))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap))
 import Pandora.Paradigm.Schemes.TU (type (<:.>))
 import Pandora.Paradigm.Schemes.T_U ( type (<:.:>))
@@ -67,7 +67,7 @@
 
 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) = (into @(o ds) -<$>-) ||= xs
+	morphing (premorph -> xs) = (into @(o ds) <$>) ||= xs
 
 instance Substructure Left (Flip (:*:) a) where
 	type Available Left (Flip (:*:) a) = Identity
diff --git a/Pandora/Paradigm/Structure/Ability.hs b/Pandora/Paradigm/Structure/Ability.hs
--- a/Pandora/Paradigm/Structure/Ability.hs
+++ b/Pandora/Paradigm/Structure/Ability.hs
@@ -3,7 +3,6 @@
 import Pandora.Paradigm.Structure.Ability.Monotonic as Exports
 import Pandora.Paradigm.Structure.Ability.Zipper as Exports
 import Pandora.Paradigm.Structure.Ability.Substructure as Exports
-import Pandora.Paradigm.Structure.Ability.Measurable as Exports
 import Pandora.Paradigm.Structure.Ability.Morphable as Exports
 import Pandora.Paradigm.Structure.Ability.Accessible as Exports
 import Pandora.Paradigm.Structure.Ability.Nullable as Exports
diff --git a/Pandora/Paradigm/Structure/Ability/Measurable.hs b/Pandora/Paradigm/Structure/Ability/Measurable.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Ability/Measurable.hs
+++ /dev/null
@@ -1,15 +0,0 @@
-{-# LANGUAGE AllowAmbiguousTypes #-}
-
-module Pandora.Paradigm.Structure.Ability.Measurable where
-
-import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
-
-class Measurable f t where
-	type Measural (f :: k) (t :: * -> *) a
-	measurement :: Tagged f (t a) -> Measural f t a
-
-measure :: forall f t a . Measurable f t => t a -> Measural f t a
-measure = measurement . Tag @f
-
-data Scale = Length | Heighth | Depth
diff --git a/Pandora/Paradigm/Structure/Ability/Substructure.hs b/Pandora/Paradigm/Structure/Ability/Substructure.hs
--- a/Pandora/Paradigm/Structure/Ability/Substructure.hs
+++ b/Pandora/Paradigm/Structure/Ability/Substructure.hs
@@ -4,7 +4,7 @@
 module Pandora.Paradigm.Structure.Ability.Substructure where
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
@@ -24,4 +24,4 @@
 	substructure :: (Tagged segment <:.> structure) #=@ Substance segment structure := Available segment structure
 
 	sub :: (Covariant (->) (->) structure) => structure #=@ Substance segment structure := Available segment structure
-	sub = lift @(->) >-> (lower @(->) -<$>-) ||= substructure @segment @structure
+	sub = 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
@@ -28,4 +28,4 @@
 subset = Convergence $ \s ss -> Nothing != (find @f @t @Maybe % s) . equate <<- ss
 
 cardinality :: Traversable (->) (->) t => t a -> Numerator
-cardinality s = attached . run @(State _) % Zero $ (modify @Numerator (+ one) !.) <<- s
+cardinality s = attached . run @(->) @(State _) % Zero $ (modify @Numerator (+ one) !.) <<- s
diff --git a/Pandora/Paradigm/Structure/Modification/Comprehension.hs b/Pandora/Paradigm/Structure/Modification/Comprehension.hs
--- a/Pandora/Paradigm/Structure/Modification/Comprehension.hs
+++ b/Pandora/Paradigm/Structure/Modification/Comprehension.hs
@@ -4,14 +4,17 @@
 module Pandora.Paradigm.Structure.Modification.Comprehension where
 
 import Pandora.Core.Functor (type (:=))
+import Pandora.Core.Appliable ((!))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
-import Pandora.Pattern.Functor.Contravariant ((->$<-))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant ((>$<))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
@@ -23,31 +26,29 @@
 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.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))
 import Pandora.Paradigm.Primary.Algebraic (empty)
 
 newtype Comprehension t a = Comprehension (t <:.> Construction t := a)
 
-instance Interpreted (Comprehension t) where
+instance Interpreted (->) (Comprehension t) where
 	type Primary (Comprehension t) a = t <:.> Construction t := a
 	run ~(Comprehension x) = x
 	unite = Comprehension
 
 instance Covariant (->) (->) (t <:.> Construction t) => Covariant (->) (->) (Comprehension t) where
-	f -<$>- Comprehension x = Comprehension $ f -<$>- x
+	f <$> Comprehension x = Comprehension $ f <$> x
 
 instance Traversable (->) (->) (t <:.> Construction t) => Traversable (->) (->) (Comprehension t) where
-	f <<- Comprehension x = Comprehension -<$>- f <<- x
-
-instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Semimonoidal (->) (:*:) (:*:) (Comprehension t) where
-	multiply (Comprehension x :*: Comprehension y) = Comprehension $ multiply (x :*: y)
+	f <<- Comprehension x = Comprehension <$> f <<- x
 
-instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:+:) t) => Semimonoidal (->) (:*:) (:+:) (Comprehension t) where
-	multiply (Comprehension x :*: Comprehension y) = Comprehension $ multiply (x :*: y)
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) right t, Semimonoidal (-->) (:*:) right (t <:.> Construction t)) => Semimonoidal (-->) (:*:) right (Comprehension t) where
+	mult = Straight $ Comprehension . (mult @(-->) @(:*:) @right !) . (run @(->) <-> run @(->))
 
-instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:+:) t) => Monoidal (->) (->) (:*:) (:+:) (Comprehension t) where
-	unit _ _ = Comprehension empty
+instance (Covariant (->) (->) t, Monoidal (-->) (->) (:*:) (:+:) t) => Monoidal (-->) (->) (:*:) (:+:) (Comprehension t) where
+	unit _ = Straight $ \_ -> Comprehension empty
 
 instance (forall a . Semigroup (t <:.> Construction t := a), Bindable (->) t) => Bindable (->) (Comprehension t) where
 	f =<< Comprehension (TU t) = Comprehension . TU $ (\(Construct x xs) -> run . run $ f x + (f =<< Comprehension (TU xs))) =<< t
@@ -61,9 +62,9 @@
 instance Monoid (t <:.> Construction t := a) => Monoid (Comprehension t a) where
 	zero = Comprehension zero
 
-instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t)  => Morphable Push (Comprehension t) where
+instance (Covariant (->) (->) t, Monoidal (-->) (->) (:*:) (:*:) t)  => Morphable Push (Comprehension t) where
 	type Morphing Push (Comprehension t) = Identity <:.:> Comprehension t := (->)
 	morphing (run . premorph -> xs) = T_U $ \(Identity x) -> Comprehension . lift . Construct x . run $ xs
 
 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
@@ -5,30 +5,30 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
 import Pandora.Paradigm.Primary.Algebraic (extract)
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into), premorph)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 
 newtype Prefixed t k a = Prefixed (t :. (:*:) k := a)
 
-instance Interpreted (Prefixed t k) where
+instance Interpreted (->) (Prefixed t k) where
 	type Primary (Prefixed t k) a = t :. (:*:) k := a
 	run ~(Prefixed x) = x
 	unite = Prefixed
 
+-- TODO: Try to generalize (->) here
 instance Covariant (->) (->) t => Covariant (->) (->) (Prefixed t k) where
-	f -<$>- Prefixed x = Prefixed $ f -<$$>- x
+	(<$>) f = (||=) ((<$$>) @(->) @(->) f)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Prefixed t k) where
-	f <<- Prefixed x = Prefixed -<$>- f -<<-<<- x
+	f <<- Prefixed x = Prefixed <$> f -<<-<<- x
 
 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
@@ -2,37 +2,34 @@
 
 module Pandora.Paradigm.Structure.Some.Binary where
 
-import Pandora.Core.Functor (type (:.), type (:=), type (:=>), type (:::))
+import Pandora.Core.Functor (type (:=), type (:=>), type (:::))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable ((=<<))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Paradigm.Primary ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), type (:*:), attached, twosome)
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), (&))
-import Pandora.Paradigm.Primary.Algebraic (($$$>-), extract)
+import Pandora.Paradigm.Primary.Algebraic (($$$>-), (<-*-), extract)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (order)
-import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Numerator, Zero))
-import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (Single))
 import Pandora.Paradigm.Primary.Functor (Comparison)
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both))
-import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
 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.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Optics (over, view)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null))
-import Pandora.Paradigm.Structure.Ability.Measurable (Measurable (Measural, measurement), Scale (Heighth), measure)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (resolve))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), morph, premorph
 	, Morph (Rotate, Into, Insert, Lookup, Vary, Key, Element), Vertical (Up, Down), lookup, vary)
@@ -42,26 +39,28 @@
 
 type Binary = Maybe <:.> Construction Wye
 
-rebalance :: Chain a => (Wye :. Construction Wye := a) -> Nonempty Binary a
-rebalance (Both x y) = extract x <=> extract y & order
-	# Construct (extract x) (Both # rebalance (deconstruct x) # rebalance (deconstruct y))
-	# Construct (extract y) (Both # x # rebalance (deconstruct y))
-	# Construct (extract x) (Both # rebalance (deconstruct x) # y)
+instance {-# OVERLAPS #-} Traversable (->) (->) (Construction Wye) where
+	f <<- (Construct x (Left l)) = Construct <$> f x <-*- (Left <$> f <<- l)
+	f <<- (Construct x (Right r)) = Construct <$> f x <-*- (Right <$> f <<- r)
+	f <<- (Construct x (Both l r)) = Construct <$> f x <-*- (Both <$> f <<- l <-*- f <<- r)
+	f <<- (Construct x End) = Construct % End <$> f x
 
+--rebalance :: Chain a => (Wye :. Construction Wye := a) -> Nonempty Binary a
+--rebalance (Both x y) = extract x <=> extract y & order
+--	# Construct (extract x) (Both # rebalance (deconstruct x) # rebalance (deconstruct y))
+--	# Construct (extract y) (Both # x # rebalance (deconstruct y))
+--	# Construct (extract x) (Both # rebalance (deconstruct x) # y)
+
 instance Morphable Insert Binary where
 	type Morphing Insert Binary = (Identity <:.:> Comparison := (:*:)) <:.:> Binary := (->)
-	morphing (run . premorph -> Nothing) = T_U $ \(T_U (Identity x :*: _)) -> lift $ leaf x
-	morphing (run . premorph -> Just ne) = T_U $ \(T_U (Identity x :*: Convergence f)) ->
-		let continue xs = run # morph @Insert @(Nonempty Binary) xs $ twosome # Identity x # Convergence f in
-		let change = Just . resolve continue (leaf x) in
-		lift $ f x # extract ne & order # ne
-			# over (sub @Left) change ne
-			# over (sub @Right) change ne
-
-instance Measurable Heighth Binary where
-	type Measural Heighth Binary a = Numerator
-	measurement (run . extract -> Just bt) = Numerator $ measure @Heighth bt
-	measurement (run . extract -> Nothing) = Zero
+	morphing binary = case run # premorph binary of
+		Nothing -> T_U $ \(T_U (Identity x :*: _)) -> lift $ leaf x
+		Just non_empty_binary -> T_U $ \(T_U (Identity x :*: Convergence f)) ->
+			let continue xs = run # morph @Insert @(Nonempty Binary) xs $ twosome # Identity x # Convergence f in
+			let change = Just . resolve continue (leaf x) in
+			lift $ f x # extract non_empty_binary & order # non_empty_binary
+				# over (sub @Left) change non_empty_binary
+				# over (sub @Right) change non_empty_binary
 
 instance Nullable Binary where
 	null = Predicate $ \case { TU Nothing -> True ; _ -> False }
@@ -71,14 +70,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 ---------------------------------------
 
@@ -98,15 +97,6 @@
 			# over (sub @Right) change nonempty_list
 			# f x (extract nonempty_list)
 
-instance Measurable Heighth (Construction Wye) where
-	type Measural Heighth (Construction Wye) a = Denumerator
-	measurement (deconstruct . extract -> End) = Single
-	measurement (deconstruct . extract -> Left lst) = Single + measure @Heighth lst
-	measurement (deconstruct . extract -> Right rst) = Single + measure @Heighth rst
-	measurement (deconstruct . extract -> Both lst rst) = Single +
-		let (lm :*: rm) = measure @Heighth lst :*: measure @Heighth rst
-		in lm <=> rm & order lm rm lm
-
 instance Substructure Root (Construction Wye) where
 	type Available Root (Construction Wye) = Identity
 	type Substance Root (Construction Wye) = Identity
@@ -165,9 +155,9 @@
 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
+	_ <$> Top = Top
+	f <$> Leftward l = Leftward $ f l
+	f <$> Rightward r = Rightward $ f r
 
 type Bifurcation = Biforked <:.> Construction Biforked
 
diff --git a/Pandora/Paradigm/Structure/Some/List.hs b/Pandora/Paradigm/Structure/Some/List.hs
--- a/Pandora/Paradigm/Structure/Some/List.hs
+++ b/Pandora/Paradigm/Structure/Some/List.hs
@@ -6,7 +6,7 @@
 import Pandora.Core.Impliable (imply)
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((<$>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -20,7 +20,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 (Single))
-import Pandora.Paradigm.Primary.Algebraic ((-<*>-), (-.#..-), extract)
+import Pandora.Paradigm.Primary.Algebraic ((<-*-), (-.#..-), extract)
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached, twosome)
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
@@ -40,7 +40,6 @@
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null))
 import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)
-import Pandora.Paradigm.Structure.Ability.Measurable (Measurable (Measural, measurement), Scale (Length), measure)
 import Pandora.Paradigm.Structure.Ability.Monotonic (resolve)
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing)
 	, Morph (Rotate, Into, Push, Pop, Delete, Find, Lookup, Element, Key)
@@ -93,11 +92,6 @@
 
 instance Stack List where
 
-instance Measurable Length List where
-	type Measural Length List a = Numerator
-	measurement (run . extract -> Nothing) = zero
-	measurement (run . extract -> Just xs) = Numerator $ measure @Length xs
-
 instance Nullable List where
 	null = Predicate $ \case { TU Nothing -> True ; _ -> False }
 
@@ -112,12 +106,12 @@
 	type Available Tail List = Identity
 	type Substance Tail List = List
 	substructure = P_Q_T $ \x -> case run . extract . run $ x of
-		Just ns -> lift . lift @(->) -<$>- run (sub @Tail) ns
+		Just ns -> lift . lift @(->) <$> run (sub @Tail) ns
 		Nothing -> Store $ Identity zero :*: lift . identity . extract
 
 -- | Transform any traversable structure into a stack
 linearize :: forall t a . Traversable (->) (->) t => t a -> List a
-linearize = 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 -------------------------------------------
 
@@ -140,11 +134,6 @@
 	type Morphing Push (Construction Maybe) = Identity <:.:> Construction Maybe := (->)
 	morphing (premorph -> xs) = T_U $ \(Identity x) -> Construct x $ Just xs
 
-instance Measurable Length (Construction Maybe) where
-	type Measural Length (Construction Maybe) a = Denumerator
-	measurement (deconstruct . extract -> Nothing) = Single
-	measurement (deconstruct . extract -> Just xs) = Single + measure @Length xs
-
 instance Substructure Root (Construction Maybe) where
 	type Available Root (Construction Maybe) = Identity
 	type Substance Root (Construction Maybe) = Identity
@@ -167,37 +156,37 @@
 
 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
+		<$> f <<- Reverse past <-*- f x <-*- f <<- future
 
 instance {-# OVERLAPS #-} Extendable (->) (Tap (List <:.:> List := (:*:))) where
 	f <<= z = let move rtt = TU . deconstruct $ run . rtt .-+ z in
-		Tap # f z $ twosome # f -<$>- move (rotate @Left) # f -<$>- move (rotate @Right)
+		Tap # f z $ twosome # f <$> move (rotate @Left) # f <$> move (rotate @Right)
 
 instance Morphable (Rotate Left) (Tap (List <:.:> List := (:*:))) where
 	type Morphing (Rotate Left) (Tap (List <:.:> List := (:*:))) = Maybe <:.> Tap (List <:.:> List := (:*:))
 	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
-	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)
+	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(->) @(State _)
 		# modify . item @Push @List <<- past
 		# item @Push x future
 
 instance Morphable (Into (Comprehension Maybe)) (Tap (List <:.:> List := (:*:))) where
 	type Morphing (Into (Comprehension Maybe)) (Tap (List <:.:> List := (:*:))) = Comprehension Maybe
-	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)
+	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(->) @(State _)
 		# modify . item @Push @(Comprehension Maybe) <<- past
 		# item @Push x (Comprehension future)
 
@@ -208,12 +197,12 @@
 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 := (:*:))
@@ -226,18 +215,18 @@
 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)
+	morphing (premorph -> zipper) = let spread x y = (:*:) <$> x <-*- y in TU $
+		Tap (extract zipper) . T_U <$> ((spread |-) . (run @(->) <-> run @(->)) . run $ lower zipper)
 
 instance Morphable (Into (Construction Maybe)) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
 	type Morphing (Into (Construction Maybe)) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = Construction Maybe
-	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)
+	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(->) @(State _)
 		# modify . item @Push @(Nonempty List) <<- past
 		# item @Push x future
 
 instance Morphable (Into List) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where
 	type Morphing (Into List) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = List
-	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)
+	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(->) @(State _)
 		# modify . item @Push @List <<- past
 		# item @Push x (lift future)
 
@@ -249,11 +238,11 @@
 
 instance Setoid key => Morphable (Lookup Key) (Prefixed List key) where
 	type Morphing (Lookup Key) (Prefixed List key) = (->) key <:.> Maybe
-	morphing (run . premorph -> list) = TU $ \key -> lookup @Key key =<< Prefixed -<$>- run list 
+	morphing (run . premorph -> list) = TU $ \key -> lookup @Key key =<< Prefixed <$> run list 
 
 ------------------------------------ Prefixed non-empty list ---------------------------------------
 
 instance Setoid key => Morphable (Lookup Key) (Prefixed (Construction Maybe) key) where
 	type Morphing (Lookup Key) (Prefixed (Construction Maybe) key) = (->) key <:.> Maybe
-	morphing (run . premorph -> Construct x xs) = TU $ \key -> extract -<$>- search key where
+	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
@@ -5,7 +5,7 @@
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Contravariant ((->$<-))
+import Pandora.Pattern.Functor.Contravariant ((>$<))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
@@ -102,4 +102,4 @@
 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
@@ -6,10 +6,10 @@
 import Pandora.Core.Functor (type (~>), type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Paradigm.Primary ()
-import Pandora.Paradigm.Primary.Algebraic ((-<*>-), extract)
+import Pandora.Paradigm.Primary.Algebraic ((<-*-), extract)
 import Pandora.Paradigm.Primary.Algebraic.Product (twosome)
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
 import Pandora.Paradigm.Primary.Functor.Tagged (type (:#))
@@ -54,27 +54,27 @@
 instance Morphable (Rotate (Left Zig)) (Construction Wye) where
 	type Morphing (Rotate (Left Zig)) (Construction Wye) = Binary
 	morphing :: forall a . (:#) (Rotate (Left Zig)) <:.> Construction Wye := a -> Binary a
-	morphing (premorph -> Construct x xs) = TU $ Construct -<$>- parent -<*>- Just nodes where
+	morphing (premorph -> Construct x xs) = TU $ Construct <$> parent <-*- Just nodes where
 
 		nodes :: Wye :. Nonempty Binary := a
 		nodes = into @Wye . twosome (branch @Left xs) . Just . Construct x
-			. into @Wye $ twosome (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
 	morphing :: forall a . (:#) (Rotate (Right Zig)) <:.> Construction Wye := a -> Binary a
-	morphing (premorph -> Construct x xs) = TU $ Construct -<$>- parent -<*>- Just nodes where
+	morphing (premorph -> Construct x xs) = TU $ Construct <$> parent <-*- Just nodes where
 
 		nodes :: Wye :. Nonempty Binary := a
-		nodes = into @Wye . twosome (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
@@ -5,7 +5,7 @@
 import Pandora.Core.Functor (type (:=), type (:=>), type (:::))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (($), (#))
-import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), twosome)
 import Pandora.Paradigm.Primary.Algebraic (extract)
@@ -34,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
@@ -3,5 +3,7 @@
 import Pandora.Pattern.Object as Exports
 import Pandora.Pattern.Transformer as Exports
 import Pandora.Pattern.Functor as Exports
+import Pandora.Pattern.Morphism as Exports
+import Pandora.Pattern.Groupoid 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,6 +1,6 @@
 module Pandora.Pattern.Category (Category (..)) where
 
-import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) 
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 
 infixl 2 #
 infixr 0 $
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,7 +1,7 @@
 module Pandora.Pattern.Functor.Bivariant where
 
 import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip)
+import Pandora.Pattern.Morphism.Flip (Flip)
 
 infixl 4 <->
 
@@ -13,4 +13,4 @@
 
 class (forall i . Covariant left target (v i), forall i . Covariant right target (Flip v i))
 	=> Bivariant left right target v where
-	(<->) :: left a b -> right c d -> target (v a c) (v b d) 
+	(<->) :: left a b -> right c d -> target (v a c) (v b d)
diff --git a/Pandora/Pattern/Functor/Comonad.hs b/Pandora/Pattern/Functor/Comonad.hs
--- a/Pandora/Pattern/Functor/Comonad.hs
+++ b/Pandora/Pattern/Functor/Comonad.hs
@@ -15,4 +15,4 @@
 > * Associativity: extend f . extend g ≡ extend (f . extend g)
 -}
 
-class (Monoidal (<--) source (:*:) (:*:) t, Extendable source t) => Comonad t source
+class (Monoidal (<--) source (:*:) (:*:) t, Extendable source t) => Comonad source t
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
@@ -2,13 +2,13 @@
 
 import Pandora.Pattern.Category (Category)
 
-infixl 4 ->$<-
+infixl 4 >$<
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
-> * Identity morphism: (identity ->$<-) ≡ identity
-> * Interpreted of morphisms: (f ->$<-) . (g ->$<-) ≡ (g . f ->$<-)
+> * Identity morphism: (identity >$<) ≡ identity
+> * Interpreted of morphisms: (f >$<) . (g >$<) ≡ (g . f >$<)
 -}
 
 class (Category source, Category target) => Contravariant source target t where
-	(->$<-) :: source a b -> target (t b) (t a)
+	(>$<) :: 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,43 +1,33 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+
 module Pandora.Pattern.Functor.Covariant where
 
 import Pandora.Pattern.Semigroupoid (Semigroupoid)
 
-infixl 4 -<$>-
-infixl 3 -<<$$>-, -<$$>>-
+infixl 4 <$>
+infixl 3 <$$>
+infixl 4 <$$$>
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
-> * Identity morphism: (identity -<$>-) ≡ identity
-> * Interpreted of morphisms: (f . g -<$>-) ≡ (f -<$>-) . (g -<$>-)
+> * Identity morphism: (identity <$>) ≡ identity
+> * Interpreted of morphisms: (f . g <$>) ≡ (f <$>) . (g <$>)
 -}
 
 class (Semigroupoid source, Semigroupoid target) => Covariant source target t where
-	(-<$>-) :: source a b -> target (t a) (t b)
-	
-(-<$$>-) :: forall t u category a b 
-	. (Covariant category category u, Covariant category category t) 
-	=> category a b -> category (t (u a)) (t (u b))
-(-<$$>-) s = ((-<$>-) ((-<$>-) @category @category @u s))
-
-(-<<$$>-) :: forall t u source target a b 
-	. (Covariant source source u, Covariant source target t) 
-	=> source a b -> target (t (u a)) (t (u b))
-(-<<$$>-) s = ((-<$>-) ((-<$>-) @source @source @u s))
+	(<$>) :: source a b -> target (t a) (t b)
 
-(-<$$>>-) :: forall source target t u a b 
-	. (Covariant source target u, Covariant target target t) 
+(<$$>) :: forall source between target t u a b
+	. (Covariant source between u, Covariant between target t)
 	=> source a b -> target (t (u a)) (t (u b))
-(-<$$>>-) s = ((-<$>-) ((-<$>-) @source @target @u s))
-
--- TODO: Figure out how to work with hidden type variables
--- to put intermediate category `between`
+(<$$>) s = ((<$>) ((<$>) @source @between @u s))
 
-(-<$$$>-) :: forall t u v category a b
-	. (Covariant category category t, Covariant category category u, Covariant category category v) 
-	=> category a b -> category (t (u (v a))) (t (u (v b)))
-(-<$$$>-) s = ((-<$>-) @category @category @t ((-<$>-) @category @category @u ((-<$>-) @category @category @v s)))
+(<$$$>) :: forall source between1 between2 target t u v a b
+	. (Covariant source between1 v, Covariant between1 between2 u, Covariant between2 target t)
+	=> source a b -> target (t (u (v a))) (t (u (v b)))
+(<$$$>) s = ((<$>) @between2 @target ((<$>) @between1 @between2 @u ((<$>) @source @between1 @v s)))
 
-(-<$$$$>-) :: forall category t u v w a b
-	. (Covariant category category t, Covariant category category u, Covariant category category v, Covariant category category w) 
-	=> category a b -> category (t (u (v (w a)))) (t (u (v (w b))))
-(-<$$$$>-) s = ((-<$>-) @category @category @t ((-<$>-) @category @category @u ((-<$>-) @category @category @v ((-<$>-) @category @category @w s))))
+(<$$$$>) :: forall source between1 between2 between3 target t u v w a b
+	. (Covariant source between1 w, Covariant between1 between2 v, Covariant between2 between3 u, Covariant between3 target t)
+	=> source a b -> target (t (u (v (w a)))) (t (u (v (w b))))
+(<$$$$>) s = ((<$>) @between3 @target @t ((<$>) @between2 @between3 @u ((<$>) @between1 @between2 @v ((<$>) @source @between1 @w s))))
diff --git a/Pandora/Pattern/Functor/Distributive.hs b/Pandora/Pattern/Functor/Distributive.hs
--- a/Pandora/Pattern/Functor/Distributive.hs
+++ b/Pandora/Pattern/Functor/Distributive.hs
@@ -7,7 +7,7 @@
 
 > When providing a new instance, you should ensure it satisfies:
 > * Identity morphism: (identity -<<) . (identity -<<) ≡ identity
-> * Interchange collection: (f -<<) ≡ (identity -<<) . (f -<$>-)
+> * Interchange collection: (f -<<) ≡ (identity -<<) . (f <$>)
 -}
 
 infixl 5 -<<
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
@@ -2,7 +2,7 @@
 
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Paradigm.Primary.Transformer.Flip (Flip)
+import Pandora.Pattern.Morphism.Flip (Flip)
 
 infixl 4 >->
 
@@ -12,6 +12,6 @@
 > * Interpreted: f . g >-> h . i ≡ g >-> h . f >-> i
 -}
 
-class (forall i . Contravariant left target (Flip v i), forall i . Covariant right target (v i)) 
+class (forall i . Contravariant left target (Flip v i), forall i . Covariant right target (v i))
 	=> Divariant left right target v where
 	(>->) :: left a b -> right c d -> target (v b c) (v a d)
diff --git a/Pandora/Pattern/Functor/Extendable.hs b/Pandora/Pattern/Functor/Extendable.hs
--- a/Pandora/Pattern/Functor/Extendable.hs
+++ b/Pandora/Pattern/Functor/Extendable.hs
@@ -6,8 +6,8 @@
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
-> * Duplication interchange: (f -<$$>-) . (identity <<=) ≡ (identity <<=) . (f -<$>-)
-> * Extension interchange: (f <<=) ≡ (f -<$>-) . (identity <<=)
+> * Duplication interchange: (f -<$$>-) . (identity <<=) ≡ (identity <<=) . (f <$>)
+> * Extension interchange: (f <<=) ≡ (f <$>) . (identity <<=)
 -}
 
 class Covariant source source t => Extendable source t where
diff --git a/Pandora/Pattern/Functor/Monad.hs b/Pandora/Pattern/Functor/Monad.hs
--- a/Pandora/Pattern/Functor/Monad.hs
+++ b/Pandora/Pattern/Functor/Monad.hs
@@ -1,5 +1,6 @@
 module Pandora.Pattern.Functor.Monad where
 
+import Pandora.Pattern.Morphism.Straight (Straight)
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Bindable (Bindable)
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
@@ -19,7 +20,7 @@
 --infixl 1 >>=-, ->>=
 --infixr 1 -=<<, =<<-
 
-class (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t, Bindable (->) t) => Monad t where
+class (Covariant category category t, Monoidal (Straight category) category (:*:) (:*:) t, Bindable category t) => Monad category t where
 	--(>>=-) :: t a -> t b -> t a
 	--(>>=-) x y = x >>= \r -> y >>= \_ -> point r
 	--(->>=) :: t a -> t b -> t b
diff --git a/Pandora/Pattern/Functor/Monoidal.hs b/Pandora/Pattern/Functor/Monoidal.hs
--- a/Pandora/Pattern/Functor/Monoidal.hs
+++ b/Pandora/Pattern/Functor/Monoidal.hs
@@ -5,5 +5,5 @@
 
 type family Unit (p :: * -> * -> *) = r | r -> p
 
-class Semimonoidal p source target t => Monoidal p q source target t where
+class Semimonoidal p source target t => Monoidal p q source target t | p target -> source where
 	unit :: Proxy source -> p (q (Unit target) a) (t a)
diff --git a/Pandora/Pattern/Functor/Semimonoidal.hs b/Pandora/Pattern/Functor/Semimonoidal.hs
--- a/Pandora/Pattern/Functor/Semimonoidal.hs
+++ b/Pandora/Pattern/Functor/Semimonoidal.hs
@@ -2,5 +2,5 @@
 
 import Pandora.Pattern.Semigroupoid (Semigroupoid)
 
-class Semigroupoid p => Semimonoidal p source target t where
-	multiply :: p (source (t a) (t b)) (t (target a b))
+class Semigroupoid p => Semimonoidal p source target t | p target -> source where
+	mult :: 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
@@ -2,6 +2,7 @@
 
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
+import Pandora.Pattern.Morphism.Straight (Straight)
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 
 {- |
@@ -10,17 +11,17 @@
 
 > When providing a new instance, you should ensure it satisfies:
 > * Numeratority of traversing: g . (f <<--) ≡ (g . f <<--)
-> * Numeratority of sequencing: f . (identity <<--)= (identity <<--) . (f -<$>-)
+> * Numeratority of sequencing: f . (identity <<--)= (identity <<--) . (f <$>)
 > * Preserving point: p (point x) ≡ point x
-> * Preserving apply: f (x -<*>- y) ≡ f x -<*>- f y
+> * Preserving apply: f (x <-*- y) ≡ f x <-*- f y
 -}
 
 infixl 5 <<-, -<<-<<-
 
 class Covariant source target t => Traversable source target t where
-	(<<-) :: (Covariant source target u, Monoidal source target (:*:) (:*:) u) => source a (u b) -> target (t a) (u (t b))
+	(<<-) :: (Covariant source target u, Monoidal (Straight source) target (:*:) (:*:) u) => source a (u b) -> target (t a) (u (t b))
 
 (-<<-<<-) :: forall t u v category a b .
-	(Traversable category category t, Covariant category category u, Monoidal category category (:*:) (:*:) u, Traversable category category v) 
+	(Traversable category category t, Covariant category category u, Monoidal (Straight category) category (:*:) (:*:) u, Traversable category category v)
 	=> category a (u b) -> category (v (t a)) (u (v (t b)))
 (-<<-<<-) f = ((<<-) ((<<-) @category @category @t f))
diff --git a/Pandora/Pattern/Groupoid.hs b/Pandora/Pattern/Groupoid.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Groupoid.hs
@@ -0,0 +1,11 @@
+module Pandora.Pattern.Groupoid (Groupoid (..)) where
+
+import Pandora.Pattern.Category (Category)
+
+{- |
+> When providing a new instance, you should ensure it satisfies:
+> * Inversion absence: inversion . inversion ≡ identity
+-}
+
+class Category m => Groupoid m where
+  inversion :: m a b -> m b a
diff --git a/Pandora/Pattern/Morphism.hs b/Pandora/Pattern/Morphism.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Morphism.hs
@@ -0,0 +1,8 @@
+module Pandora.Pattern.Morphism (module Exports, Opposite) where
+
+import Pandora.Pattern.Morphism.Flip as Exports
+import Pandora.Pattern.Morphism.Straight as Exports
+
+type family Opposite m where
+	Opposite Straight = Flip
+	Opposite Flip = Straight
diff --git a/Pandora/Pattern/Morphism/Flip.hs b/Pandora/Pattern/Morphism/Flip.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Morphism/Flip.hs
@@ -0,0 +1,27 @@
+module Pandora.Pattern.Morphism.Flip where
+
+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.Core.Appliable (Appliable ((!)))
+
+newtype Flip (v :: * -> * -> *) a e = Flip (v e a)
+
+instance Semigroupoid m => Semigroupoid (Flip m) where
+  Flip g . Flip f = Flip (f . g)
+
+instance Category m => Category (Flip m) where
+	identity = Flip identity
+
+instance (Category m, Covariant m m t) => Contravariant (Flip m) m t where
+	(>$<) (Flip f) = (<$>) f
+
+instance (Category m, Covariant m m t) => Contravariant m (Flip m) t where
+	(>$<) f = Flip ((<$>) f)
+
+instance (Category m, Covariant m m t) => Covariant  (Flip m) (Flip m) t where
+	(<$>) (Flip f) = Flip ((<$>) f)
+
+instance Appliable (Flip m) b c m c b where
+	(!) (Flip m) = m
diff --git a/Pandora/Pattern/Morphism/Straight.hs b/Pandora/Pattern/Morphism/Straight.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Morphism/Straight.hs
@@ -0,0 +1,26 @@
+module Pandora.Pattern.Morphism.Straight where
+
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
+import Pandora.Pattern.Category (Category (identity))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Core.Appliable (Appliable ((!)))
+
+newtype Straight (v :: * -> * -> *) a e = Straight (v a e)
+
+instance Semigroupoid m => Semigroupoid (Straight m) where
+  Straight g . Straight f = Straight (g . f)
+
+instance Category m => Category (Straight m) where
+	identity = Straight identity
+
+instance Covariant m m t => Covariant (Straight m) m t where
+	(<$>) (Straight f) = (<$>) f
+
+instance Covariant m m t => Covariant m (Straight m) t where
+	(<$>) f = Straight ((<$>) f)
+
+instance Covariant m m t => Covariant (Straight m) (Straight m) t where
+	(<$>) (Straight f) = Straight ((<$>) f)
+
+instance Appliable (Straight m) c b m c b where
+	(!) (Straight m) = m
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
@@ -5,8 +5,8 @@
 
 {- |
 > When providing a new instance, you should ensure it satisfies one law:
-> * Identity morphism: hoist identity ≡ identity
-> * Interpreted of morphisms: hoist (f . g) ≡ hoist f . hoist g
+> * Identity morphism: (identity /|\) ≡ identity
+> * Interpreted of morphisms: (f . g /|\) ≡ (f /|\) . (g /|\)
 -}
 
 infixr 5 /|\
@@ -14,6 +14,3 @@
 class Hoistable t where
 	{-# MINIMAL (/|\) #-}
 	(/|\) :: (Covariant (->) (->) u) => u ~> v -> t u ~> t v
-
-	hoist :: (Covariant (->) (->) u) => u ~> v -> t u ~> t v
-	hoist = (/|\)
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.4.6
+version:             0.4.7
 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
@@ -23,6 +23,7 @@
     Pandora.Core
     Pandora.Core.Functor
     Pandora.Core.Impliable
+    Pandora.Core.Appliable
 
     Pandora.Paradigm
     -- Basic constructions
@@ -57,7 +58,8 @@
     Pandora.Paradigm.Primary.Transformer
     Pandora.Paradigm.Primary.Transformer.Backwards
     Pandora.Paradigm.Primary.Transformer.Reverse
-    Pandora.Paradigm.Primary.Transformer.Flip
+    Pandora.Pattern.Morphism.Flip
+    Pandora.Pattern.Morphism.Straight
     Pandora.Paradigm.Primary.Transformer.Continuation
     Pandora.Paradigm.Primary.Transformer.Construction
     Pandora.Paradigm.Primary.Transformer.Instruction
@@ -106,7 +108,6 @@
     Pandora.Paradigm.Structure.Ability
     Pandora.Paradigm.Structure.Ability.Morphable
     Pandora.Paradigm.Structure.Ability.Accessible
-    Pandora.Paradigm.Structure.Ability.Measurable
     Pandora.Paradigm.Structure.Ability.Substructure
     Pandora.Paradigm.Structure.Ability.Nonempty
     Pandora.Paradigm.Structure.Ability.Nullable
@@ -135,6 +136,8 @@
 	-- Algebra typeclasses
     Pandora.Pattern.Semigroupoid
     Pandora.Pattern.Category
+    Pandora.Pattern.Groupoid
+    Pandora.Pattern.Morphism
     -- Functor typeclassess
     Pandora.Pattern.Functor
     Pandora.Pattern.Functor.Adjoint