diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -712,7 +712,7 @@
 * Define `<-||-` length encoding operators in `Algebraic` module
 * Define `>-||-` length encoding operators in `Algebraic` module
 * Define `Horizontal` type and use it in binary tree zipper
-* Define `?==` operator as replacemet for if statement
+* Define `?=` operator as replacemet for if statement
 * Define `<:*:>`, `>:*:>`, `<:*:<`, `>:*:<` type synonyms
 * Define `<:+:>`, `>:+:>`, `<:+:<`, `>:+:<` type synonyms
 * Define `Functor` module in `Algebraic`
@@ -720,3 +720,17 @@
 * Change `Zipper` definition - tag it
 
 # 0.5.3
+* Move `Algebraic` module from `Primary` to `Paradigm`
+* Define `<:*:>` infix operator
+* Rename `Tail` constructor of `Segment` to `Rest`
+* Remove 'twosome' in favor `<:*:>`
+* Rename `?==` operator to `?=`
+* Remove `Conditional` module
+* Change operators' precedence, length of operators define precedence
+* Remove `leaf`, `left`, `right`, `both` in `Binary` module
+* Define `Zipper` instance of `Nonempty Rose` tree
+* Change `Zipper` definition - add `structure` in tag
+* Define `Roses` type synonymous
+* Move `Tape` to `Structure.Modification.Tape` module
+
+# 0.5.4
diff --git a/Pandora/Paradigm.hs b/Pandora/Paradigm.hs
--- a/Pandora/Paradigm.hs
+++ b/Pandora/Paradigm.hs
@@ -4,4 +4,5 @@
 import Pandora.Paradigm.Inventory as Exports
 import Pandora.Paradigm.Controlflow as Exports
 import Pandora.Paradigm.Primary as Exports
+import Pandora.Paradigm.Algebraic as Exports
 import Pandora.Paradigm.Schemes as Exports
diff --git a/Pandora/Paradigm/Algebraic.hs b/Pandora/Paradigm/Algebraic.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Algebraic.hs
@@ -0,0 +1,84 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Pandora.Paradigm.Algebraic (module Exports) 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.Core.Functor (type (>))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category ((<--), (<---), identity)
+import Pandora.Pattern.Kernel (constant)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
+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), type (<:.:>))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted ((<~)))
+
+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
+		T_U (lxs :*: rxs) :*: T_U (lys :*: rys)
+
+instance (Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <:*:> u) where
+	mult = Straight <-- \(T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) -> T_U <--- (mult @(-->) <~) (xls :*: yls) :*: (mult @(-->) <~) (xrs :*: yrs)
+
+instance (Semimonoidal (-->) (:*:) (:+:) t, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) (t <:*:> u) where
+	mult = Straight <-- \(T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) ->
+		(mult @(-->) @(:*:) @(:+:) <~ (xls :*: yls)) <:*:> (mult @(-->) @(:*:) @(:+:) <~ (xrs :*: yrs))
+
+instance (Monoidal (-->) (-->) (:*:) (:+:) t, Monoidal (-->) (-->) (:*:) (:+:) u)
+	=> Monoidal (-->) (-->) (:*:) (:+:) (t <:*:> u) where
+		unit _ = Straight <-- \_ -> empty <:*:> empty
+
+instance Traversable (->) (->) ((:*:) s) where
+	f <<- x = (attached x :*:) <-|- f (extract x)
+
+instance Semimonoidal (-->) (:*:) (:*:) ((->) e) where
+	mult :: ((e -> a) :*: (e -> b)) --> (e -> (a :*: b))
+	mult = Straight <-- \(g :*: h) -> \x -> g x :*: h x
+
+instance Monoidal (-->) (-->) (:*:) (:*:) ((->) e) where
+	unit _ = Straight <-- constant . (<~ One)
+
+instance Semimonoidal (<--) (:*:) (:*:) ((->) e) where
+	mult :: ((e -> a) :*: (e -> b)) <-- (e -> a :*: b)
+	mult = Flip <-- \f -> attached . f :*: extract . f
+
+instance Semimonoidal (-->) (:*:) (:+:) ((:+:) e) where
+	mult :: ((e :+: a) :*: (e :+: b)) --> (e :+: a :+: b)
+	mult = Straight <-- \case
+		Option _ :*: Option e' -> Option e'
+		Option _ :*: Adoption y -> Adoption <-- Adoption y
+		Adoption x :*: _ -> Adoption <-- Option x
+
+instance Semimonoidal (-->) (:*:) (:*:) ((:+:) e) where
+	mult = Straight <-- \case
+		Adoption x :*: Adoption y -> Adoption <--- x :*: y
+		Option e :*: _ -> Option e
+		_ :*: Option e -> Option e
+
+instance Monoidal (-->) (-->) (:*:) (:*:) ((:+:) e) where
+	unit _ = Straight <-- Adoption . (<~ One)
+
+instance Semimonoidal (<--) (:*:) (:*:) ((:*:) s) where
+	mult = Flip <-- \(s :*: x :*: y) -> (s :*: x) :*: (s :*: y)
+
+instance Monoidal (<--) (-->) (:*:) (:*:) ((:*:) s) where
+	unit _ = Flip <-- \(_ :*: x) -> Straight (\_ -> x)
+
+instance Comonad (->) ((:*:) s) where
+
+instance Semimonoidal (<--) (:*:) (:*:) (Flip (:*:) a) where
+	mult = Flip <-- \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
+
+instance Monoidal (<--) (-->) (:*:) (:*:) (Flip (:*:) a) where
+	unit _ = Flip <-- \(Flip (s :*: _)) -> Straight (\_ -> s)
diff --git a/Pandora/Paradigm/Algebraic/Exponential.hs b/Pandora/Paradigm/Algebraic/Exponential.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Algebraic/Exponential.hs
@@ -0,0 +1,69 @@
+{-# 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
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Algebraic/Functor.hs
@@ -0,0 +1,141 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Pandora.Paradigm.Algebraic.Functor where
+
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category ((<--))
+import Pandora.Pattern.Kernel (constant)
+import Pandora.Pattern.Morphism.Flip (Flip)
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|---), (<-|-|-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit), Unit)
+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.Paradigm.Primary.Functor.Proxy (Proxy (Proxy))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted ((<~), (<~~~), (-#=)))
+
+infixl 1 <-*------, .-*------, <-||-----, >-||-----
+infixl 2 <-*-----, .-*-----, <-||----, >-||----
+infixl 3 <-*----, .-*----, <-||---, >-||---
+infixl 4 <-*---, .-*---, <-*-*-, <-||--, >-||--
+infixl 5 <-*--, .-*--, .-*-*-, <-||-, >-||-
+infixl 6 <-*-, .-*-, <-+-, .-+-
+
+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)
+
+instance Adjoint (->) (->) ((:*:) s) ((->) s) where
+	(-|) :: ((s :*: a) -> b) -> a -> (s -> b)
+	f -| x = \s -> f (s :*: x)
+	(|-) :: (a -> s -> b) -> (s :*: a) -> b
+	f |- ~(s :*: x) = f x s
+
+(<-*--------), (<-*-------), (<-*------), (<-*-----), (<-*----), (<-*---), (<-*--), (<-*-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t (a -> b) -> t a -> t b
+f <-*-------- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
+f <-*------- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
+f <-*------ x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
+f <-*----- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
+f <-*---- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
+f <-*--- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
+f <-*-- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
+f <-*- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
+
+(.-*--------), (.-*-------), (.-*------), (.-*-----), (.-*----), (.-*---), (.-*--), (.-*-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t b -> t a -> t b
+y .-*-------- x = (\_ y' -> y') <-|- x <-*- y
+y .-*------- x = (\_ y' -> y') <-|- x <-*- y
+y .-*------ x = (\_ y' -> y') <-|- x <-*- y
+y .-*----- x = (\_ y' -> y') <-|- x <-*- y
+y .-*---- x = (\_ y' -> y') <-|- x <-*- y
+y .-*--- x = (\_ y' -> y') <-|- x <-*- y
+y .-*-- x = (\_ y' -> y') <-|- x <-*- y
+y .-*- x = (\_ y' -> y') <-|- x <-*- y
+
+(<-*-*-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => t (u (a -> b)) -> t (u a) -> t (u b)
+f <-*-*- x = (<-*-) <-|- f <-*- x
+
+(.-*-*-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => t (u b) -> t (u a) -> t (u b)
+y .-*-*- x = (\_ y' -> y') <-|-|- x <-*-*- y
+
+(<-+-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t) => t b -> t a -> (a :+: b -> r) -> t r
+y <-+- x = \f -> f <-|--- mult @(-->) <~~~ x :*: y
+
+(.-+-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t) => t a -> t a -> t a
+y .-+- x = (\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 = r .-*- x in r
+
+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
+
+point :: Pointable t => a -> t a
+point x = unit @(-->) Proxy <~~~ Straight <-- \One -> x
+
+pass :: Pointable t => t ()
+pass = point ()
+
+empty :: Emptiable t => t a
+empty = unit @(-->) Proxy <~ Straight absurd
+
+(<-||-), (<-||--), (<-||---), (<-||----), (<-||-----), (<-||------), (<-||-------), (<-||--------)
+	:: 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)
+
+(>-||-), (>-||--), (>-||---), (>-||----), (>-||-----), (>-||------), (>-||-------), (>-||--------)
+	:: 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)
+(>-||--) f = (-#=) @m @(Flip p c) ((>-|-) f)
+(>-||-) f = (-#=) @m @(Flip p c) ((>-|-) f)
+
+(<-|-<-|-) :: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c d .
+	(Covariant m m (p a), Covariant m m (Flip p d), Interpreted m (Flip p d))
+	=> m a b :*: m c d -> m (p a c) (p b d)
+(<-|-<-|-) (f :*: g) = (-#=) @m @(Flip p d) ((<-|-) f) . ((<-|-) g)
+
+(<-|->-|-) :: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c d .
+	(Covariant m m (Flip p c), Contravariant m m (p a), Interpreted m (Flip p c))
+	=> m a b :*: m c d -> m (p a d) (p b c)
+(<-|->-|-) (f :*: g) = (-#=) @m @(Flip p c) ((<-|-) f) . ((>-|-) g)
+
+(>-|-<-|-) :: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c d .
+	(Contravariant m m (Flip p d), Covariant m m (p b), Interpreted m (Flip p d))
+	=> m a b :*: m c d -> m (p b c) (p a d)
+(>-|-<-|-) (f :*: g) = (-#=) @m @(Flip p d) ((>-|-) f) . ((<-|-) g)
+
+(>-|->-|-) :: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c d .
+	(Contravariant m m (p b), Contravariant m m (Flip p c), Interpreted m (Flip p c))
+	=> m a b :*: m c d -> m (p b d) (p a c)
+(>-|->-|-) (f :*: g) = (-#=) @m @(Flip p c) ((>-|-) f) . ((>-|-) g)
+
+void :: Covariant (->) (->) t => t a -> t ()
+void x = constant () <-|- x
diff --git a/Pandora/Paradigm/Algebraic/One.hs b/Pandora/Paradigm/Algebraic/One.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Algebraic/One.hs
@@ -0,0 +1,3 @@
+module Pandora.Paradigm.Algebraic.One where
+
+data One = One
diff --git a/Pandora/Paradigm/Algebraic/Product.hs b/Pandora/Paradigm/Algebraic/Product.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Algebraic/Product.hs
@@ -0,0 +1,74 @@
+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.Controlflow.Effect.Interpreted ()
+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>), type (>:.:>), type (<:.:<), type (>:.:<))
+
+infixr 8 :*:
+infixr 5 <:*:>
+
+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
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Algebraic/Sum.hs
@@ -0,0 +1,35 @@
+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
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Algebraic/Zero.hs
@@ -0,0 +1,8 @@
+{-# 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.hs b/Pandora/Paradigm/Controlflow/Effect.hs
--- a/Pandora/Paradigm/Controlflow/Effect.hs
+++ b/Pandora/Paradigm/Controlflow/Effect.hs
@@ -1,6 +1,5 @@
 module Pandora.Paradigm.Controlflow.Effect (module Exports) where
 
 import Pandora.Paradigm.Controlflow.Effect.Transformer as Exports
-import Pandora.Paradigm.Controlflow.Effect.Conditional as Exports
 import Pandora.Paradigm.Controlflow.Effect.Interpreted as Exports
 import Pandora.Paradigm.Controlflow.Effect.Adaptable as Exports
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
@@ -7,9 +7,9 @@
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Transformer (Liftable (lift))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
-import Pandora.Paradigm.Primary.Algebraic (Pointable, extract, point)
+import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Paradigm.Algebraic.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/Conditional.hs b/Pandora/Paradigm/Controlflow/Effect/Conditional.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Effect/Conditional.hs
+++ /dev/null
@@ -1,24 +0,0 @@
-{-# LANGUAGE AllowAmbiguousTypes #-}
-module Pandora.Paradigm.Controlflow.Effect.Conditional where
-
-import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
-import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
-
-class Conditional prompt clause where
-	iff :: clause -> a -> a -> a
-
-instance Conditional True Boolean where
-	iff True x _ = x
-	iff False _ y = y
-
-instance Conditional False Boolean where
-	iff False x _ = x
-	iff True _ y = y
-
-instance Conditional Just (Maybe a) where
-	iff (Just _) x _ = x
-	iff Nothing _ y = y
-
-instance Conditional Nothing (Maybe a) where
-	iff Nothing x _ = x
-	iff (Just _) _ y = y
diff --git a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
@@ -6,19 +6,18 @@
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Algebraic.Exponential ()
 
 infixr 2 =#-, -#=
 
-infixl 1 <~~~~~~~~~
-infixl 2 <~~~~~~~~
-infixl 3 <~~~~~~~
-infixl 4 <~~~~~~
-infixl 5 <~~~~~
-infixl 6 <~~~~
-infixl 7 <~~~
-infixl 8 <~~
-infixl 9 <~
+infixl 1 <~~~~~~~~
+infixl 2 <~~~~~~~
+infixl 3 <~~~~~~
+infixl 4 <~~~~~
+infixl 5 <~~~~
+infixl 6 <~~~
+infixl 7 <~~
+infixl 8 <~
 
 type family Schematic (c :: (* -> * -> *) -> (* -> *) -> k) (t :: * -> *) = (r :: (* -> *) -> * -> *) | r -> t
 
@@ -28,8 +27,7 @@
 	run :: m < t a < Primary t a
 	unite :: m < Primary t a < t a
 
-	(<~~~~~~~~~), (<~~~~~~~~), (<~~~~~~~), (<~~~~~~), (<~~~~~), (<~~~~), (<~~~), (<~~), (<~) :: m < t a < Primary t a
-	(<~~~~~~~~~) = run
+	(<~~~~~~~~), (<~~~~~~~), (<~~~~~~), (<~~~~~), (<~~~~), (<~~~), (<~~), (<~) :: m < t a < Primary t a
 	(<~~~~~~~~) = run
 	(<~~~~~~~) = run
 	(<~~~~~~) = run
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
@@ -15,10 +15,10 @@
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (Extractable, point)
+import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Paradigm.Algebraic (Extractable, point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (<~~~)))
 
 class Interpreted m t => Comonadic m t where
@@ -29,7 +29,7 @@
 newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }
 
 instance Covariant (->) (->) (Schematic Comonad t u) => Covariant (->) (->) (t :< u) where
-	f <-|- TC x = TC <--- f <-|- x
+	f <-|- TC x = TC <---- f <-|- x
 
 instance Semimonoidal (-->) (:*:) (:*:) (Schematic Comonad t u) => Semimonoidal (-->) (:*:) (:*:) (t :< u) where
 	mult = Straight <-- \(TC f :*: TC x) -> TC
@@ -43,13 +43,13 @@
 	f <<- TC x = TC <-|- f <<- x
 
 instance Distributive (->) (->) (Schematic Comonad t u) => Distributive (->) (->) (t :< u) where
-	f -<< x = TC <--- tc . f --<< x
+	f -<< x = TC <--- tc . f -<< x
 
 instance Bindable (->) (Schematic Comonad t u) => Bindable (->) (t :< u) where
-	f =<< TC x = TC <--- tc . f ==<< x
+	f =<< TC x = TC <--- tc . f =<< x
 
 instance Extendable (->) (Schematic Comonad t u) => Extendable (->) (t :< u) where
-	f <<= TC x = TC <--- f . TC <<== x
+	f <<= TC x = TC <--- f . TC <<= x
 
 instance (Extractable (t :< u), Extendable (->) (t :< u)) => Comonad (->) (t :< u) where
 
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
@@ -15,11 +15,11 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (Pointable, point)
+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.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (<~~~)))
 
 class Interpreted m t => Monadic m t where
@@ -30,7 +30,7 @@
 newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
 
 instance Covariant (->) (->) (Schematic Monad t u) => Covariant (->) (->) (t :> u) where
-	f <-|- TM x = TM <--- f <-|- x
+	f <-|- TM x = TM <---- f <-|- x
 
 instance Semimonoidal (-->) (:*:) (:*:) (Schematic Monad t u) => Semimonoidal (-->) (:*:) (:*:) (t :> u) where
 	mult = Straight <-- \(TM f :*: TM x) -> TM
@@ -49,13 +49,13 @@
 	f <<- TM x = TM <-|- f <<- x
 
 instance Distributive (->) (->) (Schematic Monad t u) => Distributive (->) (->) (t :> u) where
-	f -<< x = TM <--- tm . f --<< x
+	f -<< x = TM <--- tm . f -<< x
 
 instance Bindable (->) (Schematic Monad t u) => Bindable (->) (t :> u) where
-	f =<< TM x = TM <--- tm . f ==<< x
+	f =<< TM x = TM <--- tm . f =<< x
 
 instance Extendable (->) (Schematic Monad t u) => Extendable (->) (t :> u) where
-	f <<= TM x = TM <--- f . TM <<== x
+	f <<= TM x = TM <--- f . TM <<= x
 
 instance (Covariant (->) (->) (Schematic Monad t u), Monoidal (-->) (-->) (:*:) (:*:) (Schematic Monad t u), Bindable (->) (t :> u)) => Monad (->) (t :> u) where
 
diff --git a/Pandora/Paradigm/Controlflow/Observable.hs b/Pandora/Paradigm/Controlflow/Observable.hs
--- a/Pandora/Paradigm/Controlflow/Observable.hs
+++ b/Pandora/Paradigm/Controlflow/Observable.hs
@@ -4,7 +4,7 @@
 import Pandora.Core.Functor (type (<))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---))
-import Pandora.Paradigm.Primary.Algebraic (Applicative, loop)
+import Pandora.Paradigm.Algebraic (Applicative, loop)
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~~))
 
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
@@ -5,9 +5,9 @@
 import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 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
@@ -7,7 +7,7 @@
 
 import Pandora.Core.Functor (type (~>))
 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 ((<-|-), (<-|--)))
@@ -15,9 +15,9 @@
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (--|), (|-), (|--)))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), type (<--))
-import Pandora.Paradigm.Primary.Algebraic (Pointable, extract)
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic.Exponential ((%), type (<--))
+import Pandora.Paradigm.Algebraic (Pointable, extract)
 import Pandora.Paradigm.Primary (Simplification)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
@@ -44,7 +44,7 @@
 	zoom lens less = adapt . State <-- \source -> restruct |- run (lens <~ source) where
 
 		restruct :: (Exactly ls -> bg) -> Exactly ls -> bg :*: result
-		restruct to (Exactly target) = run <--- to . Exactly <-|- Flip (less <~ target)
+		restruct to (Exactly target) = run <---- to . Exactly <-|- Flip (less <~ target)
 
 instance Zoomable State Maybe where
 	zoom :: forall bg ls t result . Stateful bg t => Obscure Lens bg ls -> State (Maybe ls) result -> t result
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
@@ -3,16 +3,16 @@
 
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---))
+import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Object.Monoid (Monoid)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
@@ -21,7 +21,7 @@
 newtype Accumulator e a = Accumulator (e :*: a)
 
 instance Covariant (->) (->) (Accumulator e) where
-	f <-|- Accumulator x = Accumulator <--- f <-|- x
+	f <-|- Accumulator x = Accumulator <---- f <-|- x
 
 instance Semigroup e => Semimonoidal (-->) (:*:) (:*:) (Accumulator e) where
 	mult = Straight <-- \(x :*: y) -> Accumulator <--- k <-- run x <-- run y where
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
@@ -2,13 +2,13 @@
 module Pandora.Paradigm.Inventory.Some.Equipment (Equipment (..), retrieve) where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<---), (<-----))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Category ((<---), (<----))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((<<=), (<<==)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Paradigm.Primary.Algebraic ()
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
+import Pandora.Paradigm.Algebraic ()
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), attached)
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Inventory.Ability.Gettable (Gettable (Getting, get))
@@ -17,13 +17,13 @@
 newtype Equipment e a = Equipment (e :*: a)
 
 instance Covariant (->) (->) (Equipment e) where
-	f <-|- Equipment x = Equipment <--- f <-|- x
+	f <-|- Equipment x = Equipment <---- f <-|- x
 
 instance Traversable (->) (->) (Equipment e) where
-	f <<- Equipment x = Equipment <-|- f <<- x
+	f <<- Equipment x = Equipment <-|-- f <<- x
 
 instance Extendable (->) (Equipment e) where
-	f <<= Equipment (e :*: x) = Equipment . (:*:) e . f . Equipment <----- e :*: x
+	f <<= Equipment (e :*: x) = Equipment . (:*:) e . f . Equipment <---- e :*: x
 
 instance Interpreted (->) (Equipment e) where
 	type Primary (Equipment e) a = e :*: a
@@ -35,7 +35,7 @@
 type Equipped e t = Adaptable (Equipment e) (->) t
 
 instance {-# OVERLAPS #-} Extendable (->) u => Extendable (->) ((:*:) e <:.> u) where
-	f <<= TU (e :*: x) = TU . (:*:) e <--- f . TU . (:*:) e <<== x
+	f <<= TU (e :*: x) = TU . (:*:) e <--- f . TU . (:*:) e <<= x
 
 retrieve :: Equipped e t => t a -> e
 retrieve = attached . run @(->) @(Equipment _) . adapt
diff --git a/Pandora/Paradigm/Inventory/Some/Imprint.hs b/Pandora/Paradigm/Inventory/Some/Imprint.hs
--- a/Pandora/Paradigm/Inventory/Some/Imprint.hs
+++ b/Pandora/Paradigm/Inventory/Some/Imprint.hs
@@ -2,14 +2,14 @@
 module Pandora.Paradigm.Inventory.Some.Imprint (Imprint (..), Traceable) where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--))
