diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -789,3 +789,34 @@
 * Define `:*+*:` type operator
 
 # 0.5.6
+* Define `until` method for repeating actons until failure
+* Define `definitely` method to simplify `State` transformer
+* Define `magnify` method to `zoom` states in `State` transformers
+* Rename `<-||-` length encoding operators to `<<-|-`
+* Define  priority and fixity for `-+` length encoding operators
+* Define `<<-|-|-` length encoding operators
+* Define `:++*:` type operator
+* Rename `<--` type synonymous of `Flip (->)` to `--<`
+* Define generalised `Functor` typeclass
+* Define `Covariant_` type synonymous for `Functor` typeclass
+* Define `Contravariant_` type synonymous for `Functor` typeclass
+* Define `Kleisli` morphism
+* Define `Bindable_` type synonymous for `Functor` typeclass
+* Rename `Pattern.Transformer` module to `Pattern.Transformation`
+* Define `Component` experimental typeclass
+* Define `Transformation` experimental typeclass
+* Define experimental `Liftable_` type alias
+* Define experimental `lift_` method
+* Define experimental `Lowerable_` type alias
+* Define experimental `lower_` method
+* Define `Tensor` product in `Morphism` module
+* Define experimental `Semimonoidal_` type alias
+* Define `Operation` umbrella module in `Pattern`
+* Move `One` module from `Algebraic` to `Operation`
+* Move `Zero` module from `Algebraic` to `Operation`
+* Move `Exponential` module from `Algebraic` to `Operation`
+* Move `<:*:>`, `<:*:<`, `>:*:>`, `>:*:<` to `Algebraic` module
+* Move `Product` module from `Algebraic` to `Operation`
+* Move `Unit` type family to `Unit` module
+
+# 0.5.7
diff --git a/Pandora/Core/Interpreted.hs b/Pandora/Core/Interpreted.hs
--- a/Pandora/Core/Interpreted.hs
+++ b/Pandora/Core/Interpreted.hs
@@ -6,7 +6,7 @@
 import Pandora.Pattern.Morphism.Trip (Trip (Trip))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
 
 infixr 2 =#-, -#=
 
diff --git a/Pandora/Paradigm/Algebraic.hs b/Pandora/Paradigm/Algebraic.hs
--- a/Pandora/Paradigm/Algebraic.hs
+++ b/Pandora/Paradigm/Algebraic.hs
@@ -1,13 +1,11 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-module Pandora.Paradigm.Algebraic (module Exports, type (:+*+:), type (:*+*:)) where
+module Pandora.Paradigm.Algebraic (module Exports, type (<:*:>), type (<:*:<), type (>:*:>), type (>:*:<), type (:+*+:), type (:*+*:), type (:++*:), (<:*:>)) where
 
 import Pandora.Paradigm.Algebraic.Functor as Exports
-import Pandora.Paradigm.Algebraic.Exponential as Exports
-import Pandora.Paradigm.Algebraic.Product as Exports
-import Pandora.Paradigm.Algebraic.Sum as Exports
-import Pandora.Paradigm.Algebraic.Zero as Exports
-import Pandora.Paradigm.Algebraic.One as Exports
+import Pandora.Pattern.Operation.Product as Exports
+import Pandora.Pattern.Operation.Sum as Exports
 
+import Pandora.Core.Functor (type (>>>>>>))
 import Pandora.Core.Interpreted (Interpreted ((<~)))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
@@ -19,12 +17,29 @@
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
-import Pandora.Paradigm.Schemes.T_U (T_U (T_U))
+import Pandora.Pattern.Operation.Exponential (type (-->), type (--<))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>), type (>:.:>), type (<:.:<), type (>:.:<))
 
-instance (Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:*:> u) where
+infixr 5 <:*:>
+
+type (<:*:>) t u = t <:.:> u >>>>>> (:*:)
+type (>:*:>) t u = t >:.:> u >>>>>> (:*:)
+type (<:*:<) t u = t <:.:< u >>>>>> (:*:)
+type (>:*:<) t u = t >:.:< u >>>>>> (:*:)
+
+type (<:+:>) t u = t <:.:> u >>>>>> (:+:)
+type (>:+:>) t u = t >:.:> u >>>>>> (:+:)
+type (<:+:<) t u = t <:.:< u >>>>>> (:+:)
+type (>:+:<) t u = t >:.:< u >>>>>> (:+:)
+
+(<:*:>) :: t a -> u a -> t <:*:> u >>>>>> a
+(<:*:>) xs ys = T_U <--- xs :*: ys
+
+instance (Semimonoidal (--<) (:*:) (:*:) t, Semimonoidal (--<) (:*:) (:*:) u) => Semimonoidal (--<) (:*:) (:*:) (t <:*:> u) where
 	mult = Flip <-- \(T_U lrxys) ->
 		-- TODO: I need matrix transposing here
-		let ((lxs :*: lys) :*: (rxs :*: rys)) = (mult @(<--) <~) <-||-- (mult @(<--) <~) <-|- lrxys in
+		let ((lxs :*: lys) :*: (rxs :*: rys)) = (mult @(--<) <~) <<-|-- (mult @(--<) <~) <-|- lrxys in
 		T_U (lxs :*: rxs) :*: T_U (lys :*: rys)
 
 instance (Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <:*:> u) where
@@ -51,8 +66,8 @@
 instance Monoidal (-->) (-->) (:*:) (:*:) ((->) e) where
 	unit _ = Straight <-- constant . (<~ One)
 
-instance Semimonoidal (<--) (:*:) (:*:) ((->) e) where
-	mult :: ((e -> a) :*: (e -> b)) <-- (e -> a :*: b)
+instance Semimonoidal (--<) (:*:) (:*:) ((->) e) where
+	mult :: ((e -> a) :*: (e -> b)) --< (e -> a :*: b)
 	mult = Flip <-- \f -> attached . f :*: extract . f
 
 instance Semimonoidal (-->) (:*:) (:+:) ((:+:) e) where
@@ -71,20 +86,22 @@
 instance Monoidal (-->) (-->) (:*:) (:*:) ((:+:) e) where
 	unit _ = Straight <-- Adoption . (<~ One)
 
-instance Semimonoidal (<--) (:*:) (:*:) ((:*:) s) where
+instance Semimonoidal (--<) (:*:) (:*:) ((:*:) s) where
 	mult = Flip <-- \(s :*: x :*: y) -> (s :*: x) :*: (s :*: y)
 
-instance Monoidal (<--) (-->) (:*:) (:*:) ((:*:) s) where
+instance Monoidal (--<) (-->) (:*:) (:*:) ((:*:) s) where
 	unit _ = Flip <-- \(_ :*: x) -> Straight (\_ -> x)
 
 instance Comonad (->) ((:*:) s) where
 
-instance Semimonoidal (<--) (:*:) (:*:) (Flip (:*:) a) where
+instance Semimonoidal (--<) (:*:) (:*:) (Flip (:*:) a) where
 	mult = Flip <-- \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
 
-instance Monoidal (<--) (-->) (:*:) (:*:) (Flip (:*:) a) where
+instance Monoidal (--<) (-->) (:*:) (:*:) (Flip (:*:) a) where
 	unit _ = Flip <-- \(Flip (s :*: _)) -> Straight (\_ -> s)
 
 type (:+*+:) l r = (l :+: r) :*: (r :+: l)
 
 type (:*+*:) l r = (l :*: r) :+: (r :*: l)
+
+type (:++*:) l r = (l :+: r) :+: (l :*: r)
diff --git a/Pandora/Paradigm/Algebraic/Exponential.hs b/Pandora/Paradigm/Algebraic/Exponential.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Algebraic/Exponential.hs
+++ /dev/null
@@ -1,69 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-module Pandora.Paradigm.Algebraic.Exponential where
-
-import Pandora.Pattern.Betwixt (Betwixt)
-import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (Category ((<--), identity))
-import Pandora.Pattern.Kernel (Kernel (constant))
-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.Object.Semigroup (Semigroup ((+)))
-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-
-infixr 7 .:..
-infixr 9 %
-infixl 1 &
-
-type instance Betwixt (->) (->) = (->)
-
-instance Semigroupoid (->) where
-	f . g = \x -> f (g x)
-
-instance Category (->) where
-	identity x = x
-
-instance Kernel (->) where
-	constant x _ = x
-
-instance Covariant (->) (->) ((->) a) where
-	(<-|-) = (.)
-
-instance Distributive (->) (->) ((->) e) where
-	f -<< g = \e -> f % e <-|- g
-
-instance Bindable (->) ((->) e) where
-	f =<< g = \x -> f <-- g x <-- x
-
-instance Semigroup r => Semigroup (e -> r) where
-	f + g = \e -> f e + g e
-
-instance Ringoid r => Ringoid (e -> r) where
-	f * g = \e -> f e * g e
-
-type (<--) = Flip (->)
-
-instance Contravariant (->) (->) ((<--) a) where
-	f >-|- Flip g = Flip <-- g . f
-
-type (-->) = Straight (->)
-
-instance Covariant (->) (->) ((-->) b) where
-	f <-|- Straight g = Straight <-- f . g
-
-(.:..) :: (Covariant (->) target (v a), Semigroupoid v) => v c d -> target (v a (v b c)) (v a (v b d))
-(.:..) f = (<-|-) (f .)
-
-{-# INLINE (%) #-}
-(%) :: (a -> b -> c) -> b -> a -> c
-(%) f x y = f y x
-
-{-# INLINE (&) #-}
-(&) :: a -> (a -> b) -> b
-x & f = f x
-
-fix :: (a -> a) -> a
-fix f = let x = f x in x
diff --git a/Pandora/Paradigm/Algebraic/Functor.hs b/Pandora/Paradigm/Algebraic/Functor.hs
--- a/Pandora/Paradigm/Algebraic/Functor.hs
+++ b/Pandora/Paradigm/Algebraic/Functor.hs
@@ -2,6 +2,7 @@
 module Pandora.Paradigm.Algebraic.Functor where
 
 import Pandora.Core.Interpreted (Interpreted ((<~), (<~~~), (-#=), run))
+import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Kernel (constant)
@@ -11,41 +12,38 @@
 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), Unit)
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->), type (<--), (&))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Algebraic.Zero (Zero, absurd)
-import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Pattern.Operation.Zero (Zero, absurd)
+import Pandora.Pattern.Operation.Exponential (type (-->), type (--<), (&))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:) (Option, Adoption))
 import Pandora.Paradigm.Primary.Functor.Proxy (Proxy (Proxy))
 
-infixl 1 <-*------, <-||-----, >-||-----
-infixl 2 <-*-----, <-||----, >-||----
-infixl 3 <-*----, <-||---, >-||---
-infixl 4 <-*---, <-*-*-, <-||--, >-||--
-infixl 5 <-*--, <-||-, >-||-
+infixl 1 <-*------, <<-|-----, <<-|-|---, >-||-----
+infixl 2 <-*-----, <<-|----, <<-|-|--, >-||----
+infixl 3 <-*----, <<-|---, <<-|-|-, >-||---
+infixl 4 <-*---, <-*-*-, <<-|--, >-||--
+infixl 5 <-*--, <<-|-, >-||-
 infixl 6 <-*-, <-+-
 
-infixr 1 --------*
-infixr 2 -------*
-infixr 3 ------*
-infixr 4 -----*
-infixr 5 ----*, -*-*-
-infixr 6 ---*
-infixr 7 --*
+infixr 1 --------*, --------+
+infixr 2 -------*, -------+
+infixr 3 ------*, ------+
+infixr 4 -----*, -----+
+infixr 5 ----*, ----+, -*-*-
+infixr 6 ---*, ---+
+infixr 7 --*, --+
 infixr 8 -*, -+
 
 infixl 6 <-|-<-|-, <-|->-|-, >-|-<-|-, >-|->-|-
 
-type instance Unit (:*:) = One
-type instance Unit (:+:) = Zero
-
 type Applicative t = (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:*:) t)
 type Alternative t = (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t, Monoidal (-->) (-->) (:*:) (:+:) t)
-type Divisible t = (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Monoidal (-->) (<--) (:*:) (:*:) t)
-type Decidable t = (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:+:) t, Monoidal (-->) (<--) (:*:) (:+:) t)
+type Divisible t = (Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t, Monoidal (-->) (--<) (:*:) (:*:) t)
+type Decidable t = (Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:+:) t, Monoidal (-->) (--<) (:*:) (:+:) t)
 
 instance Adjoint (->) (->) ((:*:) s) ((->) s) where
 	(-|) :: ((s :*: a) -> b) -> a -> (s -> b)
@@ -94,15 +92,18 @@
 x --+ y = (\r -> case r of Option rx -> rx; Adoption ry -> ry) <-|--- mult @(-->) <~~~ x :*: y
 x -+ y = (\r -> case r of Option rx -> rx; Adoption ry -> ry) <-|--- mult @(-->) <~~~ x :*: y
 
-loop :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t a -> t b
-loop x = let r = x -* r in r
+loop :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t a -> t a
+loop x = x -* loop x
 
-type Extractable t = Monoidal (<--) (-->) (:*:) (:*:) t
+until :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t, Monoidal (-->) (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:+:) t) => t a -> t ()
+until x = x -* until x --+ pass
+
+type Extractable t = Monoidal (--<) (-->) (:*:) (:*:) t
 type Pointable t = Monoidal (-->) (-->) (:*:) (:*:) t
 type Emptiable t = Monoidal (-->) (-->) (:*:) (:+:) t
 
 extract :: Extractable t => t a -> a
-extract j = unit @(<--) @(-->) Proxy <~ j <~ One
+extract j = unit @(--<) @(-->) Proxy <~ j <~ One
 
 point :: Pointable t => a -> t a
 point x = unit @(-->) Proxy <~~~ Straight <-- \One -> x
@@ -113,38 +114,34 @@
 empty :: Emptiable t => t a
 empty = unit @(-->) Proxy <~ Straight absurd
 
--- TODO: Rename <-||- to <<-|-
-(<-||-), (<-||--), (<-||---), (<-||----), (<-||-----), (<-||------), (<-||-------), (<-||--------)
+-- TODO: define priority, remove those operators that are longer than 9 symbols
+(<<-|-), (<<-|--), (<<-|---), (<<-|----), (<<-|-----)
 	:: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c .
 	(Covariant m m (Flip p c), Interpreted m (Flip p c)) => m a b -> m (p a c) (p b c)
-(<-||--------) f = (-#=) @m @(Flip p c) ((<-|-) f)
-(<-||-------) f = (-#=) @m @(Flip p c) ((<-|-) f)
-(<-||------) f = (-#=) @m @(Flip p c) ((<-|-) f)
-(<-||-----) f = (-#=) @m @(Flip p c) ((<-|-) f)
-(<-||----) f = (-#=) @m @(Flip p c) ((<-|-) f)
-(<-||---) f = (-#=) @m @(Flip p c) ((<-|-) f)
-(<-||--) f = (-#=) @m @(Flip p c) ((<-|-) f)
-(<-||-) f = (-#=) @m @(Flip p c) ((<-|-) f)
+(<<-|-----) f = (-#=) @m @(Flip p c) ((<-|-) f)
+(<<-|----) f = (-#=) @m @(Flip p c) ((<-|-) f)
+(<<-|---) f = (-#=) @m @(Flip p c) ((<-|-) f)
+(<<-|--) f = (-#=) @m @(Flip p c) ((<-|-) f)
+(<<-|-) f = (-#=) @m @(Flip p c) ((<-|-) f)
 
+(<<-|-|-), (<<-|-|--), (<<-|-|---) :: forall (m :: * -> * -> *) (p :: * -> * -> *) (t :: * -> *) a b c .
+	(Covariant m m (Flip p c), Covariant m (Betwixt m m) t, Covariant m (Betwixt m m) (Flip p c), Covariant (Betwixt m m) m (Flip p c), Interpreted m (Flip p c)) => m a b -> m (p (t a) c) (p (t b) c)
+(<<-|-|---) f = (-#=) @m @(Flip p c) ((<-|-|-) f)
+(<<-|-|--) f = (-#=) @m @(Flip p c) ((<-|-|-) f)
+(<<-|-|-) f = (-#=) @m @(Flip p c) ((<-|-|-) f)
+
 -- TODO: Rename <-|||- to <<<-|-
-(<-|||-), (<-|||--), (<-|||---), (<-|||----), (<-|||-----), (<-|||------), (<-|||-------), (<-|||--------)
+(<-|||-), (<-|||--), (<-|||---), (<-|||----)
 	:: forall (m :: * -> * -> *) (v :: * -> * -> * -> *) a b c d .
 	(Covariant m m (Trip v d c), Interpreted m (Trip v d c)) => m a b -> m (v a c d) (v b c d)
-(<-|||--------) f = (-#=) @m @(Trip v d c) ((<-|-) f)
-(<-|||-------) f = (-#=) @m @(Trip v d c) ((<-|-) f)
-(<-|||------) f = (-#=) @m @(Trip v d c) ((<-|-) f)
-(<-|||-----) f = (-#=) @m @(Trip v d c) ((<-|-) f)
 (<-|||----) f = (-#=) @m @(Trip v d c) ((<-|-) f)
 (<-|||---) f = (-#=) @m @(Trip v d c) ((<-|-) f)
 (<-|||--) f = (-#=) @m @(Trip v d c) ((<-|-) f)
 (<-|||-) f = (-#=) @m @(Trip v d c) ((<-|-) f)
 
-(>-||-), (>-||--), (>-||---), (>-||----), (>-||-----), (>-||------), (>-||-------), (>-||--------)
+(>-||-), (>-||--), (>-||---), (>-||----), (>-||-----)
 	:: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c .
 	(Contravariant m m (Flip p c), Interpreted m (Flip p c)) => m a b -> m (p b c) (p a c)
-(>-||--------) f = (-#=) @m @(Flip p c) ((>-|-) f)
-(>-||-------) f = (-#=) @m @(Flip p c) ((>-|-) f)
-(>-||------) f = (-#=) @m @(Flip p c) ((>-|-) f)
 (>-||-----) f = (-#=) @m @(Flip p c) ((>-|-) f)
 (>-||----) f = (-#=) @m @(Flip p c) ((>-|-) f)
 (>-||---) f = (-#=) @m @(Flip p c) ((>-|-) f)
diff --git a/Pandora/Paradigm/Algebraic/One.hs b/Pandora/Paradigm/Algebraic/One.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Algebraic/One.hs
+++ /dev/null
@@ -1,3 +0,0 @@
-module Pandora.Paradigm.Algebraic.One where
-
-data One = One
diff --git a/Pandora/Paradigm/Algebraic/Product.hs b/Pandora/Paradigm/Algebraic/Product.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Algebraic/Product.hs
+++ /dev/null
@@ -1,75 +0,0 @@
-module Pandora.Paradigm.Algebraic.Product where
-
-import Pandora.Core.Functor (type (>>>>>>))
-import Pandora.Pattern.Category ((<---))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
-import Pandora.Pattern.Object.Setoid (Setoid ((==)))
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Pattern.Object.Quasiring (Quasiring (one))
-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
-import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>), type (>:.:>), type (<:.:<), type (>:.:<))
-
-infixr 7 :*:
-infixr 5 <:*:>
-
--- TODO Define :*:*:, :*:*:*:, ...
-
-data (:*:) s a = s :*: a
-
-instance Covariant (->) (->) ((:*:) s) where
-	f <-|- ~(s :*: x) = s :*: f x
-
-instance Covariant (->) (->) (Flip (:*:) a) where
-	f <-|- Flip (x :*: y) = Flip (f x :*: y)
-
-instance Extendable (->) ((:*:) s) where
-	f <<= ~(s :*: x) = s :*: f (s :*: x)
-
-instance (Setoid s, Setoid a) => Setoid (s :*: a) where
-	~(sx :*: x) == ~(sy :*: y) = (sx == sy) * (x == y)
-
-instance (Semigroup s, Semigroup a) => Semigroup (s :*: a) where
-	~(sx :*: x) + ~(sy :*: y) = (sx + sy) :*: (x + y)
-
-instance (Monoid s, Monoid a) => Monoid (s :*: a) where
-	zero = zero :*: zero
-
-instance (Ringoid s, Ringoid a) => Ringoid (s :*: a) where
-	~(sx :*: x) * ~(sy :*: y) = (sx * sy) :*: (x * y)
-
-instance (Quasiring s, Quasiring a) => Quasiring (s :*: a) where
-	one = one :*: one
-
-instance (Infimum s, Infimum a) => Infimum (s :*: a) where
-	~(sx :*: x) /\ ~(sy :*: y) = sx /\ sy :*: x /\ y
-
-instance (Supremum s, Supremum a) => Supremum (s :*: a) where
-	~(sx :*: x) \/ ~(sy :*: y) = sx \/ sy :*: x \/ y
-
-instance (Lattice s, Lattice a) => Lattice (s :*: a) where
-
-instance (Group s, Group a) => Group (s :*: a) where
-	invert ~(s :*: x) = invert s :*: invert x
-
-delta :: a -> a :*: a
-delta x = x :*: x
-
-swap :: a :*: b -> b :*: a
-swap ~(x :*: y) = y :*: x
-
-attached :: a :*: b -> a
-attached ~(x :*: _) = x
-
-type (<:*:>) t u = t <:.:> u >>>>>> (:*:)
-type (>:*:>) t u = t >:.:> u >>>>>> (:*:)
-type (<:*:<) t u = t <:.:< u >>>>>> (:*:)
-type (>:*:<) t u = t >:.:< u >>>>>> (:*:)
-
-(<:*:>) :: t a -> u a -> t <:*:> u >>>>>> a
-(<:*:>) xs ys = T_U <--- xs :*: ys
diff --git a/Pandora/Paradigm/Algebraic/Sum.hs b/Pandora/Paradigm/Algebraic/Sum.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Algebraic/Sum.hs
+++ /dev/null
@@ -1,35 +0,0 @@
-module Pandora.Paradigm.Algebraic.Sum where
-
-import Pandora.Core.Functor (type (>>>>>>))
-import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Paradigm.Algebraic.Exponential ()
-import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Paradigm.Schemes.T_U (type (<:.:>), type (>:.:>), type (<:.:<), type (>:.:<))
-
-infixr 7 :+:
-
-data (:+:) o a = Option o | Adoption a
-
-instance Covariant (->) (->) ((:+:) o) where
-	_ <-|- Option s = Option s
-	f <-|- Adoption x = Adoption <-- f x
-
-instance Covariant (->) (->) (Flip (:+:) a) where
-	_ <-|- Flip (Adoption x) = Flip . Adoption <-- x
-	f <-|- Flip (Option y) = Flip . Option <-- f y
-
-sum :: (e -> r) -> (a -> r) -> e :+: a -> r
-sum f _ (Option x) = f x
-sum _ s (Adoption x) = s x
-
--- TODO: keep it until we realize how to implement n-ary functors
-bitraverse_sum :: Covariant (->) (->) t => (e -> t e') -> (a -> t a') -> (e :+: a) -> t (e' :+: a')
-bitraverse_sum f _ (Option x) = Option <-|- f x
-bitraverse_sum _ g (Adoption x) = Adoption <-|- g x
-
-type (<:+:>) t u = t <:.:> u >>>>>> (:+:)
-type (>:+:>) t u = t >:.:> u >>>>>> (:+:)
-type (<:+:<) t u = t <:.:< u >>>>>> (:+:)
-type (>:+:<) t u = t >:.:< u >>>>>> (:+:)
diff --git a/Pandora/Paradigm/Algebraic/Zero.hs b/Pandora/Paradigm/Algebraic/Zero.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Algebraic/Zero.hs
+++ /dev/null
@@ -1,8 +0,0 @@
-{-# LANGUAGE EmptyCase #-}
-
-module Pandora.Paradigm.Algebraic.Zero where
-
-data Zero
-
-absurd :: Zero -> a
-absurd x = case x of {}
diff --git a/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs b/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Adaptable.hs
@@ -6,9 +6,9 @@
 import Pandora.Pattern.Category (Category (identity))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
-import Pandora.Pattern.Transformer (Liftable (lift))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Pattern.Transformation (Liftable (lift))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.Product ((:*:))
 import Pandora.Paradigm.Algebraic (Pointable, extract, point)
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly)
 import Pandora.Paradigm.Controlflow.Effect.Transformer (Monadic, wrap, (:>))
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
@@ -14,11 +14,11 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=), (<<==)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
-import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.Product ((:*:)((:*:)))
+import Pandora.Pattern.Operation.One (One (One))
 import Pandora.Paradigm.Algebraic (Extractable, point)
 import Pandora.Paradigm.Schemes (Schematic)
 
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
@@ -14,13 +14,13 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (Pointable, point)
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.Product ((:*:)((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (Pointable, point, empty)
 import Pandora.Paradigm.Schemes (Schematic)
 
 class Interpreted m t => Monadic m t where
@@ -45,6 +45,9 @@
 	mult = Straight <-- \(TM f :*: TM x) -> TM
 		<---- mult @(-->) @(:*:) @(:+:)
 			<~~~ f :*: x
+
+instance Monoidal (-->) (-->) (:*:) (:+:) (Schematic Monad t u) => Monoidal (-->) (-->) (:*:) (:+:) (t :> u) where
+	unit _ = Straight <-- \_ -> TM empty
 
 instance Traversable (->) (->) (Schematic Monad t u) => Traversable (->) (->) (t :> u) where
 	f <-/- TM x = TM <-|-- f <-/- x
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
@@ -6,8 +6,8 @@
 import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.Product ((:*:))
 import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
 
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -1,6 +1,6 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-module Pandora.Paradigm.Inventory (module Exports, zoom, overlook, probably, (=<>), (~<>)) where
+module Pandora.Paradigm.Inventory (module Exports, zoom, magnify, overlook, probably, definitely, (=<>), (~<>)) where
 
 import Pandora.Paradigm.Inventory.Ability as Exports
 import Pandora.Paradigm.Inventory.Some as Exports
@@ -8,16 +8,16 @@
 import Pandora.Core.Functor (type (>>>))
 import Pandora.Core.Interpreted (run, (<~))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----))
+import Pandora.Pattern.Category ((<--), (<---))
 import Pandora.Pattern.Kernel (constant)
-import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (--|), (|-), (|--)))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (--|), (|-), (|--), (|---)))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Exponential ((%), type (<--))
-import Pandora.Paradigm.Algebraic (Pointable, extract)
+import Pandora.Paradigm.Primary.Functor.Exactly (Exactly)
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Exponential ((%), type (--<))
+import Pandora.Paradigm.Algebraic.Functor (Pointable, extract, (<<-|-))
 import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.TUT (TUT (TUT))
@@ -37,20 +37,31 @@
 	g |- x = run . g |-- run x
 
 zoom :: forall bg ls u result . Lens u bg ls -> State (u ls) result -> State bg result
-zoom lens less = State <-- \source -> restruct |- run (lens <~ source) where
+zoom lens less = State <-- \source -> restruct |--- run <-- lens <~ source where
 
 	restruct :: (u ls -> bg) -> u ls -> bg :*: result
-	restruct to target = run @(->) <---- to <-|- Flip <-- less <~ target
+	restruct to target = to <<-|- less <~ target
 
-overlook :: (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => State s result -> State (t s) (t result)
-overlook (State state) = State <-- \ts -> mult @(<--) @(:*:) @(:*:) <~ (state <-|- ts)
+-- TODO: Could we make it fully Stateful?
+magnify :: forall bg ls t u result . Covariant (->) (->) t
+	=> Lens u bg ls -> State (u ls) :> t >>> result -> State bg :> t >>> result 
+magnify lens less = TM . TUT <-- \source -> restruct |--- run <-- lens <~ source where
 
+	restruct :: (u ls -> bg) -> u ls -> t (bg :*: result)
+	restruct to target = (to <<-|-) <-|- less <~ target
+
+overlook :: (Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t) => State s result -> State (t s) (t result)
+overlook (State state) = State <-- \ts -> mult @(--<) @(:*:) @(:*:) <~ (state <-|- ts)
+
 -- TODO: it's better to rename it to `perhaps` but this name is already taken
 -- `Perhaps` and `Accessibe` typeclasses should be generalized to only one
 probably :: State s :> Maybe >>> result -> State s (Maybe result)
 probably (TM (TUT state)) = State <-- \old -> case state old of
 	Just (new :*: r) -> new :*: Just r
 	Nothing -> old :*: Nothing
+
+definitely :: State s :> Exactly >>> result -> State s result
+definitely (TM (TUT state)) = State <-- extract . state
 
 (=<>) :: (Pointable available, Stateful src t)
 	=> Lens available src tgt -> tgt -> t src
diff --git a/Pandora/Paradigm/Inventory/Some/Accumulator.hs b/Pandora/Paradigm/Inventory/Some/Accumulator.hs
--- a/Pandora/Paradigm/Inventory/Some/Accumulator.hs
+++ b/Pandora/Paradigm/Inventory/Some/Accumulator.hs
@@ -11,8 +11,8 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Object.Monoid (Monoid)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
diff --git a/Pandora/Paradigm/Inventory/Some/Equipment.hs b/Pandora/Paradigm/Inventory/Some/Equipment.hs
--- a/Pandora/Paradigm/Inventory/Some/Equipment.hs
+++ b/Pandora/Paradigm/Inventory/Some/Equipment.hs
@@ -9,7 +9,7 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Paradigm.Algebraic ()
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), attached)
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)), attached)
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Inventory.Ability.Gettable (Gettable (Getting, get))
 import Pandora.Paradigm.Schemes (Schematic, TU (TU), type (<:.>))
diff --git a/Pandora/Paradigm/Inventory/Some/Optics.hs b/Pandora/Paradigm/Inventory/Some/Optics.hs
--- a/Pandora/Paradigm/Inventory/Some/Optics.hs
+++ b/Pandora/Paradigm/Inventory/Some/Optics.hs
@@ -12,14 +12,14 @@
 import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Object.Setoid (Setoid ((?=)))
 import Pandora.Paradigm.Inventory.Ability.Gettable (Gettable (Getting, get))
 import Pandora.Paradigm.Inventory.Ability.Settable (Settable (Setting, set))
 import Pandora.Paradigm.Inventory.Ability.Modifiable (Modifiable (Modification, modify))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->), (%))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Exponential (type (-->), (%))
 import Pandora.Paradigm.Algebraic (Pointable, point, extract, (>-||---))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
diff --git a/Pandora/Paradigm/Inventory/Some/Provision.hs b/Pandora/Paradigm/Inventory/Some/Provision.hs
--- a/Pandora/Paradigm/Inventory/Some/Provision.hs
+++ b/Pandora/Paradigm/Inventory/Some/Provision.hs
@@ -11,10 +11,10 @@
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Paradigm.Algebraic.Exponential (type (-->), (%))
-import Pandora.Paradigm.Algebraic ((<-||-))
-import Pandora.Paradigm.Algebraic.Product ((:*:))
-import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Pattern.Operation.Exponential (type (-->), (%))
+import Pandora.Paradigm.Algebraic ((<<-|-))
+import Pandora.Pattern.Operation.Product ((:*:))
+import Pandora.Pattern.Operation.One (One (One))
 import Pandora.Paradigm.Algebraic (point)
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
@@ -32,7 +32,7 @@
 	f >-|- Flip (Provision g) = Flip . Provision <-- g . f
 
 instance Semimonoidal (-->) (:*:) (:*:) (Provision e) where
-	mult = Straight <-- Provision . (mult @(-->) <~) . (run <-||-) . (run @(->) <-|-)
+	mult = Straight <-- Provision . (mult @(-->) <~) . (run <<-|-) . (run @(->) <-|-)
 
 instance Monoidal (-->) (-->) (:*:) (:*:) (Provision e) where
 	unit _ = Straight <-- \f -> Provision <-- \_ -> run f One
diff --git a/Pandora/Paradigm/Inventory/Some/State.hs b/Pandora/Paradigm/Inventory/Some/State.hs
--- a/Pandora/Paradigm/Inventory/Some/State.hs
+++ b/Pandora/Paradigm/Inventory/Some/State.hs
@@ -20,10 +20,10 @@
 import Pandora.Paradigm.Inventory.Ability.Gettable (Gettable (Getting, get))
 import Pandora.Paradigm.Inventory.Ability.Settable (Settable (Setting, set))
 import Pandora.Paradigm.Inventory.Ability.Modifiable (Modifiable (Modification, modify))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Pattern.Operation.Exponential (type (-->))
 import Pandora.Paradigm.Algebraic ((:*:) ((:*:)), delta)
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (Pointable, point, (<-||-), (>-||-))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (Pointable, point, (<<-|-), (>-||-))
 import Pandora.Paradigm.Schemes (Schematic, TUT (TUT), type (<:<.>:>))
 
 -- | Effectful computation with a variable
@@ -47,7 +47,7 @@
 instance Monad (->) (State s) where
 
 instance Invariant (Flip State r) where
-	f <!< g = (((g >-||-) . ((f <-||-) <-|-) =#-) =#-)
+	f <!< g = (((g >-||-) . ((f <<-|-) <-|-) =#-) =#-)
 
 instance Interpreted (->) (State s) where
 	type Primary (State s) a = (->) s :. (:*:) s >>> a
diff --git a/Pandora/Paradigm/Inventory/Some/Store.hs b/Pandora/Paradigm/Inventory/Some/Store.hs
--- a/Pandora/Paradigm/Inventory/Some/Store.hs
+++ b/Pandora/Paradigm/Inventory/Some/Store.hs
@@ -13,9 +13,9 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->), (%), (.:..))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), attached)
-import Pandora.Paradigm.Algebraic (extract, (<-||-), (>-||-))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->), (%), (.:..))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)), attached)
+import Pandora.Paradigm.Algebraic (extract, (<<-|-), (>-||-))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
@@ -29,12 +29,12 @@
 instance Covariant (->) (->) (Store s) where
 	(<-|-) f = (=#-) (f <-|-|-)
 
-instance Semimonoidal (<--) (:*:) (:*:) (Store s) where
+instance Semimonoidal (--<) (:*:) (:*:) (Store s) where
 	mult = Flip <-- \(Store (s :*: f)) ->
 		let (x :*: y) = f s in
 		Store (s :*: constant x) :*: Store (s :*: constant y)
 
-instance Monoidal (<--) (-->) (:*:) (:*:) (Store s) where
+instance Monoidal (--<) (-->) (:*:) (:*:) (Store s) where
 	unit _ = Flip <-- Straight . constant . ((<--) |-) . run
 
 -- TODO: Try to generalize (->) here
@@ -44,7 +44,7 @@
 instance Comonad (->) (Store s) where
 
 instance Invariant (Flip Store r) where
-	f <!< g = (((f <-||-) . ((g >-||-) <-|-) =#-) =#-)
+	f <!< g = (((f <<-|-) . ((g >-||-) <-|-) =#-) =#-)
 
 instance Interpreted (->) (Store s) where
 	type Primary (Store s) a = (:*:) s :. (->) s >>> a
diff --git a/Pandora/Paradigm/Primary.hs b/Pandora/Paradigm/Primary.hs
--- a/Pandora/Paradigm/Primary.hs
+++ b/Pandora/Paradigm/Primary.hs
@@ -12,10 +12,10 @@
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category ((<---))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-), (-|)))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Algebraic.One (One)
-import Pandora.Paradigm.Algebraic.Zero (Zero)
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:))
+import Pandora.Pattern.Operation.One (One)
+import Pandora.Pattern.Operation.Zero (Zero)
 import Pandora.Paradigm.Schemes (TU, T_U, UT, TUT)
 
 instance Adjoint (->) (->) (Flip (:*:) s) ((->) s) where
diff --git a/Pandora/Paradigm/Primary/Auxiliary.hs b/Pandora/Paradigm/Primary/Auxiliary.hs
--- a/Pandora/Paradigm/Primary/Auxiliary.hs
+++ b/Pandora/Paradigm/Primary/Auxiliary.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Operation.Exponential ()
 
 data Vertical a = Up a | Down a
 
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
@@ -4,6 +4,7 @@
 import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Morphism.Kleisli (Kleisli (Kleisli))
 import Pandora.Pattern.Category (identity, (<--), (<---), (<----))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -11,24 +12,35 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor (Functor ((-|-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:) (Option, Adoption))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.One (One (One))
 import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))
 
 -- TODO: rename it to Progress = Stop e | Continue a
 -- it would be a more generalized and semantic-based name
 data Conclusion e a = Failure e | Success a
+
+instance Functor (-->) (-->) (Conclusion e) where
+	(-|-) (Straight f) = Straight <-- \case
+		Success x -> Success <-- f x
+		Failure y -> Failure y
+
+instance Functor (Kleisli (Conclusion e) (->)) (-->) (Conclusion e) where
+	(-|-) (Kleisli f) = Straight <-- \case
+		Failure e -> Failure e
+		Success x -> f x
 
 instance Covariant (->) (->) (Conclusion e) where
 	f <-|- Success x = Success <-- f x
diff --git a/Pandora/Paradigm/Primary/Functor/Constant.hs b/Pandora/Paradigm/Primary/Functor/Constant.hs
--- a/Pandora/Paradigm/Primary/Functor/Constant.hs
+++ b/Pandora/Paradigm/Primary/Functor/Constant.hs
@@ -14,7 +14,7 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Operation.Exponential ()
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 
 newtype Constant a b = Constant a
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
@@ -2,22 +2,28 @@
 
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
+import Pandora.Pattern.Functor (Functor ((-|-)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->), type (<--))
-import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Pattern.Operation.Exponential (type (-->), type (--<))
+import Pandora.Pattern.Operation.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Algebraic ()
 
 data Convergence r a = Convergence (a -> a -> r)
 
+instance Functor (-->) (--<) (Convergence r) where
+	(-|-) (Straight f) = Flip <-- \case
+		Convergence g -> Convergence <-- \x y -> g <-- f x <-- f y
+
 instance Contravariant (->) (->) (Convergence r) where
 	f >-|- Convergence g = Convergence <-- \x y -> g <-- f x <-- f y
 
 instance Semigroup r => Semimonoidal (-->) (:*:) (:*:) (Convergence r) where
 	mult = Straight <-- \(Convergence f :*: Convergence g) -> Convergence <-- \(a :*: b) (a' :*: b') -> f a a' + g b b'
 
-instance Monoid r => Monoidal (-->) (<--) (:*:) (:*:) (Convergence r) where
+instance Monoid r => Monoidal (-->) (--<) (:*:) (:*:) (Convergence r) where
 	unit _ = Straight <-- \_ -> Convergence <-- \_ _ -> zero
diff --git a/Pandora/Paradigm/Primary/Functor/Edges.hs b/Pandora/Paradigm/Primary/Functor/Edges.hs
--- a/Pandora/Paradigm/Primary/Functor/Edges.hs
+++ b/Pandora/Paradigm/Primary/Functor/Edges.hs
@@ -3,7 +3,7 @@
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Operation.Exponential ()
 import Pandora.Paradigm.Algebraic (point)
 
 data Edges a = Empty | Leap a | Connect a | Overlay a
diff --git a/Pandora/Paradigm/Primary/Functor/Endo.hs b/Pandora/Paradigm/Primary/Functor/Endo.hs
--- a/Pandora/Paradigm/Primary/Functor/Endo.hs
+++ b/Pandora/Paradigm/Primary/Functor/Endo.hs
@@ -6,8 +6,8 @@
 import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Algebraic.Exponential ()
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Exponential ()
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic ((>-|-<-|-))
 
 newtype Endo a = Endo { endo :: a -> a }
diff --git a/Pandora/Paradigm/Primary/Functor/Exactly.hs b/Pandora/Paradigm/Primary/Functor/Exactly.hs
--- a/Pandora/Paradigm/Primary/Functor/Exactly.hs
+++ b/Pandora/Paradigm/Primary/Functor/Exactly.hs
@@ -1,10 +1,12 @@
 module Pandora.Paradigm.Primary.Functor.Exactly where
 
 import Pandora.Core.Interpreted ((<~))
-import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Morphism.Kleisli (Kleisli (Kleisli))
+import Pandora.Pattern.Morphism.Tensor (Tensor (Tensor))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -15,6 +17,8 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Pattern.Functor (Functor ((-|-)))
+import Pandora.Pattern.Transformation (Component (component))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
@@ -24,26 +28,40 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (extract, (<-||-))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (extract, (<<-|-))
 
 newtype Exactly a = Exactly a
 
+instance Functor (-->) (-->) Exactly where
+	(-|-) (Straight f) = Straight <-- \case
+		Exactly x -> Exactly <-- f x
+
+instance Functor (Kleisli Exactly (->)) (-->) Exactly where
+	(-|-) (Kleisli f) = Straight <-- \case
+		Exactly x -> f x
+
+instance Component (Tensor (:*:) (-->) (:*:)) Exactly Exactly where
+	component = Tensor . Straight <-- \(Exactly l :*: Exactly r) -> Exactly (l :*: r)
+
+instance Component (Tensor (:*:) (--<) (:*:)) Exactly Exactly where
+	component = Tensor . Flip <-- \(Exactly (l :*: r)) -> Exactly l :*: Exactly r
+
 instance Covariant (->) (->) Exactly where
 	f <-|- Exactly x = Exactly <-- f x
 
 instance Semimonoidal (-->) (:*:) (:*:) Exactly where
-	mult = Straight <-- Exactly . (extract <-||-) .  (extract <-|-)
+	mult = Straight <-- Exactly . (extract <<-|-) .  (extract <-|-)
 
 instance Monoidal (-->) (-->) (:*:) (:*:) Exactly where
 	unit _ = Straight <-- Exactly . (<~ One)
 
-instance Semimonoidal (<--) (:*:) (:*:) Exactly where
+instance Semimonoidal (--<) (:*:) (:*:) Exactly where
 	mult = Flip <-- \(Exactly (x :*: y)) -> Exactly x :*: Exactly y
 
-instance Monoidal (<--) (-->) (:*:) (:*:) Exactly where
+instance Monoidal (--<) (-->) (:*:) (:*:) Exactly where
 	unit _ = Flip <-- \(Exactly x) -> Straight (\_ -> x)
 
 instance Traversable (->) (->) Exactly where
diff --git a/Pandora/Paradigm/Primary/Functor/Fix.hs b/Pandora/Paradigm/Primary/Functor/Fix.hs
--- a/Pandora/Paradigm/Primary/Functor/Fix.hs
+++ b/Pandora/Paradigm/Primary/Functor/Fix.hs
@@ -3,7 +3,7 @@
 import Pandora.Core.Functor (type (<:=), type (:=>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Operation.Exponential ()
 
 newtype Fix t = Fix { unfix :: t (Fix t) }
 
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
@@ -6,12 +6,14 @@
 import Pandora.Pattern.Category (identity, (<--), (<---))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Morphism.Kleisli (Kleisli (Kleisli))
 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.Functor (Functor ((-|-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
@@ -23,16 +25,26 @@
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:) (Option, Adoption))
+import Pandora.Pattern.Operation.One (One (One))
 import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))
 
 -- TODO: better to rename it to Option a = Some a | None?
 data Maybe a = Nothing | Just a
 
+instance Functor (-->) (-->) Maybe where
+	(-|-) (Straight f) = Straight <-- \case
+		Just x -> Just <-- f x
+		Nothing -> Nothing
+
+instance Functor (Kleisli Maybe (->)) (-->) Maybe where
+	(-|-) (Kleisli f) = Straight <-- \case
+		Just x -> f x
+		Nothing -> Nothing
+
 instance Covariant (->) (->) Maybe where
 	f <-|- Just x = Just <-- f x
 	_ <-|- Nothing = Nothing
@@ -56,7 +68,7 @@
 	unit _ = Straight <-- \_ -> Nothing
 
 -- TODO: Check laws
-instance Semimonoidal (<--) (:*:) (:*:) Maybe where
+instance Semimonoidal (--<) (:*:) (:*:) Maybe where
 	mult = Flip <-- \case
 		Just (x :*: y) -> Just x :*: Just y
 		Nothing -> Nothing :*: Nothing
diff --git a/Pandora/Paradigm/Primary/Functor/Predicate.hs b/Pandora/Paradigm/Primary/Functor/Predicate.hs
--- a/Pandora/Paradigm/Primary/Functor/Predicate.hs
+++ b/Pandora/Paradigm/Primary/Functor/Predicate.hs
@@ -5,18 +5,24 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
+import Pandora.Pattern.Functor (Functor ((-|-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), bool)
-import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:)(Option, Adoption))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->), type (<--))
+import Pandora.Pattern.Operation.Product ((:*:)((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:)(Option, Adoption))
+import Pandora.Pattern.Operation.Exponential (type (-->), type (--<))
 
 newtype Predicate a = Predicate (a -> Boolean)
 
+instance Functor (-->) (--<) Predicate where
+	(-|-) (Straight f) = Flip <-- \case
+		Predicate g -> Predicate <-- g . f
+
 instance Interpreted (->) Predicate where
 	type Primary Predicate a = a -> Boolean
 	run ~(Predicate f) = f
@@ -28,7 +34,7 @@
 instance Semimonoidal (-->) (:*:) (:*:) Predicate where
 	mult = Straight <-- \(Predicate f :*: Predicate g) -> Predicate <-- \(x :*: y) -> f x * g y
 
-instance Monoidal (-->) (<--) (:*:) (:*:) Predicate where
+instance Monoidal (-->) (--<) (:*:) (:*:) Predicate where
 	unit _ = Straight <-- \_ -> Predicate <-- \_ -> True
 
 instance Semimonoidal (-->) (:*:) (:+:) Predicate where
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
@@ -6,7 +6,7 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 --import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Operation.Exponential ()
 
 data Proxy a = 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
@@ -6,6 +6,7 @@
 import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Morphism.Kleisli (Kleisli (Kleisli))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
@@ -15,6 +16,7 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Functor (Functor ((-|-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
@@ -24,13 +26,21 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (extract, (<-||-))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (extract, (<<-|-))
 
 newtype Tagged tag a = Tag a
 
+instance Functor (-->) (-->) (Tagged tag) where
+	(-|-) (Straight f) = Straight <-- \case
+		Tag x -> Tag <-- f x
+
+instance Functor (Kleisli (Tagged tag) (->)) (-->) (Tagged tag) where
+	(-|-) (Kleisli f) = Straight <-- \case
+		Tag x -> f x
+
 infixr 0 :#
 type (:#) tag = Tagged tag
 
@@ -41,15 +51,15 @@
 	_ <-|- Flip (Tag x) = Flip <-- Tag x
 
 instance Semimonoidal (-->) (:*:) (:*:) (Tagged tag) where
-	mult = Straight <-- Tag . (extract <-||-) . (extract <-|-)
+	mult = Straight <-- Tag . (extract <<-|-) . (extract <-|-)
 
 instance Monoidal (-->) (-->) (:*:) (:*:) (Tagged tag) where
 	unit _ = Straight <-- Tag . (<~ One)
 
-instance Semimonoidal (<--) (:*:) (:*:) (Tagged tag) where
+instance Semimonoidal (--<) (:*:) (:*:) (Tagged tag) where
 	mult = Flip <-- \(Tag (x :*: y)) -> Tag x :*: Tag y
 
-instance Monoidal (<--) (-->) (:*:) (:*:) (Tagged tag) where
+instance Monoidal (--<) (-->) (:*:) (:*:) (Tagged tag) where
 	unit _ = Flip <-- \(Tag x) -> Straight (\_ -> x)
 
 instance Traversable (->) (->) (Tagged tag) where
diff --git a/Pandora/Paradigm/Primary/Functor/These.hs b/Pandora/Paradigm/Primary/Functor/These.hs
--- a/Pandora/Paradigm/Primary/Functor/These.hs
+++ b/Pandora/Paradigm/Primary/Functor/These.hs
@@ -4,7 +4,7 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Operation.Exponential ()
 import Pandora.Paradigm.Algebraic (point)
 
 data These e a = This a | That e | These e a
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
@@ -10,10 +10,10 @@
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:) (Option, Adoption))
+import Pandora.Pattern.Operation.One (One (One))
 import Pandora.Paradigm.Algebraic (point)
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
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
@@ -3,7 +3,7 @@
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Operation.Exponential ()
 import Pandora.Paradigm.Algebraic (point)
 
 data Wedge e a = Nowhere | Here e | There a
diff --git a/Pandora/Paradigm/Primary/Functor/Wye.hs b/Pandora/Paradigm/Primary/Functor/Wye.hs
--- a/Pandora/Paradigm/Primary/Functor/Wye.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wye.hs
@@ -3,12 +3,8 @@
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((<--))
 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.Algebraic.Exponential (type (<--))
--- import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-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
diff --git a/Pandora/Paradigm/Primary/Linear/Vector.hs b/Pandora/Paradigm/Primary/Linear/Vector.hs
--- a/Pandora/Paradigm/Primary/Linear/Vector.hs
+++ b/Pandora/Paradigm/Primary/Linear/Vector.hs
@@ -8,7 +8,7 @@
 import Pandora.Pattern.Object.Quasiring (Quasiring (one))
 import Pandora.Pattern.Object.Group (Group (invert))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 
 data Vector r a where
diff --git a/Pandora/Paradigm/Primary/Transformer/Backwards.hs b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
--- a/Pandora/Paradigm/Primary/Transformer/Backwards.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
@@ -8,14 +8,14 @@
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<), (--<<)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Algebraic ((<-*-))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->), (%))
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (point, extract, (<-||-))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->), (%))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (point, extract, (<<-|-))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))
@@ -32,10 +32,10 @@
 instance (Covariant (->) (->) t, Monoidal (-->) (-->) (:*:) (:*:) t) => Monoidal (-->) (-->) (:*:) (:*:) (Backwards t) where
 	unit _ = Straight <-- Backwards . point . (<~ One)
 
-instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Backwards t) where
-	mult = Flip <-- (Backwards <-||-) . (Backwards <-|-) . (mult @(<--) <~) . run
+instance (Semimonoidal (--<) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (--<) (:*:) (:*:) (Backwards t) where
+	mult = Flip <-- (Backwards <<-|-) . (Backwards <-|-) . (mult @(--<) <~) . run
 
-instance (Covariant (->) (->) t, Monoidal (<--) (-->) (:*:) (:*:) t) => Monoidal (<--) (-->) (:*:) (:*:) (Backwards t) where
+instance (Covariant (->) (->) t, Monoidal (--<) (-->) (:*:) (:*:) t) => Monoidal (--<) (-->) (:*:) (:*:) (Backwards t) where
 	unit _ = Flip <-- \(Backwards x) -> Straight (\_ -> extract x)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Backwards t) where
diff --git a/Pandora/Paradigm/Primary/Transformer/Construction.hs b/Pandora/Paradigm/Primary/Transformer/Construction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Construction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Construction.hs
@@ -13,18 +13,18 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)), (<-/-/-))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformation.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.Algebraic ((<-*------), extract)
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>))
-import Pandora.Paradigm.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (empty, (<-||-))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:))
+import Pandora.Paradigm.Algebraic ((<-*------), extract, type (<:*:>), (<:*:>))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (empty, (<<-|-))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Schemes (TT (TT), T_U (T_U), type (<::>))
 