+import Pandora.Pattern.Category ((<--), (<---))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Primary.Algebraic ()
+import Pandora.Paradigm.Algebraic ()
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable)
@@ -24,7 +24,7 @@
 	f >-|- Flip (Imprint g) = Flip . Imprint <-- g . f
 
 instance Distributive (->) (->) (Imprint e) where
-	f -<< g = Imprint <-- (run @(->) <-|- f) -<< g
+	f -<< g = Imprint <--- (run @(->) <-|- f) -<< g
 
 instance Semigroup e => Extendable (->) (Imprint e) where
 	f <<= Imprint x = Imprint <-- \e -> f . Imprint <-- x . (e +)
@@ -37,6 +37,6 @@
 type instance Schematic Comonad (Imprint e) = (<.:>) ((->) e)
 
 instance {-# OVERLAPS #-} (Semigroup e, Extendable (->) u) => Extendable (->) ((->) e <.:> u) where
-	f <<= UT x = UT <-- (\x' e -> f . UT . (<-|-) (. (e +)) <-- x') <<= x
+	f <<= UT x = UT <--- (\x' e -> f . UT . (<-|-) (. (e +)) <-- x') <<= x
 
 type Traceable e t = Adaptable t (->) (Imprint e)
diff --git a/Pandora/Paradigm/Inventory/Some/Optics.hs b/Pandora/Paradigm/Inventory/Some/Optics.hs
--- a/Pandora/Paradigm/Inventory/Some/Optics.hs
+++ b/Pandora/Paradigm/Inventory/Some/Optics.hs
@@ -4,20 +4,20 @@
 
 import Pandora.Core.Impliable (Impliable (Arguments, imply))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (Category (identity, (<--), (<---), (<-----), (<-------)))
+import Pandora.Pattern.Category (Category (identity, (<--), (<---), (<----), (<-----), (<-------)))
 import Pandora.Pattern.Kernel (Kernel (constant))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|-|-)))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
-import Pandora.Pattern.Object.Setoid (Setoid ((?==)))
+import Pandora.Pattern.Object.Setoid (Setoid ((?=)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run, (<~)))
 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.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), (%))
-import Pandora.Paradigm.Primary.Algebraic (Pointable, point, extract, (>-||-----), (>-|-<-|-))
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic.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))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
@@ -31,7 +31,7 @@
 type Lens = P_Q_T (->) Store
 
 instance Invariant (Flip (Lens available) tgt) where
-	f <!< g = \(Flip (P_Q_T lens)) -> Flip . P_Q_T <------- g >-||----- f <-|-|- lens
+	f <!< g = \(Flip (P_Q_T lens)) -> Flip . P_Q_T <------- g >-||--- f <-|-|- lens
 
 type family Convex lens where
 	Convex Lens = Lens Exactly
@@ -86,7 +86,7 @@
 
 -- | Representable based lens
 represent :: forall t a . (Representable t, Setoid (Representation t)) => Representation t -> Convex Lens (t a) a
-represent r = imply @(Convex Lens (t a) a) (r <#>) (\source target -> tabulate <-- \r' -> r' ?== r <----- target <----- r' <#> source)
+represent r = imply @(Convex Lens (t a) a) (r <#>) (\source target -> tabulate <-- \r' -> r' ?= r <----- target <----- r' <#> source)
 
 class Lensic previous next where
 	type Lensally previous next :: * -> *
@@ -101,7 +101,7 @@
 	P_Q_T from >>> P_Q_T to = P_Q_T <-- \source -> case run <-- from source of
 		Nothing :*: _ -> Store <--- Nothing :*: \_ -> source
 		Just between :*: mbs -> case run <-- to between of
-			Exactly target :*: itb -> Store <--- Just target :*: \mt -> mbs <--- itb . Exactly <-|- mt
+			Exactly target :*: itb -> Store <--- Just target :*: \mt -> mbs <---- itb . Exactly <-|- mt
 
 instance Lensic Exactly Maybe where
 	type Lensally Exactly Maybe = Maybe
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
@@ -2,19 +2,19 @@
 module Pandora.Paradigm.Inventory.Some.Provision where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (identity, (<--), (<---))
+import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
-import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<), (---<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), (%))
-import Pandora.Paradigm.Primary.Algebraic ((<-||-))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.Exponential (type (-->), (%))
+import Pandora.Paradigm.Algebraic ((<-||-))
+import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Paradigm.Algebraic (point)
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (<~)))
@@ -38,7 +38,7 @@
 	unit _ = Straight <-- \f -> Provision <-- \_ -> run f One
 
 instance Distributive (->) (->) (Provision e) where
-	f -<< g = Provision <-- (run @(->) <-|- f) -<< g
+	f -<< g = Provision <--- (run @(->) <-|- f) -<< g
 
 instance Bindable (->) (Provision e) where
 	f =<< Provision x = Provision <-- \e -> (run % e) . f . x <-- e
@@ -53,7 +53,7 @@
 type instance Schematic Monad (Provision e) = (<:.>) ((->) e)
 
 instance Monadic (->) (Provision e) where
-	wrap x = TM . TU <--- point <-|- run x
+	wrap x = TM . TU <---- point <-|- run x
 
 type Provided e t = Adaptable t (->) (Provision e)
 
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
@@ -5,26 +5,26 @@
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), identity)
+import Pandora.Pattern.Category ((<--), (<---), (<----), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 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.Traversable (Traversable ((<<-)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Adjoint ((-|), (|--))
+import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-)), Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, (<~), unite, (=#-)), Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 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.Schemes.TUT (TUT (TUT), type (<:<.>:>))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (.-*-), delta)
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (Pointable, point, (<-||-), (>-||-))
+import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Paradigm.Algebraic ((:*:) ((:*:)), (.-*-), delta)
+import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Paradigm.Algebraic (Pointable, point, (<-||-), (>-||-))
 
 -- | Effectful computation with a variable
 newtype State s a = State ((->) s :. (:*:) s > a)
@@ -39,10 +39,10 @@
 		new :*: x :*: y
 
 instance Monoidal (-->) (-->) (:*:) (:*:) (State s) where
-	unit _ = Straight <--- State . (identity @(->) -|) . (<-- One) . run
+	unit _ = Straight <-- State . (identity @(->) -|) . (<~ One)
 
 instance Bindable (->) (State s) where
-	f =<< x = State <--- (run . f |--) <-|- run x
+	f =<< x = State <---- (run . f |-) <-|- run x
 
 instance Monad (->) (State s) where
 
@@ -57,17 +57,17 @@
 type instance Schematic Monad (State s) = (->) s <:<.>:> (:*:) s
 
 instance Monadic (->) (State s) where
-	wrap x = TM . TUT <--- point <-|- run x
+	wrap x = TM . TUT <---- point <-|- run x
 
 type Stateful s t = Adaptable t (->) (State s)
 
 reconcile :: (Bindable (->) t, Stateful s t, Adaptable t (->) u) => (s -> u s) -> t s
-reconcile f = adapt . set @State ===<< adapt . f  ===<< adapt <-- get @State
+reconcile f = adapt . set @State ==<< adapt . f ==<< adapt <-- get @State
 
 type Memorable s t = (Covariant (->) (->) t, Pointable t, Stateful s t)
 
 fold :: (Traversable (->) (->) t, Memorable s u) => (a -> s -> s) -> t a -> u s
-fold op struct = adapt <-- get @State .-*- (adapt . modify @State . op <<-- struct)
+fold op struct = adapt <-- get @State .-*- (adapt . modify @State . op <<- struct)
 
 instance Gettable State where
 	type Getting State state ouput = State state state
@@ -79,4 +79,4 @@
 
 instance Modifiable State where
 	type Modification State state output = (state -> state) -> State state state
-	modify f = State <--- \s -> let r = f s in r :*: r
+	modify f = State <--- \s -> f s :*: f s
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
@@ -3,18 +3,18 @@
 
 import Pandora.Core (type (:.), type (>), type (<:=), type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----), identity)
+import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------), identity)
 import Pandora.Pattern.Kernel (constant)
-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.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Adjoint ((-|), (|-))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->), (%), (.:..))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
-import Pandora.Paradigm.Primary.Algebraic (extract, (<-||-), (>-||-))
+import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->), (%), (.:..))
+import Pandora.Paradigm.Algebraic.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))
@@ -39,7 +39,7 @@
 
 -- TODO: Try to generalize (->) here
 instance Extendable (->) (Store s) where
-	f <<= Store x = Store <---- f <-|-|- ((Store .:.. (identity @(->) -|)) <-|- x)
+	f <<= Store x = Store <------ f <-|-|- ((Store .:.. (identity @(->) -|)) <-|-- x)
 
 instance Comonad (->) (Store s) where
 
diff --git a/Pandora/Paradigm/Primary.hs b/Pandora/Paradigm/Primary.hs
--- a/Pandora/Paradigm/Primary.hs
+++ b/Pandora/Paradigm/Primary.hs
@@ -1,114 +1,22 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-module Pandora.Paradigm.Primary (module Exports, Simplification, twosome) where
+module Pandora.Paradigm.Primary (module Exports, Simplification) where
 
 import Pandora.Paradigm.Primary.Linear as Exports
 import Pandora.Paradigm.Primary.Transformer as Exports
 import Pandora.Paradigm.Primary.Functor as Exports
 import Pandora.Paradigm.Primary.Object as Exports
-import Pandora.Paradigm.Primary.Algebraic as Exports
 
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category ((<--), (<---))
-import Pandora.Pattern.Kernel (Kernel (constant))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
+import Pandora.Pattern.Category ((<---))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-), (-|)))
-import Pandora.Pattern.Transformer.Liftable (lift)
-import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~))
-import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
-import Pandora.Paradigm.Schemes (TU (TU), T_U (T_U), UT, TUT, P_Q_T (P_Q_T), type (<:.>), type (<:.:>))
-import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (resolve))
-import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into), premorph)
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure))
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Schemes (TU, T_U, UT, TUT)
 
 instance Adjoint (->) (->) (Flip (:*:) s) ((->) s) where
 	f -| x = \s -> f . Flip <--- x :*: s
 	f |- Flip (x :*: s) = f x s
-
-instance Morphable (Into Maybe) (Conclusion e) where
-	type Morphing (Into Maybe) (Conclusion e) = Maybe
-	morphing = conclusion (constant Nothing) Just . premorph
-
-instance Morphable (Into (Conclusion e)) Maybe where
-	type Morphing (Into (Conclusion e)) Maybe = (->) e <:.> Conclusion e
-	morphing (premorph -> Just x) = TU <-- \_ -> Success x
-	morphing (premorph -> Nothing) = TU <-- \e -> Failure e
-
-instance Morphable (Into (Flip Conclusion e)) Maybe where
-	type Morphing (Into (Flip Conclusion e)) Maybe = (->) e <:.> Flip Conclusion e
-	morphing (run . premorph -> Just x) = TU <-- \_ -> Flip <-- Failure x
-	morphing (run . premorph -> Nothing) = TU <-- Flip . Success
-
-instance Morphable (Into (Left Maybe)) Wye where
-	type Morphing (Into (Left Maybe)) Wye = Maybe
-	morphing (premorph -> Both ls _) = Just ls
-	morphing (premorph -> Left ls) = Just ls
-	morphing (premorph -> Right _) = Nothing
-	morphing (premorph -> End) = Nothing
-
-instance Morphable (Into (Right Maybe)) Wye where
-	type Morphing (Into (Right Maybe)) Wye = Maybe
-	morphing (premorph -> Both _ rs) = Just rs
-	morphing (premorph -> Left _) = Nothing
-	morphing (premorph -> Right rs) = Just rs
-	morphing (premorph -> End) = Nothing
-
-instance Morphable (Into (This Maybe)) (These e) where
-	type Morphing (Into (This Maybe)) (These e) = Maybe
-	morphing (premorph -> This x) = Just x
-	morphing (premorph -> That _) = Nothing
-	morphing (premorph -> These _ x) = Just x
-
-instance Morphable (Into (That Maybe)) (Flip These a) where
-	type Morphing (Into (That Maybe)) (Flip These a) = Maybe
-	morphing (run . premorph -> This _) = Nothing
-	morphing (run . premorph -> That x) = Just x
-	morphing (run . premorph -> These y _) = Just y
-
-instance Morphable (Into (Here Maybe)) (Flip Wedge a) where
-	type Morphing (Into (Here Maybe)) (Flip Wedge a) = Maybe
-	morphing (run . premorph -> Nowhere) = Nothing
-	morphing (run . premorph -> Here x) = Just x
-	morphing (run . premorph -> There _) = Nothing
-
-instance Morphable (Into (There Maybe)) (Wedge e) where
-	type Morphing (Into (There Maybe)) (Wedge e) = Maybe
-	morphing (premorph -> Nowhere) = Nothing
-	morphing (premorph -> Here _) = Nothing
-	morphing (premorph -> There x) = Just x
-
-instance Morphable (Into Wye) (Maybe <:.:> Maybe > (:*:)) where
-	type Morphing (Into Wye) (Maybe <:.:> Maybe > (:*:)) = Wye
-	morphing (run . premorph -> Just x :*: Just y) = Both x y
-	morphing (run . premorph -> Nothing :*: Just y) = Right y
-	morphing (run . premorph -> Just x :*: Nothing) = Left x
-	morphing (run . premorph -> Nothing :*: Nothing) = End
-
-instance Substructure Left Wye where
-	type Substance Left Wye = Maybe
-	substructure = P_Q_T <-- \new -> case lower new of
-		End -> Store <--- Nothing :*: lift . resolve Left End
-		Left x -> Store <--- Just x :*: lift . resolve Left End
-		Right y -> Store <--- Nothing :*: lift . constant (Right y)
-		Both x y -> Store <--- Just x :*: lift . resolve (Both % y) (Right y)
-
-instance Substructure Right Wye where
-	type Substance Right Wye = Maybe
-	substructure = P_Q_T <-- \new -> case lower new of
-		End -> Store <--- Nothing :*: lift . resolve Right End
-		Left x -> Store <--- Nothing :*: lift . constant (Left x)
-		Right y -> Store <--- Just y :*: lift . resolve Right End
-		Both x y -> Store <--- Just y :*: lift . resolve (Both x) (Left x)
-
-instance (Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <:.:> u > (:*:)) where
-	mult = Straight <-- \(T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) -> T_U <--- (mult @(-->) <~) (xls :*: yls) :*: (mult @(-->) <~) (xrs :*: yrs)
-
-twosome :: t a -> u a -> (<:.:>) t u (:*:) a
-twosome x y = T_U <--- x :*: y
 
 type family Simplification (t :: * -> *) (a :: *) where
 	Simplification Exactly a = a
diff --git a/Pandora/Paradigm/Primary/Algebraic.hs b/Pandora/Paradigm/Primary/Algebraic.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Algebraic.hs
+++ /dev/null
@@ -1,73 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-module Pandora.Paradigm.Primary.Algebraic (module Exports) where
-
-import Pandora.Paradigm.Primary.Algebraic.Functor as Exports
-import Pandora.Paradigm.Primary.Algebraic.Exponential as Exports
-import Pandora.Paradigm.Primary.Algebraic.Product as Exports
-import Pandora.Paradigm.Primary.Algebraic.Sum as Exports
-import Pandora.Paradigm.Primary.Algebraic.Zero as Exports
-import Pandora.Paradigm.Primary.Algebraic.One as Exports
-
-import Pandora.Core.Functor (type (>))
-import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---))
-import Pandora.Pattern.Kernel (constant)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
-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), type (<:.:>))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted ((<~)))
-
-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
-		T_U (lxs :*: rxs) :*: T_U (lys :*: rys)
-
-instance Traversable (->) (->) ((:*:) s) where
-	f <<- x = (attached x :*:) <-|- f (extract x)
-
-instance Semimonoidal (-->) (:*:) (:*:) ((->) e) where
-	mult :: ((e -> a) :*: (e -> b)) --> (e -> (a :*: b))
-	mult = Straight <-- \(g :*: h) -> \x -> g x :*: h x
-
-instance Monoidal (-->) (-->) (:*:) (:*:) ((->) e) where
-	unit _ = Straight <-- constant . (<~ One)
-
-instance Semimonoidal (<--) (:*:) (:*:) ((->) e) where
-	mult :: ((e -> a) :*: (e -> b)) <-- (e -> a :*: b)
-	mult = Flip <-- \f -> attached . f :*: extract . f
-
-instance Semimonoidal (-->) (:*:) (:+:) ((:+:) e) where
-	mult :: ((e :+: a) :*: (e :+: b)) --> (e :+: a :+: b)
-	mult = Straight <-- \case
-		Option _ :*: Option e' -> Option e'
-		Option _ :*: Adoption y -> Adoption <-- Adoption y
-		Adoption x :*: _ -> Adoption <-- Option x
-
-instance Semimonoidal (-->) (:*:) (:*:) ((:+:) e) where
-	mult = Straight <-- \case
-		Adoption x :*: Adoption y -> Adoption <--- x :*: y
-		Option e :*: _ -> Option e
-		_ :*: Option e -> Option e
-
-instance Monoidal (-->) (-->) (:*:) (:*:) ((:+:) e) where
-	unit _ = Straight <-- Adoption . (<~ One)
-
-instance Semimonoidal (<--) (:*:) (:*:) ((:*:) s) where
-	mult = Flip <-- \(s :*: x :*: y) -> (s :*: x) :*: (s :*: y)
-
-instance Monoidal (<--) (-->) (:*:) (:*:) ((:*:) s) where
-	unit _ = Flip <-- \(_ :*: x) -> Straight (\_ -> x)
-
-instance Comonad (->) ((:*:) s) where
-
-instance Semimonoidal (<--) (:*:) (:*:) (Flip (:*:) a) where
-	mult = Flip <-- \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
-
-instance Monoidal (<--) (-->) (:*:) (:*:) (Flip (:*:) a) where
-	unit _ = Flip <-- \(Flip (s :*: _)) -> Straight (\_ -> s)
diff --git a/Pandora/Paradigm/Primary/Algebraic/Exponential.hs b/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
+++ /dev/null
@@ -1,69 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-module Pandora.Paradigm.Primary.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/Primary/Algebraic/Functor.hs b/Pandora/Paradigm/Primary/Algebraic/Functor.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Algebraic/Functor.hs
+++ /dev/null
@@ -1,143 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-module Pandora.Paradigm.Primary.Algebraic.Functor where
-
-import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--))
-import Pandora.Pattern.Kernel (constant)
-import Pandora.Pattern.Morphism.Flip (Flip)
-import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|---), (<-|-|-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
-import Pandora.Pattern.Functor.Monoidal (Monoidal (unit), Unit)
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Paradigm.Primary.Functor.Proxy (Proxy (Proxy))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), type (<--), (&))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Primary.Algebraic.Zero (Zero, absurd)
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted ((<~), (<~~~), (-#=)))
-
-infixl 1 <-*--------, .-*--------, <-||--------, >-||--------
-infixl 2 <-*-------, .-*-------, <-||-------, >-||-------
-infixl 3 <-*------, .-*------, <-||------, >-||------
-infixl 4 <-*-----, .-*-----, <-||-----, >-||-----
-infixl 5 <-*----, .-*----, <-||----, >-||----
-infixl 6 <-*---, .-*---, <-||---, >-||---
-infixl 7 <-*--, .-*--, <-*-*-, .-*-*-, <-||--, >-||--
-infixl 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)
-
-instance Adjoint (->) (->) ((:*:) s) ((->) s) where
-	(-|) :: ((s :*: a) -> b) -> a -> (s -> b)
-	f -| x = \s -> f (s :*: x)
-	(|-) :: (a -> s -> b) -> (s :*: a) -> b
-	f |- ~(s :*: x) = f x s
-
-(<-*--------), (<-*-------), (<-*------), (<-*-----), (<-*----), (<-*---), (<-*--), (<-*-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t (a -> b) -> t a -> t b
-f <-*-------- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
-f <-*------- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
-f <-*------ x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
-f <-*----- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
-f <-*---- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
-f <-*--- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
-f <-*-- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
-f <-*- x = (|-) @(->) @(->) (&) <-|--- mult @(-->) @_ @(:*:) <~~~ f :*: x
-
-(.-*--------), (.-*-------), (.-*------), (.-*-----), (.-*----), (.-*---), (.-*--), (.-*-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t b -> t a -> t b
-y .-*-------- x = (\_ y' -> y') <-|- x <-*- y
-y .-*------- x = (\_ y' -> y') <-|- x <-*- y
-y .-*------ x = (\_ y' -> y') <-|- x <-*- y
-y .-*----- x = (\_ y' -> y') <-|- x <-*- y
-y .-*---- x = (\_ y' -> y') <-|- x <-*- y
-y .-*--- x = (\_ y' -> y') <-|- x <-*- y
-y .-*-- x = (\_ y' -> y') <-|- x <-*- y
-y .-*- x = (\_ y' -> y') <-|- x <-*- y
-
-(<-*-*-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => t (u (a -> b)) -> t (u a) -> t (u b)
-f <-*-*- x = (<-*-) <-|- f <-*- x
-
-(.-*-*-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => t (u b) -> t (u a) -> t (u b)
-y .-*-*- x = (\_ y' -> y') <-|-|- x <-*-*- y
-
-(<-+-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t) => t b -> t a -> (a :+: b -> r) -> t r
-y <-+- x = \f -> f <-|--- mult @(-->) <~~~ x :*: y
-
-(.-+-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t) => t a -> t a -> t a
-y .-+- x = (\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 = r .-*- x in r
-
-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
-
-point :: Pointable t => a -> t a
-point x = unit @(-->) Proxy <~~~ Straight <-- \One -> x
-
-pass :: Pointable t => t ()
-pass = point ()
-
-empty :: Emptiable t => t a
-empty = unit @(-->) Proxy <~ Straight absurd
-
-(<-||-), (<-||--), (<-||---), (<-||----), (<-||-----), (<-||------), (<-||-------), (<-||--------)
-	:: 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)
-
-(>-||-), (>-||--), (>-||---), (>-||----), (>-||-----), (>-||------), (>-||-------), (>-||--------)
-	:: 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)
-(>-||--) f = (-#=) @m @(Flip p c) ((>-|-) f)
-(>-||-) f = (-#=) @m @(Flip p c) ((>-|-) f)
-
-(<-|-<-|-) :: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c d .
-	(Covariant m m (p a), Covariant m m (Flip p d), Interpreted m (Flip p d))
-	=> m a b :*: m c d -> m (p a c) (p b d)
-(<-|-<-|-) (f :*: g) = (-#=) @m @(Flip p d) ((<-|-) f) . ((<-|-) g)
-
-(<-|->-|-) :: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c d .
-	(Covariant m m (Flip p c), Contravariant m m (p a), Interpreted m (Flip p c))
-	=> m a b :*: m c d -> m (p a d) (p b c)
-(<-|->-|-) (f :*: g) = (-#=) @m @(Flip p c) ((<-|-) f) . ((>-|-) g)
-
-(>-|-<-|-) :: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c d .
-	(Contravariant m m (Flip p d), Covariant m m (p b), Interpreted m (Flip p d))
-	=> m a b :*: m c d -> m (p b c) (p a d)
-(>-|-<-|-) (f :*: g) = (-#=) @m @(Flip p d) ((>-|-) f) . ((<-|-) g)
-
-(>-|->-|-) :: forall (m :: * -> * -> *) (p :: * -> * -> *) a b c d .
-	(Contravariant m m (p b), Contravariant m m (Flip p c), Interpreted m (Flip p c))
-	=> m a b :*: m c d -> m (p b d) (p a c)
-(>-|->-|-) (f :*: g) = (-#=) @m @(Flip p c) ((>-|-) f) . ((>-|-) g)
-
-void :: Covariant (->) (->) t => t a -> t ()
-void x = constant () <-|- x
diff --git a/Pandora/Paradigm/Primary/Algebraic/One.hs b/Pandora/Paradigm/Primary/Algebraic/One.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Algebraic/One.hs
+++ /dev/null
@@ -1,3 +0,0 @@
-module Pandora.Paradigm.Primary.Algebraic.One where
-
-data One = One
diff --git a/Pandora/Paradigm/Primary/Algebraic/Product.hs b/Pandora/Paradigm/Primary/Algebraic/Product.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Algebraic/Product.hs
+++ /dev/null
@@ -1,69 +0,0 @@
-module Pandora.Paradigm.Primary.Algebraic.Product where
-
-import Pandora.Core.Functor (type (>))
-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.Controlflow.Effect.Interpreted ()
-import Pandora.Paradigm.Schemes.T_U (type (<:.:>), type (>:.:>), type (<:.:<), type (>:.:<))
-
-infixr 8 :*:
-
-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 > (:*:)
diff --git a/Pandora/Paradigm/Primary/Algebraic/Sum.hs b/Pandora/Paradigm/Primary/Algebraic/Sum.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Algebraic/Sum.hs
+++ /dev/null
@@ -1,35 +0,0 @@
-module Pandora.Paradigm.Primary.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.Primary.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/Primary/Algebraic/Zero.hs b/Pandora/Paradigm/Primary/Algebraic/Zero.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Algebraic/Zero.hs
+++ /dev/null
@@ -1,8 +0,0 @@
-{-# LANGUAGE EmptyCase #-}
-
-module Pandora.Paradigm.Primary.Algebraic.Zero where
-
-data Zero
-
-absurd :: Zero -> a
-absurd x = case x of {}
diff --git a/Pandora/Paradigm/Primary/Functor/Conclusion.hs b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
--- a/Pandora/Paradigm/Primary/Functor/Conclusion.hs
+++ b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
@@ -15,16 +15,16 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (<~)))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Paradigm.Algebraic (point)
 
 data Conclusion e a = Failure e | Success a
 
@@ -111,4 +111,4 @@
 
 instance (Monoidal (-->) (-->) (:*:) (:*:) u, Bindable (->) u) => Catchable e (Conclusion e <.:> u) where
 	catch (UT x) handle = let conclude = conclusion <-- run . handle <-- point . Success
-		in UT <-- conclude =<< x
+		in UT <--- conclude =<< x
diff --git a/Pandora/Paradigm/Primary/Functor/Constant.hs b/Pandora/Paradigm/Primary/Functor/Constant.hs
--- a/Pandora/Paradigm/Primary/Functor/Constant.hs
+++ b/Pandora/Paradigm/Primary/Functor/Constant.hs
@@ -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.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Algebraic.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
@@ -7,9 +7,9 @@
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), type (<--))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
-import Pandora.Paradigm.Primary.Algebraic ()
+import Pandora.Paradigm.Algebraic.Exponential (type (-->), type (<--))
+import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Algebraic ()
 
 data Convergence r a = Convergence (a -> a -> r)
 
diff --git a/Pandora/Paradigm/Primary/Functor/Edges.hs b/Pandora/Paradigm/Primary/Functor/Edges.hs
--- a/Pandora/Paradigm/Primary/Functor/Edges.hs
+++ b/Pandora/Paradigm/Primary/Functor/Edges.hs
@@ -3,8 +3,8 @@
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.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,9 +6,9 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic ((>-|-<-|-))
+import Pandora.Paradigm.Algebraic.Exponential ()
+import Pandora.Paradigm.Algebraic.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,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Exactly where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---))
+import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
@@ -23,10 +23,10 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (extract, (<-||-))
+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.Paradigm.Controlflow.Effect.Interpreted ((<~))
 
 newtype Exactly a = Exactly a
@@ -66,7 +66,7 @@
 
 instance Adjoint (->) (->) Exactly Exactly where
 	f -| x = Exactly . f . Exactly <-- x
-	g |- x = extract . extract <--- g <-|- x
+	g |- x = extract . extract <---- g <-|- x
 
 instance Setoid a => Setoid (Exactly a) where
 	Exactly x == Exactly y = x == y
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.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Algebraic.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
@@ -24,11 +24,11 @@
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.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)
 
 data Maybe a = Nothing | Just a
 
diff --git a/Pandora/Paradigm/Primary/Functor/Predicate.hs b/Pandora/Paradigm/Primary/Functor/Predicate.hs
--- a/Pandora/Paradigm/Primary/Functor/Predicate.hs
+++ b/Pandora/Paradigm/Primary/Functor/Predicate.hs
@@ -10,9 +10,9 @@
 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.Primary.Algebraic.Product ((:*:)((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:)(Option, Adoption))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), type (<--))
+import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Algebraic.Sum ((:+:)(Option, Adoption))
+import Pandora.Paradigm.Algebraic.Exponential (type (-->), type (<--))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
 newtype Predicate a = Predicate (a -> Boolean)
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.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Algebraic.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
@@ -2,7 +2,7 @@
 
 import Pandora.Core.Functor (type (:=>), type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---))
+import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
@@ -23,10 +23,10 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (invert))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (extract, (<-||-))
+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.Paradigm.Controlflow.Effect.Interpreted ((<~))
 
 newtype Tagged tag a = Tag a
@@ -56,7 +56,7 @@
 	f <<- Tag x = Tag <-|- f x
 
 instance Distributive (->) (->) (Tagged tag) where
-	f -<< x = Tag <--- extract . f <-|- x
+	f -<< x = Tag <---- extract . f <-|- x
 
 instance Bindable (->) (Tagged tag) where
 	f =<< Tag x = f x
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,8 +4,8 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.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
@@ -9,11 +9,11 @@
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.Exponential (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)
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
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,8 +3,8 @@
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.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
@@ -6,8 +6,8 @@
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))
--- import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic.Exponential (type (<--))
+-- import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 
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.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic.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
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Transformer.Backwards where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---))
+import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -11,11 +11,11 @@
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Algebraic ((<-*-))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->), (%))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point, extract, (<-||-))
+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.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~)))
@@ -23,11 +23,11 @@
 newtype Backwards t a = Backwards (t a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Backwards t) where
-	f <-|- Backwards x = Backwards <--- f <-|- x
+	f <-|- Backwards x = Backwards <---- f <-|- x
 
 -- TODO: check that effects evaluation goes in opposite order
 instance (Semimonoidal (-->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (-->) (:*:) (:*:) (Backwards t) where
-	mult = Straight <-- \(Backwards x :*: Backwards y) -> Backwards <--- ((:*:) %) <-|- y <-*- x
+	mult = Straight <-- \(Backwards x :*: Backwards y) -> Backwards <---- ((:*:) %) <-|- y <-*- x
 
 instance (Covariant (->) (->) t, Monoidal (-->) (-->) (:*:) (:*:) t) => Monoidal (-->) (-->) (:*:) (:*:) (Backwards t) where
 	unit _ = Straight <-- Backwards . point . (<~ One)
@@ -42,10 +42,10 @@
 	f <<- Backwards x = Backwards <-|- f <<- x
 
 instance Distributive (->) (->) t => Distributive (->) (->) (Backwards t) where
-	f -<< x = Backwards <--- run . f --<< x
+	f -<< x = Backwards <--- run . f -<< x
 
 instance Contravariant (->) (->) t => Contravariant (->) (->) (Backwards t) where
-	f >-|- Backwards x = Backwards <--- f >-|- x
+	f >-|- Backwards x = Backwards <---- f >-|- x
 
 instance Interpreted (->) (Backwards t) where
 	type Primary (Backwards t) a = t a
diff --git a/Pandora/Paradigm/Primary/Transformer/Construction.hs b/Pandora/Paradigm/Primary/Transformer/Construction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Construction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Construction.hs
@@ -3,8 +3,8 @@
 
 import Pandora.Core.Functor (type (:.), type (>), type (:=>), type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|---), (<-|-|-)))
+import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------))
+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 ((<<-)), (<<-<<-))
@@ -16,32 +16,30 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid ((*))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Primary.Algebraic ((<-*--), extract)
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (empty, (<-||-))
+import Pandora.Paradigm.Algebraic ((<-*----), extract)
+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, (<-||-))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~), (<~~~))
-import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
-import Pandora.Paradigm.Schemes (type (<::>))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~), (<~~~), (<~~~~))
 
 infixr 7 .-+
 
 data Construction t a = Construct a (t :. Construction t > a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Construction t) where
-	f <-|- ~(Construct x xs) = Construct <---- f x <---- f <-|-|- xs
+	f <-|- ~(Construct x xs) = Construct <------ f x <------ f <-|-|- xs
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Semimonoidal (-->) (:*:) (:*:) (Construction t) where
 	mult = Straight <-- \(Construct x xs :*: Construct y ys) -> Construct <----- x :*: y
-		<----- (mult @(-->) <~) <-|--- mult @(-->) <~~~ xs :*: ys
+		<----- (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
+		<----- mult @(<--) <~~~~ (mult @(<--) <~) <-|- xys
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoidal (<--) (-->) (:*:) (:*:) (Construction t) where
 	unit _ = Flip <-- \(Construct x _) -> Straight (\_ -> x)
@@ -50,10 +48,10 @@
 	unit _ = Straight <-- \f -> Construct <-- run f One <-- empty
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Construction t) where
-	f <<- ~(Construct x xs) = Construct <-|-- f x <-*-- f <<-<<- xs
+	f <<- ~(Construct x xs) = Construct <-|---- f x <-*---- f <<-<<- xs
 
 instance Covariant (->) (->) t => Extendable (->) (Construction t) where
-	f <<= x = Construct <--- f x <--- (f <<=) <-|- deconstruct x
+	f <<= x = Construct <---- f x <---- (f <<=) <-|- deconstruct x
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Comonad (->) (Construction t) where
 
@@ -61,7 +59,7 @@
 	lower x = extract <-|- deconstruct x
 
 instance (forall u . Semimonoidal (<--) (:*:) (:*:) u, forall u . Covariant (->) (->) u) => Hoistable (->) Construction where
-	f /|\ x = Construct <--- extract x <--- (/|\) @(->) f <-|- f (deconstruct x)
+	f /|\ x = Construct <---- extract x <---- (/|\) @(->) f <-|- f (deconstruct x)
 
 instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Setoid (Construction t a) where
 	x == y = (extract x == extract y) * (deconstruct x == deconstruct y)
@@ -72,18 +70,18 @@
 instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoid (Construction t a) where
 	zero = Construct zero zero
 
-instance Monotonic a (t :. Construction t > a) => Monotonic a (Construction t a) where
-	reduce f r ~(Construct x xs) = f x <-- reduce f r xs
-
-instance Monotonic a (t :. Construction t > a) => Monotonic a (t <::> Construction t > a) where
-	reduce f r = reduce f r . run
+-- instance Monotonic a (t :. Construction t > a) => Monotonic a (Construction t a) where
+-- 	reduce f r ~(Construct x xs) = f x <-- reduce f r xs
+--
+-- instance Monotonic a (t :. Construction t > a) => Monotonic a (t <::> Construction t > a) where
+-- 	reduce f r = reduce f r . run
 
 deconstruct :: Construction t a -> t :. Construction t > a
 deconstruct ~(Construct _ xs) = xs
 
 -- Generate a construction from seed using effectful computation
 (.-+) :: Covariant (->) (->) t => a :=> t -> a :=> Construction t
-f .-+ x = Construct x <--- (f .-+) <-|- f x
+f .-+ x = Construct x <---- (f .-+) <-|- f x
 
 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
@@ -11,9 +11,9 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.Exponential ((%), type (-->))
+import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Algebraic (point)
 
 newtype Continuation r t a = Continuation ((->) ::|:. a :. 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
@@ -7,7 +7,7 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((.:..))
+import Pandora.Paradigm.Algebraic.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
@@ -3,7 +3,7 @@
 
 import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----))
+import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|---), (<-|-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -14,40 +14,40 @@
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
+import Pandora.Paradigm.Algebraic.One (One (One))
+import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~), (<~~~))
 
 data Instruction t a = Enter a | Instruct (t :. Instruction t > a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Instruction t) where
 	f <-|- Enter x = Enter <-- f x
-	f <-|- Instruct xs = Instruct <---- f <-|-|- xs
+	f <-|- Instruct xs = Instruct <------ f <-|-|- xs
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Semimonoidal (-->) (:*:) (:*:) (Instruction t) where
 	mult = Straight <-- \case
 		Enter x :*: Enter y -> Enter <--- x :*: y
 		Enter x :*: Instruct y -> (x :*:) <-|- Instruct y
 		Instruct x :*: Enter y -> (:*: y) <-|- Instruct x
-		Instruct x :*: Instruct y -> Instruct <----- (mult @(-->) <~) <-|--- mult @(-->) <~~~ x :*: y
+		Instruct x :*: Instruct y -> Instruct <----- (mult @(-->) <~) <-|-- mult @(-->) <~~~ x :*: y
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Monoidal (-->) (-->) (:*:) (:*:) (Instruction t) where
 	unit _ = Straight <-- Enter . (<~ One)
 
 instance Covariant (->) (->) t => Bindable (->) (Instruction t) where
 	f =<< Enter x = f x
-	f =<< Instruct xs = Instruct <--- (f =<<) <-|- xs
+	f =<< Instruct xs = Instruct <---- (f =<<) <-|- xs
 
 instance Monad (->) t => Monad (->) (Instruction t) where
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Instruction t) where
 	f <<- Enter x = Enter <-|- f x
-	f <<- Instruct xs = Instruct <-|-- f <<-<<- xs
+	f <<- Instruct xs = Instruct <-|- (f <<-<<- xs)
 
 instance Liftable (->) Instruction where
-	lift x = Instruct <--- Enter <-|- x
+	lift x = Instruct <---- Enter <-|- x
 
 instance (forall t . Bindable (->) t, forall t . Monoidal (-->) (-->) (:*:) (:*:) t) => Lowerable (->) Instruction where
 	lower (Enter x) = point x
@@ -55,4 +55,4 @@
 
 instance (forall v . Covariant (->) (->) v) => Hoistable (->) Instruction where
 	_ /|\ Enter x = Enter x
-	f /|\ Instruct xs = Instruct <--- (f /|\) <-|- f xs
+	f /|\ Instruct xs = Instruct <---- (f /|\) <-|- f xs
diff --git a/Pandora/Paradigm/Primary/Transformer/Jack.hs b/Pandora/Paradigm/Primary/Transformer/Jack.hs
--- a/Pandora/Paradigm/Primary/Transformer/Jack.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Jack.hs
@@ -2,7 +2,7 @@
 module Pandora.Paradigm.Primary.Transformer.Jack where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), identity)
+import Pandora.Pattern.Category ((<--), (<---), (<----), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-))
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
@@ -12,9 +12,9 @@
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Paradigm.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
 
@@ -22,7 +22,7 @@
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Jack t) where
 	f <-|- It x = It <-- f x
-	f <-|- Other y = Other <--- f <-|- y
+	f <-|- Other y = Other <---- f <-|- y
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Jack t) where
 	f <<- It x = It <-|- f x
@@ -30,11 +30,11 @@
 
 instance (Monoidal (-->) (-->) (:*:) (:*:) t, Bindable (->) t) => Bindable (->) (Jack t) where
 	f =<< It x = f x
-	f =<< Other x = Other <--- jack point identity . f ==<< x
+	f =<< Other x = Other <--- jack point identity . f =<< x
 
 instance Extendable (->) t => Extendable (->) (Jack t) where
 	f <<= It x = It . f <-- It x
-	f <<= Other x = Other <--- f . Other <<== x
+	f <<= Other x = Other <--- f . Other <<= x
 
 instance Liftable (->) Jack where
 	lift = Other
diff --git a/Pandora/Paradigm/Primary/Transformer/Jet.hs b/Pandora/Paradigm/Primary/Transformer/Jet.hs
--- a/Pandora/Paradigm/Primary/Transformer/Jet.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Jet.hs
@@ -1,15 +1,17 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Primary.Transformer.Jet where
 
-import Pandora.Pattern.Category ((<----))
+import Pandora.Pattern.Category ((<------))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|-|-), (<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
-import Pandora.Paradigm.Primary.Algebraic ((<-*--))
+import Pandora.Paradigm.Algebraic ((<-*--))
 
 data Jet t a = Jet a (Jet t (t a))
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Jet t) where
-	f <-|- Jet x xs = Jet <---- f x <---- f <-|-|- xs
+	f <-|- Jet x xs = Jet
+		<------ f x
+		<------ f <-|-|- xs
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Jet t) where
-	f <<- Jet x xs = Jet <-|-- f x <-*-- f <<-<<- xs
+	f <<- Jet x xs = Jet <-|-- f x <-*-- (f <<-<<- xs)
diff --git a/Pandora/Paradigm/Primary/Transformer/Outline.hs b/Pandora/Paradigm/Primary/Transformer/Outline.hs
--- a/Pandora/Paradigm/Primary/Transformer/Outline.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Outline.hs
@@ -2,11 +2,11 @@
 module Pandora.Paradigm.Primary.Transformer.Outline where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (identity, (<--), (<---), (<------))
+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.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Algebraic.Exponential ()
 
 data Outline t a where
 	Line :: a -> Outline t a
@@ -14,7 +14,7 @@
 
 instance Covariant (->) (->) (Outline t) where
 	f <-|- Line a = Line (f a)
-	f <-|- Outlined x y = Outlined x <--- (.) f <-|- y
+	f <-|- Outlined x y = Outlined x <---- (.) f <-|- y
 
 instance Liftable (->) Outline where
 	lift t = Outlined t <-- Line identity
diff --git a/Pandora/Paradigm/Primary/Transformer/Reverse.hs b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
--- a/Pandora/Paradigm/Primary/Transformer/Reverse.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
@@ -2,7 +2,7 @@
 module Pandora.Paradigm.Primary.Transformer.Reverse where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----))
+import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -13,10 +13,11 @@
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
 import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point, extract, (<-||-))
+import Pandora.Paradigm.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.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~)))
@@ -24,7 +25,7 @@
 newtype Reverse t a = Reverse (t a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Reverse t) where
-	f <-|- Reverse x = Reverse <--- f <-|- x
+	f <-|- Reverse x = Reverse <---- f <-|- x
 
 instance (Semimonoidal (-->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (-->) (:*:) (:*:) (Reverse t) where
 	mult = Straight <-- \(Reverse x :*: Reverse y) -> Reverse <---- mult @(-->) <~~~ x :*: y
@@ -38,14 +39,20 @@
 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
+	mult = Straight <-- \(Reverse x :*: Reverse y) -> Reverse <---- mult @(-->)  @(:*:) @(:+:) <~~~ x :*: y
+
+instance (Covariant (->) (->) t, Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:+:) (Reverse t) where
+	unit _ = Straight <-- \_ -> Reverse empty
+
 instance Traversable (->) (->) t => Traversable (->) (->) (Reverse t) where
 	f <<- Reverse x = Reverse <-|- run (Backwards . f <<-- x)
 
 instance Distributive (->) (->) t => Distributive (->) (->) (Reverse t) where
-	f -<< x = Reverse <--- run . f --<< x
+	f -<< x = Reverse <--- run . f -<< x
 
 instance Contravariant (->) (->) t => Contravariant (->) (->) (Reverse t) where
-	f >-|- Reverse x = Reverse <--- f >-|- x
+	f >-|- Reverse x = Reverse <---- f >-|- x
 
 instance Interpreted (->) (Reverse t) where
 	type Primary (Reverse t) a = t a
diff --git a/Pandora/Paradigm/Primary/Transformer/Tap.hs b/Pandora/Paradigm/Primary/Transformer/Tap.hs
--- a/Pandora/Paradigm/Primary/Transformer/Tap.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Tap.hs
@@ -3,41 +3,32 @@
 
 import Pandora.Core.Functor (type (>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Category ((<--), (<---), (<----), (<------))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=), (<<==)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~~~), (-#=))
-import Pandora.Paradigm.Primary.Algebraic ((<-*-), extract)
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->), (%))
-import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~), (<~~~))
+import Pandora.Paradigm.Algebraic ((<-*-), (<-||--), extract)
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), (<:*:>))
+import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
-import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
-import Pandora.Paradigm.Structure.Ability.Substructure
-	(Substructure (Substance, substructure), Segment (Root))
 
 data Tap t a = Tap a (t a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Tap t) where
-	f <-|- Tap x xs = Tap <--- f x <--- f <-|- xs
+	f <-|- Tap x xs = Tap <---- f x <---- f <-|- xs
 
 instance Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (Tap t) where