@@ -37,11 +37,11 @@
 	mult = Straight <-- \(Construct x xs :*: Construct y ys) -> Construct <----- x :*: y
 		<----- (mult @(-->) <~) <-|-- mult @(-->) <~~~ xs :*: ys
 
-instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Semimonoidal (<--) (:*:) (:*:) (Construction t) where
-	mult = Flip <-- \(Construct (x :*: y) xys) -> (Construct x <-||-) . (Construct y <-|-)
-		<----- mult @(<--) <~~~~ (mult @(<--) <~) <-|- xys
+instance (Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t) => Semimonoidal (--<) (:*:) (:*:) (Construction t) where
+	mult = Flip <-- \(Construct (x :*: y) xys) -> (Construct x <<-|-) . (Construct y <-|-)
+		<----- mult @(--<) <~~~~ (mult @(--<) <~) <-|- xys
 
-instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoidal (<--) (-->) (:*:) (:*:) (Construction t) where
+instance (Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t) => Monoidal (--<) (-->) (:*:) (:*:) (Construction t) where
 	unit _ = Flip <-- \(Construct x _) -> Straight (\_ -> x)
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:*:) (Construction t) where
@@ -53,21 +53,21 @@
 instance Covariant (->) (->) t => Extendable (->) (Construction t) where
 	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