-	mult = Straight <-- \(Tap x xs :*: Tap y ys) -> Tap 
-		<---- x :*: y
-		<---- mult @(-->) <~~~ xs :*: ys
+	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) -> ((-#=) @(->) @(Flip _ _) (Tap x <-|-) . (Tap y <-|-)) (mult @(<--) <~~~ xys)
+	mult = Flip <-- \(Tap (x :*: y) xys) -> Tap x <-||-- Tap y <-|- mult @(<--) <~ xys
 
 instance Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (-->) (:*:) (:*:) (Tap t) where
 	unit _ = Flip <-- \(Tap x _) -> Straight (\_ -> x)
@@ -46,7 +37,7 @@
 	f <<- Tap x xs = Tap <-|- f x <-*- f <<- xs
 
 instance (Semimonoidal (<--) (:*:) (:*:) t, Extendable (->) t, Covariant (->) (->) t) => Extendable (->) (Tap t) where
-	f <<= x = Tap <--- f x <--- f . Tap (extract x) <<== lower x
+	f <<= x = Tap <--- f x <--- f . Tap (extract x) <<= lower x
 
 instance Lowerable (->) Tap where
 	lower (Tap _ xs) = xs
@@ -56,19 +47,4 @@
 
 instance {-# OVERLAPS #-} Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (Tap (t <:.:> t > (:*:))) where
 	mult = Straight <-- \(Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) ->
-		Tap (x :*: y) . T_U <--- (mult @(-->) <~~~ xls :*: yls) :*: (mult @(-->) <~~~ xrs :*: yrs)
-
-instance (Covariant (->) (->) t) => Substructure Root (Tap (t <:.:> t > (:*:))) where
-	type Substance Root (Tap (t <:.:> t > (:*:))) = Exactly
-	substructure = P_Q_T <-- \zipper -> case lower zipper of
-		Tap x xs -> Store <--- Exactly x :*: lift . (Tap % xs) . extract
-
-instance (Covariant (->) (->) t) => Substructure Left (Tap (t <:.:> t > (:*:))) where
-	type Substance Left (Tap (t <:.:> t > (:*:))) = t
-	substructure = P_Q_T <-- \zipper -> case lower zipper of
-		Tap x (T_U (future :*: past)) -> Store <--- future :*: lift . Tap x . T_U . (:*: past)
-
-instance (Covariant (->) (->) t) => Substructure Right (Tap (t <:.:> t > (:*:))) where
-	type Substance Right (Tap (t <:.:> t > (:*:))) = t
-	substructure = P_Q_T <-- \zipper -> case lower zipper of
-		Tap x (T_U (future :*: past)) -> Store <--- past :*: lift . Tap x . T_U . (future :*:)
+		Tap (x :*: y) <------ (mult @(-->) <~~~ xls :*: yls) <:*:> (mult @(-->) <~~~ xrs :*: yrs)
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
@@ -6,7 +6,7 @@
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ()
+import Pandora.Paradigm.Algebraic.Exponential ()
 
 newtype Yoneda t a = Yoneda
 	{ yoneda :: forall b . (a -> b) -> t b }
diff --git a/Pandora/Paradigm/Schemes.hs b/Pandora/Paradigm/Schemes.hs
--- a/Pandora/Paradigm/Schemes.hs
+++ b/Pandora/Paradigm/Schemes.hs
@@ -17,31 +17,30 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (--|), (|-), (|--)))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 
 instance (Covariant (->) (->) (v <:.> t), Covariant (->) (->) (u <:.> w), Adjoint (->) (->) t u, Adjoint (->) (->) v w)
-
 	=> Adjoint (->) (->) (v <:.> t) (u <:.> w) where
-		g |- TU y = (run . g |--) |- y
-		f -| x = TU <-- (f . TU --|) -| x
+		g |- TU y = (run . g |-) |- y
+		f -| x = TU <-- (f . TU -|) -| x
 
 instance (Covariant (->) (->) (v <:.> t), Covariant (->) (->) (w <.:> u), Adjoint (->) (->) t u, Adjoint (->) (->) v w)
 	=> Adjoint (->) (->) (v <:.> t) (w <.:> u) where
-		g |- TU t = (run . g |--) |- t
-		f -| x = UT <-- (f . TU --|) -| x
+		g |- TU t = (run . g |-) |- t
+		f -| x = UT <-- (f . TU -|) -| x
 
 instance (Covariant (->) (->) (t <.:> v), Covariant (->) (->) (w <.:> u), Adjoint (->) (->) t u, Adjoint (->) (->) v w)
 	=> Adjoint (->) (->) (t <.:> v) (w <.:> u) where
-		g |- UT t =  (run . g |--) |- t
-		f -| x = UT <-- (f . UT --|) -| x
+		g |- UT t =  (run . g |-) |- t
+		f -| x = UT <-- (f . UT -|) -| x
 
 instance (Covariant (->) (->) (t <.:> v), Covariant (->) (->) (w <:.> u), Adjoint (->) (->) v u, Adjoint (->) (->) t w)
 	=> Adjoint (->) (->) (t <.:> v) (w <:.> u) where
-		g |- UT x = (run . g |--) |- x
-		f -| x = TU <-- (f . UT --|) -| x
+		g |- UT x = (run . g |-) |- x
+		f -| x = TU <-- (f . UT -|) -| x
 
 instance (Covariant (->) (->) ((t <:<.>:> u) t'),  Covariant (->) (->) ((v <:<.>:> w) v'), Adjoint (->) (->) t w, Adjoint (->) (->) t' v', Adjoint (->) (->) t v, Adjoint (->) (->) u v, Adjoint (->) (->) v' t')
 	=> Adjoint (->) (->) ((t <:<.>:> u) t') ((v <:<.>:> w) v') where
-		g |- TUT x = ((run . g |--) |-) |- x
-		f -| x = TUT <--  ((f . TUT --|) -|) -| x
+		g |- TUT x = ((run . g |-) |-) |- x
+		f -| x = TUT <-- ((f . TUT -|) -|) -| x
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
@@ -11,17 +11,17 @@
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
-import Pandora.Pattern.Functor.Distributive (Distributive ((--<<)))
+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.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (=#-)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:), bitraverse_sum)
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (empty, point, extract, (<-||-))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-)))
+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.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
@@ -51,23 +51,23 @@
 instance (Covariant (->) (->) t, Covariant (->) (->) t', Semimonoidal (-->) (:*:) (:+:) t) => Semimonoidal (-->) (:*:) (:+:) (t <::> t') where
 	mult = Straight <-- \(TT x :*: TT y) -> TT
 		<----- bitraverse_sum identity identity
-			<-|--- mult @(-->) @(:*:) @(:+:)
+			<-|-- mult @(-->) @(:*:) @(:+:)
 				<~~~ x :*: y
 
 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
+	mult = Flip <-- \(TT xys) -> TT <-||--- TT <-|--- mult @(<--) <~~~~ (mult @(<--) <~) <-|- xys
 
 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
-	f <<- x = TT <-|-- f <<-<<- run x
+	f <<- x = TT <-|-- (f <<-<<- run x)
 
 instance (Bindable (->) t, Distributive (->) (->) t, Covariant (->) (->) t', Bindable (->) t') => Bindable (->) (t <::> t') where
-	f =<< TT x = TT <-- (\i -> (identity =<<) <-|-- run . f --<< i) =<< x
+	f =<< TT x = TT <--- (\i -> (identity =<<) <-|- run . f -<< i) =<< x
 
 instance Monoidal (-->) (-->) (:*:) (:*:) t => Liftable (->) (TT Covariant Covariant t) where
 	lift :: Covariant (->) (->) t' => t' ~> t <::> t'
@@ -79,4 +79,4 @@
 
 instance Covariant (->) (->) t => Hoistable (->) (TT Covariant Covariant t) where
 	(/|\) :: t' ~> v -> (t <::> t' ~> t <::> v)
-	f /|\ TT x = TT <--- f <-|- x
+	f /|\ TT x = TT <---- f <-|- 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
@@ -4,23 +4,23 @@
 import Pandora.Core.Functor (type (:.), type (>), type (~>))
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (identity, (<--), (<---), (<-----))
+import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|---), (<-|-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
-import Pandora.Pattern.Functor.Distributive (Distributive ((--<<)))
+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.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (=#-)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (empty, point, extract, (<-||-))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-)))
+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.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
@@ -50,23 +50,23 @@
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) (t <:.> u) where
 	mult = Straight <-- \(TU x :*: TU y) -> TU
 		<----- mult @(-->) @(:*:) @(:+:)
-			<-|--- mult @(-->) @(:*:) @(:*:)
+			<-|-- mult @(-->) @(:*:) @(:*:)
 				<~~~ x :*: y
 
 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
+	mult = Flip <-- \(TU xys) -> TU <-||--- TU <-|--- mult @(<--) <~~~~ (mult @(<--) <~) <-|- xys
 
 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
-	f <<- x = TU <-|-- f <<-<<- run x
+	f <<- x = TU <-|-- (f <<-<<- run x)
 
 instance (Bindable (->) t, Distributive (->) (->) t, Covariant (->) (->) u, Bindable (->) u) => Bindable (->) (t <:.> u) where
-	f =<< TU x = TU <-- (\i -> (identity =<<) <-|-- run . f --<< i) =<< x
+	f =<< TU x = TU <--- (\i -> (identity =<<) <-|- run . f -<< i) =<< x
 
 instance Monoidal (-->) (-->) (:*:) (:*:) t => Liftable (->) (TU Covariant Covariant t) where
 	lift :: Covariant (->) (->) u => u ~> t <:.> u
@@ -78,4 +78,4 @@
 
 instance Covariant (->) (->) t => Hoistable (->) (TU Covariant Covariant t) where
 	(/|\) :: u ~> v -> (t <:.> u ~> t <:.> v)
-	f /|\ TU x = TU <--- f <-|- x
+	f /|\ TU x = TU <---- f <-|- x
diff --git a/Pandora/Paradigm/Schemes/TUT.hs b/Pandora/Paradigm/Schemes/TUT.hs
--- a/Pandora/Paradigm/Schemes/TUT.hs
+++ b/Pandora/Paradigm/Schemes/TUT.hs
@@ -4,8 +4,8 @@
 import Pandora.Core.Functor (type (:.), type (>), type (~>))
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (identity, (<--), (<---), (<------))
-import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((<-|-), (<-|---), (<-|-|-), (<-|-|---), (<-|-|-|-)))
+import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<------))
+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((<-|-), (<-|--), (<-|---), (<-|-|-), (<-|-|---), (<-|-|-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
@@ -15,11 +15,11 @@
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (--|), (|-), (|--)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point, extract, (<-||-))
+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.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (=#-)))
@@ -58,8 +58,8 @@
 instance {-# OVERLAPS #-} (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) ((->) s <:<.>:> (:*:) s > u) where
  mult = Straight <-- \(TUT x :*: TUT y) -> TUT
 	<------ product_over_sum
-		<-|-|--- mult @(-->) @(:*:) @(:+:)
-			<-|--- mult @(-->) @(:*:) @(:*:) 
+		<-|-|- mult @(-->) @(:*:) @(:+:)
+			<-|-- mult @(-->) @(:*:) @(:*:)
 				<~~~ x :*: y
 
 product_over_sum :: s :*: a :+: s :*: b -> s :*: (a :+: b)
@@ -67,13 +67,13 @@
 product_over_sum (Adoption (s :*: y)) = s :*: Adoption y
 
 instance (Covariant (->) (->) t, Covariant (->) (->) t', Adjoint (->) (->) t' t, Bindable (->) u) => Bindable (->) (t <:<.>:> t' > u) where
-	f =<< x = TUT <--- ((run . f |--) =<<) <-|- run x
+	f =<< x = TUT <---- ((run . f |--) =<<) <-|- run x
 
 instance (Bindable (->) u, Monoidal (-->) (-->) (:*:) (:*:) u, Adjoint (->) (->) t' t) => Monoidal (-->) (-->) (:*:) (:*:) (t <:<.>:> t' > u) where
 	unit _ = Straight <-- unite . (point -|) . (<~ One)
 
 instance (Adjoint (->) (->) t' t, Extendable (->) u) => Extendable (->) (t' <:<.>:> t > u) where
-	f <<= x = TUT <--- ((f . unite --|) <<=) <-|- run x
+	f <<= x = TUT <---- ((f . unite --|) <<=) <-|- run x
 
 instance (Adjoint (->) (->) t' t, Distributive (->) (->) t) => Liftable (->) (t <:<.>:> t') where
 	lift :: Covariant (->) (->) u => u ~> t <:<.>:> t' > u
diff --git a/Pandora/Paradigm/Schemes/UT.hs b/Pandora/Paradigm/Schemes/UT.hs
--- a/Pandora/Paradigm/Schemes/UT.hs
+++ b/Pandora/Paradigm/Schemes/UT.hs
@@ -6,7 +6,7 @@
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|---), (<-|-|-)))
+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))
@@ -14,12 +14,12 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<--)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (=#-)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point, extract, (<-||-))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-)))
+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.Morphism.Flip (Flip (Flip))
 
 newtype UT ct cu t u a = UT (u :. t > a)
@@ -45,7 +45,7 @@
 instance (Covariant (->) (->) u, Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) u, Semimonoidal (-->) (:*:) (:+:) t) => Semimonoidal (-->) (:*:) (:+:) (t <.:> u) where
 	mult = Straight <-- \(UT x :*: UT y) -> UT
 		<----- mult @(-->) @(:*:) @(:+:)
-			<-|--- mult @(-->) @(:*:) @(:*:)
+			<-|-- mult @(-->) @(:*:) @(:*:)
 				<~~~ x :*: y
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) u, Monoidal (-->) (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:*:) u) => Monoidal (-->) (-->) (:*:) (:*:) (t <.:> u) where
@@ -55,14 +55,14 @@
 	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
+	mult = Flip <-- \(UT xys) -> UT <-||--- UT <-|--- mult @(<--) <~~~~ (mult @(<--) <~) <-|- xys
 
 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
+	lift x = UT <---- point <-|- x
 
 instance Monoidal (<--) (-->) (:*:) (:*:) t => Lowerable (->) (UT Covariant Covariant t) where
 	lower :: Covariant (->) (->) u => t <.:> u ~> u
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -7,38 +7,114 @@
 import Pandora.Paradigm.Structure.Modification as Exports
 import Pandora.Paradigm.Structure.Some as Exports
 
-import Pandora.Core.Functor (type (>))
 import Pandora.Pattern.Semigroupoid ((.))
 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.Object.Semigroup ((+))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (=#-), (<~))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~))
 import Pandora.Paradigm.Inventory.Some.Optics ()
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
-import Pandora.Paradigm.Primary.Algebraic (extract)
+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.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))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Both, Left, Right, End))
+import Pandora.Paradigm.Primary.Functor.Wedge (Wedge (Nowhere, Here, There))
+import Pandora.Paradigm.Primary.Functor.These (These (This, That, These))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
 import Pandora.Paradigm.Primary.Linear.Vector (Vector (Scalar, Vector))
-import Pandora.Paradigm.Primary (twosome)
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap))
-import Pandora.Paradigm.Schemes.TU (type (<:.>))
 import Pandora.Paradigm.Schemes.TT (TT (TT))
-import Pandora.Paradigm.Schemes.T_U ( type (<:.:>))
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
 
 instance Monotonic s a => Monotonic s (s :*: a) where
 	reduce f r x = reduce f <-- f (attached x) r <-- extract x
 
-instance (Covariant (->) (->) t) => Substructure Tail (Tap t) where
-	type Substance Tail (Tap t) = t
+instance Morphable (Into Maybe) (Conclusion e) where
+	type Morphing (Into Maybe) (Conclusion e) = Maybe
+	morphing = conclusion (constant Nothing) Just . premorph
+
+instance Morphable (Into (Conclusion e)) Maybe where
+	type Morphing (Into (Conclusion e)) Maybe = (->) e <:.> Conclusion e
+	morphing (premorph -> Just x) = TU <-- \_ -> Success x
+	morphing (premorph -> Nothing) = TU <-- \e -> Failure e
+
+instance Morphable (Into (Flip Conclusion e)) Maybe where
+	type Morphing (Into (Flip Conclusion e)) Maybe = (->) e <:.> Flip Conclusion e
+	morphing (run . premorph -> Just x) = TU <-- \_ -> Flip <-- Failure x
+	morphing (run . premorph -> Nothing) = TU <-- Flip . Success
+
+instance Morphable (Into (Left Maybe)) Wye where
+	type Morphing (Into (Left Maybe)) Wye = Maybe
+	morphing (premorph -> Both ls _) = Just ls
+	morphing (premorph -> Left ls) = Just ls
+	morphing (premorph -> Right _) = Nothing
+	morphing (premorph -> End) = Nothing
+
+instance Morphable (Into (Right Maybe)) Wye where
+	type Morphing (Into (Right Maybe)) Wye = Maybe
+	morphing (premorph -> Both _ rs) = Just rs
+	morphing (premorph -> Left _) = Nothing
+	morphing (premorph -> Right rs) = Just rs
+	morphing (premorph -> End) = Nothing
+
+instance Morphable (Into (This Maybe)) (These e) where
+	type Morphing (Into (This Maybe)) (These e) = Maybe
+	morphing (premorph -> This x) = Just x
+	morphing (premorph -> That _) = Nothing
+	morphing (premorph -> These _ x) = Just x
+
+instance Morphable (Into (That Maybe)) (Flip These a) where
+	type Morphing (Into (That Maybe)) (Flip These a) = Maybe
+	morphing (run . premorph -> This _) = Nothing
+	morphing (run . premorph -> That x) = Just x
+	morphing (run . premorph -> These y _) = Just y
+
+instance Morphable (Into (Here Maybe)) (Flip Wedge a) where
+	type Morphing (Into (Here Maybe)) (Flip Wedge a) = Maybe
+	morphing (run . premorph -> Nowhere) = Nothing
+	morphing (run . premorph -> Here x) = Just x
+	morphing (run . premorph -> There _) = Nothing
+
+instance Morphable (Into (There Maybe)) (Wedge e) where
+	type Morphing (Into (There Maybe)) (Wedge e) = Maybe
+	morphing (premorph -> Nowhere) = Nothing
+	morphing (premorph -> Here _) = Nothing
+	morphing (premorph -> There x) = Just x
+
+instance Morphable (Into Wye) (Maybe <:*:> Maybe) where
+	type Morphing (Into Wye) (Maybe <:*:> Maybe) = Wye
+	morphing (run . premorph -> Just x :*: Just y) = Both x y
+	morphing (run . premorph -> Nothing :*: Just y) = Right y
+	morphing (run . premorph -> Just x :*: Nothing) = Left x
+	morphing (run . premorph -> Nothing :*: Nothing) = End
+
+instance Substructure Left Wye where
+	type Substance Left Wye = Maybe
+	substructure = P_Q_T <-- \new -> case lower new of
+		End -> Store <--- Nothing :*: lift . resolve Left End
+		Left x -> Store <--- Just x :*: lift . resolve Left End
+		Right y -> Store <--- Nothing :*: lift . constant (Right y)
+		Both x y -> Store <--- Just x :*: lift . resolve (Both % y) (Right y)
+
+instance Substructure Right Wye where
+	type Substance Right Wye = Maybe
+	substructure = P_Q_T <-- \new -> case lower new of
+		End -> Store <--- Nothing :*: lift . resolve Right End
+		Left x -> Store <--- Nothing :*: lift . constant (Left x)
+		Right y -> Store <--- Just y :*: lift . resolve Right End
+		Both x y -> Store <--- Just y :*: lift . resolve (Both x) (Left x)
+
+instance (Covariant (->) (->) t) => Substructure Rest (Tap t) where
+	type Substance Rest (Tap t) = t
 	substructure = P_Q_T <-- \tap -> case extract <-- run tap of
 		Tap x xs -> Store <--- xs :*: lift . Tap x
 
diff --git a/Pandora/Paradigm/Structure/Ability.hs b/Pandora/Paradigm/Structure/Ability.hs
--- a/Pandora/Paradigm/Structure/Ability.hs
+++ b/Pandora/Paradigm/Structure/Ability.hs
@@ -1,7 +1,6 @@
 module Pandora.Paradigm.Structure.Ability (module Exports) where
 
 import Pandora.Paradigm.Structure.Ability.Monotonic as Exports
-import Pandora.Paradigm.Structure.Ability.Zipper as Exports
 import Pandora.Paradigm.Structure.Ability.Substructure as Exports
 import Pandora.Paradigm.Structure.Ability.Morphable as Exports
 import Pandora.Paradigm.Structure.Ability.Possible as Exports
diff --git a/Pandora/Paradigm/Structure/Ability/Monotonic.hs b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
--- a/Pandora/Paradigm/Structure/Ability/Monotonic.hs
+++ b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Pattern.Category ((<----))
 import Pandora.Pattern.Kernel (constant)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((.:..))
+import Pandora.Paradigm.Algebraic.Exponential ((.:..))
 
 class Monotonic a e where
 	{-# MINIMAL reduce #-}
diff --git a/Pandora/Paradigm/Structure/Ability/Morphable.hs b/Pandora/Paradigm/Structure/Ability/Morphable.hs
--- a/Pandora/Paradigm/Structure/Ability/Morphable.hs
+++ b/Pandora/Paradigm/Structure/Ability/Morphable.hs
@@ -6,8 +6,8 @@
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
 import Pandora.Pattern.Object.Setoid (Setoid)
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic (extract)
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic (extract)
 import Pandora.Paradigm.Primary.Functor (Comparison)
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
@@ -18,7 +18,8 @@
 import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 
-class Morphable mod struct | mod struct -> struct where
+-- type Morphable :: k -> (* -> *) -> Constraint
+class Morphable (mod :: k) struct | mod struct -> struct where
 	type Morphing (mod :: k) (struct :: * -> *) :: * -> *
 	morphing :: Tagged mod <::> struct ~> Morphing mod struct
 
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
@@ -2,26 +2,25 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Structure.Ability.Substructure where
 
-import Pandora.Core.Functor (type (>))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (identity, (<--), (<---), (<-----))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Category ((<--), (<---), (<----))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-|-)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (=#-))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite, (=#-))
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
-import Pandora.Paradigm.Inventory.Some.Optics (Lens, Convex, type (#=@), type (@>>>))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), type (<:*:>))
-import Pandora.Paradigm.Primary.Algebraic ((>-|-<-|-))
-import Pandora.Paradigm.Primary.Functor.Exactly (Exactly)
+import Pandora.Paradigm.Inventory.Some.Optics (type (@>>>), view, replace)
+import Pandora.Paradigm.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>))
+import Pandora.Paradigm.Algebraic ((>-||-), extract)
+import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
 import Pandora.Paradigm.Schemes.TU (type (<:.>))
-import Pandora.Paradigm.Schemes.T_U (T_U (T_U))
+import Pandora.Paradigm.Schemes.TT (type (<::>))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
 
-data Segment a = Root a | Tail a
-
 type Substructured segment source target = (Substructure segment source, Substance segment source ~ target)
 
 class Substructure segment (structure :: * -> *) where
@@ -29,24 +28,36 @@
 	substructure :: (Tagged segment <:.> structure) @>>> Substance segment structure
 
 	sub :: (Covariant (->) (->) structure) => structure @>>> Substance segment structure
-	sub = ((lift :*: (lower @(->) <-|-)) >-|-<-|-) =#- substructure @segment @structure
-
--- TODO: generalize `available` and then rename to `singleton`
--- The main problem is that we should handle (Maybe target -> sourse)
--- For Convex Lens: we can ignore Exactly cause we can wrap/unwrap its value
--- For Obscure Lens: if we got nothing -> nothing should change
---only :: forall segment structure element . (Covariant (->) (->) structure, Substructured segment structure Exactly Exactly) => Convex Lens (structure element) element
---only = inner . ((sub @segment) :: Convex Lens (structure element) (Exactly element)) where
+	sub = (lift >-||-) . (lower @(->) <-|-|-) =#- substructure @segment @structure
 
---	inner :: Convex Lens (Exactly element) element
---	inner = P_Q_T <-- \x -> Store <--- x :*: identity
+tagstruct :: Covariant (->) (->) structure => (Tagged segment <:.> structure) @>>> structure
+tagstruct = P_Q_T <-- \ts -> case lower ts of
+	struct -> Store <--- struct :*: lift
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u) => Substructure Left (t <:*:> u) where
 	type Substance Left (t <:*:> u) = t
 	substructure = P_Q_T <-- \x -> case run <-- lower x of
-		ls :*: rs -> Store <--- ls :*: lift . (T_U . (:*: rs))
+		ls :*: rs -> Store <--- ls :*: lift . (<:*:> rs)
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u) => Substructure Right (t <:*:> u) where
 	type Substance Right (t <:*:> u) = u
 	substructure = P_Q_T <-- \x -> case run <-- lower x of
-		ls :*: rs -> Store <--- rs :*: lift . (T_U . (ls :*:))
+		ls :*: rs -> Store <--- rs :*: lift . (ls <:*:>)
+
+data Segment a = Root a | Rest a | Branch a | Ancestors a | Forest a
+
+instance Covariant (->) (->) t => Substructure Root (Construction t) where
+	type Substance Root (Construction t) = Exactly
+	substructure = P_Q_T <-- \source -> case lower source of
+		Construct x xs -> Store <--- Exactly x :*: lift . (Construct % xs) . extract
+
+instance Covariant (->) (->) t => Substructure Rest (Construction t) where
+	type Substance Rest (Construction t) = t <::> Construction t
+	substructure = P_Q_T <-- \source -> case lower source of
+		Construct x xs -> Store <--- unite xs :*: lift . Construct x . run
+
+instance (Covariant (->) (->) t, Substructure i t) => Substructure (i Branch) (Construction t) where
+	type Substance (i Branch) (Construction t) = Substance i t <::> Construction t
+	substructure = P_Q_T <-- \source -> case lower source of
+		Construct x xs -> Store <--- unite (view <-- sub @i <-- xs) :*: \target ->
+			lift <---- Construct x <--- replace <-- run target <-- sub @i <-- xs
diff --git a/Pandora/Paradigm/Structure/Ability/Zipper.hs b/Pandora/Paradigm/Structure/Ability/Zipper.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Ability/Zipper.hs
+++ /dev/null
@@ -1,107 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-module Pandora.Paradigm.Structure.Ability.Zipper where
-
-import Pandora.Core.Functor (type (>), type (<), type (:.), type (:::))
-import Pandora.Core.Impliable (Impliable (Arguments, imply))
-import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----))
-import Pandora.Pattern.Kernel (constant)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--)))
-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.Primary.Algebraic (extract)
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->), (%))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), type (<:*:>))
-import Pandora.Paradigm.Primary.Algebraic ((<-*-), (<-*--), point)
-import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)
-import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))
-import Pandora.Paradigm.Primary (twosome)
-import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
-import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
-import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
-import Pandora.Paradigm.Structure.Ability.Morphable (Morphable, Morph (Rotate), Vertical (Up, Down), Occurrence (All))
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root), sub)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~), (=#-))
-import Pandora.Paradigm.Inventory.Ability.Gettable (get)
-import Pandora.Paradigm.Inventory.Ability.Settable (set)
-import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
-import Pandora.Paradigm.Inventory.Some.Optics (Lens, Convex, view, replace, mutate)
-
-class Zippable (structure :: * -> *) where
-	type Breadcrumbs structure :: * -> *
-
-type Zipper (structure :: * -> *) = Tagged Zippable <:.> (Exactly <:*:> Breadcrumbs structure)
-
-type Breadcrumbed structure t = (Zippable structure, Breadcrumbs structure ~ t)
-
-instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t
-	=> Semimonoidal (<--) (:*:) (:*:) (Exactly <:.:> t > (:*:)) where
-	mult = Flip <-- \(T_U (Exactly (x :*: y) :*: xys)) ->
-		let xs :*: ys = mult @(<--) <~ xys in
-			T_U (Exactly x :*: xs) :*: T_U (Exactly y :*: ys)
-
-instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (-->) (:*:) (:*:) (Exactly <:.:> t > (:*:)) where
-	unit _ = Flip <-- \(T_U (Exactly x :*: _)) -> Straight (\_ -> x)
-
-type family Fastenable structure rs where
-	Fastenable structure (r ::: rs) = (Morphable < Rotate r < structure, Fastenable structure rs)
-	Fastenable structure r = Morphable < Rotate r < structure
-
-type Tape t = Tagged Zippable <:.> (Exactly <:*:> (Reverse t <:*:> t))
-
-instance Covariant (->) (->) t => Impliable (Tape t a) where
-	type Arguments (Tape t a) = a -> t a -> t a -> Tape t a
-	imply focused left right = lift
-		<---- twosome <-- Exactly focused 
-			<--- twosome <-- Reverse left <-- right
-
--- TODO: Isn't too fragile to define such an instance without any hints about zippers?
-instance Covariant (->) (->) t => Substructure Root (Tape t) where
-	type Substance Root (Tape t) = Exactly
-	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of
-		 Exactly x :*: xs -> Store <--- Exactly x :*: lift . lift . T_U . (:*: xs)
-
-instance Covariant (->) (->) t => Substructure Left (Tape t) where
-	type Substance Left (Tape t) = Reverse t
-	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of
-		Exactly x :*: T_U (ls :*: rs) -> Store <--- ls :*: lift . (imply @(Tape t _) x % rs) . run
-
-instance Covariant (->) (->) t => Substructure Right (Tape t) where
-	type Substance Right (Tape t) = t
-	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of
-		Exactly x :*: T_U (Reverse ls :*: rs) -> Store <--- rs :*: lift . imply @(Tape t _) x ls
-
-instance Covariant (->) (->) t => Substructure Up (Tape t <::> Tape t) where
-	type Substance Up (Tape t <::> Tape t) = t <::> Tape t
-	substructure = P_Q_T <-- \x -> case run . lower . run . lower <-- x of
-		Exactly focused :*: T_U (Reverse d :*: u) ->
-			Store <--- TT u :*: lift . TT . imply @(Tape t _) focused d . run
-
-instance Covariant (->) (->) t => Substructure Down (Tape t <::> Tape t) where
-	type Substance Down (Tape t <::> Tape t) = Reverse t <::> Tape t
-	substructure = P_Q_T <-- \ii -> case run . lower . run . lower <-- ii of
-		Exactly focused :*: T_U (d :*: u) ->
-			Store <--- TT d :*: lift . TT . (imply @(Tape t _) focused % u) . run . run
-
-instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure (All Left) (Tape t <::> Tape t) where
-	type Substance (All Left) (Tape t <::> Tape t) = Tape t <::> Reverse t
-	substructure = P_Q_T <-- \source ->
-		let target = (view (sub @Left) <-|-) =#- lower source in
-		let updated new = replace % sub @Left <-|-- new <-*-- run <-- lower source in
-		Store <--- target :*: lift . (updated =#-)
-
-instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure (All Right) (Tape t <::> Tape t) where
-	type Substance (All Right) (Tape t <::> Tape t) = Tape t <::> t
-	substructure = P_Q_T <-- \source ->
-		let target = (view (sub @Right) <-|-) =#- lower source in
-		let updated new = replace % sub @Right <-|-- new <-*-- run <-- lower source in
-			Store <--- target :*: lift . (updated =#-)
diff --git a/Pandora/Paradigm/Structure/Interface.hs b/Pandora/Paradigm/Structure/Interface.hs
--- a/Pandora/Paradigm/Structure/Interface.hs
+++ b/Pandora/Paradigm/Structure/Interface.hs
@@ -1,5 +1,6 @@
 module Pandora.Paradigm.Structure.Interface (module Exports) where
 
+import Pandora.Paradigm.Structure.Interface.Zipper as Exports
 import Pandora.Paradigm.Structure.Interface.Stack as Exports
 import Pandora.Paradigm.Structure.Interface.Dictionary as Exports
 import Pandora.Paradigm.Structure.Interface.Set as Exports
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
@@ -5,13 +5,13 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---))
 import Pandora.Pattern.Kernel (constant)
-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-), (<<--)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((!=)))
 import Pandora.Pattern.Object.Semigroup ((+))
 import Pandora.Pattern.Object.Quasiring (one)
-import Pandora.Paradigm.Primary.Algebraic ()
-import Pandora.Paradigm.Primary.Algebraic.Product (attached)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Algebraic ()
+import Pandora.Paradigm.Algebraic.Product (attached)
+import Pandora.Paradigm.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)
@@ -26,7 +26,7 @@
 type Set t f a = (Traversable (->) (->) t, Setoid a, Setoid (t a), Morphable (Find f) t)
 
 subset :: forall t f a . (Set t f a, Morphing (Find f) t ~ (Predicate <:.:> Maybe > (->))) => Convergence Boolean > t a
-subset = Convergence <-- \s ss -> Nothing != (find @f @t @Maybe % s) . equate <<-- ss
+subset = Convergence <-- \s ss -> Nothing != ((find @f @t @Maybe % s) . equate <<- ss)
 
 cardinality :: Traversable (->) (->) t => t a -> Numerator
 cardinality s = attached <--- constant (modify @State (+ one)) <<- s <~~ Zero
diff --git a/Pandora/Paradigm/Structure/Interface/Stack.hs b/Pandora/Paradigm/Structure/Interface/Stack.hs
--- a/Pandora/Paradigm/Structure/Interface/Stack.hs
+++ b/Pandora/Paradigm/Structure/Interface/Stack.hs
@@ -15,5 +15,6 @@
 	type Popping t :: * -> *
 	type Pushing t :: * -> *
 	top :: Lens (Topping t) (t e) e
+	-- TODO: In case of nonempty list we know that we return an element
 	pop :: State ((Popping t) e) (Maybe e)
 	push :: e -> State ((Pushing t) e) e
diff --git a/Pandora/Paradigm/Structure/Interface/Zipper.hs b/Pandora/Paradigm/Structure/Interface/Zipper.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Interface/Zipper.hs
@@ -0,0 +1,55 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+module Pandora.Paradigm.Structure.Interface.Zipper where
+
+import Pandora.Core.Functor (type (>), type (<), type (:.), type (:::))
+import Pandora.Core.Impliable (Impliable (Arguments, imply))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Semigroupoid ((.))
+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.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.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
+import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
+import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable, Morph (Rotate))
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure, sub), Segment (Root, Rest))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite, (<~), (=#-))
+
+class Zippable (structure :: * -> *) where
+	type Breadcrumbs structure :: * -> *
+
+type Zipper (structure :: * -> *) = Tagged (Zippable structure) <:.> (Exactly <:*:> Breadcrumbs structure)
+
+type Breadcrumbed structure t = (Zippable structure, Breadcrumbs structure ~ t)
+
+instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t
+	=> Semimonoidal (<--) (:*:) (:*:) (Exactly <:*:> t) where
+	mult = Flip <-- \(T_U (Exactly (x :*: y) :*: xys)) ->
+		let xs :*: ys = mult @(<--) <~ xys in
+			(Exactly x <:*:> xs) :*: (Exactly y <:*:> ys)
+
+instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (-->) (:*:) (:*:) (Exactly <:*:> t) where
+	unit _ = Flip <-- \(T_U (Exactly x :*: _)) -> Straight (\_ -> x)
+
+instance Covariant (->) (->) t => Substructure Root (Tagged (Zippable structure) <:.> (Exactly <:*:> t)) where
+	type Substance Root (Tagged (Zippable structure) <:.> (Exactly <:*:> t)) = Exactly
+	substructure = P_Q_T <-- \source -> case lower . lower <-- source of
+		T_U (Exactly x :*: xs) -> Store <--- Exactly x :*: lift . lift . (<:*:> xs)
+
+type family Fastenable structure rs where
+	Fastenable structure (r ::: rs) = (Morphable < Rotate r < structure, Fastenable structure rs)
+	Fastenable structure r = Morphable < Rotate r < structure
diff --git a/Pandora/Paradigm/Structure/Modification.hs b/Pandora/Paradigm/Structure/Modification.hs
--- a/Pandora/Paradigm/Structure/Modification.hs
+++ b/Pandora/Paradigm/Structure/Modification.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Structure.Modification (module Exports) where
 
 import Pandora.Paradigm.Structure.Modification.Turnover as Exports
+import Pandora.Paradigm.Structure.Modification.Tape as Exports
 import Pandora.Paradigm.Structure.Modification.Prefixed as Exports
 import Pandora.Paradigm.Structure.Modification.Comprehension as Exports
 import Pandora.Paradigm.Structure.Modification.Combinative as Exports
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
@@ -10,7 +10,7 @@
 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.Bindable (Bindable ((=<<), (==<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
@@ -21,10 +21,10 @@
 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.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))
-import Pandora.Paradigm.Primary.Algebraic (empty, (<-|-<-|-))
+import Pandora.Paradigm.Algebraic.Exponential (type (-->))
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic.Sum ((:+:))
+import Pandora.Paradigm.Algebraic (empty, (<-|-<-|-))
 
 newtype Comprehension t a = Comprehension (t <::> Construction t > a)
 
@@ -34,7 +34,7 @@
 	unite = Comprehension
 
 instance Covariant (->) (->) (t <::> Construction t) => Covariant (->) (->) (Comprehension t) where
-	f <-|- Comprehension x = Comprehension <--- f <-|- x
+	f <-|- Comprehension x = Comprehension <---- f <-|- x
 
 instance Traversable (->) (->) (t <::> Construction t) => Traversable (->) (->) (Comprehension t) where
 	f <<- Comprehension x = Comprehension <-|- f <<- x
@@ -46,7 +46,7 @@
 	unit _ = Straight <-- \_ -> Comprehension empty
 
 instance (forall a . Semigroup (t <::> Construction t > a), Bindable (->) t) => Bindable (->) (Comprehension t) where
-	f =<< Comprehension (TT t) = Comprehension . TT <-- (\(Construct x xs) -> run . run @(->) <---- f x + (f ===<< Comprehension <-- TT xs)) =<< t
+	f =<< Comprehension (TT t) = Comprehension . TT <--- (\(Construct x xs) -> run . run @(->) <-- f x + (f ==<< Comprehension <-- TT xs)) =<< t
 
 instance Setoid (t <::> Construction t > a) => Setoid (Comprehension t a) where
 	Comprehension ls == Comprehension rs = ls == rs
diff --git a/Pandora/Paradigm/Structure/Modification/Prefixed.hs b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
--- a/Pandora/Paradigm/Structure/Modification/Prefixed.hs
+++ b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
@@ -4,10 +4,10 @@
 
 import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|-|-)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|----), (<-|-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
-import Pandora.Paradigm.Primary.Algebraic (extract)
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Algebraic (extract)
+import Pandora.Paradigm.Algebraic.Product ((:*:))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-)))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into), premorph)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
@@ -24,7 +24,7 @@
 	(<-|-) f = (=#-) (f <-|-|-)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Prefixed t k) where
-	f <<- Prefixed x = Prefixed <-|-- f <<-<<- x
+	f <<- Prefixed x = Prefixed <-|---- f <<-<<- x
 
 instance Covariant (->) (->) t => Morphable (Into t) (Prefixed t k) where
 	type Morphing (Into t) (Prefixed t k) = t
diff --git a/Pandora/Paradigm/Structure/Modification/Tape.hs b/Pandora/Paradigm/Structure/Modification/Tape.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Modification/Tape.hs
@@ -0,0 +1,78 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Pandora.Paradigm.Structure.Modification.Tape where
+
+import Pandora.Core.Impliable (Impliable (Arguments, imply))
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category ((<--), (<---), (<----), (<------))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|---)))
+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.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
+import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
+import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)
+import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
+import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite, (<~), (=#-))
+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable, Morph (Rotate), Vertical (Up, Down), Occurrence (All))
+import Pandora.Paradigm.Structure.Interface.Zipper (Zippable)
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root), sub)
+import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
+import Pandora.Paradigm.Inventory.Some.Optics (Lens, Convex, view, replace, mutate)
+
+type Tape structure = Tagged (Zippable structure)
+	<:.> (Exactly <:*:> Reverse structure <:*:> structure)
+
+instance {-# OVERLAPS #-} Traversable (->) (->) t => Traversable (->) (->) (Tape t) where
+	f <<- z = (\ls x rs -> lift <------ x <:*:> ls <:*:> rs)
+		<-|--- f <<--- view <-- sub @Left <-- z
+		<-*--- f <<--- view <-- sub @Root <-- z
+		<-*--- f <<--- view <-- sub @Right <-- z
+
+instance Covariant (->) (->) t => Impliable (Tape t a) where
+	type Arguments (Tape t a) = a -> t a -> t a -> Tape t a
+	imply focused left right = lift <------ Exactly focused <:*:> Reverse left <:*:> right
+
+instance Covariant (->) (->) t => Substructure Left (Tape t) where
+	type Substance Left (Tape t) = Reverse t
+	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of
+		Exactly x :*: T_U (ls :*: rs) -> Store <--- ls :*: lift . (imply @(Tape t _) x % rs) . run
+
+instance Covariant (->) (->) t => Substructure Right (Tape t) where
+	type Substance Right (Tape t) = t
+	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of
+		Exactly x :*: T_U (Reverse ls :*: rs) -> Store <--- rs :*: lift . imply @(Tape t _) x ls
+
+instance Covariant (->) (->) t => Substructure Up (Tape t <::> Tape t) where
+	type Substance Up (Tape t <::> Tape t) = t <::> Tape t
+	substructure = P_Q_T <-- \x -> case run . lower . run . lower <-- x of
+		Exactly focused :*: T_U (Reverse d :*: u) ->
+			Store <--- TT u :*: lift . TT . imply @(Tape t _) focused d . run
+
+instance Covariant (->) (->) t => Substructure Down (Tape t <::> Tape t) where
+	type Substance Down (Tape t <::> Tape t) = Reverse t <::> Tape t
+	substructure = P_Q_T <-- \ii -> case run . lower . run . lower <-- ii of
+		Exactly focused :*: T_U (d :*: u) ->
+			Store <--- TT d :*: lift . TT . (imply @(Tape t _) focused % u) . run . run
+
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure (All Left) (Tape t <::> Tape t) where
+	type Substance (All Left) (Tape t <::> Tape t) = Tape t <::> Reverse t
+	substructure = P_Q_T <-- \source ->
+		let target = (view (sub @Left) <-|-) =#- lower source in
+		let updated new = replace % sub @Left <-|-- new <-*-- run <-- lower source in
+		Store <--- target :*: lift . (updated =#-)
+
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure (All Right) (Tape t <::> Tape t) where
+	type Substance (All Right) (Tape t <::> Tape t) = Tape t <::> t
+	substructure = P_Q_T <-- \source ->
+		let target = (view (sub @Right) <-|-) =#- lower source in
+		let updated new = replace % sub @Right <-|-- new <-*-- run <-- lower source in
+			Store <--- target :*: lift . (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.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Transformer.Hoistable ((/|\))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic ((>-|-<-|-))
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Algebraic ((>-|-<-|-))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-)))
 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
@@ -7,13 +7,13 @@
 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.Bindable (Bindable ((=<<), (==<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), type (:*:), type (<:*:>), attached)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), (&), (.:..))
-import Pandora.Paradigm.Primary.Algebraic ((<-*-), (<-*--), (<-*-*-), extract, point, empty)
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached)
+import Pandora.Paradigm.Algebraic.Exponential ((%), (&), (.:..))
+import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (<-*-*-), extract, point, empty)
 import Pandora.Paradigm.Primary.Object.Ordering (order)
 import Pandora.Paradigm.Primary.Functor (Comparison)
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
@@ -21,7 +21,6 @@
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
-import Pandora.Paradigm.Primary (twosome)
 import Pandora.Paradigm.Schemes (TT (TT), T_U (T_U), P_Q_T (P_Q_T), type (<::>), type (<:.:>))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~))
 import Pandora.Paradigm.Inventory.Ability.Gettable (get)
@@ -33,26 +32,12 @@
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (resolve))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), morph, premorph
 	, Morph (Rotate, Into, Insert, Lookup, Key), Vertical (Up, Down), Horizontal (Leftward, Rightward), lookup)
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root), sub)
-import Pandora.Paradigm.Structure.Ability.Zipper (Zippable (Breadcrumbs))
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root, Branch), sub)
+import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs))
 import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed (Prefixed))
 
 type Binary = Maybe <::> Construction (Maybe <:*:> Maybe)
 