+instance (forall u . Semimonoidal (--<) (:*:) (:*:) u) => Lowerable (->) Construction where
 	lower x = extract <-|- deconstruct x
 
-instance (forall u . Semimonoidal (<--) (:*:) (:*:) u, forall u . Covariant (->) (->) u) => Hoistable (->) Construction where
+instance (forall u . Semimonoidal (--<) (:*:) (:*:) u, forall u . Covariant (->) (->) u) => Hoistable (->) Construction where
 	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
+instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t) => Setoid (Construction t a) where
 	x == y = (extract x == extract y) * (deconstruct x == deconstruct y)
 
-instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Semigroup (Construction t a) where
+instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t) => Semigroup (Construction t a) where
 	x + y = Construct <-- extract x + extract y <-- deconstruct x + deconstruct y
 
-instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoid (Construction t a) where
+instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t) => Monoid (Construction t a) where
 	zero = Construct zero zero
 
 instance Interpreted (->) (Construction t) where
@@ -88,5 +88,5 @@
 constitute :: Covariant (->) (->) t => (a -> t a) -> a -> Construction t a
 constitute f x = Construct x <---- constitute 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
@@ -8,10 +8,10 @@
 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.Pattern.Transformation.Liftable (Liftable (lift))
 import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))
-import Pandora.Paradigm.Algebraic.Exponential ((%), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Pattern.Operation.Exponential ((%), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:))
 import Pandora.Paradigm.Algebraic (point)
 
 newtype Continuation r t a = Continuation ((->) ((->) a (t r)) (t r))
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
@@ -6,8 +6,8 @@
 import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Algebraic.Exponential ((.:..))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Operation.Exponential ((.:..))
 
 data Day t u a = forall b c . Day (t b) (u c) (b -> c -> 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
@@ -5,18 +5,18 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|---), (<-|-|-)))
+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 ((/|\)))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
-import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.Product ((:*:)((:*:)))
+import Pandora.Pattern.Operation.One (One (One))
 import Pandora.Paradigm.Algebraic (point)
 import Pandora.Core.Interpreted ((<~), (<~~~))
 
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
@@ -8,12 +8,12 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=), (<<==)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.Product ((:*:))
 import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
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
@@ -6,7 +6,7 @@
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Operation.Exponential ()
 
 data family Kan (v :: * -> k) (t :: * -> *) (u :: * -> *) b a
 
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,9 +4,9 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, (<--), (<----), (<------))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Operation.Exponential ()
 
 data Outline t a where
 	Line :: a -> Outline t a