--- instance {-# OVERLAPS #-} Traversable (->) (->) (Construction Wye) where
-	-- f <<- Construct x (Left l) = Construct <-|-- f x <-*-- Left <-|- f <<- l
-	-- f <<- Construct x (Right r) = Construct <-|-- f x <-*-- Right <-|- f <<- r
-	-- f <<- Construct x (Both l r) = Construct <-|-- f x <-*-- Both <-|- f <<- l <-*- f <<- r
-	-- f <<- Construct x End = Construct % End <-|- f x
-
--- instance {-# OVERLAPS #-} Traversable (->) (->) (Construction (Maybe <:*:> Maybe)) where
-	-- f <<- Construct x branches = Construct <-|- f x <-*- (f <<- branches :: _)
-
-	-- f <<- Construct x (Left l) = Construct <-|-- f x <-*-- Left <-|- f <<- l
-	-- f <<- Construct x (Right r) = Construct <-|-- f x <-*-- Right <-|- f <<- r
-	-- f <<- Construct x (Both l r) = Construct <-|-- f x <-*-- Both <-|- f <<- l <-*- f <<- r
-	-- f <<- Construct x (Nothing <:*:> Nothing) = Construct % (Nothing <:*:> Nothing) <-|- f x
-
 --rebalance :: Chain a => (Wye :. Construction Wye > a) -> Nonempty Binary a
 --rebalance (Both x y) = extract x <=> extract y & order
 --	# Construct (extract x) (Both # rebalance (deconstruct x) # rebalance (deconstruct y))
@@ -62,65 +47,60 @@
 -- instance Morphable Insert Binary where
 	-- type Morphing Insert Binary = (Exactly <:.:> Comparison > (:*:)) <:.:> Binary > (->)
 	-- morphing struct = case run ---> premorph struct of
-		-- Nothing -> T_U <-- \(T_U (Exactly x :*: _)) -> lift <-- leaf x
+		-- Nothing -> T_U <-- \(T_U (Exactly x :*: _)) -> lift <-- point x
 		-- Just binary -> T_U <-- \(T_U (Exactly x :*: Convergence f)) ->
 			-- let continue xs = run <-- morph @Insert @(Nonempty Binary) xs <--- twosome <-- Exactly x <-- Convergence f in
-			-- let step = iff @Just <-|-|- get @(Obscure Lens) <-*-*- modify @(Obscure Lens) continue <-*-*- set @(Obscure Lens) <-- leaf x in
+			-- let step = iff @Just <-|-|- get @(Obscure Lens) <-*-*- modify @(Obscure Lens) continue <-*-*- set @(Obscure Lens) <-- point x in
 			-- lift <---- order binary
 				-- <--- step <-- sub @Left <-- binary
 				-- <--- step <-- sub @Right <-- binary
 				-- <--- f x <-- extract binary
 
-instance Substructure Left Binary where
-	type Substance Left Binary = Binary
+instance Substructure (Left Branch) Binary where
+	type Substance (Left Branch) Binary = Binary
 	substructure = P_Q_T <-- \struct -> case run <-- lower struct of
 		Nothing -> Store <--- empty :*: lift . constant empty
-		Just tree -> lift . lift @(->) <-|- sub @Left <~ tree
+		Just tree -> lift . lift @(->) <-|- sub @(Left Branch) <~ tree
 
-instance Substructure Right Binary where
-	type Substance Right Binary = Binary
+instance Substructure (Right Branch) Binary where
+	type Substance (Right Branch) Binary = Binary
 	substructure = P_Q_T <-- \struct -> case run . extract . run ---> struct of
 		Nothing -> Store <--- empty :*: lift . constant empty
-		Just tree -> lift . lift @(->) <-|- sub @Right <~ tree
+		Just tree -> lift . lift @(->) <-|- sub @(Right Branch) <~ tree
 
 -------------------------------------- Non-empty binary tree ---------------------------------------
 
-type instance Nonempty Binary = Construction (Maybe <:*:> Maybe)
+type instance Nonempty Binary = Construction > Maybe <:*:> Maybe
 
-instance Morphable (Into Binary) (Construction (Maybe <:*:> Maybe)) where
-	type Morphing (Into Binary) (Construction (Maybe <:*:> Maybe)) = Binary
+instance Morphable (Into Binary) (Construction > Maybe <:*:> Maybe) where
+	type Morphing (Into Binary) (Construction > Maybe <:*:> Maybe) = Binary
 	morphing = lift . premorph
 
 -- instance Morphable Insert (Construction Wye) where
 	-- type Morphing Insert (Construction Wye) = (Exactly <:.:> Comparison > (:*:)) <:.:> Construction Wye > (->)
 	-- morphing (premorph -> struct) = T_U <-- \(T_U (Exactly x :*: Convergence f)) ->
 		-- let continue xs = run <--- morph @Insert @(Nonempty Binary) xs <---- twosome <--- Exactly x <--- Convergence f in
-		-- let step = iff @Just <-|-|- (run .:.. view) <-*-*- mutate continue <-*-*- replace (leaf x) in
+		-- let step = iff @Just <-|-|- (run .:.. view) <-*-*- mutate continue <-*-*- replace (point x) in
 		-- order struct
 			-- <---- step <--- sub @Left <--- struct
 			-- <---- step <--- sub @Right <--- struct
 			-- <---- f x <--- extract struct
 
-instance Substructure Root (Construction (Maybe <:*:> Maybe)) where
-	type Substance Root (Construction (Maybe <:*:> Maybe)) = Exactly
-	substructure = P_Q_T <-- \struct -> case lower struct of
-		Construct x xs -> Store <--- Exactly x :*: lift . (Construct % xs) . extract
-
-instance Substructure Left (Construction (Maybe <:*:> Maybe)) where
-	type Substance Left (Construction (Maybe <:*:> Maybe)) = Binary
-	substructure = P_Q_T <-- \struct -> case extract ---> run struct of
-		Construct x (T_U (Nothing :*: Nothing)) -> Store <--- TT Nothing :*: lift . resolve (Construct x . left) (leaf x) . run
-		Construct x (T_U (Just lst :*: Nothing)) -> Store <--- TT (Just lst) :*: lift . Construct x . resolve left end . run
-		Construct x (T_U (Nothing :*: Just rst)) -> Store <--- TT Nothing :*: lift . Construct x . resolve (both % rst) (right rst) . run
-		Construct x (T_U (Just lst :*: Just rst)) -> Store <--- TT (Just lst) :*: lift . Construct x . resolve (both % rst) (right rst) . run
-
-instance Substructure Right (Construction (Maybe <:*:> Maybe)) where
-	type Substance Right (Construction (Maybe <:*:> Maybe)) = Binary
-	substructure = P_Q_T <-- \struct -> case extract <-- run struct of
-		Construct x (T_U (Nothing :*: Nothing)) -> Store <--- TT Nothing :*: lift . resolve (Construct x . right) (leaf x) . run
-		Construct x (T_U (Just lst :*: Nothing)) -> Store <--- TT Nothing :*: lift . Construct x . resolve (both lst) (left lst) . run
-		Construct x (T_U (Nothing :*: Just rst)) -> Store <--- TT (Just rst) :*: lift . Construct x . resolve right end . run
-		Construct x (T_U (Just lst :*: Just rst)) -> Store <--- TT (Just rst) :*: lift . Construct x . resolve (both lst) (left lst) . run
+-- instance Substructure Left (Construction (Maybe <:*:> Maybe)) where
+-- 	type Substance Left (Construction (Maybe <:*:> Maybe)) = Binary
+-- 	substructure = P_Q_T <-- \struct -> case extract ---> run struct of
+-- 		Construct x (T_U (Nothing :*: Nothing)) -> Store <--- TT Nothing :*: lift . resolve (Construct x . left) (point x) . run
+-- 		Construct x (T_U (Just lst :*: Nothing)) -> Store <--- TT (Just lst) :*: lift . Construct x . resolve left end . run
+-- 		Construct x (T_U (Nothing :*: Just rst)) -> Store <--- TT Nothing :*: lift . Construct x . resolve (both % rst) (right rst) . run
+-- 		Construct x (T_U (Just lst :*: Just rst)) -> Store <--- TT (Just lst) :*: lift . Construct x . resolve (both % rst) (right rst) . run
+--
+-- instance Substructure Right (Construction (Maybe <:*:> Maybe)) where
+-- 	type Substance Right (Construction (Maybe <:*:> Maybe)) = Binary
+-- 	substructure = P_Q_T <-- \struct -> case extract <-- run struct of
+-- 		Construct x (T_U (Nothing :*: Nothing)) -> Store <--- TT Nothing :*: lift . resolve (Construct x . right) (point x) . run
+-- 		Construct x (T_U (Just lst :*: Nothing)) -> Store <--- TT Nothing :*: lift . Construct x . resolve (both lst) (left lst) . run
+-- 		Construct x (T_U (Nothing :*: Just rst)) -> Store <--- TT (Just rst) :*: lift . Construct x . resolve right end . run
+-- 		Construct x (T_U (Just lst :*: Just rst)) -> Store <--- TT (Just rst) :*: lift . Construct x . resolve (both lst) (left lst) . run
 
 -------------------------------------- Prefixed binary tree ----------------------------------------
 
@@ -129,15 +109,15 @@
 	morphing struct = case run . run . premorph <-- struct of
 		Nothing -> TT <-- \_ -> Nothing
 		Just tree -> TT <-- \key ->
-			key <=> attached <-- extract tree & order
-				<---- Just --> extract --> extract tree
-				<---- lookup @Key key . Prefixed ===<< run (view <-- sub @Left <-- tree)
-				<---- lookup @Key key . Prefixed ===<< run (view <-- sub @Right <-- tree)
+			key <=> attached (extract tree) & order
+				<--- Just --> extract --> extract tree
+				<--- lookup @Key key . Prefixed =<< run (view <-- sub @(Left Branch) <-- tree)
+				<--- lookup @Key key . Prefixed =<< run (view <-- sub @(Right Branch) <-- tree)
 
 -- instance Chain k => Morphable (Vary Element) (Prefixed Binary k) where
 	-- type Morphing (Vary Element) (Prefixed Binary k) = ((:*:) k <::> Exactly) <:.:> Prefixed Binary k > (->)
 	-- morphing struct = case run . run . premorph ! struct of
-		-- Nothing -> T_U ! \(TT (key :*: Exactly value)) -> Prefixed . lift . leaf ! key :*: value
+		-- Nothing -> T_U ! \(TT (key :*: Exactly value)) -> Prefixed . lift . point ! key :*: value
 		-- Just tree -> T_U ! \(TT (key :*: Exactly value)) ->
 			-- let continue = ((vary @Element @k @_ @(Prefixed Binary _) key value -#=) -#=) in
 			-- Prefixed . lift ! key <=> attached (extract tree) & order
@@ -152,8 +132,8 @@
 	morphing (run . premorph -> Construct x xs) = TT <-- \key ->
 		key <=> attached x & order
 			<---- Just <-- extract x
-			<---- lookup @Key key . Prefixed ===<< get @(Obscure Lens) <-- sub @Left <-- xs
-			<---- lookup @Key key . Prefixed ===<< get @(Obscure Lens) <-- sub @Left <-- xs
+			<---- lookup @Key key . Prefixed ==<< get @(Obscure Lens) <-- sub @Left <-- xs
+			<---- lookup @Key key . Prefixed ==<< get @(Obscure Lens) <-- sub @Left <-- xs
 
 -------------------------------------- Zipper of binary tree ---------------------------------------
 	{-
@@ -184,34 +164,34 @@
 		= Maybe <::> ((Exactly <:.:> Wye <::> Construction Wye > (:*:)) <:.:> Bifurcation <::> Bicursor > (:*:))
 	morphing struct = case run ---> premorph struct of
 		focused :*: TT (TT (Horizontal (Rightward (Construct (T_U (Exactly parent :*: rest)) next)))) ->
-			lift . (twosome % TT (TT next)) . twosome (Exactly parent) . TT <---- resolve
+			lift . ((<:*:>) % TT (TT next)) . (<:*:>) (Exactly parent) . TT <---- resolve
 				<--- Both <-- _focused_part_to_nonempty_binary_tree focused
 				<--- Left <-- _focused_part_to_nonempty_binary_tree focused
 				<--- run rest
 		focused :*: TT (TT (Horizontal (Leftward (Construct (T_U (Exactly parent :*: rest)) next)))) ->
-			lift . (twosome % TT (TT next)) . twosome (Exactly parent) . TT <---- resolve
+			lift . ((<:*:>) % TT (TT next)) . (<:*:>) (Exactly parent) . TT <---- resolve
 				<--- Both % _focused_part_to_nonempty_binary_tree focused
 				<--- Right <-- _focused_part_to_nonempty_binary_tree focused
 				<--- run rest
 		_ -> TT Nothing
 
 _nonempty_binary_tree_to_focused_part :: Construction Wye ~> Exactly <:.:> Wye <::> Construction Wye > (:*:)
-_nonempty_binary_tree_to_focused_part (Construct x xs) = twosome <--- Exactly x <--- TT xs
+_nonempty_binary_tree_to_focused_part (Construct x xs) = Exactly x <:*:> TT xs
 
 instance Morphable (Rotate > Down Left) ((Exactly <:.:> Wye <::> Construction Wye > (:*:)) <:.:> (Bifurcation <::> Bicursor) > (:*:)) where
 	type Morphing (Rotate > Down Left) ((Exactly <:.:> Wye <::> Construction Wye > (:*:)) <:.:> (Bifurcation <::> Bicursor) > (:*:))
 		= Maybe <::> ((Exactly <:.:> Wye <::> Construction Wye > (:*:)) <:.:> Bifurcation <::> Bicursor > (:*:))
 	morphing struct = case run ---> premorph struct of
 		T_U (Exactly x :*: TT (Left lst)) :*: TT (TT next) ->
-			lift . twosome (_nonempty_binary_tree_to_focused_part lst)
-				. TT . TT . Horizontal . Leftward <---- Construct 
-					<--- twosome <-- Exactly x <-- TT Nothing 
-					<--- next
+			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part lst)
+				. TT . TT . Horizontal . Leftward <------- Construct
+					<------ Exactly x <:*:> TT Nothing
+					<------ next
 		T_U (Exactly x :*: TT (Both lst rst)) :*: TT (TT next) ->
-			lift . twosome (_nonempty_binary_tree_to_focused_part lst)
-				. TT . TT . Horizontal . Leftward <---- Construct
-					<--- twosome <-- Exactly x <-- lift rst 
-					<--- next
+			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part lst)
+				. TT . TT . Horizontal . Leftward <------- Construct
+					<------ Exactly x <:*:> lift rst
+					<------ next
 		_ -> TT Nothing
 
 instance Morphable (Rotate > Down Right) ((Exactly <:.:> Wye <::> Construction Wye > (:*:)) <:.:> (Bifurcation <::> Bicursor) > (:*:)) where
@@ -219,18 +199,10 @@
 		= Maybe <::> ((Exactly <:.:> Wye <::> Construction Wye > (:*:)) <:.:> Bifurcation <::> Bicursor > (:*:))
 	morphing struct = case run ---> premorph struct of
 		T_U (Exactly x :*: TT (Right rst)) :*: TT (TT next) ->
-			lift . twosome (_nonempty_binary_tree_to_focused_part rst)
-				. TT . TT . Horizontal . Rightward <---- Construct (twosome <--- Exactly x <--- TT Nothing) next
+			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part rst)
+				. TT . TT . Horizontal . Rightward <---- Construct (Exactly x <:*:> TT Nothing) next
 		T_U (Exactly x :*: TT (Both lst rst)) :*: TT (TT next) ->
-			lift . twosome (_nonempty_binary_tree_to_focused_part rst)
-				. TT . TT . Horizontal . Rightward <---- Construct (twosome <--- Exactly x <--- lift lst) next
+			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part rst)
+				. TT . TT . Horizontal . Rightward <---- Construct (Exactly x <:*:> lift lst) next
 		_ -> TT Nothing
 -}
-
-leaf :: a :=> Nonempty Binary
-leaf x = Construct x end
-
-left x = T_U <--- Just x :*: Nothing
-right x = T_U <--- Nothing :*: Just x
-both x y = T_U <--- Just x :*: Just y
-end = T_U <--- Nothing :*: Nothing
diff --git a/Pandora/Paradigm/Structure/Some/List.hs b/Pandora/Paradigm/Structure/Some/List.hs
--- a/Pandora/Paradigm/Structure/Some/List.hs
+++ b/Pandora/Paradigm/Structure/Some/List.hs
@@ -4,22 +4,22 @@
 import Pandora.Core.Functor (type (:.), type (<), type (>))
 import Pandora.Core.Impliable (imply)
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (-->), (--->), (---->), identity)
+import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------), (-->), (--->), (---->), identity)
 import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((<-|-), (<-|--), (<-|-|-)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-), (<<--)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<), (===<<), (====<<)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Pattern.Object.Setoid (Setoid ((==), (?==)))
+import Pandora.Pattern.Object.Setoid (Setoid ((==), (?=)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Primary.Algebraic ((<-*-), (<-*--), (.-*-), (.-+-), (.:..), extract, point, empty, void)
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
-import Pandora.Paradigm.Primary.Algebraic ((<-|-<-|-))
+import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (.-*-), (.-+-), (.:..), extract, point, empty, void)
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached)
+import Pandora.Paradigm.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Algebraic ((<-|-<-|-))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
@@ -28,29 +28,30 @@
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+))
 import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))
-import Pandora.Paradigm.Primary (twosome)
+import Pandora.Paradigm.Primary ()
 import Pandora.Paradigm.Inventory.Ability.Gettable (get)
 import Pandora.Paradigm.Inventory.Ability.Settable (set)
 import Pandora.Paradigm.Inventory.Ability.Modifiable (modify)
 import Pandora.Paradigm.Inventory.Some.State (State, fold)
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Some.Optics (Convex, Obscure, Lens)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~), (=#-))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~), (<~~~), (=#-))
 import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
 import Pandora.Paradigm.Schemes.TU (TU (TU))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
-import Pandora.Paradigm.Structure.Ability.Zipper (Zippable (Breadcrumbs), Zipper, Tape)
+import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs), Zipper)
 import Pandora.Paradigm.Structure.Ability.Monotonic (resolve)
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing)
 	, Morph (Rotate, Into, Push, Pop, Delete, Find, Lookup, Element, Key)
 	, Occurrence (All, First), premorph, rotate, item, filter, find, lookup, into)
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure, sub), Segment (Root, Tail))
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure, sub), Segment (Root, Rest))
 import Pandora.Paradigm.Structure.Interface.Stack (Stack (Popping, Pushing, Topping, push, pop, top))
 import Pandora.Paradigm.Structure.Modification.Combinative (Combinative)
 import Pandora.Paradigm.Structure.Modification.Comprehension (Comprehension (Comprehension))
 import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed (Prefixed))
+import Pandora.Paradigm.Structure.Modification.Tape (Tape)
 import Pandora.Paradigm.Structure.Modification.Turnover (Turnover (Turnover))
 
 -- | Linear data structure that serves as a collection of elements
@@ -80,24 +81,24 @@
 	morphing list = case run --> premorph list of
 		Nothing -> T_U <-- \_ -> Nothing
 		Just (Construct x xs) -> T_U <-- \p ->
-			p <~ x ?== True <----- Just x
-				<----- find @Element @List @Maybe <-- p <-- TT xs
+			(p <~ x) ?= True <---- Just x
+				<---- find @Element @List @Maybe <-- p <-- TT xs
 
 instance Morphable (Delete First) List where
 	type Morphing (Delete First) List = Predicate <:.:> List > (->)
 	morphing list = case run --> premorph list of
 		Nothing -> T_U <-- constant empty
-		Just (Construct x xs) -> T_U <-- \p -> 
-			p <~ x ?== True <----- TT xs
-				<----- lift . Construct x . run . filter @First @List p <-- TT xs
+		Just (Construct x xs) -> T_U <-- \p ->
+			(p <~ x) ?= True <--- TT xs
+				<--- lift . Construct x . run . filter @First @List p <-- TT xs
 
 instance Morphable (Delete All) List where
 	type Morphing (Delete All) List = Predicate <:.:> List > (->)
 	morphing list = case run <--- premorph list of
 		Nothing -> T_U <-- constant empty
-		Just (Construct x xs) -> T_U <-- \p -> p <~ x ?== True
-				<----- filter @All @List p <-- TT xs
-				<----- lift . Construct x . run . filter @All @List p <-- TT xs
+		Just (Construct x xs) -> T_U <-- \p -> (p <~ x) ?= True
+				<--- filter @All @List p <-- TT xs
+				<--- lift . Construct x . run . filter @All @List p <-- TT xs
 
 instance Stack List where
 	type Topping List = Maybe
@@ -107,7 +108,7 @@
 		TT Nothing -> Store <--- Nothing :*: constant empty
 		TT (Just xs) -> Store <--- Just (extract xs) :*: \new -> case new of
 			Nothing -> TT <-- deconstruct xs
-			Just x -> TT <--- Construct x . Just <-|- deconstruct xs
+			Just x -> TT <---- Construct x . Just <-|- deconstruct xs
 	pop = resolve @(Nonempty List _) (\(Construct x xs) -> constant (Just x) <-|- set @State (TT xs)) (point Nothing) . run ==<< get @State
 	push x = point x .-*- modify @State (item @Push x)
 
@@ -117,10 +118,10 @@
 		Just (Construct x xs) -> Store <--- Just x :*: lift . resolve (lift . (Construct % xs)) zero
 		Nothing -> Store <--- Nothing :*: lift . resolve (lift . point) zero
 
-instance Substructure Tail List where
-	type Substance Tail List = List
+instance Substructure Rest List where
+	type Substance Rest List = List
 	substructure = P_Q_T <-- \source -> case run . lower <-- source of
-		Just ns -> lift . lift @(->) <-|- run (sub @Tail) ns
+		Just ns -> lift . lift @(->) <-|- run (sub @Rest) ns
 		Nothing -> Store <--- zero :*: lift . identity
 
 -- | Transform any traversable structure into a list
@@ -137,7 +138,7 @@
 
 instance Morphable (Find Element) (Construction Maybe) where
 	type Morphing (Find Element) (Construction Maybe) = Predicate <:.:> Maybe > (->)