diff --git a/Pandora/Paradigm/Primary/Transformer/Reverse.hs b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
--- a/Pandora/Paradigm/Primary/Transformer/Reverse.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
@@ -9,15 +9,15 @@
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-), (<-/--)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<), (--<<)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (point, extract, empty, (<-||-))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (point, extract, empty, (<<-|-))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~)))
@@ -33,10 +33,10 @@
 instance (Covariant (->) (->) t, Monoidal (-->) (-->) (:*:) (:*:) t) => Monoidal (-->) (-->) (:*:) (:*:) (Reverse t) where
 	unit _ = Straight <-- Reverse . point . (<~ One)
 
-instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Reverse t) where
-	mult = Flip <-- (Reverse <-||-) . (Reverse <-|-) . (mult @(<--) <~) . run
+instance (Semimonoidal (--<) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (--<) (:*:) (:*:) (Reverse t) where
+	mult = Flip <-- (Reverse <<-|-) . (Reverse <-|-) . (mult @(--<) <~) . run
 
-instance (Covariant (->) (->) t, Monoidal (<--) (-->) (:*:) (:*:) t) => Monoidal (<--) (-->) (:*:) (:*:) (Reverse t) where
+instance (Covariant (->) (->) t, Monoidal (--<) (-->) (:*:) (:*:) t) => Monoidal (--<) (-->) (:*:) (:*:) (Reverse t) where
 	unit _ = Flip <-- \(Reverse x) -> Straight (\_ -> extract x)
 
 instance (Semimonoidal (-->) (:*:) (:+:) t, Covariant (->) (->) t) => Semimonoidal (-->) (:*:) (:+:) (Reverse t) where
diff --git a/Pandora/Paradigm/Primary/Transformer/Tap.hs b/Pandora/Paradigm/Primary/Transformer/Tap.hs
--- a/Pandora/Paradigm/Primary/Transformer/Tap.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Tap.hs
@@ -9,12 +9,12 @@
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=), (<<==)))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
 import Pandora.Core.Interpreted ((<~), (<~~~))
-import Pandora.Paradigm.Algebraic ((<-*--), (<-||--), extract)
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), (<:*:>))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
+import Pandora.Paradigm.Algebraic ((<-*--), (<<-|--), extract, type (<:*:>), (<:*:>))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.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 (<:.:>))
@@ -27,16 +27,16 @@
 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
-	mult = Flip <-- \(Tap (x :*: y) xys) -> Tap x <-||-- Tap y <-|- mult @(<--) <~ xys
+instance Semimonoidal (--<) (:*:) (:*:) t => Semimonoidal (--<) (:*:) (:*:) (Tap t) where
+	mult = Flip <-- \(Tap (x :*: y) xys) -> Tap x <<-|-- Tap y <-|- mult @(--<) <~ xys
 
-instance Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (-->) (:*:) (:*:) (Tap t) where
+instance Semimonoidal (--<) (:*:) (:*:) t => Monoidal (--<) (-->) (:*:) (:*:) (Tap t) where
 	unit _ = Flip <-- \(Tap x _) -> Straight (\_ -> x)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Tap t) where
 	f <-/- Tap x xs = Tap <-|-- f x <-*-- f <-/- xs
 
-instance (Semimonoidal (<--) (:*:) (:*:) t, Extendable (->) t, Covariant (->) (->) t) => Extendable (->) (Tap t) where
+instance (Semimonoidal (--<) (:*:) (:*:) t, Extendable (->) t, Covariant (->) (->) t) => Extendable (->) (Tap t) where
 	f <<= x = Tap <--- f x <--- f . Tap (extract x) <<= lower x
 
 instance Lowerable (->) Tap where
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
@@ -5,8 +5,8 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Operation.Exponential ()
 
 newtype Yoneda t a = Yoneda
 	{ yoneda :: forall b . (a -> b) -> t b }
diff --git a/Pandora/Paradigm/Schemes/TT.hs b/Pandora/Paradigm/Schemes/TT.hs
--- a/Pandora/Paradigm/Schemes/TT.hs
+++ b/Pandora/Paradigm/Schemes/TT.hs
@@ -14,14 +14,14 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)), (<-/-/-))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:), bitraverse_sum)
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (empty, point, extract, (<-||-), (<-||---))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:), bitraverse_sum)
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (empty, point, extract, (<<-|-), (<<-|---))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
@@ -43,7 +43,7 @@
 	(<-|-) f = (=#-) ((<-|-|-) f)
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) t') => Semimonoidal (-->) (:*:) (:*:) (t <::> t') where
-	mult = Straight <-- TT . (<-|-) (mult @(-->) <~) . (mult @(-->) <~) . (run <-||-) . (run @(->) <-|-)
+	mult = Straight <-- TT . (<-|-) (mult @(-->) <~) . (mult @(-->) <~) . (run <<-|-) . (run @(->) <-|-)
 
 instance (Covariant (->) (->) t, Covariant (->) (->) t', Semimonoidal (-->) (:*:) (:*:) t', Monoidal (-->) (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:*:) t') => Monoidal (-->) (-->) (:*:) (:*:) (t <::> t') where
 	unit _ = Straight <-- TT . point . point . (<~ One)
@@ -57,10 +57,10 @@
 instance (Covariant (->) (->) t, Covariant (->) (->) t', Semimonoidal (-->) (:*:) (:+:) t, Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:+:) (t <::> t') where
 	unit _ = Straight <-- \_ -> TT empty
 
-instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <::> t') where
-	mult = Flip <-- \(TT xys) -> TT <-||--- TT <-|--- mult @(<--) <~~~~ (mult @(<--) <~) <-|- xys
+instance (Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t, Semimonoidal (--<) (:*:) (:*:) t') => Semimonoidal (--<) (:*:) (:*:) (t <::> t') where
+	mult = Flip <-- \(TT xys) -> TT <<-|--- TT <-|--- mult @(--<) <~~~~ (mult @(--<) <~) <-|- xys
 
-instance (Covariant (->) (->) t, Monoidal (<--) (-->) (:*:) (:*:) t, Monoidal (<--) (-->) (:*:) (:*:) t') => Monoidal (<--) (-->) (:*:) (:*:) (t <::> t') where
+instance (Covariant (->) (->) t, Monoidal (--<) (-->) (:*:) (:*:) t, Monoidal (--<) (-->) (:*:) (:*:) t') => Monoidal (--<) (-->) (:*:) (:*:) (t <::> t') where
 	unit _ = Flip <-- \(TT x) -> Straight <---- constant <--- extract <-- extract x
 
 instance (Traversable (->) (->) t, Traversable (->) (->) t') => Traversable (->) (->) (t <::> t') where
@@ -73,7 +73,7 @@
 	lift :: Covariant (->) (->) t' => t' ~> t <::> t'
 	lift = TT . point
 
-instance Monoidal (<--) (-->) (:*:) (:*:) t => Lowerable (->) (TT Covariant Covariant t) where
+instance Monoidal (--<) (-->) (:*:) (:*:) t => Lowerable (->) (TT Covariant Covariant t) where
 	lower :: t <::> t' ~> t'
 	lower (TT x) = extract x
 
diff --git a/Pandora/Paradigm/Schemes/TU.hs b/Pandora/Paradigm/Schemes/TU.hs
--- a/Pandora/Paradigm/Schemes/TU.hs
+++ b/Pandora/Paradigm/Schemes/TU.hs
@@ -13,14 +13,14 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)), (<-/-/-))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (empty, point, extract, (<-||-), (<-||---))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformation.Hoistable (Hoistable ((/|\)))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (empty, point, extract, (<<-|-), (<<-|---))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
@@ -42,7 +42,7 @@
 	(<-|-) f = (=#-) ((<-|-|-) f)
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <:.> u) where
-	mult = Straight <-- TU . (<-|-) (mult @(-->) <~) . (mult @(-->) <~) . (run <-||-) . (run @(->) <-|-)
+	mult = Straight <-- TU . (<-|-) (mult @(-->) <~) . (mult @(-->) <~) . (run <<-|-) . (run @(->) <-|-)
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) u, Monoidal (-->) (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:*:) u) => Monoidal (-->) (-->) (:*:) (:*:) (t <:.> u) where
 	unit _ = Straight <-- TU . point . point . (<~ One)
@@ -56,10 +56,10 @@
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:+:) u, Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:+:) (t <:.> u) where
 	unit _ = Straight <-- \_ -> TU empty
 
-instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:.> u) where
-	mult = Flip <-- \(TU xys) -> TU <-||--- TU <-|--- mult @(<--) <~~~~ (mult @(<--) <~) <-|- xys
+instance (Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t, Semimonoidal (--<) (:*:) (:*:) u) => Semimonoidal (--<) (:*:) (:*:) (t <:.> u) where
+	mult = Flip <-- \(TU xys) -> TU <<-|--- TU <-|--- mult @(--<) <~~~~ (mult @(--<) <~) <-|- xys
 
-instance (Covariant (->) (->) t, Monoidal (<--) (-->) (:*:) (:*:) t, Monoidal (<--) (-->) (:*:) (:*:) u) => Monoidal (<--) (-->) (:*:) (:*:) (t <:.> u) where
+instance (Covariant (->) (->) t, Monoidal (--<) (-->) (:*:) (:*:) t, Monoidal (--<) (-->) (:*:) (:*:) u) => Monoidal (--<) (-->) (:*:) (:*:) (t <:.> u) where
 	unit _ = Flip <-- \(TU x) -> Straight (\_ -> extract <-- extract x)
 
 instance (Traversable (->) (->) t, Traversable (->) (->) u) => Traversable (->) (->) (t <:.> u) where
@@ -72,7 +72,7 @@
 	lift :: Covariant (->) (->) u => u ~> t <:.> u
 	lift = TU . point
 
-instance Monoidal (<--) (-->) (:*:) (:*:) t => Lowerable (->) (TU Covariant Covariant t) where
+instance Monoidal (--<) (-->) (:*:) (:*:) t => Lowerable (->) (TU Covariant Covariant t) where
 	lower :: t <:.> u ~> u
 	lower (TU x) = extract x
 
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
@@ -6,6 +6,7 @@
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<------))
+import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((<-|-), (<-|--), (<-|---), (<-|-|-), (<-|-|---), (<-|-|-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -14,13 +15,13 @@
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (--|), (|-), (|--)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (point, extract, (<-||-))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:) (Option, Adoption))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (point, extract, empty, (<<-|-))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
@@ -48,19 +49,24 @@
 instance (Adjoint (->) (->) t' t, Bindable (->) u) => Semimonoidal (-->) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where
 	mult = Straight <-- \(TUT x :*: TUT y) -> TUT ((((\r -> (<-|-|-|-) (r :*:) y) |-) =<<) <-|- x)
 
-instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where
-	mult = Flip <-- (TUT <-||-) . (TUT <-|-) . (mult @(<--) <~) . (<-|-) (mult @(<--) <~) . (<-|-|-) @_ @(->) (mult @(<--) <~) . run
+instance (Covariant (->) (->) t, Semimonoidal (--<) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (--<) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (--<) (:*:) (:*:) t') => Semimonoidal (--<) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) 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
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (--<) (:*:) (:*:) t, Semimonoidal (--<) (:*:) (:*:) t', Monoidal (--<) (-->) (:*:) (:*:) u, Adjoint (->) (->) t t') => Monoidal (--<) (-->) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where
 	unit _ = Flip <-- \(TUT xys) -> Straight (\_ -> (extract |-) xys)
 
 -- TODO: generalize on (->) and (:*:)
-instance {-# OVERLAPS #-} (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) ((->) s <:<.>:> (:*:) s >>>>>>>> u) where
- mult = Straight <-- \(TUT x :*: TUT y) -> TUT
-	<------ product_over_sum
-		<-|-|- mult @(-->) @(:*:) @(:+:)
-			<-|-- mult @(-->) @(:*:) @(:*:)
-				<~~~ x :*: y
+instance {-# OVERLAPS #-} (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:+:) u) 
+	=> Semimonoidal (-->) (:*:) (:+:) ((->) s <:<.>:> (:*:) s >>>>>>>> u) where
+	mult = Straight <-- \(TUT x :*: TUT y) -> TUT
+		<------ product_over_sum
+			<-|-|- mult @(-->) @(:*:) @(:+:)
+				<-|-- mult @(-->) @(:*:) @(:*:)
+					<~~~ x :*: y
+
+instance {-# OVERLAPS #-} (Covariant (->) (->) u, Monoidal (-->) (-->) (:*:) (:+:) u) 
+	=> Monoidal (-->) (-->) (:*:) (:+:) ((->) s <:<.>:> (:*:) s >>>>>>>> u) where
+	unit _ = Straight <-- \_ -> empty
 
 product_over_sum :: (s :*: a) :+: (s :*: b) -> s :*: (a :+: b)
 product_over_sum (Option (s :*: x)) = s :*: Option x
diff --git a/Pandora/Paradigm/Schemes/T_U.hs b/Pandora/Paradigm/Schemes/T_U.hs
--- a/Pandora/Paradigm/Schemes/T_U.hs
+++ b/Pandora/Paradigm/Schemes/T_U.hs
@@ -7,7 +7,7 @@
 import Pandora.Pattern.Morphism.Flip (Flip)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-|-)))
-import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Pattern.Operation.Exponential ()
 
 newtype T_U ct cu p t u a = T_U (p (t a) (u a))
 
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
@@ -13,13 +13,13 @@
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/--)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Algebraic.One (One (One))
-import Pandora.Paradigm.Algebraic (point, extract, (<-||-), (<-||---))
+import Pandora.Pattern.Transformation.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformation.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:))
+import Pandora.Pattern.Operation.One (One (One))
+import Pandora.Paradigm.Algebraic (point, extract, (<<-|-), (<<-|---))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 
 newtype UT ct cu t u a = UT (u :. t >>> a)
@@ -40,7 +40,7 @@
 	(<-|-) f = (=#-) ((<-|-|-) f)
 
 instance (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <.:> u) where
-	mult = Straight <-- UT . (<-|-) (mult @(-->) <~) . (mult @(-->) <~) . (run <-||-) . (run @(->) <-|-)
+	mult = Straight <-- UT . (<-|-) (mult @(-->) <~) . (mult @(-->) <~) . (run <<-|-) . (run @(->) <-|-)
 
 instance (Covariant (->) (->) u, Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) u, Semimonoidal (-->) (:*:) (:+:) t) => Semimonoidal (-->) (:*:) (:+:) (t <.:> u) where
 	mult = Straight <-- \(UT x :*: UT y) -> UT
@@ -54,16 +54,16 @@
 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
-	mult = Flip <-- \(UT xys) -> UT <-||--- UT <-|--- mult @(<--) <~~~~ (mult @(<--) <~) <-|- xys
+instance (Covariant (->) (->) u, Semimonoidal (--<) (:*:) (:*:) t, Semimonoidal (--<) (:*:) (:*:) u) => Semimonoidal (--<) (:*:) (:*:) (t <.:> u) where
+	mult = Flip <-- \(UT xys) -> UT <<-|--- UT <-|--- mult @(--<) <~~~~ (mult @(--<) <~) <-|- xys
 
-instance (Covariant (->) (->) u, Monoidal (<--) (-->) (:*:) (:*:) t, Monoidal (<--) (-->) (:*:) (:*:) u) => Monoidal (<--) (-->) (:*:) (:*:) (t <.:> u) where
+instance (Covariant (->) (->) u, Monoidal (--<) (-->) (:*:) (:*:) t, Monoidal (--<) (-->) (:*:) (:*:) u) => Monoidal (--<) (-->) (:*:) (:*:) (t <.:> u) where
 	unit _ = Flip <-- \(UT x) -> Straight (\_ -> extract <-- extract x)
 
 instance Monoidal (-->) (-->) (:*:) (:*:) t => Liftable (->) (UT Covariant Covariant t) where
 	lift :: Covariant (->) (->) u => u ~> t <.:> u
 	lift x = UT <---- point <-|- x
 
-instance Monoidal (<--) (-->) (:*:) (:*:) t => Lowerable (->) (UT Covariant Covariant t) where
+instance Monoidal (--<) (-->) (:*:) (:*:) t => Lowerable (->) (UT Covariant Covariant t) where
 	lower :: Covariant (->) (->) u => t <.:> u ~> u
 	lower (UT x) = extract <-|- x
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -12,15 +12,15 @@
 import Pandora.Pattern.Category ((<--), (<---), identity)
 import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Transformer.Liftable (lift)
-import Pandora.Pattern.Transformer.Lowerable (lower)
+import Pandora.Pattern.Transformation.Liftable (lift)
+import Pandora.Pattern.Transformation.Lowerable (lower)
 import Pandora.Pattern.Object.Semigroup ((+))
 import Pandora.Paradigm.Inventory.Some.Optics ()
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
-import Pandora.Paradigm.Algebraic.Exponential ((%))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), attached)
-import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Algebraic (extract)
+import Pandora.Pattern.Operation.Exponential ((%))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)), attached)
+import Pandora.Pattern.Operation.Sum ((:+:) (Option, Adoption))
+import Pandora.Paradigm.Algebraic (type (<:*:>), extract)
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (Failure, Success), conclusion)
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
diff --git a/Pandora/Paradigm/Structure/Ability/Monotonic.hs b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
--- a/Pandora/Paradigm/Structure/Ability/Monotonic.hs
+++ b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
@@ -2,8 +2,8 @@
 
 import Pandora.Pattern.Category ((<----))
 import Pandora.Pattern.Kernel (constant)
-import Pandora.Paradigm.Algebraic.Exponential ((.:..))
-import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption))
+import Pandora.Pattern.Operation.Exponential ((.:..))
+import Pandora.Pattern.Operation.Sum ((:+:) (Option, Adoption))
 
 class Monotonic a e where
 	{-# MINIMAL reduce #-}
@@ -18,8 +18,8 @@
 
 instance Monotonic a (o :+: a) where
 	reduce fun def (Adoption x) = fun x def
-	reduce _ def (Option x) = def
+	reduce _ def (Option _) = def
 
 instance Monotonic o (o :+: a) where
 	reduce fun def (Option x) = fun x def
-	reduce _ def (Adoption x) = def
+	reduce _ def (Adoption _) = def
diff --git a/Pandora/Paradigm/Structure/Ability/Morphable.hs b/Pandora/Paradigm/Structure/Ability/Morphable.hs
--- a/Pandora/Paradigm/Structure/Ability/Morphable.hs
+++ b/Pandora/Paradigm/Structure/Ability/Morphable.hs
@@ -7,7 +7,7 @@
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Setoid (Setoid)
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic (extract)
 import Pandora.Paradigm.Primary.Functor (Comparison)
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
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
@@ -7,13 +7,14 @@
 import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|-|-)))
-import Pandora.Pattern.Transformer.Liftable (lift)
-import Pandora.Pattern.Transformer.Lowerable (lower)
+import Pandora.Pattern.Transformation.Liftable (lift)
+import Pandora.Pattern.Transformation.Lowerable (lower)
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Some.Optics (type (@>>>), view, replace)
-import Pandora.Paradigm.Algebraic.Exponential ((%))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>))
+import Pandora.Pattern.Operation.Exponential ((%))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic.Functor ((>-||-), extract, empty)
+import Pandora.Paradigm.Algebraic (type (<:*:>), (<:*:>))
 import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
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
@@ -11,8 +11,8 @@
 import Pandora.Pattern.Object.Semigroup ((+))
 import Pandora.Pattern.Object.Quasiring (one)
 import Pandora.Paradigm.Algebraic ()
-import Pandora.Paradigm.Algebraic.Product (attached)
-import Pandora.Paradigm.Algebraic.Exponential ((%))
+import Pandora.Pattern.Operation.Product (attached)
+import Pandora.Pattern.Operation.Exponential ((%))
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)
diff --git a/Pandora/Paradigm/Structure/Interface/Zipper.hs b/Pandora/Paradigm/Structure/Interface/Zipper.hs
--- a/Pandora/Paradigm/Structure/Interface/Zipper.hs
+++ b/Pandora/Paradigm/Structure/Interface/Zipper.hs
@@ -15,11 +15,11 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-), (<-/---)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
-import Pandora.Pattern.Transformer.Liftable (lift)
-import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->), (%))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>))
-import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (<-*---), extract, point)
+import Pandora.Pattern.Transformation.Liftable (lift)
+import Pandora.Pattern.Transformation.Lowerable (lower)
+import Pandora.Pattern.Operation.Exponential (type (--<), type (-->), (%))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (<-*---), extract, point, type (<:*:>), (<:*:>))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)
@@ -39,11 +39,11 @@
 
 type Zipper (structure :: * -> *) = Exactly <:*:> Breadcrumbs structure
 
-instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t
-	=> Semimonoidal (<--) (:*:) (:*:) (Exactly <:*:> t) where
+instance {-# OVERLAPS #-} Semimonoidal (--<) (:*:) (:*:) t
+	=> Semimonoidal (--<) (:*:) (:*:) (Exactly <:*:> t) where
 	mult = Flip <-- \(T_U (Exactly (x :*: y) :*: xys)) ->
-		let xs :*: ys = mult @(<--) <~ xys in
+		let xs :*: ys = mult @(--<) <~ xys in
 			(Exactly x <:*:> xs) :*: (Exactly y <:*:> ys)
 
-instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (-->) (:*:) (:*:) (Exactly <:*:> t) where
+instance {-# OVERLAPS #-} Semimonoidal (--<) (:*:) (:*:) t => Monoidal (--<) (-->) (:*:) (:*:) (Exactly <:*:> t) where
 	unit _ = Flip <-- \(T_U (Exactly x :*: _)) -> Straight (\_ -> x)
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
@@ -12,7 +12,7 @@
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<)))
-import Pandora.Pattern.Transformer.Liftable (lift)
+import Pandora.Pattern.Transformation.Liftable (lift)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
@@ -21,9 +21,9 @@
 import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Push), premorph)
-import Pandora.Paradigm.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Algebraic.Sum ((:+:))
+import Pandora.Pattern.Operation.Exponential (type (-->))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Operation.Sum ((:+:))
 import Pandora.Paradigm.Algebraic (empty, (<-|-<-|-))
 
 newtype Comprehension t a = Comprehension (t <::> Construction t >>>>> a)
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
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Structure.Modification.Prefixed where
 
 import Pandora.Paradigm.Schemes (type (<::>))
-import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Pattern.Operation.Product ((:*:))
 
 type Prefixed t k = t <::> (:*:) k
diff --git a/Pandora/Paradigm/Structure/Modification/Tape.hs b/Pandora/Paradigm/Structure/Modification/Tape.hs
--- a/Pandora/Paradigm/Structure/Modification/Tape.hs
+++ b/Pandora/Paradigm/Structure/Modification/Tape.hs
@@ -2,34 +2,36 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Structure.Modification.Tape where
 
-import Pandora.Core.Functor (type (>), type (>>>))
+import Pandora.Core.Functor (type (>), type (<), type (>>>))
 import Pandora.Core.Impliable (Impliable (Arguments, imply))
-import Pandora.Core.Interpreted (run, (=#-))
+import Pandora.Core.Interpreted (run, (=#-), (<~~))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----), (<------))
+import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-), (<-/---)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((====<<)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal)
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
-import Pandora.Pattern.Transformer.Liftable (lift)
-import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Paradigm.Algebraic.Exponential (type (-->), (%))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>))
-import Pandora.Paradigm.Algebraic.Functor ((<-*--), extract, point, void)
+import Pandora.Pattern.Transformation.Liftable (lift)
+import Pandora.Pattern.Transformation.Lowerable (lower)
+import Pandora.Pattern.Operation.Exponential (type (-->), (%))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)), attached)
+import Pandora.Paradigm.Algebraic.Functor ((<-*--), (-+), extract, void, until)
+import Pandora.Paradigm.Algebraic (type (<:*:>), (<:*:>))
 import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U))
+import Pandora.Paradigm.Schemes.TUT (TUT (TUT))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
 import Pandora.Paradigm.Primary.Auxiliary (Vertical (Up, Down), Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
 import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))
-import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)
-import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>), wrap)
+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>) (TM), wrap)
 import Pandora.Paradigm.Structure.Ability.Morphable (Occurrence (All))
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root, Branch, Rest), sub)
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root, Rest), sub)
 import Pandora.Paradigm.Structure.Ability.Slidable (Slidable (Sliding, slide))
 import Pandora.Paradigm.Structure.Interface.Stack (Stack (Topping, push, pop))
+import Pandora.Paradigm.Structure.Modification.Turnover (Turnover (Turnover))
 import Pandora.Paradigm.Inventory.Some.State (State, change)
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Some.Optics (view, replace, mutate, transwrap)
@@ -91,3 +93,18 @@
 			====<< wrap . zoom @(Tape structure e) (sub @Root) . overlook . change . constant
 				====<< lift ====<< wrap <---- zoom @(Tape structure e) <--- sub @Rest
 					<--- zoom <-- sub @Left <-- zoom transwrap pop