-	morphing (premorph -> Construct x xs) = T_U <-- \p -> p <~ x ?== True <----- Just x
+	morphing (premorph -> Construct x xs) = T_U <-- \p -> (p <~ x) ?= True <----- Just x
 		<----- find @Element @(Nonempty List) @Maybe <-- p ===<< xs
 
 instance Morphable (Into List) (Construction Maybe) where
@@ -156,16 +157,6 @@
 	type Morphing Push (Construction Maybe) = Exactly <:.:> Construction Maybe > (->)
 	morphing (premorph -> xs) = T_U <-- \(Exactly x) -> Construct x <-- Just xs
 
-instance Substructure Root (Construction Maybe) where
-	type Substance Root (Construction Maybe) = Exactly
-	substructure = P_Q_T <-- \source -> case lower source of
-		Construct x xs -> Store <--- Exactly x :*: lift . (Construct % xs) . extract
-
-instance Substructure Tail (Construction Maybe) where
-	type Substance Tail (Construction Maybe) = List
-	substructure = P_Q_T <-- \source -> case lower source of
-		Construct x xs -> Store <--- TT xs :*: lift . Construct x . run
-
 instance Stack (Construction Maybe) where
 	type Topping (Construction Maybe) = Exactly
 	type Popping (Construction Maybe) = Construction Maybe
@@ -182,11 +173,11 @@
 ----------------------------------------- Zipper of list -------------------------------------------
 
 instance Zippable List where
-	type Breadcrumbs List = Reverse List <:.:> List > (:*:)
+	type Breadcrumbs List = Reverse List <:*:> List
 
 instance {-# OVERLAPS #-} Traversable (->) (->) (Tape List) where
-	f <<- TU (Tag (T_U (Exactly x :*: T_U (left :*: right)))) = 
-		(\past' x' left' -> lift <---- twosome <-- Exactly x' <--- twosome <-- left' <-- run past')
+	f <<- TU (Tag (T_U (Exactly x :*: T_U (left :*: right)))) =
+		(\past' x' left' -> lift <------ Exactly x' <:*:> left' <:*:> run past')
 			<-|- f <<- Reverse right <-*- f x <-*- f <<- left
 
 -- instance {-# OVERLAPS #-} Extendable (->) (Tape List) where
@@ -206,7 +197,7 @@
 		rotate_left focused rs (Construct lx lxs) = imply @(Tape List _) <-- lx <-- TT lxs <-- item @Push focused rs
 
 		rotate_over :: a -> Nonempty List a -> Tape List a
-		rotate_over focused rs = let new_left = attached <--- run <-- put_over <<- rs <-- point focused in
+		rotate_over focused rs = let new_left = attached <--- (put_over <<- rs <~~~ point focused) in
 			imply @(Tape List _) <--- extract new_left <--- TT <-- deconstruct new_left <--- empty
 
 		put_over :: a -> State (Nonempty List a) ()
@@ -222,7 +213,7 @@
 		rotate_right focused ls (Construct rx rxs) = imply @(Tape List _) <-- rx <-- item @Push focused ls <-- TT rxs
 
 		rotate_over :: a -> Nonempty List a -> Tape List a
-		rotate_over focused ls = let new_right = attached (run <-- put_over <<- ls <-- point focused) in
+		rotate_over focused ls = let new_right = attached (put_over <<- ls <~~~ point focused) in
 			imply @(Tape List _) <--- extract new_right <--- empty <--- TT <-- deconstruct new_right
 
 		put_over :: a -> State (Nonempty List a) ()
@@ -235,19 +226,19 @@
 instance Morphable (Into List) (Tape List) where
 	type Morphing (Into List) (Tape List) = List
 	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)
-		<--- modify @State . item @Push @List <<-- right
+		<--- modify @State . item @Push @List <<- right
 		<--- item @Push x left
 
 instance Morphable (Into > Comprehension Maybe) (Tape List) where
 	type Morphing (Into > Comprehension Maybe) (Tape List) = Comprehension Maybe
 	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)
-		<--- modify @State . item @Push @(Comprehension Maybe) <<-- right
+		<--- modify @State . item @Push @(Comprehension Maybe) <<- right
 		<--- item @Push x <-- Comprehension left
 
 ------------------------------------- Zipper of non-empty list -------------------------------------
 
 instance Zippable (Construction Maybe) where
-	type Breadcrumbs (Construction Maybe) = Reverse > Construction Maybe <:.:> Construction Maybe > (:*:)
+	type Breadcrumbs (Construction Maybe) = Reverse > Construction Maybe <:*:> Construction Maybe
 
 instance Morphable (Rotate Left) (Tape > Construction Maybe) where
 	type Morphing (Rotate Left) (Tape > Construction Maybe) = Maybe <::> (Tape > Construction Maybe)
@@ -282,19 +273,19 @@
 instance Morphable (Into > Construction Maybe) (Tape > Construction Maybe) where
 	type Morphing (Into > Construction Maybe) (Tape > Construction Maybe) = Construction Maybe
 	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)
-		<--- modify @State . item @Push @(Nonempty List) <<-- right
+		<--- modify @State . item @Push @(Nonempty List) <<- right
 		<--- item @Push x left
 
 instance Morphable (Into List) (Tape > Construction Maybe) where
 	type Morphing (Into List) (Tape > Construction Maybe) = List
 	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)
-		<--- modify @State . item @Push @List <<-- right
+		<--- modify @State . item @Push @List <<- right
 		<--- item @Push x <-- lift left
 
 ------------------------------------ Zipper of combinative list ------------------------------------
 
 instance Zippable (Comprehension Maybe) where
-	type Breadcrumbs (Comprehension Maybe) = Comprehension Maybe <:.:> Comprehension Maybe > (:*:)
+	type Breadcrumbs (Comprehension Maybe) = Comprehension Maybe <:*:> Comprehension Maybe
 
 ----------------------------------------- Prefixed list --------------------------------------------
 
@@ -307,5 +298,6 @@
 instance Setoid key => Morphable (Lookup Key) (Prefixed < Construction Maybe < key) where
 	type Morphing (Lookup Key) (Prefixed < Construction Maybe < key) = (->) key <::> Maybe
 	morphing (run . premorph -> Construct x xs) = TT <-- \key -> extract <-|- search key where
-		search key = key ?== attached x <----- Just x 
-			<----- find @Element <--- Predicate <-- (key ==) . attached ====<< xs
+		search key = key ?= attached x
+			<----- Just x
+			<----- find @Element <--- Predicate <-- (key ==) . attached ===<< xs
diff --git a/Pandora/Paradigm/Structure/Some/Rose.hs b/Pandora/Paradigm/Structure/Some/Rose.hs
--- a/Pandora/Paradigm/Structure/Some/Rose.hs
+++ b/Pandora/Paradigm/Structure/Some/Rose.hs
@@ -5,64 +5,50 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----))
 import Pandora.Pattern.Kernel (constant)
-import Pandora.Pattern.Functor.Contravariant ((>-|--))
+import Pandora.Pattern.Functor.Covariant ((<-|-), (<-|-|-))
+import Pandora.Pattern.Functor.Contravariant ((>-|-))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Pattern.Object.Setoid (Setoid ((==), (!=), (?==)))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
-import Pandora.Paradigm.Primary.Algebraic (extract)
+import Pandora.Pattern.Transformer.Hoistable ((/|\))
+import Pandora.Pattern.Object.Setoid (Setoid ((==), (!=), (?=)))
+import Pandora.Pattern.Object.Semigroup ((+))
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), attached)
+import Pandora.Paradigm.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Algebraic (extract, empty, (>-||-))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
-import Pandora.Paradigm.Primary.Algebraic (extract)
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached)
+import Pandora.Paradigm.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Algebraic (extract, point)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (equate)
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)
+import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
-import Pandora.Paradigm.Schemes (TU (TU), P_Q_T (P_Q_T), type (<:.>))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse)
+import Pandora.Paradigm.Schemes (TU (TU), TT (TT), T_U (T_U), P_Q_T (P_Q_T),  type (<::>), type (<:.>))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite, (<~), (=#-), (<~~~~))
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
-import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Lookup, Element, Key), premorph, find)
+import Pandora.Paradigm.Inventory.Some.Optics (view)
+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing)
+	, Morph (Into, Rotate, Lookup, Element, Key), Vertical (Up, Down), premorph, find)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root, Tail))
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure)
+	, Segment (Root, Rest, Forest), sub, tagstruct)
+import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs))
+import Pandora.Paradigm.Structure.Interface.Stack (Stack (pop, push))
 import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed)
+import Pandora.Paradigm.Structure.Modification.Tape (Tape)
 import Pandora.Paradigm.Structure.Some.List (List)
 
 type Rose = Maybe <:.> Construction List
 
--- FIXME: If we want to remove root node, we ruin the whole tree
---instance Substructure Root Rose where
---	type Available Root Rose = Maybe
---	type Substance Root Rose = Exactly
---	substructure = P_Q_T <-- \rose -> case run # lower rose of
---		Nothing -> Store <--- Nothing :*: TU . Tag . TU . ((Construct % empty) . extract <-|-)
---		Just nonempty_rose -> Store <--- Just (Exactly # extract nonempty_rose) :*: \case
---			Just (Exactly new) -> lift . TU . Just . Construct new <-- deconstruct nonempty_rose
---			Nothing -> lift empty
-
---instance Substructure Just Rose where
---	type Available Just Rose = Exactly
---	type Substance Just Rose = List <:.> Construction List
---	substructure = P_Q_T <-- \rose -> case run . extract . run # rose of
---		Nothing -> Store <--- Exactly empty :*: constant (lift empty)
---		Just (Construct x xs) -> Store <--- Exactly (TU xs) :*: lift . lift . Construct x . run . extract
-
 --------------------------------------- Non-empty rose tree ----------------------------------------
 
 type instance Nonempty Rose = Construction List
 
-instance Substructure Root (Construction List) where
-	type Substance Root (Construction List) = Exactly
-	--substructure = P_Q_T <-- \rose -> Store <--- Exactly (Exactly <-- extract (lower rose)) :*: lift . (Construct % deconstruct (lower rose)) . extract . extract
-
-instance Substructure Tail (Construction List) where
-	type Substance Tail (Construction List) = List <:.> Construction List
-	--substructure = P_Q_T <-- \rose -> case extract <-- run rose of
-	--	Construct x xs -> Store <--- Exactly (TU xs) :*: lift . Construct x . run . extract
-
 --------------------------------------- Prefixed rose tree -----------------------------------------
 
 instance Setoid k => Morphable (Lookup Key) (Prefixed Rose k) where
@@ -96,8 +82,72 @@
 --			! Construct (key :*: value) . lift ! vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value -#=!> subtree
 
 find_rose_sub_tree :: forall k a . Setoid k => Nonempty List k -> Nonempty Rose > k :*: a -> Maybe a
-find_rose_sub_tree (Construct k Nothing) tree = k ?== attached <-- extract tree <----- Just <--- extract <-- extract tree <----- Nothing
-find_rose_sub_tree (Construct k (Just ks)) tree = k ?== attached <-- extract tree <----- find_rose_sub_tree ks =<< subtree <----- Nothing where 
+find_rose_sub_tree (Construct k ks) tree = k ?= attached (extract tree)
+	<----- case ks of
+		Just keys -> find_rose_sub_tree keys =<< subtree keys
+		Nothing -> Just <--- extract <-- extract tree
+	<----- Nothing where
 
-	subtree :: Maybe :. Nonempty Rose > k :*: a
-	subtree = find @Element <---- attached . extract >-|-- equate <-- extract ks <---- deconstruct tree
+	subtree :: Nonempty List k -> Maybe :. Nonempty Rose > k :*: a
+	subtree keys = find @Element
+		<---- attached . extract
+			>-|- equate <-- extract keys
+		<---- deconstruct tree
+
+------------------------------ Non-empty rose tree zipper -----------------------------
+
+type Roses = List <::> Construction List
+
+instance Zippable (Construction List) where
+	type Breadcrumbs (Construction List) = Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)
+
+-- TODO: Try to use substructure @Right . substructure @Right . substructure @Right . substructure @Right here
+instance Substructure (Up Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where
+	type Substance (Up Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = List <::> Tape Roses
+	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of
+		Exactly x :*: T_U (down :*: T_U (left :*: T_U (right :*: up))) ->
+			Store <--- up :*: lift . lift . (Exactly x <:*:>) . (down <:*:>) . (left <:*:>) . (right <:*:>)
+
+-- TODO: Try to use substructure @Left . substructure @Right here
+instance Substructure (Down Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where
+	type Substance (Down Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Roses
+	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of
+		Exactly x :*: T_U (down :*: rest) ->
+			Store <--- down :*: lift . lift . (Exactly x <:*:>) . (<:*:> rest)
+
+-- TODO: Try to use substructure @Left . substructure @Right . substructure @Right here
+instance Substructure (Left Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where
+	type Substance (Left Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Reverse Roses
+	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of
+		Exactly x :*: T_U (down :*: T_U (left :*: rest)) ->
+			Store <--- left :*: lift . lift . (Exactly x <:*:>) . (down <:*:>) . (<:*:> rest)
+
+-- TODO: Try to use substructure @Left . substructure @Right . substructure @Right . substructure @Right here
+instance Substructure (Right Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where
+	type Substance (Right Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Roses
+	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of
+		Exactly x :*: T_U (down :*: T_U (left :*: T_U (right :*: rest))) ->
+			Store <--- right :*: lift . lift . (Exactly x <:*:>) . (down <:*:>) . (left <:*:>) . (<:*:> rest)
+
+instance Morphable (Into (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)))) (Construction List) where
+	type Morphing (Into (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)))) (Construction List) =
+		Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))
+	morphing nonempty_rose_tree = case premorph nonempty_rose_tree of
+		Construct x xs -> lift <----- Exactly x <:*:> unite xs <:*:> empty <:*:> empty <:*:> empty
+
+instance Morphable (Rotate Up) (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))) where
+	type Morphing (Rotate Up) (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))) =
+		Maybe <::> (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)))
+	morphing (premorph -> nonempty_rose_tree) = case pop @List <~ run (view <-- sub @(Up Forest) <-- nonempty_rose_tree) of
+		-- TODO: Traversable for Maybe up over Product
+		parents :*: Just parent ->
+			let child_node = extract <--- view <-- sub @Root <-- nonempty_rose_tree in
+			let central_children = run <--- view <-- sub @(Down Forest) <-- nonempty_rose_tree in
+			let left_children = run @(->) <---- run <--- view <-- sub @(Left Forest) <-- nonempty_rose_tree in
+			let right_children = run <--- view <-- sub @(Right Forest) <-- nonempty_rose_tree in
+			lift . lift <----- view <-- sub @Root <-- parent
+				<:*:> unite <-- left_children + point (Construct child_node central_children) + right_children
+				<:*:> view <-- sub @Left <-- parent
+				<:*:> view <-- sub @Right <-- parent
+				<:*:> unite parents
+		_ :*: Nothing -> empty
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
@@ -2,26 +2,23 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
 module Pandora.Paradigm.Structure.Some.Splay where
 
-import Pandora.Core.Functor (type (~>), type (:.), type (>))
+import Pandora.Core.Functor (type (~>), type (>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((==<<), (===<<)))
+import Pandora.Pattern.Category ((<--), (<---), (<----), identity)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|---)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<), (===<<)))
 import Pandora.Pattern.Transformer.Hoistable ((/|\))
-import Pandora.Paradigm.Primary ()
-import Pandora.Paradigm.Primary.Algebraic ((<-*-), extract)
-import Pandora.Paradigm.Primary.Algebraic.Product (type (<:*:>))
+import Pandora.Paradigm.Algebraic ((<-*-), extract)
+import Pandora.Paradigm.Algebraic.Product (type (<:*:>), (<:*:>))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
-import Pandora.Paradigm.Primary.Functor.Tagged (type (:#))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
-import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
-import Pandora.Paradigm.Primary (twosome)
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Inventory.Some.Optics (view, mutate)
 import Pandora.Paradigm.Schemes (TT (TT), type (<::>))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morphed, Morph (Rotate), premorph, rotate)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
-import Pandora.Paradigm.Structure.Ability.Substructure (sub)
+import Pandora.Paradigm.Structure.Ability.Substructure (Segment (Root, Branch), sub)
 import Pandora.Paradigm.Structure.Ability.Monotonic (resolve)
 import Pandora.Paradigm.Structure.Some.Binary (Binary)
 
@@ -29,82 +26,75 @@
 
 instance Morphable (Rotate > Left Zig) Binary where
 	type Morphing (Rotate > Left Zig) Binary = Binary
-	morphing (premorph -> binary) = TT <--- run . rotate @(Left Zig) ==<< run binary
+	morphing (premorph -> binary) = TT <--- run . rotate @(Left Zig) =<< run binary
 
 instance Morphable (Rotate > Right Zig) Binary where
 	type Morphing (Rotate > Right Zig) Binary = Binary
-	morphing (premorph -> binary) = TT <--- run . rotate @(Right Zig) ==<< run binary
+	morphing (premorph -> binary) = TT <--- run . rotate @(Right Zig) =<< run binary
 
 instance Morphable (Rotate > Left > Zig Zig) Binary where
 	type Morphing (Rotate > Left > Zig Zig) Binary = Binary
-	morphing (premorph -> binary) = TT <--- run . rotate @(Left > Zig Zig) ==<< run binary
+	morphing (premorph -> binary) = TT <--- run . rotate @(Left > Zig Zig) =<< run binary
 
 instance Morphable (Rotate > Right > Zig Zig) Binary where
 	type Morphing (Rotate > Right > Zig Zig) Binary = Binary
-	morphing (premorph -> binary) = TT <--- run . rotate @(Right > Zig Zig) ==<< run binary
+	morphing (premorph -> binary) = TT <--- run . rotate @(Right > Zig Zig) =<< run binary
 
 instance Morphable (Rotate > Left > Zig Zag) Binary where
 	type Morphing (Rotate > Left > Zig Zag) Binary = Binary
-	morphing (premorph -> binary) = TT <--- run . rotate @(Left > Zig Zag) ==<< run binary
+	morphing (premorph -> binary) = TT <--- run . rotate @(Left > Zig Zag) =<< run binary
 
 instance Morphable (Rotate > Right > Zig Zag) Binary where
 	type Morphing (Rotate > Right > Zig Zag) Binary = Binary
-	morphing (premorph -> binary) = TT <--- run . rotate @(Right > Zig Zag) ==<< run binary
+	morphing (premorph -> binary) = TT <--- run . rotate @(Right > Zig Zag) =<< run binary
 
 -------------------------------------- Non-empty Splay tree ----------------------------------------
 
--- TODO: refactor so that there is only one expression
 instance Morphable (Rotate > Left Zig) (Construction (Maybe <:*:> Maybe)) where
 	type Morphing (Rotate > Left Zig) (Construction (Maybe <:*:> Maybe)) = Binary
-	morphing :: forall a . (:#) (Rotate > Left Zig) <::> Construction (Maybe <:*:> Maybe) > a -> Binary a
-	morphing (premorph -> Construct x xs) = TT <--- Construct <-|- parent <-*- Just nodes where
-
-		nodes :: (Maybe <:*:> Maybe) :. Nonempty Binary > a
-		nodes = twosome
-			<------ view <-- sub @Left <-- xs
-			<------ Just . Construct x
-				<----- twosome
-					<---- view (sub @Left) ===<< deconstruct <-|- view (sub @Right) xs
-					<---- view (sub @Right) ===<< deconstruct <-|- view (sub @Right) xs
-
-		parent :: Maybe a
-		parent = extract <-|-- view <-- sub @Right <-- xs
+	morphing (premorph -> tree) = TT <---- Construct
+		<-|- (extract <-|--- run <--- view <-- sub @(Right Branch) <-- tree)
+		<-*- Just (
+			(<:*:>)
+				(run <--- view <-- sub @(Left Branch) <-- tree)
+				(Just . Construct (extract <--- view <-- sub @Root <-- tree) <-- (<:*:>)
+					(run . view (sub @(Left Branch)) ===<< run <--- view <-- sub @(Right Branch) <-- tree)
+					(run . view (sub @(Right Branch)) ===<< run <--- view <-- sub @(Right Branch) <-- tree)
+				)
+			)
 
 instance Morphable (Rotate > Right Zig) (Construction (Maybe <:*:> Maybe)) where
 	type Morphing (Rotate > Right Zig) (Construction (Maybe <:*:> Maybe)) = Binary
-	morphing :: forall a . (:#) (Rotate > Right Zig) <::> Construction (Maybe <:*:> Maybe) > a -> Binary a
-	morphing (premorph -> Construct x xs) = TT <--- Construct <-|- parent <-*- Just nodes where
-
-		nodes :: (Maybe <:*:> Maybe) :. Nonempty Binary > a
-		nodes = twosome
-			<------ view (sub @Left) ===<< deconstruct <-|- view (sub @Left) xs
-			<------ Just . Construct x
-				<----- twosome
-					<---- view (sub @Right) ===<< deconstruct <-|- view (sub @Left) xs
-					<---- view (sub @Right) xs
-
-		parent :: Maybe a
-		parent = extract <-|-- view <-- sub @Left <-- xs
+	morphing (premorph -> tree) = TT <---- Construct
+		<-|- (extract <-|--- run <--- view <-- sub @(Left Branch) <-- tree)
+		<-*- Just (
+			(<:*:>)
+				(run . view (sub @(Left Branch)) ===<< run <--- view <-- sub @(Left Branch) <-- tree)
+				(Just . Construct (extract <--- view <-- sub @Root <-- tree) <-- (<:*:>)
+					(run . view (sub @(Left Branch)) ===<< run <--- view <-- sub @(Left Branch) <-- tree)
+					(run <--- view <-- sub @(Right Branch) <-- tree)
+				)
+			)
 
 -- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary
 instance Morphable (Rotate > Left > Zig Zig) (Construction (Maybe <:*:> Maybe)) where
 	type Morphing (Rotate > Left > Zig Zig) (Construction (Maybe <:*:> Maybe)) = Maybe <::> Construction (Maybe <:*:> Maybe)
-	morphing (premorph -> tree) = TT <---- run . rotate @(Left Zig) ===<< run <-- rotate @(Left Zig) tree
+	morphing (premorph -> tree) = TT <---- run . rotate @(Left Zig) ==<< run <-- rotate @(Left Zig) tree
 
 -- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary
 instance Morphable (Rotate > Right > Zig Zig) (Construction (Maybe <:*:> Maybe)) where
 	type Morphing (Rotate > Right > Zig Zig) (Construction (Maybe <:*:> Maybe)) = Maybe <::> Construction (Maybe <:*:> Maybe)
-	morphing (premorph -> tree) = TT <---- run . rotate @(Right Zig) ===<< run <-- rotate @(Right Zig) tree
+	morphing (premorph -> tree) = TT <---- run . rotate @(Right Zig) ==<< run <-- rotate @(Right Zig) tree
 
 -- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary
 instance Morphable (Rotate > Left > Zig Zag) (Construction (Maybe <:*:> Maybe)) where
 	type Morphing (Rotate > Left > Zig Zag) (Construction (Maybe <:*:> Maybe)) = Maybe <::> Construction (Maybe <:*:> Maybe)
-	morphing (premorph -> struct) = rotate @(Left Zig) <--- mutate <-- (try_to_rotate @(Right Zig) /|\) <-- sub @Left <-- struct
+	morphing (premorph -> struct) = rotate @(Left Zig) <--- mutate <-- (try_to_rotate @(Right Zig) /|\) <-- sub @(Left Branch) <-- struct
 
 -- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary
 instance Morphable (Rotate > Right > Zig Zag) (Construction (Maybe <:*:> Maybe)) where
 	type Morphing (Rotate > Right > Zig Zag) (Construction (Maybe <:*:> Maybe)) = Maybe <::> Construction (Maybe <:*:> Maybe)
-	morphing (premorph -> struct) = rotate @(Right Zig) <--- mutate <-- (try_to_rotate @(Left Zig) /|\) <-- sub @Right <-- struct
+	morphing (premorph -> struct) = rotate @(Right Zig) <--- mutate <-- (try_to_rotate @(Left Zig) /|\) <-- sub @(Right Branch) <-- struct
 
 -- TODO: Include error instead of returning empty tree
 try_to_rotate :: forall direction . Morphed (Rotate direction) (Nonempty Binary) Binary => Nonempty Binary ~> Nonempty Binary
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
@@ -8,22 +8,23 @@
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|--)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic (extract)
+import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>))
+import Pandora.Paradigm.Algebraic (extract)
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+))
 import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate), premorph, rotate)