+
+-- TODO: generalize this instance over direction, but for this we need a defintion of opposite derection
+instance (Covariant (->) (->) structure, Stack structure, Topping structure ~ Maybe) => Slidable Left (Turnover > Tape structure) where
+	type Sliding Left (Turnover > Tape structure) = Exactly
+	slide :: forall e . State (Turnover < Tape structure < e) :> Exactly >>> ()
+	slide = TM . TUT <-- \(Turnover tape) ->
+		let Just updated = attached <-|- slide @Left -+ until (slide @Right) <~~ tape in
+		Exactly <--- Turnover updated :*: ()
+
+instance (Covariant (->) (->) structure, Stack structure, Topping structure ~ Maybe) => Slidable Right (Turnover > Tape structure) where
+	type Sliding Right (Turnover > Tape structure) = Exactly
+	slide :: forall e . State (Turnover < Tape structure < e) :> Exactly >>> ()
+	slide = TM . TUT <-- \(Turnover tape) ->
+		let Just updated = attached <-|- slide @Right -+ until (slide @Left) <~~ tape in
+		Exactly <--- Turnover updated :*: ()
diff --git a/Pandora/Paradigm/Structure/Modification/Turnover.hs b/Pandora/Paradigm/Structure/Modification/Turnover.hs
--- a/Pandora/Paradigm/Structure/Modification/Turnover.hs
+++ b/Pandora/Paradigm/Structure/Modification/Turnover.hs
@@ -3,8 +3,8 @@
 
 import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (=#-)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Transformer.Hoistable ((/|\))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Pattern.Transformation.Hoistable ((/|\))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic ((>-|-<-|-))
 import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure))
 
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
@@ -9,11 +9,12 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|---)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<), (=====<<)))
-import Pandora.Pattern.Transformer.Liftable (lift)
-import Pandora.Pattern.Transformer.Lowerable (lower)
+import Pandora.Pattern.Transformation.Liftable (lift)
+import Pandora.Pattern.Transformation.Lowerable (lower)
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached)
-import Pandora.Paradigm.Algebraic.Exponential ((&), (.:..))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)), attached)
+import Pandora.Paradigm.Algebraic (type (<:*:>), (<:*:>))
+import Pandora.Pattern.Operation.Exponential ((&), (.:..))
 import Pandora.Paradigm.Algebraic.Functor ((<-*---), (-------*), extract, empty, void)
 import Pandora.Paradigm.Primary.Auxiliary (Vertical (Up, Down), Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Object.Ordering (order)
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
@@ -1,7 +1,7 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Structure.Some.List where
 
-import Pandora.Core.Functor (type (:.), type (<), type (>), type (>>>), type (>>>>>>))
+import Pandora.Core.Functor (type (<), type (>), type (>>>>>>))
 import Pandora.Core.Impliable (imply)
 import Pandora.Core.Interpreted (run, (<~), (<~~~), (=#-))
 import Pandora.Pattern.Semigroupoid ((.))
@@ -10,14 +10,15 @@
 import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((<-|-), (<-|--)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<), (===<<)))
-import Pandora.Pattern.Transformer.Liftable (lift)
-import Pandora.Pattern.Transformer.Lowerable (lower)
+import Pandora.Pattern.Transformation.Liftable (lift)
+import Pandora.Pattern.Transformation.Lowerable (lower)
 import Pandora.Pattern.Object.Setoid (Setoid ((==), (?=)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Algebraic ((<-*--), (-*), (-+), (.:..), extract, point, empty, void)
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached)
-import Pandora.Paradigm.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Algebraic ((<-*--), (-*), (-+), extract, point, empty, void)
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)), attached)
+import Pandora.Paradigm.Algebraic (type (<:*:>), (<:*:>))
+import Pandora.Pattern.Operation.Exponential ((.:..), (%))
 import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
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
@@ -10,12 +10,13 @@
 import Pandora.Pattern.Functor.Contravariant ((>-|-))
 import Pandora.Pattern.Functor.Traversable ((<-/-))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (====<<), (=====<<), (======<<)))
-import Pandora.Pattern.Transformer.Liftable (lift)
-import Pandora.Pattern.Transformer.Lowerable (lower)
+import Pandora.Pattern.Transformation.Liftable (lift)
+import Pandora.Pattern.Transformation.Lowerable (lower)
 import Pandora.Pattern.Object.Setoid (Setoid ((?=)))
 import Pandora.Pattern.Object.Semigroup ((+))
-import Pandora.Paradigm.Algebraic.Exponential ((%), (.:..))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached)
+import Pandora.Pattern.Operation.Exponential ((%), (.:..))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)), attached)
+import Pandora.Paradigm.Algebraic (type (<:*:>), (<:*:>))
 import Pandora.Paradigm.Algebraic.Functor ((<-*-), (<-*----), extract, point, empty, void)
 import Pandora.Paradigm.Primary.Auxiliary (Vertical (Up, Down), Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
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
@@ -9,10 +9,11 @@
 import Pandora.Pattern.Category ((<--), (<---), (<----), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|---)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<), (===<<)))
-import Pandora.Pattern.Transformer.Liftable (lift)
-import Pandora.Pattern.Transformer.Hoistable ((/|\))
+import Pandora.Pattern.Transformation.Liftable (lift)
+import Pandora.Pattern.Transformation.Hoistable ((/|\))
 import Pandora.Paradigm.Algebraic.Functor ((<-*-), extract, point, void)
-import Pandora.Paradigm.Algebraic.Product (type (<:*:>), (<:*:>), attached)
+import Pandora.Pattern.Operation.Product (attached)
+import Pandora.Paradigm.Algebraic (type (<:*:>), (<:*:>))
 import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
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
@@ -10,8 +10,9 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((<-/-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>))
+import Pandora.Pattern.Operation.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic.Functor (extract, empty, (-*))
+import Pandora.Paradigm.Algebraic (type (<:*:>), (<:*:>))
 import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
diff --git a/Pandora/Pattern.hs b/Pandora/Pattern.hs
--- a/Pandora/Pattern.hs
+++ b/Pandora/Pattern.hs
@@ -1,11 +1,17 @@
+-- {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Pattern (module Exports) where
 
 import Pandora.Pattern.Betwixt as Exports
+import Pandora.Pattern.Operation as Exports
 import Pandora.Pattern.Object as Exports
-import Pandora.Pattern.Transformer as Exports
+import Pandora.Pattern.Transformation as Exports
 import Pandora.Pattern.Functor as Exports
 import Pandora.Pattern.Morphism as Exports
 import Pandora.Pattern.Groupoid as Exports
 import Pandora.Pattern.Kernel as Exports
 import Pandora.Pattern.Category as Exports
 import Pandora.Pattern.Semigroupoid as Exports
+
+-- TODO: Bindable -> Bindable_
+instance (Semigroupoid source, Bindable source t) => Semigroupoid (Kleisli t source) where
+	Kleisli g . Kleisli f = Kleisli ((=<<) g . f)
diff --git a/Pandora/Pattern/Functor.hs b/Pandora/Pattern/Functor.hs
--- a/Pandora/Pattern/Functor.hs
+++ b/Pandora/Pattern/Functor.hs
@@ -1,4 +1,4 @@
-module Pandora.Pattern.Functor (module Exports) where
+module Pandora.Pattern.Functor (module Exports, Functor (..), Covariant_, Contravariant_, Bindable_) where
 
 import Pandora.Pattern.Functor.Comonad as Exports
 import Pandora.Pattern.Functor.Monad as Exports
@@ -14,8 +14,15 @@
 import Pandora.Pattern.Functor.Contravariant as Exports
 import Pandora.Pattern.Functor.Covariant as Exports
 
---type family Endofunctor constraint functor category where
-	--Endofunctor Covariant t category = Covariant category category t
-	--Endofunctor Contravariant t category = Contravariant t category category
-	--Endofunctor Traversable t category = Traversable t category category
-	--Endofunctor Distributive t category = Distributive t category category
+import Pandora.Pattern.Morphism.Flip (Flip)
+import Pandora.Pattern.Morphism.Straight (Straight)
+import Pandora.Pattern.Morphism.Kleisli (Kleisli)
+
+-- TODO: think about prerequisites on morphisms
+-- Semifunctors from Semigroupoids and Functors from Categories?
+class Functor source target t where
+	(-|-) :: source a b -> target (t a) (t b)
+
+type Covariant_ source target = Functor (Straight source) (Straight target)
+type Contravariant_ source target = Functor (Straight source) (Flip target)
+type Bindable_ source t = Functor (Kleisli t source) (Straight source) t
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
@@ -3,8 +3,8 @@
 import Pandora.Pattern.Morphism.Straight (Straight)
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Extendable (Extendable)
-import Pandora.Paradigm.Algebraic.Exponential (type (<--))
-import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Pattern.Operation.Exponential (type (--<))
+import Pandora.Pattern.Operation.Product ((:*:))
 
 {- |
 > Let f :: (Extendable t, Extractable t) => t a -> b
@@ -16,4 +16,4 @@
 > * Associativity: extend f . extend g ≡ extend (f . extend g)
 -}
 
-class (Monoidal (<--) (Straight source) (:*:) (:*:) t, Extendable source t) => Comonad source t
+class (Monoidal (--<) (Straight source) (:*:) (:*:) t, Extendable source t) => Comonad source t
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
@@ -20,6 +20,7 @@
 class (Semigroupoid source, Semigroupoid target) => Covariant source target t where
 	(<-|-) :: source a b -> target (t a) (t b)
 
+	-- TODO: remove those operators that are longer than 9 symbols
 	(<-|--), (<-|---), (<-|----), (<-|-----), (<-|------),
 		(<-|-------), (<-|--------) :: source a b -> target (t a) (t b)
 	(<-|--) = (<-|-)
@@ -30,6 +31,7 @@
 	(<-|-------) = (<-|-)
 	(<-|--------) = (<-|-)
 
+	-- TODO: remove those operators that are longer than 9 symbols
 	(<-|-|-), (<-|-|--), (<-|-|---), (<-|-|----), (<-|-|-----), (<-|-|------), (<-|-|-------) :: (Covariant source (Betwixt source target) u, Covariant (Betwixt source target) target t)
 		=> source a b -> target (t (u a)) (t (u b))
 	(<-|-|-------) s = ((<-|-) ((<-|-) @source @(Betwixt source target) @_ s))
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
@@ -4,7 +4,7 @@
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Bindable (Bindable)
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
-import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Pattern.Operation.Product ((:*:))
 
 {- |
 > Let f :: (Monoidal t (->) (->) (:*:) (:*:), Bindable t) => a -> t a
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
@@ -1,9 +1,8 @@
 module Pandora.Pattern.Functor.Monoidal where
 
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal)
+import Pandora.Pattern.Operation.Unit (Unit)
 import Pandora.Paradigm.Primary.Functor.Proxy (Proxy)
-
-type family Unit (p :: * -> * -> *) = r | r -> p
 
 class Semimonoidal p source target t => Monoidal p q source target t | p target -> source where
 	unit :: Proxy source -> p (q (Unit target) a) (t a)
diff --git a/Pandora/Pattern/Functor/Traversable.hs b/Pandora/Pattern/Functor/Traversable.hs
--- a/Pandora/Pattern/Functor/Traversable.hs
+++ b/Pandora/Pattern/Functor/Traversable.hs
@@ -3,7 +3,7 @@
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Morphism.Straight (Straight)
-import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Pattern.Operation.Product ((:*:))
 
 {- |
 > Let f :: (Applicative t, Applicative g) => t a -> u a
diff --git a/Pandora/Pattern/Morphism.hs b/Pandora/Pattern/Morphism.hs
--- a/Pandora/Pattern/Morphism.hs
+++ b/Pandora/Pattern/Morphism.hs
@@ -2,6 +2,8 @@
 
 import Pandora.Pattern.Morphism.Trip as Exports
 import Pandora.Pattern.Morphism.Flip as Exports
+import Pandora.Pattern.Morphism.Tensor as Exports
+import Pandora.Pattern.Morphism.Kleisli as Exports
 import Pandora.Pattern.Morphism.Straight as Exports
 
 type family Opposite m where
diff --git a/Pandora/Pattern/Morphism/Kleisli.hs b/Pandora/Pattern/Morphism/Kleisli.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Morphism/Kleisli.hs
@@ -0,0 +1,3 @@
+module Pandora.Pattern.Morphism.Kleisli where
+
+newtype Kleisli t (v :: * -> * -> *) a e = Kleisli (v a (t e))
diff --git a/Pandora/Pattern/Morphism/Straight.hs b/Pandora/Pattern/Morphism/Straight.hs
--- a/Pandora/Pattern/Morphism/Straight.hs
+++ b/Pandora/Pattern/Morphism/Straight.hs
@@ -7,7 +7,7 @@
 newtype Straight (v :: * -> * -> *) a e = Straight (v a e)
 
 instance Semigroupoid m => Semigroupoid (Straight m) where
-  Straight g . Straight f = Straight (g . f)
+	Straight g . Straight f = Straight (g . f)
 
 instance Category m => Category (Straight m) where
 	identity = Straight identity
diff --git a/Pandora/Pattern/Morphism/Tensor.hs b/Pandora/Pattern/Morphism/Tensor.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Morphism/Tensor.hs
@@ -0,0 +1,4 @@
+module Pandora.Pattern.Morphism.Tensor where
+
+data Tensor p m q l r where
+	Tensor :: m (p (t l) (t r)) (t (q l r)) -> Tensor p m q (t l) (t r) 
diff --git a/Pandora/Pattern/Operation.hs b/Pandora/Pattern/Operation.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Operation.hs
@@ -0,0 +1,11 @@
+module Pandora.Pattern.Operation (module Exports) where
+
+import Pandora.Pattern.Operation.Zero as Exports
+import Pandora.Pattern.Operation.One as Exports
+import Pandora.Pattern.Operation.Unit as Exports
+import Pandora.Pattern.Operation.Sum as Exports
+import Pandora.Pattern.Operation.Product as Exports
+import Pandora.Pattern.Operation.Exponential as Exports
+
+type instance Unit (:*:) = One
+type instance Unit (:+:) = Zero
diff --git a/Pandora/Pattern/Operation/Exponential.hs b/Pandora/Pattern/Operation/Exponential.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Operation/Exponential.hs
@@ -0,0 +1,69 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Pandora.Pattern.Operation.Exponential where
+
+import Pandora.Pattern.Betwixt (Betwixt)
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
+import Pandora.Pattern.Category (Category ((<--), identity))
+import Pandora.Pattern.Kernel (Kernel (constant))
+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.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+
+infixr 7 .:..
+infixr 9 %
+infixl 1 &
+
+type instance Betwixt (->) (->) = (->)
+
+instance Semigroupoid (->) where
+	f . g = \x -> f (g x)
+
+instance Category (->) where
+	identity x = x
+
+instance Kernel (->) where
+	constant x _ = x
+
+instance Covariant (->) (->) ((->) a) where
+	(<-|-) = (.)
+
+instance Distributive (->) (->) ((->) e) where
+	f -<< g = \e -> f % e <-|- g
+
+instance Bindable (->) ((->) e) where
+	f =<< g = \x -> f <-- g x <-- x
+
+instance Semigroup r => Semigroup (e -> r) where
+	f + g = \e -> f e + g e
+
+instance Ringoid r => Ringoid (e -> r) where
+	f * g = \e -> f e * g e
+
+type (--<) = Flip (->)
+
+instance Contravariant (->) (->) ((--<) a) where
+	f >-|- Flip g = Flip <-- g . f
+
+type (-->) = Straight (->)
+
+instance Covariant (->) (->) ((-->) b) where
+	f <-|- Straight g = Straight <-- f . g
+
+(.:..) :: (Covariant (->) target (v a), Semigroupoid v) => v c d -> target (v a (v b c)) (v a (v b d))
+(.:..) f = (<-|-) (f .)
+
+{-# INLINE (%) #-}
+(%) :: (a -> b -> c) -> b -> a -> c
+(%) f x y = f y x
+
+{-# INLINE (&) #-}
+(&) :: a -> (a -> b) -> b
+x & f = f x
+
+fix :: (a -> a) -> a
+fix f = let x = f x in x
diff --git a/Pandora/Pattern/Operation/One.hs b/Pandora/Pattern/Operation/One.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Operation/One.hs
@@ -0,0 +1,3 @@
+module Pandora.Pattern.Operation.One where
+
+data One = One
diff --git a/Pandora/Pattern/Operation/Product.hs b/Pandora/Pattern/Operation/Product.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Operation/Product.hs
@@ -0,0 +1,69 @@
+module Pandora.Pattern.Operation.Product where
+
+import Pandora.Pattern.Category ((<---))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
+import Pandora.Pattern.Object.Lattice (Lattice)
+import Pandora.Pattern.Object.Group (Group (invert))
+import Pandora.Pattern.Operation.Exponential ()
+import Pandora.Pattern.Operation.Unit (Unit)
+import Pandora.Pattern.Operation.One (One)
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+
+infixr 7 :*:
+
+-- TODO Define :*:*:, :*:*:*:, ...
+
+data (:*:) s a = s :*: a
+
+type instance Unit (:*:) = One
+
+instance Covariant (->) (->) ((:*:) s) where
+	f <-|- ~(s :*: x) = s :*: f x
+
+instance Covariant (->) (->) (Flip (:*:) a) where
+	f <-|- Flip (x :*: y) = Flip (f x :*: y)
+
+instance Extendable (->) ((:*:) s) where
+	f <<= ~(s :*: x) = s :*: f (s :*: x)
+
+instance (Setoid s, Setoid a) => Setoid (s :*: a) where
+	~(sx :*: x) == ~(sy :*: y) = (sx == sy) * (x == y)
+
+instance (Semigroup s, Semigroup a) => Semigroup (s :*: a) where
+	~(sx :*: x) + ~(sy :*: y) = (sx + sy) :*: (x + y)
+
+instance (Monoid s, Monoid a) => Monoid (s :*: a) where
+	zero = zero :*: zero
+
+instance (Ringoid s, Ringoid a) => Ringoid (s :*: a) where
+	~(sx :*: x) * ~(sy :*: y) = (sx * sy) :*: (x * y)
+
+instance (Quasiring s, Quasiring a) => Quasiring (s :*: a) where
+	one = one :*: one
+
+instance (Infimum s, Infimum a) => Infimum (s :*: a) where
+	~(sx :*: x) /\ ~(sy :*: y) = sx /\ sy :*: x /\ y
+
+instance (Supremum s, Supremum a) => Supremum (s :*: a) where
+	~(sx :*: x) \/ ~(sy :*: y) = sx \/ sy :*: x \/ y
+
+instance (Lattice s, Lattice a) => Lattice (s :*: a) where
+
+instance (Group s, Group a) => Group (s :*: a) where
+	invert ~(s :*: x) = invert s :*: invert x
+
+delta :: a -> a :*: a
+delta x = x :*: x
+
+swap :: a :*: b -> b :*: a
+swap ~(x :*: y) = y :*: x
+
+attached :: a :*: b -> a
+attached ~(x :*: _) = x
diff --git a/Pandora/Pattern/Operation/Sum.hs b/Pandora/Pattern/Operation/Sum.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Operation/Sum.hs
@@ -0,0 +1,32 @@
+module Pandora.Pattern.Operation.Sum where
+
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category ((<--))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Operation.Exponential ()
+import Pandora.Pattern.Operation.Unit (Unit)
+import Pandora.Pattern.Operation.Zero (Zero)
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+
+infixr 7 :+:
+
+data (:+:) o a = Option o | Adoption a
+
+type instance Unit (:+:) = Zero
+
+instance Covariant (->) (->) ((:+:) o) where
+	_ <-|- Option s = Option s
+	f <-|- Adoption x = Adoption <-- f x
+
+instance Covariant (->) (->) (Flip (:+:) a) where
+	_ <-|- Flip (Adoption x) = Flip . Adoption <-- x
+	f <-|- Flip (Option y) = Flip . Option <-- f y
+
+sum :: (e -> r) -> (a -> r) -> e :+: a -> r
+sum f _ (Option x) = f x
+sum _ s (Adoption x) = s x
+
+-- TODO: keep it until we realize how to implement n-ary functors
+bitraverse_sum :: Covariant (->) (->) t => (e -> t e') -> (a -> t a') -> (e :+: a) -> t (e' :+: a')
+bitraverse_sum f _ (Option x) = Option <-|- f x
+bitraverse_sum _ g (Adoption x) = Adoption <-|- g x
diff --git a/Pandora/Pattern/Operation/Zero.hs b/Pandora/Pattern/Operation/Zero.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Operation/Zero.hs
@@ -0,0 +1,7 @@
+{-# LANGUAGE EmptyCase #-}
+module Pandora.Pattern.Operation.Zero where
+
+data Zero
+
+absurd :: Zero -> a
+absurd x = case x of {}
diff --git a/Pandora/Pattern/Transformation.hs b/Pandora/Pattern/Transformation.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Transformation.hs
@@ -0,0 +1,28 @@
+module Pandora.Pattern.Transformation (module Exports, Component (..), Transformation (..)) where
+
+import Pandora.Pattern.Transformation.Lowerable as Exports
+import Pandora.Pattern.Transformation.Liftable as Exports
+import Pandora.Pattern.Transformation.Hoistable as Exports
+
+import Pandora.Pattern.Morphism.Tensor (Tensor)
+import Pandora.Pattern.Functor (Functor)
+
+-- TODO: Category/Semigroupoid and Functor constrants
+class Component category t u where
+	component :: category (t a) (u a)
+
+type Semimonoidal_ category p q t = Component (Tensor p category q) t t
+-- TODO: Monoidal category p q t =
+type Liftable_ category u t = Component category u (t u)
+type Lowerable_ category t u = Component category (t u) u
+
+lift_ :: Liftable_ category u t => category (u a) (t u a)
+lift_ = component
+
+lower_ :: Lowerable_ category t u => category (t u a) (u a)
+lower_ = component
+
+-- Law: (-|-) morphism . component = component . (-|-) morphism
+-- TODO: natural transformations on semigroupoids?
+class (Functor source target t, Functor source target u) => Transformation source target t u where
+	(|-|) :: source a b -> target (t a) (u b)
diff --git a/Pandora/Pattern/Transformation/Hoistable.hs b/Pandora/Pattern/Transformation/Hoistable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Transformation/Hoistable.hs
@@ -0,0 +1,15 @@
+module Pandora.Pattern.Transformation.Hoistable (Hoistable (..)) where
+
+import Pandora.Pattern.Functor.Covariant (Covariant)
+
+{- |
+> When providing a new instance, you should ensure it satisfies one law:
+> * Exactly morphism: (identity /|\) ≡ identity
+> * Interpreted of morphisms: (f . g /|\) ≡ (f /|\) . (g /|\)
+-}
+
+infixr 5 /|\
+
+class Hoistable m t where
+	{-# MINIMAL (/|\) #-}
+	(/|\) :: Covariant m m u => (forall a . m (u a) (v a)) -> (forall a . m (t u a) (t v a))
diff --git a/Pandora/Pattern/Transformation/Liftable.hs b/Pandora/Pattern/Transformation/Liftable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Transformation/Liftable.hs
@@ -0,0 +1,11 @@
+module Pandora.Pattern.Transformation.Liftable (Liftable (..)) where
+
+import Pandora.Pattern.Functor.Covariant (Covariant)
+
+{- |
+> When providing a new instance, you should ensure it satisfies one law:
+> * Interchange: lift . point ≡ point
+-}
+
+class Liftable cat t where
+	lift :: Covariant cat cat u => cat (u a) (t u a)
diff --git a/Pandora/Pattern/Transformation/Lowerable.hs b/Pandora/Pattern/Transformation/Lowerable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Transformation/Lowerable.hs
@@ -0,0 +1,11 @@
+module Pandora.Pattern.Transformation.Lowerable (Lowerable (..)) where
+
+import Pandora.Pattern.Functor.Covariant (Covariant)
+
+{- |
+> When providing a new instance, you should ensure it satisfies one law:
+> * Interchange: extract . lower ≡ extract
+-}
+
+class Lowerable cat t where
+	lower :: Covariant cat cat u => cat (t u a) (u a)
diff --git a/Pandora/Pattern/Transformer.hs b/Pandora/Pattern/Transformer.hs
deleted file mode 100644
--- a/Pandora/Pattern/Transformer.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module Pandora.Pattern.Transformer (module Exports) where
-
-import Pandora.Pattern.Transformer.Lowerable as Exports
-import Pandora.Pattern.Transformer.Liftable as Exports
-import Pandora.Pattern.Transformer.Hoistable as Exports
diff --git a/Pandora/Pattern/Transformer/Hoistable.hs b/Pandora/Pattern/Transformer/Hoistable.hs
deleted file mode 100644
--- a/Pandora/Pattern/Transformer/Hoistable.hs
+++ /dev/null
@@ -1,15 +0,0 @@
-module Pandora.Pattern.Transformer.Hoistable (Hoistable (..)) where
-
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-{- |
-> When providing a new instance, you should ensure it satisfies one law:
-> * Exactly morphism: (identity /|\) ≡ identity
-> * Interpreted of morphisms: (f . g /|\) ≡ (f /|\) . (g /|\)
--}
-
-infixr 5 /|\
-
-class Hoistable m t where
-	{-# MINIMAL (/|\) #-}
-	(/|\) :: Covariant m m u => (forall a . m (u a) (v a)) -> (forall a . m (t u a) (t v a))
diff --git a/Pandora/Pattern/Transformer/Liftable.hs b/Pandora/Pattern/Transformer/Liftable.hs
deleted file mode 100644
--- a/Pandora/Pattern/Transformer/Liftable.hs
+++ /dev/null
@@ -1,11 +0,0 @@
-module Pandora.Pattern.Transformer.Liftable (Liftable (..)) where
-
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-{- |
-> When providing a new instance, you should ensure it satisfies one law:
-> * Interchange: lift . point ≡ point
--}
-
-class Liftable cat t where
-	lift :: Covariant cat cat u => cat (u a) (t u a)
diff --git a/Pandora/Pattern/Transformer/Lowerable.hs b/Pandora/Pattern/Transformer/Lowerable.hs
deleted file mode 100644
--- a/Pandora/Pattern/Transformer/Lowerable.hs
+++ /dev/null
@@ -1,11 +0,0 @@
-module Pandora.Pattern.Transformer.Lowerable (Lowerable (..)) where
-
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-{- |
-> When providing a new instance, you should ensure it satisfies one law:
-> * Interchange: extract . lower ≡ extract
--}
-
-class Lowerable cat t where
-	lower :: Covariant cat cat u => cat (t u a) (u a)
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.5.5
+version:             0.5.6
 synopsis:            A box of patterns and paradigms
 description:         Humble attempt to define a library for problem solving based on math abstractions.
 homepage:            https://github.com/iokasimov/pandora
@@ -29,11 +29,6 @@
     -- Basic constructions
     Pandora.Paradigm.Algebraic
     Pandora.Paradigm.Algebraic.Functor
-    Pandora.Paradigm.Algebraic.Exponential
-    Pandora.Paradigm.Algebraic.Product
-    Pandora.Paradigm.Algebraic.Sum
-    Pandora.Paradigm.Algebraic.Zero
-    Pandora.Paradigm.Algebraic.One
     Pandora.Paradigm.Primary
     Pandora.Paradigm.Primary.Auxiliary
     Pandora.Paradigm.Primary.Object
@@ -145,6 +140,8 @@
     -- Different morphisms
     Pandora.Pattern.Morphism.Trip
     Pandora.Pattern.Morphism.Flip
+    Pandora.Pattern.Morphism.Tensor
+    Pandora.Pattern.Morphism.Kleisli
     Pandora.Pattern.Morphism.Straight
     -- Algebra typeclasses
     Pandora.Pattern.Semigroupoid
@@ -181,11 +178,18 @@
     Pandora.Pattern.Object.Ringoid
     Pandora.Pattern.Object.Semilattice
     Pandora.Pattern.Object.Semiring
+    -- Typeclassess about object ops
+    Pandora.Pattern.Operation
+    Pandora.Pattern.Operation.One
+    Pandora.Pattern.Operation.Zero
+    Pandora.Pattern.Operation.Exponential
+    Pandora.Pattern.Operation.Product
+    Pandora.Pattern.Operation.Sum
     -- Typeclassess about object composition of functors
-    Pandora.Pattern.Transformer
-    Pandora.Pattern.Transformer.Hoistable
-    Pandora.Pattern.Transformer.Liftable
-    Pandora.Pattern.Transformer.Lowerable
+    Pandora.Pattern.Transformation
+    Pandora.Pattern.Transformation.Hoistable
+    Pandora.Pattern.Transformation.Liftable
+    Pandora.Pattern.Transformation.Lowerable
   default-extensions:
     DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints, InstanceSigs, StandaloneKindSignatures
     FlexibleContexts, FlexibleInstances, KindSignatures, StandaloneKindSignatures, LiberalTypeSynonyms, LambdaCase, FunctionalDependencies