-import Pandora.Paradigm.Structure.Ability.Zipper (Zippable (Breadcrumbs), Tape)
-import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
-import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs))
+import Pandora.Paradigm.Structure.Modification.Tape (Tape)
+import Pandora.Paradigm.Schemes.T_U (T_U (T_U))
+import Pandora.Paradigm.Algebraic (point)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 
 type Stream = Construction Exactly
 
 instance Zippable (Construction Exactly) where
-	type Breadcrumbs (Construction Exactly) = Reverse Stream <:.:> Stream > (:*:)
+	type Breadcrumbs (Construction Exactly) = Reverse Stream <:*:> Stream
 
 instance Morphable (Rotate Left) (Tape Stream) where
 	type Morphing (Rotate Left) (Tape Stream) = Tape Stream
diff --git a/Pandora/Pattern/Category.hs b/Pandora/Pattern/Category.hs
--- a/Pandora/Pattern/Category.hs
+++ b/Pandora/Pattern/Category.hs
@@ -2,23 +2,21 @@
 
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 
-infixl 1 <---------
-infixl 2 <--------
-infixl 3 <-------
-infixl 4 <------
-infixl 5 <-----
-infixl 6 <----
-infixl 7 <---
-infixl 8 <--
+infixl 1 <--------
+infixl 2 <-------
+infixl 3 <------
+infixl 4 <-----
+infixl 5 <----
+infixl 6 <---
+infixl 7 <--
 
-infixr 1 --------->
-infixr 2 -------->
-infixr 3 ------->
-infixr 4 ------>
-infixr 5 ----->
-infixr 6 ---->
-infixr 7 --->
-infixr 8 -->
+infixr 1 -------->
+infixr 2 ------->
+infixr 3 ------>
+infixr 4 ----->
+infixr 5 ---->
+infixr 6 --->
+infixr 7 -->
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -29,8 +27,7 @@
 class Semigroupoid m => Category m where
 	identity :: m a a
 
-	(<---------), (<--------), (<-------), (<------), (<-----), (<----), (<---), (<--) :: m (m a b) (m a b)
-	(<---------) = identity . identity
+	(<--------), (<-------), (<------), (<-----), (<----), (<---), (<--) :: m (m a b) (m a b)
 	(<--------) = identity . identity
 	(<-------) = identity . identity
 	(<------) = identity . identity
@@ -39,8 +36,7 @@
 	(<---) = identity . identity
 	(<--) = identity . identity
 
-	(--------->), (-------->), (------->), (------>), (----->), (---->), (--->), (-->) :: m (m a b) (m a b)
-	(--------->) = identity . identity
+	(-------->), (------->), (------>), (----->), (---->), (--->), (-->) :: m (m a b) (m a b)
 	(-------->) = identity . identity
 	(------->) = identity . identity
 	(------>) = identity . identity
diff --git a/Pandora/Pattern/Functor/Adjoint.hs b/Pandora/Pattern/Functor/Adjoint.hs
--- a/Pandora/Pattern/Functor/Adjoint.hs
+++ b/Pandora/Pattern/Functor/Adjoint.hs
@@ -4,15 +4,14 @@
 
 type (-|) = Adjoint
 
-infixl 1 ---------|, |---------
-infixl 2 --------|, |--------
-infixl 3 -------|, |-------
-infixl 4 ------|, |------
-infixl 5 -----|, |-----
-infixl 6 ----|, |----
-infixl 7 ---|, |---
-infixl 8 --|, |--
-infixl 9 -|, |-
+infixl 1 --------|, |--------
+infixl 2 -------|, |-------
+infixl 3 ------|, |------
+infixl 4 -----|, |-----
+infixl 5 ----|, |----
+infixl 6 ---|, |---
+infixl 7 --|, |--
+infixl 8 -|, |-
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -26,22 +25,20 @@
 	(-|) :: source (t a) b -> target a (u b)
 	(|-) :: target a (u b) -> source (t a) b
 
-	(|--), (|---), (|----), (|-----), (|------), (|-------), (|--------), (|---------)  :: target a (u b) -> source (t a) b
-	(|--) = (|-)
-	(|---) = (|-)
-	(|----) = (|-)
-	(|-----) = (|-)
-	(|------) = (|-)
-	(|-------) = (|-)
+	(|--------), (|-------), (|------),  (|-----),  (|----), (|---), (|--) :: target a (u b) -> source (t a) b
 	(|--------) = (|-)
-	(|---------) = (|--)
-	
-	(--|), (---|), (----|), (-----|), (------|), (-------|), (--------|), (---------|)  :: source (t a) b -> target a (u b)
-	(--|) = (-|)
-	(---|) = (-|)
-	(----|) = (-|)
-	(-----|) = (-|)
-	(------|) = (-|)
-	(-------|) = (-|)
+	(|-------) = (|-)
+	(|------) = (|-)
+	(|-----) = (|-)
+	(|----) = (|-)
+	(|---) = (|-)
+	(|--) = (|-)
+
+	(--------|), (-------|), (------|), (-----|), (----|), (---|), (--|) :: source (t a) b -> target a (u b)
 	(--------|) = (-|)
-	(---------|) = (-|)
+	(-------|) = (-|)
+	(------|) = (-|)
+	(-----|) = (-|)
+	(----|) = (-|)
+	(---|) = (-|)
+	(--|) = (-|)
diff --git a/Pandora/Pattern/Functor/Bindable.hs b/Pandora/Pattern/Functor/Bindable.hs
--- a/Pandora/Pattern/Functor/Bindable.hs
+++ b/Pandora/Pattern/Functor/Bindable.hs
@@ -2,15 +2,13 @@
 
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
-infixr 1 =========<<
-infixr 2 ========<<
-infixr 3 =======<<
-infixr 4 ======<<
-infixr 5 =====<<
-infixr 6 ====<<
-infixr 7 ===<<
-infixr 8 ==<<
-infixr 9 =<<
+infixr 1 =======<<
+infixr 2 ======<<
+infixr 3 =====<<
+infixr 4 ====<<
+infixr 5 ===<<
+infixr 6 ==<<
+infixr 7 =<<
 
 {- |
 > When providing a new instance, you should ensure it satisfies :
@@ -20,13 +18,10 @@
 class Covariant source source t => Bindable source t where
 	(=<<) :: source a (t b) -> source (t a) (t b)
 
-	(==<<), (===<<), (====<<), (=====<<), (======<<),
-		(=======<<), (========<<), (=========<<)  :: source a (t b) -> source (t a) (t b)
+	(==<<), (===<<), (====<<), (=====<<), (======<<), (=======<<)  :: source a (t b) -> source (t a) (t b)
 	(==<<) = (=<<)
 	(===<<) = (=<<)
 	(====<<) = (=<<)
 	(=====<<) = (=<<)
 	(======<<) = (=<<)
 	(=======<<) = (=<<)
-	(========<<) = (=<<)
-	(=========<<) = (=<<)
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.Primary.Algebraic.Exponential (type (<--))
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Algebraic.Exponential (type (<--))
+import Pandora.Paradigm.Algebraic.Product ((:*:))
 
 {- |
 > Let f :: (Extendable t, Extractable t) => t a -> b
diff --git a/Pandora/Pattern/Functor/Contravariant.hs b/Pandora/Pattern/Functor/Contravariant.hs
--- a/Pandora/Pattern/Functor/Contravariant.hs
+++ b/Pandora/Pattern/Functor/Contravariant.hs
@@ -3,14 +3,12 @@
 import Pandora.Pattern.Category (Category)
 import Pandora.Pattern.Betwixt (Betwixt)
 
-infixl 1 >-|--------
-infixl 2 >-|-------
-infixl 3 >-|------, >-|-|-, >$$<
-infixl 4 >-|-----
-infixl 5 >-|----
-infixl 6 >-|---
-infixl 7 >-|--
-infixl 8 >-|-
+infixl 1 >-|------
+infixl 2 >-|-----
+infixl 3 >-|----
+infixl 4 >-|---, >-|-|-
+infixl 5 >-|--
+infixl 6 >-|-
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
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
@@ -4,14 +4,12 @@
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid)
 
-infixl 1 <-|--------, <-|-|-------
-infixl 2 <-|-------, <-|-|------
-infixl 3 <-|------, <-|-|-----, <$$>
-infixl 4 <-|-----, <-|-|----, <$$$>
-infixl 5 <-|----, <-|-|---
-infixl 6 <-|---, <-|-|--, <-|-|-|-
-infixl 7 <-|--, <-|-|-
-infixl 8 <-|-
+infixl 1 <-|------, <-|-|----
+infixl 2 <-|-----, <-|-|-|-, <-|-|---
+infixl 3 <-|----, <-|-|--
+infixl 4 <-|---, <-|-|-
+infixl 5 <-|--
+infixl 6 <-|-
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -21,7 +19,7 @@
 
 class (Semigroupoid source, Semigroupoid target) => Covariant source target t where
 	(<-|-) :: source a b -> target (t a) (t b)
-	
+
 	(<-|--), (<-|---), (<-|----), (<-|-----), (<-|------),
 		(<-|-------), (<-|--------) :: source a b -> target (t a) (t b)
 	(<-|--) = (<-|-)
diff --git a/Pandora/Pattern/Functor/Distributive.hs b/Pandora/Pattern/Functor/Distributive.hs
--- a/Pandora/Pattern/Functor/Distributive.hs
+++ b/Pandora/Pattern/Functor/Distributive.hs
@@ -10,25 +10,21 @@
 > * Interchange collection: (f -<<) ≡ (identity -<<) . (f <-|-)
 -}
 
-infixl 1 ---------<<
-infixl 2 --------<<
-infixl 3 -------<<
-infixl 4 ------<<
-infixl 5 -----<<
-infixl 6 ----<<
-infixl 7 ---<<
-infixl 8 --<<
-infixl 9 -<<
+infixl 1 -------<<
+infixl 2 ------<<
+infixl 3 -----<<
+infixl 4 ----<<
+infixl 5 ---<<
+infixl 6 --<<
+infixl 7 -<<
 
 class Covariant source target t => Distributive source target t where
 	(-<<) :: Covariant source target u => source a (t b) -> target (u a) (t (u b))
-	
-	(--<<), (---<<), (----<<), (-----<<), (------<<), (-------<<), (--------<<), (---------<<) :: Covariant source target u => source a (t b) -> target (u a) (t (u b))
+
+	(--<<), (---<<), (----<<), (-----<<), (------<<), (-------<<) :: Covariant source target u => source a (t b) -> target (u a) (t (u b))
 	(--<<) = (-<<)
 	(---<<) = (-<<)
 	(----<<) = (-<<)
 	(-----<<) = (-<<)
 	(------<<) = (-<<)
 	(-------<<) = (-<<)
-	(--------<<) = (-<<)
-	(---------<<) = (-<<)
diff --git a/Pandora/Pattern/Functor/Extendable.hs b/Pandora/Pattern/Functor/Extendable.hs
--- a/Pandora/Pattern/Functor/Extendable.hs
+++ b/Pandora/Pattern/Functor/Extendable.hs
@@ -2,15 +2,13 @@
 
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
-infixr 1 <<=========
-infixr 2 <<========
-infixr 3 <<=======
-infixr 4 <<======
-infixr 5 <<=====
-infixr 6 <<====
-infixr 7 <<===
-infixr 8 <<==
-infixr 9 <<=
+infixr 1 <<=======
+infixr 2 <<======
+infixr 3 <<=====
+infixr 4 <<====
+infixr 5 <<===
+infixr 6 <<==
+infixr 7 <<=
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -20,9 +18,8 @@
 
 class Covariant source source t => Extendable source t where
 	(<<=) :: source (t a) b -> source (t a) (t b)
-	
-	(<<==), (<<===), (<<====), (<<=====), (<<======), (<<=======), (<<========), (<<=========)  :: source (t a) b -> source (t a) (t b)
-	(<<=========) = (<<=)
+
+	(<<==), (<<===), (<<====), (<<=====), (<<======), (<<=======), (<<========)  :: source (t a) b -> source (t a) (t b)
 	(<<========) = (<<=)
 	(<<=======) = (<<=)
 	(<<======) = (<<=)
diff --git a/Pandora/Pattern/Functor/Invariant.hs b/Pandora/Pattern/Functor/Invariant.hs
--- a/Pandora/Pattern/Functor/Invariant.hs
+++ b/Pandora/Pattern/Functor/Invariant.hs
@@ -6,7 +6,7 @@
 > Interpreted of morphisms: invmap g j . invmap f h = invmap (g . f) (h . j)
 -}
 
-infixl 4 <!<
+infixl 7 <!<
 
 class Invariant (t :: * -> *) where
 	{-# MINIMAL (<!<) #-}
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.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Algebraic.Product ((:*:))
 
 {- |
 > Let f :: (Monoidal t (->) (->) (:*:) (:*:), Bindable t) => a -> t a
diff --git a/Pandora/Pattern/Functor/Representable.hs b/Pandora/Pattern/Functor/Representable.hs
--- a/Pandora/Pattern/Functor/Representable.hs
+++ b/Pandora/Pattern/Functor/Representable.hs
@@ -10,7 +10,7 @@
 > * Interchange tabulation: comap f . tabulate ≡ tabulate . comap f
 -}
 
-infixr 6 <#>
+infixr 7 <#>
 
 class Representable t where
 	{-# MINIMAL (<#>), tabulate #-}
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.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Algebraic.Product ((:*:))
 
 {- |
 > Let f :: (Applicative t, Applicative g) => t a -> u a
@@ -16,31 +16,28 @@
 > * Preserving apply: f (x <.-*- y) ≡ f x <.-*- f y
 -}
 
-infixl 8 <<-<<-
+infixl 4 <<-<<-
 
-infixl 1 <<---------
-infixl 2 <<--------
-infixl 3 <<-------
-infixl 4 <<------
-infixl 5 <<-----
-infixl 6 <<----
-infixl 7 <<---
-infixl 8 <<--
-infixl 9 <<-
+infixl 1 <<-------
+infixl 2 <<------
+infixl 3 <<-----
+infixl 4 <<----
+infixl 5 <<---
+infixl 6 <<--
+infixl 7 <<-
 
 class Covariant source target t => Traversable source target t where
 	(<<-) :: (Covariant source target u, Monoidal (Straight source) (Straight target) (:*:) (:*:) u) => source a (u b) -> target (t a) (u (t b))
 
-	(<<--), (<<---), (<<----), (<<-----), (<<------),
-		(<<-------), (<<--------), (<<---------) :: (Covariant source target u, Monoidal (Straight source) (Straight target) (:*:) (:*:) u) => source a (u b) -> target (t a) (u (t b))
-	(<<--) = (<<-)
-	(<<---) = (<<-)
-	(<<----) = (<<-)
-	(<<-----) = (<<-)
-	(<<------) = (<<-)
+	(<<-------), (<<------), (<<-----), (<<----), (<<---), (<<--)
+		:: (Covariant source target u, Monoidal (Straight source) (Straight target) (:*:) (:*:) u)
+		=> source a (u b) -> target (t a) (u (t b))
 	(<<-------) = (<<-)
-	(<<--------) = (<<-)
-	(<<---------) = (<<-)
+	(<<------) = (<<-)
+	(<<-----) = (<<-)
+	(<<----) = (<<-)
+	(<<---) = (<<-)
+	(<<--) = (<<-)
 
 (<<-<<-) :: forall t u v category a b .
 	(Traversable category category t, Covariant category category u, Monoidal (Straight category) (Straight category) (:*:) (:*:) u, Traversable category category v)
diff --git a/Pandora/Pattern/Object/Chain.hs b/Pandora/Pattern/Object/Chain.hs
--- a/Pandora/Pattern/Object/Chain.hs
+++ b/Pandora/Pattern/Object/Chain.hs
@@ -4,7 +4,9 @@
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering, order)
 
-infixl 4 <=>, <, <=, >=, >
+infixl 7 <=>
+infixl 8 <=, >=
+infixl 9 <, >
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
diff --git a/Pandora/Pattern/Object/Setoid.hs b/Pandora/Pattern/Object/Setoid.hs
--- a/Pandora/Pattern/Object/Setoid.hs
+++ b/Pandora/Pattern/Object/Setoid.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False, True))
 
-infix 6 ==, !=, ?==
+infix 8 ==, !=, ?=
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -21,7 +21,7 @@
 		True -> False
 		False -> True
 
-	(?==) :: a -> a -> r -> r -> r
-	(?==) x y xc yc = case x == y of
+	(?=) :: a -> a -> r -> r -> r
+	(?=) x y xc yc = case x == y of
 		True -> xc
 		False -> yc
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.5.2
+version:             0.5.3
 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
@@ -26,15 +26,15 @@
 
     Pandora.Paradigm
     -- 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.Object
-    Pandora.Paradigm.Primary.Algebraic
-    Pandora.Paradigm.Primary.Algebraic.Functor
-    Pandora.Paradigm.Primary.Algebraic.Exponential
-    Pandora.Paradigm.Primary.Algebraic.Product
-    Pandora.Paradigm.Primary.Algebraic.Sum
-    Pandora.Paradigm.Primary.Algebraic.Zero
-    Pandora.Paradigm.Primary.Algebraic.One
     Pandora.Paradigm.Primary.Object.Boolean
     Pandora.Paradigm.Primary.Object.Ordering
     Pandora.Paradigm.Primary.Object.Numerator
@@ -58,8 +58,6 @@
     Pandora.Paradigm.Primary.Transformer
     Pandora.Paradigm.Primary.Transformer.Backwards
     Pandora.Paradigm.Primary.Transformer.Reverse
-    Pandora.Pattern.Morphism.Flip
-    Pandora.Pattern.Morphism.Straight
     Pandora.Paradigm.Primary.Transformer.Continuation
     Pandora.Paradigm.Primary.Transformer.Construction
     Pandora.Paradigm.Primary.Transformer.Instruction
@@ -89,7 +87,6 @@
     -- Typeclassess about functor junctions
     Pandora.Paradigm.Controlflow.Effect
     Pandora.Paradigm.Controlflow.Effect.Interpreted
-    Pandora.Paradigm.Controlflow.Effect.Conditional
     Pandora.Paradigm.Controlflow.Effect.Transformer
     Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic
     Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic
@@ -118,17 +115,18 @@
     Pandora.Paradigm.Structure.Ability.Possible
     Pandora.Paradigm.Structure.Ability.Substructure
     Pandora.Paradigm.Structure.Ability.Nonempty
-    Pandora.Paradigm.Structure.Ability.Zipper
     Pandora.Paradigm.Structure.Ability.Monotonic
     Pandora.Paradigm.Structure.Modification
     Pandora.Paradigm.Structure.Modification.Combinative
     Pandora.Paradigm.Structure.Modification.Comprehension
     Pandora.Paradigm.Structure.Modification.Prefixed
     Pandora.Paradigm.Structure.Modification.Turnover
+    Pandora.Paradigm.Structure.Modification.Tape
     Pandora.Paradigm.Structure.Interface
     Pandora.Paradigm.Structure.Interface.Set
     Pandora.Paradigm.Structure.Interface.Dictionary
     Pandora.Paradigm.Structure.Interface.Stack
+    Pandora.Paradigm.Structure.Interface.Zipper
     Pandora.Paradigm.Structure.Some
     Pandora.Paradigm.Structure.Some.Stream
     Pandora.Paradigm.Structure.Some.List
@@ -142,6 +140,9 @@
 
     Pandora.Pattern
     Pandora.Pattern.Betwixt
+    -- Different morphisms
+    Pandora.Pattern.Morphism.Flip
+    Pandora.Pattern.Morphism.Straight
     -- Algebra typeclasses
     Pandora.Pattern.Semigroupoid
     Pandora.Pattern.Category
@@ -183,7 +184,7 @@
     Pandora.Pattern.Transformer.Liftable
     Pandora.Pattern.Transformer.Lowerable
   default-extensions:
-    DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints, InstanceSigs
+    DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints, InstanceSigs, StandaloneKindSignatures
     FlexibleContexts, FlexibleInstances, KindSignatures, StandaloneKindSignatures, LiberalTypeSynonyms, LambdaCase, FunctionalDependencies
     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes, ViewPatterns
     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators