diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -734,3 +734,27 @@
 * Move `Tape` to `Structure.Modification.Tape` module
 
 # 0.5.4
+* Define `<` length encoding type operators in `Functor` module
+* Change precedence for `::|:.`, `::|.:`, `::|::`, `.:`, `:.`, `:::`
+* Define `>` length encoding type operators in `Functor` module
+* Change precedence for `<:.>`, `>:.>`, `<:.<`, `>:.<`,  `<::>`, `>::>`, `<::<`, `>::<`
+* Rename `.-+-` `Alternative` operator to `-+-`
+* Change `Prefixed` definition - from newtype to type alias
+* Remove `Breadcrumbed` type synonymous
+* Change `Zipper` definition - remove tagging
+* Rename `.-+` `Construction` operator to `constitute`
+* Define `Slidable` typeclass for data structures
+* Define `current` and `change` methods in `State`
+* Remove `Zoomable` typeclass, leave `zoom` method
+* Change `zoom` definition - not an adaptable effect
+* Change `change` method of `State` - return an old value
+* Define `transwrap` lens for underlying effect in transformer
+* Change `pop` method in `Stack` typeclass: returns not `Maybe` but `Topping t`
+* Remove `Pushing` and `Popping` type familes from `Stack` typeclass
+* Move `Interpreted` module to `Core`
+* Move `Schematic` type family to `Schemes` module
+* Move `Vertical` and `Horizontal` datatypes to `Auxiliary` module
+* Rename `Horizontal` constructors to `Left` and `Right`
+* Move `Nonempty` from `Ability` to `Modification` module
+
+# 0.5.5
diff --git a/Pandora/Core.hs b/Pandora/Core.hs
--- a/Pandora/Core.hs
+++ b/Pandora/Core.hs
@@ -1,4 +1,5 @@
 module Pandora.Core (module Exports) where
 
+import Pandora.Core.Interpreted as Exports
 import Pandora.Core.Impliable as Exports
 import Pandora.Core.Functor as Exports
diff --git a/Pandora/Core/Functor.hs b/Pandora/Core/Functor.hs
--- a/Pandora/Core/Functor.hs
+++ b/Pandora/Core/Functor.hs
@@ -1,17 +1,51 @@
 module Pandora.Core.Functor where
 
-infixl 0 <
-infixr 0 >
+infixl 9 <
+infixl 8 <<
+infixl 7 <<<
+infixl 6 <<<<
+infixl 5 <<<<<
+infixl 4 <<<<<<
+infixl 3 <<<<<<<
+infixl 2 <<<<<<<<
+infixl 1 <<<<<<<<<
+
+infixr 9 >
+infixr 8 >>
+infixr 7 >>>
+infixr 6 >>>>
+infixr 5 >>>>>
+infixr 4 >>>>>>
+infixr 3 >>>>>>>
+infixr 2 >>>>>>>>
+infixr 1 >>>>>>>>>
+
 infixr 0 <:=, :=>, :=:=>, ~>
-infixr 1 .:, :.
-infixr 2 ::|:., ::|.:, ::|::
-infixr 9 :::
+infixr 8 .:, :.
+infixr 5 ::|:., ::|.:, ::|::
+infixr 7 :::
 
 -- | Arguments consuming
 type (<) t a = t a
+type (<<) t a = t a
+type (<<<) t a = t a
+type (<<<<) t a = t a
+type (<<<<<) t a = t a
+type (<<<<<<) t a = t a
+type (<<<<<<<) t a = t a
+type (<<<<<<<<) t a = t a
+type (<<<<<<<<<) t a = t a
 
 -- | Type application
 type (>) t a = t a
+type (>>) t a = t a
+type (>>>) t a = t a
+type (>>>>) t a = t a
+type (>>>>>) t a = t a
+type (>>>>>>) t a = t a
+type (>>>>>>>) t a = t a
+type (>>>>>>>>) t a = t a
+type (>>>>>>>>>) t a = t a
 
 -- | Functors composition
 type (:.) t u a = t (u a)
diff --git a/Pandora/Core/Interpreted.hs b/Pandora/Core/Interpreted.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Core/Interpreted.hs
@@ -0,0 +1,79 @@
+module Pandora.Core.Interpreted where
+
+import Pandora.Core.Functor (type (<), type (>))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
+
+infixr 2 =#-, -#=
+
+infixl 1 <~~~~~~~~
+infixl 2 <~~~~~~~
+infixl 3 <~~~~~~
+infixl 4 <~~~~~
+infixl 5 <~~~~
+infixl 6 <~~~
+infixl 7 <~~
+infixl 8 <~
+
+class Interpreted m t where
+	{-# MINIMAL run, unite #-}
+	type Primary t a :: *
+	run :: m < t a < Primary t a
+	unite :: m < Primary t a < t a
+
+	(<~~~~~~~~), (<~~~~~~~), (<~~~~~~), (<~~~~~), (<~~~~), (<~~~), (<~~), (<~) :: m < t a < Primary t a
+	(<~~~~~~~~) = run
+	(<~~~~~~~) = run
+	(<~~~~~~) = run
+	(<~~~~~) = run
+	(<~~~~) = run
+	(<~~~) = run
+	(<~~) = run
+	(<~) = run
+
+	(=#-) :: (Semigroupoid m, Interpreted m u) => m < Primary t a < Primary u b -> m < t a < u b
+	(=#-) f = unite . f . run
+
+	(-#=) :: (Semigroupoid m, Interpreted m u) => m < t a < u b -> m < Primary t a < Primary u b
+	(-#=) f = run . f . unite
+
+	(<$=#-) :: (Semigroupoid m, Covariant m m j, Interpreted m u)
+                => m < Primary t a < Primary u b -> m (j > t a) (j > u b)
+	(<$=#-) f = (<-|-) ((=#-) f)
+
+	--(<$$=#-) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Interpreted m u)
+	--	=> m (Primary t a) (Primary u b) -> m (j :. k > t a) (j :. k > u b)
+	--(<$$=#-) f = (<$$>) @m @m ((=#-) f)
+
+	--(<$$$=#-) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)
+	--	=> m (Primary t a) (Primary u b) -> m (j :. k :. l > t a) (j :. k :. l > u b)
+	--(-<$$$=#-) f = (<$$$>) @m @m @m ((=#-) f)
+
+	(-#=$>) :: (Covariant m m j, Interpreted m u)
+		=> m < t a < u b -> m (j > Primary t a) (j > Primary u b)
+	(-#=$>) f = (<-|-) ((-#=) f)
+
+	--(-#=$$>) :: (Covariant m m j, Covariant m m k, Interpreted m u)
+	--	=> m (t a) (u b) -> m (j :. k > Primary t a) (j :. k > Primary u b)
+	--(-#=$$>) f = (<$$>) @m @m ((-#=) f)
+
+	--(-#=$$$>) :: (Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)
+	--	=> m (t a) (u b) -> m (j :. k :. l > Primary t a) (j :. k :. l > Primary u b)
+	--(-#=$$$>) f = (<$$$>) @m @m @m ((-#=) f)
+
+(-=:) :: (Liftable m t, Interpreted m > t u, Interpreted m > t v, Covariant m m u)
+	=> m < t u a < t v b -> m < u a < Primary (t v) b
+(-=:) f = run . f . lift
+
+instance Interpreted (->) (Flip v a) where
+	type Primary (Flip v a) e = v e a
+	run ~(Flip x) = x
+	unite = Flip
+
+instance Interpreted (->) (Straight v e) where
+	type Primary (Straight v e) a = v e a
+	run ~(Straight x) = x
+	unite = Straight
diff --git a/Pandora/Paradigm/Algebraic.hs b/Pandora/Paradigm/Algebraic.hs
--- a/Pandora/Paradigm/Algebraic.hs
+++ b/Pandora/Paradigm/Algebraic.hs
@@ -9,18 +9,18 @@
 import Pandora.Paradigm.Algebraic.One as Exports
 
 import Pandora.Core.Functor (type (>))
+import Pandora.Core.Interpreted (Interpreted ((<~)))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 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.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) ->
@@ -38,6 +38,9 @@
 instance (Monoidal (-->) (-->) (:*:) (:+:) t, Monoidal (-->) (-->) (:*:) (:+:) u)
 	=> Monoidal (-->) (-->) (:*:) (:+:) (t <:*:> u) where
 		unit _ = Straight <-- \_ -> empty <:*:> empty
+
+instance (Traversable (->) (->) t, Traversable (->) (->) u) => Traversable (->) (->) (t <:*:> u) where
+	f <<- T_U (xs :*: ys) = T_U <-|-- (:*:) <-|- f <<- xs <-*- f <<- ys
 
 instance Traversable (->) (->) ((:*:) s) where
 	f <<- x = (attached x :*:) <-|- f (extract x)
diff --git a/Pandora/Paradigm/Algebraic/Functor.hs b/Pandora/Paradigm/Algebraic/Functor.hs
--- a/Pandora/Paradigm/Algebraic/Functor.hs
+++ b/Pandora/Paradigm/Algebraic/Functor.hs
@@ -1,6 +1,7 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Algebraic.Functor where
 
+import Pandora.Core.Interpreted (Interpreted ((<~), (<~~~), (-#=)))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Kernel (constant)
@@ -17,14 +18,14 @@
 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 <-*-, .-*-, <-+-
+infixl 7 -+-
 
 infixl 6 <-|-<-|-, <-|->-|-, >-|-<-|-, >-|->-|-
 
@@ -71,8 +72,8 @@
 (<-+-) :: (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
+(-+-) :: (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
diff --git a/Pandora/Paradigm/Algebraic/Product.hs b/Pandora/Paradigm/Algebraic/Product.hs
--- a/Pandora/Paradigm/Algebraic/Product.hs
+++ b/Pandora/Paradigm/Algebraic/Product.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Algebraic.Product where
 
-import Pandora.Core.Functor (type (>))
+import Pandora.Core.Functor (type (>>>>>>))
 import Pandora.Pattern.Category ((<---))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -13,9 +13,9 @@
 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 (>:.:<))
 
+-- TODO: Change precedence to 7
 infixr 8 :*:
 infixr 5 <:*:>
 
@@ -65,10 +65,10 @@
 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 > (:*:)
+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
+(<:*:>) :: 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
--- a/Pandora/Paradigm/Algebraic/Sum.hs
+++ b/Pandora/Paradigm/Algebraic/Sum.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Algebraic.Sum where
 
-import Pandora.Core.Functor (type (>))
+import Pandora.Core.Functor (type (>>>>>>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
@@ -29,7 +29,7 @@
 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 > (:+:)
+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/Controlflow/Effect.hs b/Pandora/Paradigm/Controlflow/Effect.hs
--- a/Pandora/Paradigm/Controlflow/Effect.hs
+++ b/Pandora/Paradigm/Controlflow/Effect.hs
@@ -1,5 +1,4 @@
 module Pandora.Paradigm.Controlflow.Effect (module Exports) where
 
 import Pandora.Paradigm.Controlflow.Effect.Transformer 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
@@ -1,7 +1,7 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Controlflow.Effect.Adaptable where
 
-import Pandora.Core.Functor (type (>), type (<))
+import Pandora.Core.Functor (type (>), type (>>>), type (<))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (Category (identity))
 import Pandora.Pattern.Functor.Covariant (Covariant)
@@ -20,11 +20,8 @@
 instance Category m => Adaptable t m t where
 	adapt = identity @m
 
-instance {-# OVERLAPS #-} Monoidal (-->) (-->) (:*:) (:*:) u => Adaptable u (->) Exactly where
-	adapt = point . extract
-
 class Effectful m v t u where
-	effect :: m (v a) (t :> u > a)
+	effect :: m (v a) (t :> u >>> a)
 
 instance (Pointable u, Monadic m t) => Effectful m t t u where
 	effect = wrap
diff --git a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
+++ /dev/null
@@ -1,82 +0,0 @@
-module Pandora.Paradigm.Controlflow.Effect.Interpreted where
-
-import Pandora.Core.Functor (type (<), type (>))
-import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Paradigm.Algebraic.Exponential ()
-
-infixr 2 =#-, -#=
-
-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
-
-class Interpreted m t where
-	{-# MINIMAL run, unite #-}
-	type Primary t a :: *
-	run :: m < t a < Primary t a
-	unite :: m < Primary t a < t a
-
-	(<~~~~~~~~), (<~~~~~~~), (<~~~~~~), (<~~~~~), (<~~~~), (<~~~), (<~~), (<~) :: m < t a < Primary t a
-	(<~~~~~~~~) = run
-	(<~~~~~~~) = run
-	(<~~~~~~) = run
-	(<~~~~~) = run
-	(<~~~~) = run
-	(<~~~) = run
-	(<~~) = run
-	(<~) = run
-
-	(=#-) :: (Semigroupoid m, Interpreted m u) => m < Primary t a < Primary u b -> m < t a < u b
-	(=#-) f = unite . f . run
-
-	(-#=) :: (Semigroupoid m, Interpreted m u) => m < t a < u b -> m < Primary t a < Primary u b
-	(-#=) f = run . f . unite
-
-	(<$=#-) :: (Semigroupoid m, Covariant m m j, Interpreted m u)
-                => m < Primary t a < Primary u b -> m (j > t a) (j > u b)
-	(<$=#-) f = (<-|-) ((=#-) f)
-
-	--(<$$=#-) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Interpreted m u)
-	--	=> m (Primary t a) (Primary u b) -> m (j :. k > t a) (j :. k > u b)
-	--(<$$=#-) f = (<$$>) @m @m ((=#-) f)
-
-	--(<$$$=#-) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)
-	--	=> m (Primary t a) (Primary u b) -> m (j :. k :. l > t a) (j :. k :. l > u b)
-	--(-<$$$=#-) f = (<$$$>) @m @m @m ((=#-) f)
-
-	(-#=$>) :: (Covariant m m j, Interpreted m u)
-		=> m < t a < u b -> m (j > Primary t a) (j > Primary u b)
-	(-#=$>) f = (<-|-) ((-#=) f)
-
-	--(-#=$$>) :: (Covariant m m j, Covariant m m k, Interpreted m u)
-	--	=> m (t a) (u b) -> m (j :. k > Primary t a) (j :. k > Primary u b)
-	--(-#=$$>) f = (<$$>) @m @m ((-#=) f)
-
-	--(-#=$$$>) :: (Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)
-	--	=> m (t a) (u b) -> m (j :. k :. l > Primary t a) (j :. k :. l > Primary u b)
-	--(-#=$$$>) f = (<$$$>) @m @m @m ((-#=) f)
-
-(-=:) :: (Liftable m t, Interpreted m > t u, Interpreted m > t v, Covariant m m u)
-	=> m < t u a < t v b -> m < u a < Primary (t v) b
-(-=:) f = run . f . lift
-
-instance Interpreted (->) (Flip v a) where
-	type Primary (Flip v a) e = v e a
-	run ~(Flip x) = x
-	unite = Flip
-
-instance Interpreted (->) (Straight v e) where
-	type Primary (Straight v e) a = v e a
-	run ~(Straight x) = x
-	unite = Straight
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
@@ -2,6 +2,7 @@
 module Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (..), (:<) (..)) where
 
 import Pandora.Core.Functor (type (<))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~~~)))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
@@ -19,7 +20,7 @@
 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, (<~~~)))
+import Pandora.Paradigm.Schemes (Schematic)
 
 class Interpreted m t => Comonadic m t where
 	{-# MINIMAL bring #-}
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
@@ -2,16 +2,17 @@
 module Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (..), (:>) (..)) where
 
 import Pandora.Core.Functor (type (<))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~~~)))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
-import Pandora.Pattern.Functor.Distributive (Distributive ((-<<), (--<<)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((<<=), (<<==)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
@@ -20,13 +21,13 @@
 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, (<~~~)))
+import Pandora.Paradigm.Schemes (Schematic)
 
 class Interpreted m t => Monadic m t where
 	{-# MINIMAL wrap #-}
 	wrap :: Pointable u => m < t a < (t :> u) a
 
-infixr 3 :>
+infixr 8 :>
 newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
 
 instance Covariant (->) (->) (Schematic Monad t u) => Covariant (->) (->) (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
@@ -2,11 +2,11 @@
 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where
 
 import Pandora.Core.Functor (type (<))
+import Pandora.Core.Interpreted ((<~~))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---))
 import Pandora.Paradigm.Algebraic (Applicative, loop)
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~~))
 
 newtype Capture r t a = Capture { captured :: t r }
 
diff --git a/Pandora/Paradigm/Controlflow/Pipeline.hs b/Pandora/Paradigm/Controlflow/Pipeline.hs
--- a/Pandora/Paradigm/Controlflow/Pipeline.hs
+++ b/Pandora/Paradigm/Controlflow/Pipeline.hs
@@ -1,5 +1,6 @@
 module Pandora.Paradigm.Controlflow.Pipeline (Pipeline, await, yield, finish, impact, (=*=), pipeline) where
 
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Kernel (constant)
@@ -8,7 +9,6 @@
 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))
 
 newtype Producer i t r = Producer { produce :: Consumer i t r -> t r }
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -1,11 +1,12 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-module Pandora.Paradigm.Inventory (module Exports, Zoomable (zoom), overlook, (=<>), (~<>)) where
+module Pandora.Paradigm.Inventory (module Exports, zoom, overlook, (=<>), (~<>)) where
 
 import Pandora.Paradigm.Inventory.Ability as Exports
 import Pandora.Paradigm.Inventory.Some as Exports
 
 import Pandora.Core.Functor (type (~>))
+import Pandora.Core.Interpreted (run, (<~))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Kernel (constant)
@@ -19,7 +20,6 @@
 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))
 
 instance Adjoint (->) (->) (Store s) (State s) where
@@ -36,22 +36,11 @@
 	f -| x = Provision <--- f . Equipment --| x
 	g |- x = run . g |-- run x
 
-class Zoomable (tool :: * -> * -> *) (available :: * -> *) where
-	zoom :: forall bg ls t . Adaptable t (->) (tool bg) => Lens available bg ls -> tool (Simplification available ls) ~> t
-
-instance Zoomable State Exactly where
-	zoom :: forall bg ls t result . Stateful bg t => Convex Lens bg ls -> State ls result -> t result
-	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)
-
-instance Zoomable State Maybe where
-	zoom :: forall bg ls t result . Stateful bg t => Obscure Lens bg ls -> State (Maybe ls) result -> t result
-	zoom lens less = adapt . State <-- \source -> restruct |- run (lens <~ source) where
+zoom :: forall bg ls u result . Lens u bg ls -> State (u ls) result -> State bg result
+zoom lens less = State <-- \source -> restruct |- run (lens <~ source) where
 
-		restruct :: (Maybe ls -> bg) -> Maybe ls -> bg :*: result
-		restruct to target = run (to <-|-- Flip <-- run less target)
+	restruct :: (u ls -> bg) -> u ls -> bg :*: result
+	restruct to target = run @(->) <---- to <-|- Flip (less <~ target)
 
 overlook :: (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => State s result -> State (t s) (t result)
 overlook (State state) = State <-- \ts -> mult @(<--) @(:*:) @(:*:) <~ (state <-|- ts)
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
@@ -1,6 +1,7 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Inventory.Some.Accumulator (Accumulator (..), Accumulated, gather) where
 
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----))
@@ -13,10 +14,9 @@
 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))
-import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
+import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))
 
 newtype Accumulator e a = Accumulator (e :*: a)
 
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
@@ -1,6 +1,7 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Inventory.Some.Equipment (Equipment (..), retrieve) where
 
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<---), (<----))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--)))
@@ -10,9 +11,8 @@
 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))
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes (Schematic, TU (TU), type (<:.>))
 
 newtype Equipment e a = Equipment (e :*: a)
 
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
@@ -1,6 +1,7 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Inventory.Some.Imprint (Imprint (..), Traceable) where
 
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
@@ -11,9 +12,8 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 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)
-import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
+import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))
 
 newtype Imprint e a = Imprint (e -> a)
 
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
@@ -2,7 +2,9 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Inventory.Some.Optics where
 
+import Pandora.Core.Functor (type (<))
 import Pandora.Core.Impliable (Impliable (Arguments, imply))
+import Pandora.Core.Interpreted (Interpreted (run, (<~)))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (Category (identity, (<--), (<---), (<----), (<-----), (<-------)))
 import Pandora.Pattern.Kernel (Kernel (constant))
@@ -10,8 +12,9 @@
 import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.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))
@@ -134,3 +137,6 @@
 
 mutate :: (i target -> i target) -> Lens i source target -> source -> source
 mutate mut lens source = extract . retrofit mut <-- lens <~ source
+
+transwrap :: (Covariant (->) (->) u, Liftable (->) t, Lowerable (->) t) => Lens u < t u e < e
+transwrap = P_Q_T <-- \origin -> Store <--- lower origin :*: lift
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
@@ -1,13 +1,14 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Inventory.Some.Provision where
 
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))
 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.Algebraic.Exponential (type (-->), (%))
@@ -17,11 +18,10 @@
 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, (<~)))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Inventory.Ability.Gettable (Gettable (Getting, get))
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes (Schematic, TU (TU), type (<:.>))
 
 newtype Provision e a = Provision (e -> a)
 
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
@@ -1,9 +1,10 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Inventory.Some.State where
 
+import Pandora.Core.Functor (type (:.), type (>>>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, (<~), unite, (=#-)))
 import Pandora.Pattern.Morphism.Flip (Flip)
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Core.Functor (type (:.), type (>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
@@ -15,19 +16,18 @@
 import Pandora.Pattern.Functor.Monad (Monad)
 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.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.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Algebraic ((:*:) ((:*:)), (.-*-), delta)
 import Pandora.Paradigm.Algebraic.One (One (One))
 import Pandora.Paradigm.Algebraic (Pointable, point, (<-||-), (>-||-))
+import Pandora.Paradigm.Schemes (Schematic, TUT (TUT), type (<:<.>:>))
 
 -- | Effectful computation with a variable
-newtype State s a = State ((->) s :. (:*:) s > a)
+newtype State s a = State ((->) s :. (:*:) s >>> a)
 
 instance Covariant (->) (->) (State s) where
 	f <-|- x = State <--- (<-|-) f . run x
@@ -50,7 +50,7 @@
 	f <!< g = (((g >-||-) . ((f <-||-) <-|-) =#-) =#-)
 
 instance Interpreted (->) (State s) where
-	type Primary (State s) a = (->) s :. (:*:) s > a
+	type Primary (State s) a = (->) s :. (:*:) s >>> a
 	run ~(State x) = x
 	unite = State
 
@@ -60,6 +60,13 @@
 	wrap x = TM . TUT <---- point <-|- run x
 
 type Stateful s t = Adaptable t (->) (State s)
+
+current :: Stateful s t => t s
+current = adapt <-- State delta
+
+-- Modify the state, state is new value, return old value
+change :: Stateful s t => (s -> s) -> t s
+change f = adapt . State <-- \s -> f s :*: 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
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
@@ -1,9 +1,10 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Inventory.Some.Store where
 
-import Pandora.Core (type (:.), type (>), type (<:=), type (~>))
+import Pandora.Core (type (:.), type (>>>), type (<:=), type (~>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (=#-)))
 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.Semimonoidal (Semimonoidal (mult))
@@ -18,12 +19,11 @@
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-)), Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))
-import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))
+import Pandora.Paradigm.Schemes (Schematic, TUT (TUT), type (<:<.>:>))
 
 -- | Context based computation on value
-newtype Store s a = Store ((:*:) s :. (->) s > a)
+newtype Store s a = Store ((:*:) s :. (->) s >>> a)
 
 -- TODO: Try to generalize (->) here
 instance Covariant (->) (->) (Store s) where
@@ -47,7 +47,7 @@
 	f <!< g = (((f <-||-) . ((g >-||-) <-|-) =#-) =#-)
 
 instance Interpreted (->) (Store s) where
-	type Primary (Store s) a = (:*:) s :. (->) s > a
+	type Primary (Store s) a = (:*:) s :. (->) s >>> a
 	run ~(Store x) = x
 	unite = Store
 
diff --git a/Pandora/Paradigm/Primary.hs b/Pandora/Paradigm/Primary.hs
--- a/Pandora/Paradigm/Primary.hs
+++ b/Pandora/Paradigm/Primary.hs
@@ -1,13 +1,14 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Primary (module Exports, Simplification) where
 
+import Pandora.Paradigm.Primary.Auxiliary as Exports
 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.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Core.Functor (type (:.), type (>))
+import Pandora.Core.Functor (type (:.), type (>>>))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category ((<---))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-), (-|)))
@@ -20,8 +21,8 @@
 
 type family Simplification (t :: * -> *) (a :: *) where
 	Simplification Exactly a = a
-	Simplification (TU _ _ t u) a = t :. u > a
-	Simplification (UT _ _ t u) a = u :. t > a
-	Simplification (TUT _ _ _ t t' u) a = t :. u :. t' > a
+	Simplification (TU _ _ t u) a = t :. u >>> a
+	Simplification (UT _ _ t u) a = u :. t >>> a
+	Simplification (TUT _ _ _ t t' u) a = t :. u :. t' >>> a
 	Simplification (T_U _ _ p t u) a = p (t a) (u a)
 	Simplification t a = t a
diff --git a/Pandora/Paradigm/Primary/Auxiliary.hs b/Pandora/Paradigm/Primary/Auxiliary.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Primary/Auxiliary.hs
@@ -0,0 +1,5 @@
+module Pandora.Paradigm.Primary.Auxiliary where
+
+data Vertical a = Up a | Down a
+
+data Horizontal a = Left a | Right a
diff --git a/Pandora/Paradigm/Primary/Functor/Conclusion.hs b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
--- a/Pandora/Paradigm/Primary/Functor/Conclusion.hs
+++ b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
@@ -1,9 +1,10 @@
 module Pandora.Paradigm.Primary.Functor.Conclusion where
 
 import Pandora.Core.Functor (type (~>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Category (identity, (<--), (<---))
+import Pandora.Pattern.Category (identity, (<--), (<---), (<----))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
@@ -18,13 +19,12 @@
 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.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Algebraic.One (One (One))
 import Pandora.Paradigm.Algebraic (point)
+import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))
 
 data Conclusion e a = Failure e | Success a
 
@@ -32,10 +32,6 @@
 	f <-|- Success x = Success <-- f x
 	_ <-|- Failure y = Failure y
 
-instance Covariant (->) (->) (Flip Conclusion e) where
-	_ <-|- Flip (Success x) = Flip <-- Success x
-	f <-|- Flip (Failure y) = Flip . Failure <-- f y
-
 instance Semimonoidal (-->) (:*:) (:*:) (Conclusion e) where
 	mult = Straight <-- \case
 		Success x :*: Success y -> Success <--- x :*: y
@@ -112,3 +108,16 @@
 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
+
+instance Covariant (->) (->) (Flip Conclusion a) where
+	_ <-|- Flip (Success x) = Flip <-- Success x
+	f <-|- Flip (Failure y) = Flip . Failure <-- f y
+
+instance Semimonoidal (-->) (:*:) (:*:) (Flip Conclusion a) where
+	mult = Straight <-- \case
+		Flip (Failure x) :*: Flip (Failure y) -> Flip <---- Failure <--- x :*: y
+		Flip (Success x) :*: _ -> Flip <-- Success x
+		_ :*: Flip (Success x) -> Flip <-- Success x
+
+instance Monoidal (-->) (-->) (:*:) (:*:) (Flip Conclusion a) where
+	unit _ = Straight <--- Flip . Failure . (<~ One)
diff --git a/Pandora/Paradigm/Primary/Functor/Endo.hs b/Pandora/Paradigm/Primary/Functor/Endo.hs
--- a/Pandora/Paradigm/Primary/Functor/Endo.hs
+++ b/Pandora/Paradigm/Primary/Functor/Endo.hs
@@ -1,11 +1,11 @@
 module Pandora.Paradigm.Primary.Functor.Endo where
 
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (=#-)))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, (<--))
 import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 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.Algebraic.Exponential ()
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic ((>-|-<-|-))
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,5 +1,6 @@
 module Pandora.Paradigm.Primary.Functor.Exactly where
 
+import Pandora.Core.Interpreted ((<~))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
@@ -27,7 +28,6 @@
 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
 
diff --git a/Pandora/Paradigm/Primary/Functor/Maybe.hs b/Pandora/Paradigm/Primary/Functor/Maybe.hs
--- a/Pandora/Paradigm/Primary/Functor/Maybe.hs
+++ b/Pandora/Paradigm/Primary/Functor/Maybe.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Maybe where
 
-import Pandora.Core.Functor (type (:.), type (>))
+import Pandora.Core.Functor (type (:.), type (>>>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, (<--), (<---))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
@@ -19,16 +20,15 @@
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater))
-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.Structure.Ability.Monotonic (Monotonic (reduce))
 import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption))
 import Pandora.Paradigm.Algebraic.One (One (One))
 import Pandora.Paradigm.Algebraic (point)
+import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))
 
 data Maybe a = Nothing | Just a
 
@@ -115,7 +115,7 @@
 	reduce f r (Just x) = f x r
 	reduce _ r Nothing = r
 
-instance Monotonic a (t a) => Monotonic a (Maybe :. t > a) where
+instance Monotonic a (t a) => Monotonic a (Maybe :. t >>> a) where
 	reduce f r (Just x) = reduce f r x
 	reduce _ r Nothing = r
 
diff --git a/Pandora/Paradigm/Primary/Functor/Predicate.hs b/Pandora/Paradigm/Primary/Functor/Predicate.hs
--- a/Pandora/Paradigm/Primary/Functor/Predicate.hs
+++ b/Pandora/Paradigm/Primary/Functor/Predicate.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Predicate where
 
 import Pandora.Core.Functor (type (~>), type (:=>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
@@ -13,7 +14,6 @@
 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/Tagged.hs b/Pandora/Paradigm/Primary/Functor/Tagged.hs
--- a/Pandora/Paradigm/Primary/Functor/Tagged.hs
+++ b/Pandora/Paradigm/Primary/Functor/Tagged.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Tagged where
 
 import Pandora.Core.Functor (type (:=>), type (~>))
+import Pandora.Core.Interpreted ((<~))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
@@ -27,7 +28,6 @@
 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
 
diff --git a/Pandora/Paradigm/Primary/Functor/Validation.hs b/Pandora/Paradigm/Primary/Functor/Validation.hs
--- a/Pandora/Paradigm/Primary/Functor/Validation.hs
+++ b/Pandora/Paradigm/Primary/Functor/Validation.hs
@@ -1,5 +1,6 @@
 module Pandora.Paradigm.Primary.Functor.Validation where
 
+import Pandora.Core.Interpreted ((<~))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
@@ -18,7 +19,6 @@
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~))
 
 data Validation e a = Flaws e | Validated 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
@@ -11,38 +11,38 @@
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 
-data Wye a = End | Left a | Right a | Both a a
+data Wye a = End | Left_ a | Right_ a | Both a a
 
 instance Covariant (->) (->) Wye where
 	_ <-|- End = End
-	f <-|- Left x = Left <-- f x
-	f <-|- Right y = Right <-- f y
+	f <-|- Left_ x = Left_ <-- f x
+	f <-|- Right_ y = Right_ <-- f y
 	f <-|- Both x y = Both <-- f x <-- f y
 
 -- instance Semimonoidal (<--) (:*:) (:*:) Wye where
 -- 	mult = Flip <-- \case
 -- 		End -> End :*: End
--- 		Left (x :*: y) -> Left x :*: Left y
--- 		Right (x :*: y) -> Right x :*: Right y
+-- 		Left_ (x :*: y) -> Left_ x :*: Left_ y
+-- 		Right_ (x :*: y) -> Right_ x :*: Right_ y
 -- 		Both (x :*: y) (x' :*: y') -> Both x x' :*: Both y y'
 
 instance Monotonic a (Wye a) where
-	reduce f r (Left x) = f x r
-	reduce f r (Right x) = f x r
+	reduce f r (Left_ x) = f x r
+	reduce f r (Right_ x) = f x r
 	reduce f r (Both x y) = f y <-- f x r
 	reduce _ r End = r
 
 instance Semigroup a => Semigroup (Wye a) where
 	End + x = x
 	x + End = x
-	Left x + Left x' = Left <-- x + x'
-	Left x + Right y = Both <-- x <-- y
-	Left x + Both x' y = Both <-- x + x' <-- y
-	Right y + Left x = Both <-- x <-- y
-	Right y + Right y' = Right <-- y + y'
-	Right y + Both x y' = Both <-- x <-- y + y'
-	Both x y + Left x' = Both <-- x + x' <-- y
-	Both x y + Right y' = Both <-- x <-- y + y'
+	Left_ x + Left_ x' = Left_ <-- x + x'
+	Left_ x + Right_ y = Both <-- x <-- y
+	Left_ x + Both x' y = Both <-- x + x' <-- y
+	Right_ y + Left_ x = Both <-- x <-- y
+	Right_ y + Right_ y' = Right_ <-- y + y'
+	Right_ y + Both x y' = Both <-- x <-- y + y'
+	Both x y + Left_ x' = Both <-- x + x' <-- y
+	Both x y + Right_ y' = Both <-- x <-- y + y'
 	Both x y + Both x' y' = Both <-- x + x' <-- y + y'
 
 instance Semigroup a => Monoid (Wye a) where
@@ -50,12 +50,12 @@
 
 wye :: r -> (a -> r) -> (a -> r) -> (a -> a -> r) -> Wye a -> r
 wye r _ _ _ End = r
-wye _ f _ _ (Left x) = f x
-wye _ _ g _ (Right y) = g y
+wye _ f _ _ (Left_ x) = f x
+wye _ _ g _ (Right_ y) = g y
 wye _ _ _ h (Both x y) = h x y
 
 swop :: Wye ~> Wye
 swop End = End
 swop (Both l r) = Both r l
-swop (Left l) = Right l
-swop (Right r) = Left r
+swop (Left_ l) = Right_ l
+swop (Right_ r) = Left_ r
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
@@ -18,7 +18,7 @@
 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, (<~)))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))
 
 newtype Backwards t a = Backwards (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
@@ -1,7 +1,7 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Primary.Transformer.Construction where
 
-import Pandora.Core.Functor (type (:.), type (>), type (:=>), type (~>))
+import Pandora.Core.Functor (type (:.), type (>>>), type (:=>), type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|----), (<-|-|-)))
@@ -24,11 +24,9 @@
 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, (<~), (<~~~), (<~~~~))
-
-infixr 7 .-+
+import Pandora.Core.Interpreted (run, (<~), (<~~~), (<~~~~))
 
-data Construction t a = Construct a (t :. Construction t > a)
+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
@@ -76,12 +74,12 @@
 -- 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 :: 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
+constitute :: Covariant (->) (->) t => (a -> t a) -> a -> Construction t a
+constitute f x = Construct x <---- constitute f <-|- f x
 
 section :: (Comonad (->) t, Monoidal (<--) (-->) (:*:) (:*:) t) => t ~> Construction t
 section xs = Construct <--- extract xs <--- section <<= xs
diff --git a/Pandora/Paradigm/Primary/Transformer/Continuation.hs b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
--- a/Pandora/Paradigm/Primary/Transformer/Continuation.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
@@ -1,7 +1,6 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Primary.Transformer.Continuation where
 
-import Pandora.Core.Functor (type (:.), type (>), type (::|:.))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Kernel (constant)
@@ -10,15 +9,15 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~)))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))
 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)
+newtype Continuation r t a = Continuation ((->) ((->) a (t r)) (t r))
 
 instance Interpreted (->) (Continuation r t) where
-	type Primary (Continuation r t) a = (->) ::|:. a :. t > r
+	type Primary (Continuation r t) a = ((->) ((->) a (t r)) (t r))
 	run ~(Continuation x) = x
 	unite = Continuation
 
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
@@ -1,7 +1,7 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Primary.Transformer.Instruction where
 
-import Pandora.Core.Functor (type (:.), type (>))
+import Pandora.Core.Functor (type (:.), type (>>>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
@@ -18,9 +18,9 @@
 import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Algebraic.One (One (One))
 import Pandora.Paradigm.Algebraic (point)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~), (<~~~))
+import Pandora.Core.Interpreted ((<~), (<~~~))
 
-data Instruction t a = Enter a | Instruct (t :. Instruction t > a)
+data Instruction t a = Enter a | Instruct (t :. Instruction t >>> a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Instruction t) where
 	f <-|- Enter x = Enter <-- f x
diff --git a/Pandora/Paradigm/Primary/Transformer/Kan.hs b/Pandora/Paradigm/Primary/Transformer/Kan.hs
--- a/Pandora/Paradigm/Primary/Transformer/Kan.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Kan.hs
@@ -1,11 +1,12 @@
 module Pandora.Paradigm.Primary.Transformer.Kan where
 
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
+import Pandora.Paradigm.Algebraic.Exponential ()
 
 data family Kan (v :: * -> k) (t :: * -> *) (u :: * -> *) b a
 
diff --git a/Pandora/Paradigm/Primary/Transformer/Reverse.hs b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
--- a/Pandora/Paradigm/Primary/Transformer/Reverse.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
@@ -20,7 +20,7 @@
 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, (<~), (<~~~)))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~)))
 
 newtype Reverse t a = Reverse (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
@@ -1,7 +1,7 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Primary.Transformer.Tap where
 
-import Pandora.Core.Functor (type (>))
+import Pandora.Core.Functor (type (>>>>>>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), (<------))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|-)))
@@ -11,7 +11,7 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=), (<<==)))
 import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~), (<~~~))
+import Pandora.Core.Interpreted ((<~), (<~~~))
 import Pandora.Paradigm.Algebraic ((<-*-), (<-||--), extract)
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), (<:*:>))
 import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))
@@ -45,6 +45,6 @@
 instance Hoistable (->) Tap where
 	f /|\ Tap x xs = Tap x <-- f xs
 
-instance {-# OVERLAPS #-} Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (Tap (t <:.:> t > (:*:))) where
+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) <------ (mult @(-->) <~~~ xls :*: yls) <:*:> (mult @(-->) <~~~ xrs :*: yrs)
diff --git a/Pandora/Paradigm/Schemes.hs b/Pandora/Paradigm/Schemes.hs
--- a/Pandora/Paradigm/Schemes.hs
+++ b/Pandora/Paradigm/Schemes.hs
@@ -1,5 +1,5 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-module Pandora.Paradigm.Schemes (module Exports) where
+module Pandora.Paradigm.Schemes (module Exports, Schematic) where
 
 import Pandora.Paradigm.Schemes.PQ_ as Exports
 import Pandora.Paradigm.Schemes.P_Q_T as Exports
@@ -14,11 +14,13 @@
 import Pandora.Paradigm.Schemes.TU as Exports
 import Pandora.Paradigm.Schemes.TT as Exports
 
+import Pandora.Core.Interpreted (run)
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+
+type family Schematic (c :: (* -> * -> *) -> (* -> *) -> k) (t :: * -> *) = (r :: (* -> *) -> * -> *) | r -> t
 
 instance (Covariant (->) (->) (v <:.> t), Covariant (->) (->) (u <:.> w), Adjoint (->) (->) t u, Adjoint (->) (->) v w)
 	=> Adjoint (->) (->) (v <:.> t) (u <:.> w) where
diff --git a/Pandora/Paradigm/Schemes/PQ_.hs b/Pandora/Paradigm/Schemes/PQ_.hs
--- a/Pandora/Paradigm/Schemes/PQ_.hs
+++ b/Pandora/Paradigm/Schemes/PQ_.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Schemes.PQ_ where
 
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 
 newtype PQ_ p q a b = PQ_ (p a (q b a))
 
diff --git a/Pandora/Paradigm/Schemes/PTU.hs b/Pandora/Paradigm/Schemes/PTU.hs
--- a/Pandora/Paradigm/Schemes/PTU.hs
+++ b/Pandora/Paradigm/Schemes/PTU.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Schemes.PTU where
 
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 
 newtype PTU p t u a b = PTU (p (t a) (u b))
 
diff --git a/Pandora/Paradigm/Schemes/P_Q_T.hs b/Pandora/Paradigm/Schemes/P_Q_T.hs
--- a/Pandora/Paradigm/Schemes/P_Q_T.hs
+++ b/Pandora/Paradigm/Schemes/P_Q_T.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Schemes.P_Q_T where
 
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 
 newtype P_Q_T (p :: * -> * -> *) (q :: * -> * -> *) (t :: * -> *) (a :: *) (b :: *) = P_Q_T (p a (q (t b) a))
 
diff --git a/Pandora/Paradigm/Schemes/P_T.hs b/Pandora/Paradigm/Schemes/P_T.hs
--- a/Pandora/Paradigm/Schemes/P_T.hs
+++ b/Pandora/Paradigm/Schemes/P_T.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Schemes.P_T where
 
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 
 newtype P_T p t a b = P_T (p (t a) b)
 
diff --git a/Pandora/Paradigm/Schemes/TT.hs b/Pandora/Paradigm/Schemes/TT.hs
--- a/Pandora/Paradigm/Schemes/TT.hs
+++ b/Pandora/Paradigm/Schemes/TT.hs
@@ -1,7 +1,8 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Schemes.TT where
 
-import Pandora.Core.Functor (type (:.), type (>), type (~>))
+import Pandora.Core.Functor (type (:.), type (>), type (>>>), type (~>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-)))
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))
@@ -16,7 +17,6 @@
 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.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic.Sum ((:+:), bitraverse_sum)
@@ -25,9 +25,9 @@
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
-newtype TT ct ct' t t' a = TT (t :. t' > a)
+newtype TT ct ct' t t' a = TT (t :. t' >>> a)
 
-infixr 3 <::>, >::>, <::<, >::<
+infixr 6 <::>, >::>, <::<, >::<
 
 type (<::>) = TT Covariant Covariant
 type (>::>) = TT Contravariant Covariant
@@ -35,7 +35,7 @@
 type (>::<) = TT Contravariant Contravariant
 
 instance Interpreted (->) (TT ct ct' t t') where
-	type Primary (TT ct ct' t t') a = t :. t' > a
+	type Primary (TT ct ct' t t') a = t :. t' >>> a
 	run ~(TT x) = x
 	unite = TT
 
diff --git a/Pandora/Paradigm/Schemes/TU.hs b/Pandora/Paradigm/Schemes/TU.hs
--- a/Pandora/Paradigm/Schemes/TU.hs
+++ b/Pandora/Paradigm/Schemes/TU.hs
@@ -1,7 +1,8 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Schemes.TU where
 
-import Pandora.Core.Functor (type (:.), type (>), type (~>))
+import Pandora.Core.Functor (type (:.), type (>), type (>>>), type (~>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-)))
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))
@@ -15,7 +16,6 @@
 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.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic.Sum ((:+:))
@@ -24,9 +24,9 @@
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
-newtype TU ct cu t u a = TU (t :. u > a)
+newtype TU ct cu t u a = TU (t :. u >>> a)
 
-infixr 3 <:.>, >:.>, <:.<, >:.<
+infixr 6 <:.>, >:.>, <:.<, >:.<
 
 type (<:.>) = TU Covariant Covariant
 type (>:.>) = TU Contravariant Covariant
@@ -34,7 +34,7 @@
 type (>:.<) = TU Contravariant Contravariant
 
 instance Interpreted (->) (TU ct cu t u) where
-	type Primary (TU ct cu t u) a = t :. u > a
+	type Primary (TU ct cu t u) a = t :. u >>> a
 	run ~(TU x) = x
 	unite = TU
 
diff --git a/Pandora/Paradigm/Schemes/TUT.hs b/Pandora/Paradigm/Schemes/TUT.hs
--- a/Pandora/Paradigm/Schemes/TUT.hs
+++ b/Pandora/Paradigm/Schemes/TUT.hs
@@ -1,7 +1,8 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Schemes.TUT where
 
-import Pandora.Core.Functor (type (:.), type (>), type (~>))
+import Pandora.Core.Functor (type (:.), type (>), type (>>>), type (>>>>>>>>), type (~>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (=#-)))
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<------))
@@ -22,9 +23,8 @@
 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, (<~), (<~~~), (=#-)))
 
-newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' > a)
+newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' >>> a)
 
 infix 3 <:<.>:>, >:<.>:>, <:<.>:<, >:<.>:<, <:>.<:>, >:>.<:>, <:>.<:<, >:>.<:<
 
@@ -38,24 +38,24 @@
 type (>:>.<:<) = TUT Contravariant Contravariant Contravariant
 
 instance Interpreted (->) (TUT ct ct' cu t t' u) where
-	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' > a
+	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' >>> a
 	run ~(TUT x) = x
 	unite = TUT
 
-instance (Semigroupoid m, Covariant m m t, Covariant (Betwixt (Betwixt m m) m) m t, Covariant (Betwixt m (Betwixt m m)) (Betwixt (Betwixt m m) m) u, Covariant m (Betwixt m (Betwixt m m)) t', Interpreted m (t <:<.>:> t' > u)) => Covariant m m (t <:<.>:> t' > u) where
+instance (Semigroupoid m, Covariant m m t, Covariant (Betwixt (Betwixt m m) m) m t, Covariant (Betwixt m (Betwixt m m)) (Betwixt (Betwixt m m) m) u, Covariant m (Betwixt m (Betwixt m m)) t', Interpreted m (t <:<.>:> t' >>>>>>>> u)) => Covariant m m (t <:<.>:> t' >>>>>>>> u) where
 	(<-|-) f = (=#-) ((<-|-|-|-) f)
 
-instance (Adjoint (->) (->) t' t, Bindable (->) u) => Semimonoidal (-->) (:*:) (:*:) (t <:<.>:> t' > u) where
+instance (Adjoint (->) (->) t' t, Bindable (->) u) => Semimonoidal (-->) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where
 	mult = Straight <-- \(TUT x :*: TUT y) -> TUT ((((\r -> (<-|-|-|-) (r :*:) y) |-) =<<) <-|- x)
 
-instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <:<.>:> t' > u) where
+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where
 	mult = Flip <-- (TUT <-||-) . (TUT <-|-) . (mult @(<--) <~) . (<-|-) (mult @(<--) <~) . (<-|-|-) @_ @(->) (mult @(<--) <~) . run
 
-instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t', Monoidal (<--) (-->) (:*:) (:*:) u, Adjoint (->) (->) t t') => Monoidal (<--) (-->) (:*:) (:*:) (t <:<.>:> t' > u) where
+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t', Monoidal (<--) (-->) (:*:) (:*:) u, Adjoint (->) (->) t t') => Monoidal (<--) (-->) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where
 	unit _ = Flip <-- \(TUT xys) -> Straight (\_ -> (extract |-) xys)
 
 -- TODO: generalize on (->) and (:*:)
-instance {-# OVERLAPS #-} (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) ((->) s <:<.>:> (:*:) s > u) where
+instance {-# OVERLAPS #-} (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) ((->) s <:<.>:> (:*:) s >>>>>>>> u) where
  mult = Straight <-- \(TUT x :*: TUT y) -> TUT
 	<------ product_over_sum
 		<-|-|- mult @(-->) @(:*:) @(:+:)
@@ -66,19 +66,19 @@
 product_over_sum (Option (s :*: x)) = s :*: Option x
 product_over_sum (Adoption (s :*: y)) = s :*: Adoption y
 
-instance (Covariant (->) (->) t, Covariant (->) (->) t', Adjoint (->) (->) t' t, Bindable (->) u) => Bindable (->) (t <:<.>:> t' > u) where
+instance (Covariant (->) (->) t, Covariant (->) (->) t', Adjoint (->) (->) t' t, Bindable (->) u) => Bindable (->) (t <:<.>:> t' >>>>>>>> u) where
 	f =<< x = TUT <---- ((run . f |--) =<<) <-|- run x
 
-instance (Bindable (->) u, Monoidal (-->) (-->) (:*:) (:*:) u, Adjoint (->) (->) t' t) => Monoidal (-->) (-->) (:*:) (:*:) (t <:<.>:> t' > u) where
+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
+instance (Adjoint (->) (->) t' t, Extendable (->) u) => Extendable (->) (t' <:<.>:> t >>>>>>>> u) where
 	f <<= x = TUT <---- ((f . unite --|) <<=) <-|- run x
 
 instance (Adjoint (->) (->) t' t, Distributive (->) (->) t) => Liftable (->) (t <:<.>:> t') where
-	lift :: Covariant (->) (->) u => u ~> t <:<.>:> t' > u
+	lift :: Covariant (->) (->) u => u ~> t <:<.>:> t' >>>>>>>> u
 	lift x = TUT <--- (identity @(->) -|) -<< x
 
 instance (Adjoint (->) (->) t t', Distributive (->) (->) t') => Lowerable (->) (t <:<.>:> t') where
-	lower :: Covariant (->) (->) u => (t <:<.>:> t' > u) ~> u
+	lower :: Covariant (->) (->) u => (t <:<.>:> t' >>>>>>>> u) ~> u
 	lower (TUT x) = (identity @(->) -<<) |- x
diff --git a/Pandora/Paradigm/Schemes/TUVW.hs b/Pandora/Paradigm/Schemes/TUVW.hs
--- a/Pandora/Paradigm/Schemes/TUVW.hs
+++ b/Pandora/Paradigm/Schemes/TUVW.hs
@@ -1,11 +1,11 @@
 module Pandora.Paradigm.Schemes.TUVW (TUVW (..)) where
 
-import Pandora.Core.Functor (type (:.), type (>))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Core.Functor (type (:.), type (>>>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 
-newtype TUVW ct cu cv cw t u v w a = TUVW (t :. u :. v :. w > a)
+newtype TUVW ct cu cv cw t u v w a = TUVW (t :. u :. v :. w >>> a)
 
 instance Interpreted (->) (TUVW ct cu cv cw t u v w) where
-	type Primary (TUVW ct cu cv cw t u v w) a = t :. u :. v :. w > a
+	type Primary (TUVW ct cu cv cw t u v w) a = t :. u :. v :. w >>> a
 	run ~(TUVW x) = x
 	unite = TUVW
diff --git a/Pandora/Paradigm/Schemes/T_U.hs b/Pandora/Paradigm/Schemes/T_U.hs
--- a/Pandora/Paradigm/Schemes/T_U.hs
+++ b/Pandora/Paradigm/Schemes/T_U.hs
@@ -1,16 +1,17 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Schemes.T_U where
 
-import Pandora.Core.Functor (type (>))
+import Pandora.Core.Functor (type (>>>>>>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (=#-), (-#=)))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Morphism.Flip (Flip)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-|-)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-), (-#=)))
+import Pandora.Paradigm.Algebraic.Exponential ()
 
 newtype T_U ct cu p t u a = T_U (p (t a) (u a))
 
-infixr 2 <:.:>, >:.:>, <:.:<, >:.:<
+infixr 5 <:.:>, >:.:>, <:.:<, >:.:<
 
 type (<:.:>) t u p = T_U Covariant Covariant p t u
 type (>:.:>) t u p = T_U Contravariant Covariant p t u
@@ -23,9 +24,9 @@
 	unite = T_U
 
 -- TODO: generalize over (->)
-instance (forall i . Covariant (->) (->) (p i), forall o . Covariant (->) (->) (Flip p o), Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <:.:> u > p) where
+instance (forall i . Covariant (->) (->) (p i), forall o . Covariant (->) (->) (Flip p o), Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <:.:> u >>>>>> p) where
 	f <-|- x = ((-#=) @_ @(Flip _ _) ((<-|-|-) f) . ((<-|-|-) f)) =#- x
 
 -- TODO: generalize over (->)
-instance (Contravariant (->) (->) t, forall a . Covariant (->) (->) (p (t a)), Covariant (->) (->) u, forall b . Contravariant (->) (->) (Flip p (u b))) => Covariant (->) (->) (t >:.:> u > p) where
+instance (Contravariant (->) (->) t, forall a . Covariant (->) (->) (p (t a)), Covariant (->) (->) u, forall b . Contravariant (->) (->) (Flip p (u b))) => Covariant (->) (->) (t >:.:> u >>>>>> p) where
 	(<-|-) f = (=#-) ((-#=) @_ @(Flip _ _) ((>-|-|-) f) . ((<-|-|-) f))
diff --git a/Pandora/Paradigm/Schemes/UT.hs b/Pandora/Paradigm/Schemes/UT.hs
--- a/Pandora/Paradigm/Schemes/UT.hs
+++ b/Pandora/Paradigm/Schemes/UT.hs
@@ -1,7 +1,8 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Schemes.UT where
 
-import Pandora.Core.Functor (type (:.), type (>), type (~>))
+import Pandora.Core.Functor (type (:.), type (>>>), type (~>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-)))
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))
@@ -14,7 +15,6 @@
 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.Algebraic.Exponential (type (<--), type (-->))
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic.Sum ((:+:))
@@ -22,7 +22,7 @@
 import Pandora.Paradigm.Algebraic (point, extract, (<-||-), (<-||---))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 
-newtype UT ct cu t u a = UT (u :. t > a)
+newtype UT ct cu t u a = UT (u :. t >>> a)
 
 infixr 3 <.:>, >.:>, <.:<, >.:<
 
@@ -32,7 +32,7 @@
 type (>.:<) = UT Contravariant Contravariant
 
 instance Interpreted (->) (UT ct cu t u) where
-	type Primary (UT ct cu t u) a = u :. t > a
+	type Primary (UT ct cu t u) a = u :. t >>> a
 	run ~(UT x) = x
 	unite = UT
 
diff --git a/Pandora/Paradigm/Schemes/UTU.hs b/Pandora/Paradigm/Schemes/UTU.hs
--- a/Pandora/Paradigm/Schemes/UTU.hs
+++ b/Pandora/Paradigm/Schemes/UTU.hs
@@ -1,11 +1,11 @@
 module Pandora.Paradigm.Schemes.UTU where
 
-import Pandora.Core.Functor (type (:.), type (>))
+import Pandora.Core.Functor (type (:.), type (>>>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
-newtype UTU ct cu t u u' a = UTU (u :. t :. u' > a)
+newtype UTU ct cu t u u' a = UTU (u :. t :. u' >>> a)
 
 type (<.<:>.>) = UTU Covariant Covariant Covariant
 type (>.<:>.>) = UTU Contravariant Covariant Covariant
@@ -17,6 +17,6 @@
 type (>.>:<.<) = UTU Contravariant Contravariant Contravariant
 
 instance Interpreted (->) (UTU ct cu t u u') where
-	type Primary (UTU ct cu t u u') a = u :. t :. u' > a
+	type Primary (UTU ct cu t u u') a = u :. t :. u' >>> a
 	run ~(UTU x) = x
 	unite = UTU
diff --git a/Pandora/Paradigm/Schemes/U_T.hs b/Pandora/Paradigm/Schemes/U_T.hs
--- a/Pandora/Paradigm/Schemes/U_T.hs
+++ b/Pandora/Paradigm/Schemes/U_T.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Schemes.U_T where
 
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))
 
 newtype U_T ct cu t p u a = U_T (p (u a) (t a))
 
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -7,6 +7,7 @@
 import Pandora.Paradigm.Structure.Modification as Exports
 import Pandora.Paradigm.Structure.Some as Exports
 
+import Pandora.Core.Interpreted (run, (<~))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), identity)
 import Pandora.Pattern.Kernel (constant)
@@ -14,7 +15,6 @@
 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.Inventory.Some.Optics ()
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
 import Pandora.Paradigm.Algebraic.Exponential ((%))
@@ -24,7 +24,7 @@
 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.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))
@@ -52,18 +52,18 @@
 	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
+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 -> 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
+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 -> Left_ _) = Nothing
+	morphing (premorph -> Right_ rs) = Just rs
 	morphing (premorph -> End) = Nothing
 
 instance Morphable (Into (This Maybe)) (These e) where
@@ -93,25 +93,25 @@
 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 :*: 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
+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)
+		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
+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)
+		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
@@ -122,37 +122,37 @@
 	type Morphing (Into (Preorder (Construction Maybe))) (Construction Wye) = Construction Maybe
 	morphing nonempty_binary = case premorph nonempty_binary of
 		Construct x End -> Construct x Nothing
-		Construct x (Left lst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) lst
-		Construct x (Right rst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) rst
+		Construct x (Left_ lst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) lst
+		Construct x (Right_ rst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) rst
 		Construct x (Both lst rst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) lst + into @(Preorder (Nonempty List)) rst
 
 instance Morphable (Into (Inorder (Construction Maybe))) (Construction Wye) where
 	type Morphing (Into (Inorder (Construction Maybe))) (Construction Wye) = Construction Maybe
 	morphing nonempty_binary = case premorph nonempty_binary of
 		Construct x End -> Construct x Nothing
-		Construct x (Left lst) -> into @(Inorder (Nonempty List)) lst + Construct x Nothing
-		Construct x (Right rst) -> Construct x Nothing + into @(Inorder (Nonempty List)) rst
+		Construct x (Left_ lst) -> into @(Inorder (Nonempty List)) lst + Construct x Nothing
+		Construct x (Right_ rst) -> Construct x Nothing + into @(Inorder (Nonempty List)) rst
 		Construct x (Both lst rst) -> into @(Inorder (Nonempty List)) lst + Construct x Nothing + into @(Inorder (Nonempty List)) rst
 
 instance Morphable (Into (Postorder (Construction Maybe))) (Construction Wye) where
 	type Morphing (Into (Postorder (Construction Maybe))) (Construction Wye) = Construction Maybe
 	morphing nonempty_binary = case premorph nonempty_binary of
 		Construct x End -> Construct x Nothing
-		Construct x (Left lst) -> into @(Postorder (Nonempty List)) lst + Construct x Nothing
-		Construct x (Right rst) -> into @(Postorder (Nonempty List)) rst + Construct x Nothing
+		Construct x (Left_ lst) -> into @(Postorder (Nonempty List)) lst + Construct x Nothing
+		Construct x (Right_ rst) -> into @(Postorder (Nonempty List)) rst + Construct x Nothing
 		Construct x (Both lst rst) -> into @(Postorder (Nonempty List)) lst + into @(Postorder (Nonempty List)) rst + Construct x Nothing
 
 -- instance Morphable (Into (o ds)) (Construction Wye) => Morphable (Into (o ds)) Binary where
 	-- type Morphing (Into (o ds)) Binary = Maybe <:.> Morphing (Into (o ds)) (Construction Wye)
 	-- morphing (premorph -> xs) = (into @(o ds) <-|-) =#- xs
 
-instance Substructure Left (Flip (:*:) a) where
-	type Substance Left (Flip (:*:) a) = Exactly
+instance Substructure Left_ (Flip (:*:) a) where
+	type Substance Left_ (Flip (:*:) a) = Exactly
 	substructure = P_Q_T <-- \product -> case run <-- lower product of
 		s :*: x -> Store <--- Exactly s :*: lift . Flip . (:*: x) . extract
 
-instance Substructure Right ((:*:) s) where
-	type Substance Right ((:*:) s) = Exactly
+instance Substructure Right_ ((:*:) s) where
+	type Substance Right_ ((:*:) s) = Exactly
 	substructure = P_Q_T <-- \product -> case lower product of
 		s :*: x -> Store <--- Exactly x :*: lift . (s :*:) . extract
 
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,8 +1,8 @@
 module Pandora.Paradigm.Structure.Ability (module Exports) where
 
+import Pandora.Paradigm.Structure.Ability.Slidable as Exports
 import Pandora.Paradigm.Structure.Ability.Monotonic 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
 import Pandora.Paradigm.Structure.Ability.Accessible as Exports
-import Pandora.Paradigm.Structure.Ability.Nonempty as Exports
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
@@ -1,7 +1,8 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
 module Pandora.Paradigm.Structure.Ability.Morphable where
 
-import Pandora.Core.Functor (type (>), type (~>), type (:=:=>))
+import Pandora.Core.Functor (type (>>>>>>), type (>>>>>>>), type (~>), type (:=:=>))
+import Pandora.Core.Interpreted (run)
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
@@ -14,7 +15,6 @@
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 
@@ -37,36 +37,32 @@
 
 data Occurrence a = All a | First a
 
-data Vertical a = Up a | Down a
-
-data Horizontal a = Leftward a | Rightward a
-
 rotate :: forall mod struct . Morphable (Rotate mod) struct => struct ~> Morphing (Rotate mod) struct
 rotate = morphing . TT . Tag @(Rotate mod)
 
 into :: forall mod struct . Morphable (Into mod) struct => struct ~> Morphing (Into mod) struct
 into = morphing . TT . Tag @(Into mod)
 
-insert :: forall mod struct a . Morphed (Insert mod) struct (Exactly <:.:> struct > (->)) => a :=:=> struct
+insert :: forall mod struct a . Morphed (Insert mod) struct (Exactly <:.:> struct >>>>>> (->)) => a :=:=> struct
 insert new xs = run <-- morph @(Insert mod) xs <-- Exactly new
 
-item :: forall mod struct a . Morphed mod struct (Exactly <:.:> struct > (->)) => a :=:=> struct
+item :: forall mod struct a . Morphed mod struct (Exactly <:.:> struct >>>>>> (->)) => a :=:=> struct
 item new xs = run <-- morph @mod xs <-- Exactly new
 
-collate :: forall mod struct a . (Chain a, Morphed mod struct ((Exactly <:.:> Comparison > (:*:)) <:.:> struct > (->))) => a :=:=> struct
+collate :: forall mod struct a . (Chain a, Morphed mod struct ((Exactly <:.:> Comparison >>>>>> (:*:)) <:.:> struct >>>>>> (->))) => a :=:=> struct
 collate new xs = run <-- morph @mod xs <-- T_U (Exactly new :*: Convergence (<=>))
 
-delete :: forall mod struct a . (Setoid a, Morphed (Delete mod) struct (Predicate <:.:> struct > (->))) => a :=:=> struct
+delete :: forall mod struct a . (Setoid a, Morphed (Delete mod) struct (Predicate <:.:> struct >>>>>> (->))) => a :=:=> struct
 delete x xs = run <-- morph @(Delete mod) xs <-- equate x
 
-filter :: forall mod struct a . (Morphed (Delete mod) struct (Predicate <:.:> struct > (->))) => Predicate a -> struct a -> struct a
+filter :: forall mod struct a . (Morphed (Delete mod) struct (Predicate <:.:> struct >>>>>> (->))) => Predicate a -> struct a -> struct a
 filter p xs = run <-- morph @(Delete mod) xs <-- p
 
-find :: forall mod struct result a . (Morphed (Find mod) struct (Predicate <:.:> result > (->))) => Predicate a -> struct a -> result a
+find :: forall mod struct result a . (Morphed (Find mod) struct (Predicate <:.:> result >>>>>> (->))) => Predicate a -> struct a -> result a
 find p xs = run <-- morph @(Find mod) xs <-- p
 
 lookup :: forall mod key struct a . (Morphed (Lookup mod) struct ((->) key <::> Maybe)) => key -> struct a -> Maybe a
 lookup key struct = run <-- morph @(Lookup mod) struct <-- key
 
-vary :: forall mod key value struct . (Morphed (Vary mod) struct (((:*:) key <::> Exactly) <:.:> struct > (->))) => key -> value -> struct value -> struct value
+vary :: forall mod key value struct . (Morphed (Vary mod) struct (((:*:) key <::> Exactly) <:.:> struct >>>>>>> (->))) => key -> value -> struct value -> struct value
 vary key value xs = run <-- morph @(Vary mod) @struct xs <-- TT (key :*: Exactly value)
diff --git a/Pandora/Paradigm/Structure/Ability/Nonempty.hs b/Pandora/Paradigm/Structure/Ability/Nonempty.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Ability/Nonempty.hs
+++ /dev/null
@@ -1,4 +0,0 @@
-module Pandora.Paradigm.Structure.Ability.Nonempty where
-
--- | Type synonymous for at least one element data structure
-type family Nonempty (s :: * -> *) = (r :: * -> *) | r -> s
diff --git a/Pandora/Paradigm/Structure/Ability/Slidable.hs b/Pandora/Paradigm/Structure/Ability/Slidable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Ability/Slidable.hs
@@ -0,0 +1,10 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+module Pandora.Paradigm.Structure.Ability.Slidable where
+
+import Pandora.Core.Functor (type (>>>), type (<))
+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>))
+import Pandora.Paradigm.Inventory.Some.State (State)
+
+class Slidable d (s :: * -> *) where
+	type Sliding d s :: * -> *
+	slide :: State < s e :> Sliding d s >>> ()
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,20 +2,20 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Structure.Ability.Substructure where
 
+import Pandora.Core.Interpreted (run, unite, (=#-))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 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, unite, (=#-))
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Some.Optics (type (@>>>), view, replace)
 import Pandora.Paradigm.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>))
 import Pandora.Paradigm.Algebraic ((>-||-), extract)
+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
 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.TT (type (<::>))
@@ -45,6 +45,14 @@
 		ls :*: rs -> Store <--- rs :*: lift . (ls <:*:>)
 
 data Segment a = Root a | Rest a | Branch a | Ancestors a | Forest a
+
+instance Covariant (->) (->) t => Substructure Root (Exactly <:*:> t) where
+	type Substance Root (Exactly <:*:> t) = Exactly
+	substructure = (lower >-||-) . (lift @(->) <-|-|-) =#- sub @Left
+
+instance Covariant (->) (->) t => Substructure Rest (Exactly <:*:> t) where
+	type Substance Rest (Exactly <:*:> t) = t
+	substructure = (lower >-||-) . (lift @(->) <-|-|-) =#- sub @Right
 
 instance Covariant (->) (->) t => Substructure Root (Construction t) where
 	type Substance Root (Construction t) = Exactly
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
@@ -1,7 +1,8 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
 module Pandora.Paradigm.Structure.Interface.Set where
 
-import Pandora.Core.Functor (type (>))
+import Pandora.Core.Functor (type (>), type (>>>>>>))
+import Pandora.Core.Interpreted ((<~~))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---))
 import Pandora.Pattern.Kernel (constant)
@@ -21,11 +22,10 @@
 import Pandora.Paradigm.Inventory.Ability.Modifiable (modify)
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing), Morph (Find), find)
 import Pandora.Paradigm.Inventory.Some.State (State)
-import Pandora.Paradigm.Controlflow.Effect ((<~~))
 
 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 :: forall t f a . (Set t f a, Morphing (Find f) t ~ (Predicate <:.:> Maybe >>>>>> (->))) => Convergence Boolean > t a
 subset = Convergence <-- \s ss -> Nothing != ((find @f @t @Maybe % s) . equate <<- ss)
 
 cardinality :: Traversable (->) (->) t => t a -> Numerator
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
@@ -1,6 +1,7 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
 module Pandora.Paradigm.Structure.Interface.Stack where
 
+import Pandora.Core.Functor (type (<), type (<<))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)
 import Pandora.Paradigm.Inventory.Some.State (State)
 import Pandora.Paradigm.Inventory.Some.Optics (Lens)
@@ -10,11 +11,8 @@
 > * Idempotency: item @Push x . morph @Pop ≡ identity
 -}
 
-class Stack t where
-	type Topping t :: * -> *
-	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
+class Stack structure where
+	type Topping structure :: * -> *
+	top :: Lens < Topping structure < structure e < e
+	pop :: State < structure e < Topping structure e
+	push :: e -> State < structure e < e
diff --git a/Pandora/Paradigm/Structure/Interface/Zipper.hs b/Pandora/Paradigm/Structure/Interface/Zipper.hs
--- a/Pandora/Paradigm/Structure/Interface/Zipper.hs
+++ b/Pandora/Paradigm/Structure/Interface/Zipper.hs
@@ -4,6 +4,7 @@
 module Pandora.Paradigm.Structure.Interface.Zipper where
 
 import Pandora.Core.Functor (type (>), type (<), type (:.), type (:::))
+import Pandora.Core.Interpreted (run, unite, (<~), (=#-))
 import Pandora.Core.Impliable (Impliable (Arguments, imply))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
@@ -27,14 +28,12 @@
 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, (<~), (=#-))
 
+-- TODO: Use Slidable superclass with Slides associated type family
 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)
+type Zipper (structure :: * -> *) = Exactly <:*:> Breadcrumbs structure
 
 instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t
 	=> Semimonoidal (<--) (:*:) (:*:) (Exactly <:*:> t) where
@@ -44,11 +43,6 @@
 
 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)
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
@@ -3,5 +3,6 @@
 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.Nonempty 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
@@ -2,7 +2,8 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Structure.Modification.Comprehension where
 
-import Pandora.Core.Functor (type (>))
+import Pandora.Core.Functor (type (>), type (>>>>>), type (>>>>>>))
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
@@ -17,7 +18,6 @@
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~)))
 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)
@@ -26,10 +26,10 @@
 import Pandora.Paradigm.Algebraic.Sum ((:+:))
 import Pandora.Paradigm.Algebraic (empty, (<-|-<-|-))
 
-newtype Comprehension t a = Comprehension (t <::> Construction t > a)
+newtype Comprehension t a = Comprehension (t <::> Construction t >>>>> a)
 
 instance Interpreted (->) (Comprehension t) where
-	type Primary (Comprehension t) a = t <::> Construction t > a
+	type Primary (Comprehension t) a = t <::> Construction t >>>>> a
 	run ~(Comprehension x) = x
 	unite = Comprehension
 
@@ -45,18 +45,18 @@
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) (Construction t), Semimonoidal (-->) (:*:) (:+:) t, Semimonoidal (-->) (:*:) (:+:) (Construction t), Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:+:) (Comprehension t) where
 	unit _ = Straight <-- \_ -> Comprehension empty
 
-instance (forall a . Semigroup (t <::> Construction t > a), Bindable (->) t) => Bindable (->) (Comprehension t) where
+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
 
-instance Setoid (t <::> Construction t > a) => Setoid (Comprehension t a) where
+instance Setoid (t <::> Construction t >>>>> a) => Setoid (Comprehension t a) where
 	Comprehension ls == Comprehension rs = ls == rs
 
-instance Semigroup (t <::> Construction t > a) => Semigroup (Comprehension t a) where
+instance Semigroup (t <::> Construction t >>>>> a) => Semigroup (Comprehension t a) where
 	Comprehension x + Comprehension y = Comprehension <---- x + y
 
-instance Monoid (t <::> Construction t > a) => Monoid (Comprehension t a) where
+instance Monoid (t <::> Construction t >>>>> a) => Monoid (Comprehension t a) where
 	zero = Comprehension zero
 
 instance (Covariant (->) (->) t, Monoidal (-->) (-->) (:*:) (:*:) t) => Morphable Push (Comprehension t) where
-	type Morphing Push (Comprehension t) = Exactly <:.:> Comprehension t > (->)
+	type Morphing Push (Comprehension t) = Exactly <:.:> Comprehension t >>>>>> (->)
 	morphing (run . premorph -> xs) = T_U <-- \(Exactly x) -> Comprehension . lift . Construct x . run <-- xs
diff --git a/Pandora/Paradigm/Structure/Modification/Nonempty.hs b/Pandora/Paradigm/Structure/Modification/Nonempty.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Modification/Nonempty.hs
@@ -0,0 +1,4 @@
+module Pandora.Paradigm.Structure.Modification.Nonempty where
+
+-- | Type synonymous for at least one element data structure
+type family Nonempty (s :: * -> *) = (r :: * -> *) | r -> s
diff --git a/Pandora/Paradigm/Structure/Modification/Prefixed.hs b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
--- a/Pandora/Paradigm/Structure/Modification/Prefixed.hs
+++ b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
@@ -1,33 +1,6 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Structure.Modification.Prefixed where
 
-import Pandora.Core.Functor (type (:.), type (>))
-import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|----), (<-|-|-)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
-import Pandora.Paradigm.Algebraic (extract)
+import Pandora.Paradigm.Schemes (type (<::>))
 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)
 
-newtype Prefixed t k a = Prefixed (t :. (:*:) k > a)
-
-instance Interpreted (->) (Prefixed t k) where
-	type Primary (Prefixed t k) a = t :. (:*:) k > a
-	run ~(Prefixed x) = x
-	unite = Prefixed
-
--- TODO: Try to generalize (->) here
-instance Covariant (->) (->) t => Covariant (->) (->) (Prefixed t k) where
-	(<-|-) f = (=#-) (f <-|-|-)
-
-instance Traversable (->) (->) t => Traversable (->) (->) (Prefixed t k) where
-	f <<- Prefixed x = Prefixed <-|---- f <<-<<- x
-
-instance Covariant (->) (->) t => Morphable (Into t) (Prefixed t k) where
-	type Morphing (Into t) (Prefixed t k) = t
-	morphing (run . premorph -> prefixed) = extract <-|- prefixed
-
-type instance Nonempty (Prefixed t k) = Prefixed (Nonempty t) k
+type Prefixed t k = t <::> (:*:) k
diff --git a/Pandora/Paradigm/Structure/Modification/Tape.hs b/Pandora/Paradigm/Structure/Modification/Tape.hs
--- a/Pandora/Paradigm/Structure/Modification/Tape.hs
+++ b/Pandora/Paradigm/Structure/Modification/Tape.hs
@@ -1,78 +1,93 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Structure.Modification.Tape where
 
+import Pandora.Core.Functor (type (>), type (>>>))
 import Pandora.Core.Impliable (Impliable (Arguments, imply))
+import Pandora.Core.Interpreted (run, (=#-))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), (<------))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|---)))
+import Pandora.Pattern.Kernel (constant)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-), (<<---)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((====<<)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
-import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
+import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->), (%))
+import Pandora.Paradigm.Algebraic.Exponential (type (-->), (%))
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>))
-import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (<-*---), (.-*-), extract, point)
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Algebraic.Functor ((<-*--), extract, point, void)
 import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
-import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
+import Pandora.Paradigm.Schemes.T_U (T_U (T_U))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
+import Pandora.Paradigm.Primary.Auxiliary (Vertical (Up, Down), Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
-import Pandora.Paradigm.Primary.Functor.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.Controlflow.Effect.Adaptable (adapt)
+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>), wrap)
+import Pandora.Paradigm.Structure.Ability.Morphable (Occurrence (All))
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root, Rest), sub)
+import Pandora.Paradigm.Structure.Ability.Slidable (Slidable (Sliding, slide))
+import Pandora.Paradigm.Structure.Interface.Stack (Stack (Topping, push, pop))
+import Pandora.Paradigm.Inventory.Some.State (State, change)
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
-import Pandora.Paradigm.Inventory.Some.Optics (Lens, Convex, view, replace, mutate)
+import Pandora.Paradigm.Inventory.Some.Optics (view, replace, mutate, transwrap)
+import Pandora.Paradigm.Inventory (zoom, overlook)
 
-type Tape structure = Tagged (Zippable structure)
-	<:.> (Exactly <:*:> Reverse structure <:*:> structure)
+type Tape 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
+-- TODO: No overlapping, let's use wrappers instead
+-- 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
+	imply focused left right = Exactly focused <:*:> Reverse left <:*:> right
 
 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
+	substructure = P_Q_T <-- \x -> case run . 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
+	substructure = P_Q_T <-- \ii -> case run . 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
+		let target = (view (sub @Left) . view (sub @Rest) <-|-) =#- lower source in
+		let updated new = (\trg src -> mutate (replace <-- trg <-- sub @Left) <-- sub @Rest <-- src) <-|-- 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 =#-)
+		let target = (view (sub @Right) . view (sub @Rest) <-|-) =#- lower source in
+		let updated new = (\trg src -> mutate (replace <-- trg <-- sub @Right) <-- sub @Rest <-- src) <-|-- new <-*-- run <-- lower source in
+		Store <--- target :*: lift . (updated =#-)
+
+instance (Covariant (->) (->) structure, Bindable (->) (Topping structure), Monoidal (-->) (-->) (:*:) (:*:) (Topping structure), Stack structure) => Slidable Left (Tape structure) where
+	type Sliding Left (Tape structure) = Topping structure
+	slide :: forall e . State > Tape structure e :> Topping structure >>> ()
+	slide = void . wrap . zoom @(Tape structure e) (sub @Rest)
+		. zoom (sub @Left) . zoom transwrap . push @structure . extract
+			====<< wrap . zoom @(Tape structure e) (sub @Root) . overlook . change . constant
+				====<< lift ====<< wrap <---- zoom @(Tape structure e) <--- sub @Rest
+					<--- zoom <-- sub @Right <-- pop @structure
+
+instance (Covariant (->) (->) structure, Stack structure, Bindable (->) (Topping structure), Monoidal (-->) (-->) (:*:) (:*:) (Topping structure)) => Slidable Right (Tape structure) where
+	type Sliding Right (Tape structure) = Topping structure
+	slide :: forall e . State > Tape structure e :> Topping structure >>> ()
+	slide = void . wrap . zoom @(Tape structure e) (sub @Rest)
+		. zoom (sub @Right) . push . extract
+			====<< wrap . zoom @(Tape structure e) (sub @Root) . overlook . change . constant
+				====<< lift ====<< wrap <---- zoom @(Tape structure e) <--- sub @Rest
+					<--- zoom <-- sub @Left <-- zoom transwrap pop
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
@@ -1,11 +1,11 @@
 {-# LANGUAGE UndecidableInstances #-}
 module Pandora.Paradigm.Structure.Modification.Turnover where
 
+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (=#-)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Transformer.Hoistable ((/|\))
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Algebraic ((>-|-<-|-))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-)))
 import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure))
 
 newtype Turnover t a = Turnover (t a)
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
@@ -1,7 +1,8 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Structure.Some.Binary where
 
-import Pandora.Core.Functor (type (~>), type (>), type (<), type (:=>))
+import Pandora.Core.Functor (type (~>), type (>), type (>>>>>>), type (<), type (:=>))
+import Pandora.Core.Interpreted (run, (<~))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (-->), (--->))
 import Pandora.Pattern.Kernel (constant)
@@ -14,27 +15,27 @@
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached)
 import Pandora.Paradigm.Algebraic.Exponential ((%), (&), (.:..))
 import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (<-*-*-), extract, point, empty)
+import Pandora.Paradigm.Primary.Auxiliary (Vertical (Up, Down), Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Object.Ordering (order)
+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Functor (Comparison)
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 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.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)
 import Pandora.Paradigm.Inventory.Ability.Settable (set)
 import Pandora.Paradigm.Inventory.Ability.Modifiable (modify)
 import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Some.Optics (Lens, Obscure, view, replace, mutate)
-import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
+import Pandora.Paradigm.Structure.Modification.Nonempty (Nonempty)
 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)
+	, Morph (Rotate, Into, Insert, Lookup, Key), lookup)
 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))
+import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed)
 
 type Binary = Maybe <::> Construction (Maybe <:*:> Maybe)
 
@@ -70,10 +71,10 @@
 
 -------------------------------------- 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
@@ -111,8 +112,8 @@
 		Just tree -> TT <-- \key ->
 			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)
+				<--- lookup @Key key . TT @Covariant @Covariant =<< run (view <-- sub @(Left Branch) <-- tree)
+				<--- lookup @Key key . TT @Covariant @Covariant =<< 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 > (->)
@@ -132,8 +133,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 . TT @Covariant @Covariant ==<< get @(Obscure Lens) <-- sub @Left <-- xs
+			<---- lookup @Key key . TT @Covariant @Covariant ==<< get @(Obscure Lens) <-- sub @Left <-- xs
 
 -------------------------------------- Zipper of binary tree ---------------------------------------
 	{-
@@ -141,13 +142,13 @@
 
 instance Covariant (->) (->) Biforked where
 	_ <-|- Top = Top
-	f <-|- Horizontal (Leftward l) = Horizontal . Leftward <-- f l
-	f <-|- Horizontal (Rightward r) = Horizontal . Rightward <-- f r
+	f <-|- Horizontal (Left l) = Horizontal . Left <-- f l
+	f <-|- Horizontal (Right r) = Horizontal . Right <-- f r
 
 instance Traversable (->) (->) Biforked where
 	_ <<- Top = point Top
-	f <<- Horizontal (Leftward l) = Horizontal . Leftward <-|- f l
-	f <<- Horizontal (Rightward r) = Horizontal . Rightward <-|- f r
+	f <<- Horizontal (Left l) = Horizontal . Left <-|- f l
+	f <<- Horizontal (Right r) = Horizontal . Right <-|- f r
 
 type Bifurcation = Biforked <::> Construction Biforked
 
@@ -163,12 +164,12 @@
 	type Morphing (Rotate Up) ((Exactly <:.:> Wye <::> Construction Wye > (:*:)) <:.:> (Bifurcation <::> Bicursor) > (:*:))
 		= 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)))) ->
+		focused :*: TT (TT (Horizontal (Right (Construct (T_U (Exactly parent :*: rest)) next)))) ->
 			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)))) ->
+		focused :*: TT (TT (Horizontal (Left (Construct (T_U (Exactly parent :*: rest)) next)))) ->
 			lift . ((<:*:>) % TT (TT next)) . (<:*:>) (Exactly parent) . TT <---- resolve
 				<--- Both % _focused_part_to_nonempty_binary_tree focused
 				<--- Right <-- _focused_part_to_nonempty_binary_tree focused
@@ -184,12 +185,12 @@
 	morphing struct = case run ---> premorph struct of
 		T_U (Exactly x :*: TT (Left lst)) :*: TT (TT next) ->
 			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part lst)
-				. TT . TT . Horizontal . Leftward <------- Construct
+				. TT . TT . Horizontal . Left <------- Construct
 					<------ Exactly x <:*:> TT Nothing
 					<------ next
 		T_U (Exactly x :*: TT (Both lst rst)) :*: TT (TT next) ->
 			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part lst)
-				. TT . TT . Horizontal . Leftward <------- Construct
+				. TT . TT . Horizontal . Left <------- Construct
 					<------ Exactly x <:*:> lift rst
 					<------ next
 		_ -> TT Nothing
@@ -200,9 +201,9 @@
 	morphing struct = case run ---> premorph struct of
 		T_U (Exactly x :*: TT (Right rst)) :*: TT (TT next) ->
 			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part rst)
-				. TT . TT . Horizontal . Rightward <---- Construct (Exactly x <:*:> TT Nothing) next
+				. TT . TT . Horizontal . Right <---- Construct (Exactly x <:*:> TT Nothing) next
 		T_U (Exactly x :*: TT (Both lst rst)) :*: TT (TT next) ->
 			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part rst)
-				. TT . TT . Horizontal . Rightward <---- Construct (Exactly x <:*:> lift lst) next
+				. TT . TT . Horizontal . Right <---- Construct (Exactly x <:*:> lift lst) next
 		_ -> TT 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
@@ -1,8 +1,9 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Structure.Some.List where
 
-import Pandora.Core.Functor (type (:.), type (<), type (>))
+import Pandora.Core.Functor (type (:.), type (<), type (>), type (>>>), type (>>>>>>))
 import Pandora.Core.Impliable (imply)
+import Pandora.Core.Interpreted (run, unite, (<~), (<~~~), (=#-))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------), (-->), (--->), (---->), identity)
 import Pandora.Pattern.Kernel (constant)
@@ -16,41 +17,44 @@
 import Pandora.Pattern.Object.Setoid (Setoid ((==), (?=)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (.-*-), (.-+-), (.:..), extract, point, empty, void)
+import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (.-*-), (-+-), (.:..), extract, point, empty, void)
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached)
 import Pandora.Paradigm.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Algebraic ((<-|-<-|-))
+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
-import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+))
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
 import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))
 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.Adaptable (adapt)
+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>))
 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.Interface.Zipper (Zippable (Breadcrumbs), Zipper)
+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, current, change)
+import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
+import Pandora.Paradigm.Inventory.Some.Optics (Convex, Obscure, Lens, transwrap)
+import Pandora.Paradigm.Inventory (zoom, overlook)
+import Pandora.Paradigm.Structure.Modification.Nonempty (Nonempty)
 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.Slidable (Slidable (Sliding, slide))
 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.Interface.Stack (Stack (Topping, push, pop, top))
+import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs), Zipper)
 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.Prefixed (Prefixed)
 import Pandora.Paradigm.Structure.Modification.Tape (Tape)
 import Pandora.Paradigm.Structure.Modification.Turnover (Turnover (Turnover))
 
@@ -69,7 +73,7 @@
 	zero = empty
 
 instance Morphable Push List where
-	type Morphing Push List = Exactly <:.:> List > (->)
+	type Morphing Push List = Exactly <:.:> List >>>>>> (->)
 	morphing (premorph -> xs) = T_U <-- lift . (Construct % run xs) . extract
 
 instance Morphable Pop List where
@@ -77,7 +81,7 @@
 	morphing (premorph -> xs) = resolve deconstruct Nothing =#- xs
 
 instance Morphable (Find Element) List where
-	type Morphing (Find Element) List = Predicate <:.:> Maybe > (->)
+	type Morphing (Find Element) List = Predicate <:.:> Maybe >>>>>> (->)
 	morphing list = case run --> premorph list of
 		Nothing -> T_U <-- \_ -> Nothing
 		Just (Construct x xs) -> T_U <-- \p ->
@@ -85,7 +89,7 @@
 				<---- find @Element @List @Maybe <-- p <-- TT xs
 
 instance Morphable (Delete First) List where
-	type Morphing (Delete First) List = Predicate <:.:> List > (->)
+	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 ->
@@ -93,7 +97,7 @@
 				<--- lift . Construct x . run . filter @First @List p <-- TT xs
 
 instance Morphable (Delete All) List where
-	type Morphing (Delete All) List = Predicate <:.:> List > (->)
+	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
@@ -102,8 +106,6 @@
 
 instance Stack List where
 	type Topping List = Maybe
-	type Popping List = List
-	type Pushing List = List
 	top = P_Q_T <-- \list -> case list of
 		TT Nothing -> Store <--- Nothing :*: constant empty
 		TT (Just xs) -> Store <--- Just (extract xs) :*: \new -> case new of
@@ -126,7 +128,7 @@
 
 -- | Transform any traversable structure into a list
 linearize :: forall t a . Traversable (->) (->) t => t a -> List a
-linearize = TT . extract . (run @(->) @(State (Maybe :. Nonempty List > a)) % Nothing) . fold (Just .:.. Construct)
+linearize = TT . extract . (run @(->) @(State (Maybe :. Nonempty List >>> a)) % Nothing) . fold (Just .:.. Construct)
 
 ----------------------------------------- Non-empty list -------------------------------------------
 
@@ -137,7 +139,7 @@
 	Construct x (Just xs) + ys = Construct x . Just <-- xs + ys
 
 instance Morphable (Find Element) (Construction Maybe) where
-	type Morphing (Find Element) (Construction Maybe) = Predicate <:.:> Maybe > (->)
+	type Morphing (Find Element) (Construction Maybe) = Predicate <:.:> Maybe >>>>>> (->)
 	morphing (premorph -> Construct x xs) = T_U <-- \p -> (p <~ x) ?= True <----- Just x
 		<----- find @Element @(Nonempty List) @Maybe <-- p ===<< xs
 
@@ -154,16 +156,14 @@
 		Construct Nothing Nothing -> empty
 
 instance Morphable Push (Construction Maybe) where
-	type Morphing Push (Construction Maybe) = Exactly <:.:> Construction Maybe > (->)
+	type Morphing Push (Construction Maybe) = Exactly <:.:> Construction Maybe >>>>>> (->)
 	morphing (premorph -> xs) = T_U <-- \(Exactly x) -> Construct x <-- Just xs
 
 instance Stack (Construction Maybe) where
 	type Topping (Construction Maybe) = Exactly
-	type Popping (Construction Maybe) = Construction Maybe
-	type Pushing (Construction Maybe) = Construction Maybe
 	top = P_Q_T <-- \xs -> Store <--- Exactly (extract xs) :*: \(Exactly new) -> Construct new <--- deconstruct xs
 	-- It will never return you the last element
-	pop = (\(Construct x xs) -> constant x <-|-|- set @State <<- xs) =<< get @State
+	pop = (\(Construct x xs) -> constant <-- Exactly x <-|- change @(Nonempty List _) . constant <<- xs) =<< current @(Nonempty List _)
 	push x = point x .-*- (modify @State <-- Construct x . Just)
 
 ---------------------------------------- Combinative list ------------------------------------------
@@ -175,23 +175,25 @@
 instance Zippable List where
 	type Breadcrumbs List = Reverse List <:*:> List
 
+-- TODO: No overlapping, let's use wrappers instead
 instance {-# OVERLAPS #-} Traversable (->) (->) (Tape List) where
-	f <<- TU (Tag (T_U (Exactly x :*: T_U (left :*: right)))) =
-		(\past' x' left' -> lift <------ Exactly x' <:*:> left' <:*:> run past')
+	f <<- T_U (Exactly x :*: T_U (left :*: right)) =
+		(\past' x' left' -> Exactly x' <:*:> left' <:*:> run past')
 			<-|- f <<- Reverse right <-*- f x <-*- f <<- left
 
+-- TODO: Try to generalize to Extendable (Tape structure)
 -- instance {-# OVERLAPS #-} Extendable (->) (Tape List) where
-	-- f <<= z = let move rtt = TT . deconstruct <----- run . rtt .-+ z in
-		-- imply @(Tape List _)
-			-- <---- f z
-			-- <---- f <-|-- move <-- rotate @Left
-			-- <---- f <-|-- move <-- rotate @Right
+-- 	f <<= z = let move rtt = TT . deconstruct <----- run . rtt .-+ z in
+-- 		imply @(Tape List _)
+-- 			<---- f z
+-- 			<---- f <-|-- move <-- rotate @Left
+-- 			<---- f <-|-- move <-- rotate @Right
 
 instance Morphable (Rotate Left) (Turnover < Tape List) where
 	type Morphing (Rotate Left) (Turnover < Tape List) = Turnover < Tape List
-	morphing s@(lower . run . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =
+	morphing s@(run . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =
 		resolve @(Tape List _) <--- Turnover <--- premorph s <----
-			(rotate_over x <-|- run right) .-+- (rotate_left x right <-|- run left) where
+			(rotate_over x <-|- run right) -+- (rotate_left x right <-|- run left) where
 
 		rotate_left :: a -> List a -> Nonempty List a -> Tape List a
 		rotate_left focused rs (Construct lx lxs) = imply @(Tape List _) <-- lx <-- TT lxs <-- item @Push focused rs
@@ -200,14 +202,14 @@
 		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) ()
+		put_over :: a -> State < Nonempty List a < ()
 		put_over = void . modify @State . item @Push
 
 instance Morphable (Rotate Right) (Turnover < Tape List) where
 	type Morphing (Rotate Right) (Turnover < Tape List) = Turnover < Tape List
-	morphing s@(lower . run . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =
+	morphing s@(run . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =
 		resolve @(Tape List _) <--- Turnover <--- premorph s
-			<---- (rotate_over x <-|- run left) .-+- (rotate_right x left <-|- run right) where
+			<---- (rotate_over x <-|- run left) -+- (rotate_right x left <-|- run right) where
 
 		rotate_right :: a -> List a -> Nonempty List a -> Tape List a
 		rotate_right focused ls (Construct rx rxs) = imply @(Tape List _) <-- rx <-- item @Push focused ls <-- TT rxs
@@ -225,13 +227,13 @@
 
 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 _)
+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)
 		<--- 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 _)
+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)
 		<--- modify @State . item @Push @(Comprehension Maybe) <<- right
 		<--- item @Push x <-- Comprehension left
 
@@ -242,7 +244,7 @@
 
 instance Morphable (Rotate Left) (Tape > Construction Maybe) where
 	type Morphing (Rotate Left) (Tape > Construction Maybe) = Maybe <::> (Tape > Construction Maybe)
-	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =
+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =
 		TT <----- imply @(Tape (Nonempty List) _)
 			<-|-- point <-- extract left
 			<-*-- deconstruct left
@@ -250,8 +252,8 @@
 
 instance Morphable (Rotate Right) (Tape > Construction Maybe) where
 	type Morphing (Rotate Right) (Tape > Construction Maybe) = Maybe <::> Tape (Construction Maybe)
-	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =
-		TT <----- imply @(Tape (Nonempty List) _)
+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =
+		TT <----- imply @(Tape < Nonempty List < _)
 			<-|-- point <-- extract right
 			<-*-- point <-- item @Push x left
 			<-*-- deconstruct right
@@ -272,13 +274,13 @@
 
 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 _)
+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)
 		<--- 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 _)
+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)
 		<--- modify @State . item @Push @List <<- right
 		<--- item @Push x <-- lift left
 
@@ -291,7 +293,7 @@
 
 instance Setoid key => Morphable (Lookup Key) (Prefixed List key) where
 	type Morphing (Lookup Key) (Prefixed List key) = (->) key <::> Maybe
-	morphing (run . premorph -> list) = TT <-- \key -> lookup @Key key ===<< Prefixed <-|- run list
+	morphing (run . premorph -> list) = TT <-- \key -> lookup @Key key ===<< TT @Covariant @Covariant <-|- run list
 
 ------------------------------------ Prefixed non-empty list ---------------------------------------
 
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
@@ -1,44 +1,36 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Pandora.Paradigm.Structure.Some.Rose where
 
-import Pandora.Core.Functor (type (:.), type (>))
+import Pandora.Core.Functor (type (:.), type (>>>))
+import Pandora.Core.Interpreted (run, unite, (<~))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----))
+import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), identity)
 import Pandora.Pattern.Kernel (constant)
-import Pandora.Pattern.Functor.Covariant ((<-|-), (<-|-|-))
+import Pandora.Pattern.Functor.Covariant ((<-|-))
 import Pandora.Pattern.Functor.Contravariant ((>-|-))
+import Pandora.Pattern.Functor.Traversable ((<<-))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Pattern.Transformer.Hoistable ((/|\))
-import Pandora.Pattern.Object.Setoid (Setoid ((==), (!=), (?=)))
+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.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.Algebraic.Functor (extract, point, empty)
+import Pandora.Paradigm.Primary.Auxiliary (Vertical (Up, Down), Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, 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.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.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, Rest, Forest), sub, tagstruct)
+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into, Rotate, Lookup, Element, Key), premorph, find)
+import Pandora.Paradigm.Structure.Modification.Nonempty (Nonempty)
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root, Rest, Forest), sub)
 import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs))
-import Pandora.Paradigm.Structure.Interface.Stack (Stack (pop, push))
+import Pandora.Paradigm.Structure.Interface.Stack (Stack (pop))
 import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed)
 import Pandora.Paradigm.Structure.Modification.Tape (Tape)
 import Pandora.Paradigm.Structure.Some.List (List)
@@ -81,14 +73,14 @@
 --		Construct key (Just keys) -> Prefixed ! attached x != key ? Construct x # lift subtree
 --			! Construct (key :*: value) . lift ! vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value -#=!> subtree
 
-find_rose_sub_tree :: forall k a . Setoid k => Nonempty List k -> Nonempty Rose > k :*: a -> Maybe a
+find_rose_sub_tree :: forall k a . Setoid k => Nonempty List k -> Nonempty Rose >>> k :*: a -> Maybe a
 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 :: Nonempty List k -> Maybe :. Nonempty Rose > k :*: a
+	subtree :: Nonempty List k -> Maybe :. Nonempty Rose >>> k :*: a
 	subtree keys = find @Element
 		<---- attached . extract
 			>-|- equate <-- extract keys
@@ -102,52 +94,52 @@
 	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
+instance Substructure (Up Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where
+	type Substance (Up Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = List <::> Tape Roses
+	substructure = P_Q_T <-- \zipper -> case run <-- lower zipper of
 		Exactly x :*: T_U (down :*: T_U (left :*: T_U (right :*: up))) ->
-			Store <--- up :*: lift . lift . (Exactly x <:*:>) . (down <:*:>) . (left <:*:>) . (right <:*:>)
+			Store <--- up :*: 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
+instance Substructure (Down Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where
+	type Substance (Down Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Roses
+	substructure = P_Q_T <-- \zipper -> case run <-- lower zipper of
 		Exactly x :*: T_U (down :*: rest) ->
-			Store <--- down :*: lift . lift . (Exactly x <:*:>) . (<:*:> rest)
+			Store <--- down :*: 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
+instance Substructure (Left Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where
+	type Substance (Left Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Reverse Roses
+	substructure = P_Q_T <-- \zipper -> case run <-- lower zipper of
 		Exactly x :*: T_U (down :*: T_U (left :*: rest)) ->
-			Store <--- left :*: lift . lift . (Exactly x <:*:>) . (down <:*:>) . (<:*:> rest)
+			Store <--- left :*: 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
+-- TODO: Try to use substructure  @Left . substructure @Right . substructure @Right . substructure @Right here
+instance Substructure (Right Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where
+	type Substance (Right Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Roses
+	substructure = P_Q_T <-- \zipper -> case run <-- lower zipper of
 		Exactly x :*: T_U (down :*: T_U (left :*: T_U (right :*: rest))) ->
-			Store <--- right :*: lift . lift . (Exactly x <:*:>) . (down <:*:>) . (left <:*:>) . (<:*:> rest)
+			Store <--- right :*: 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))
+instance Morphable (Into (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))) (Construction List) where
+	type Morphing (Into (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))) (Construction List) =
+		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
+		Construct x xs -> 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
+instance Morphable (Rotate Up) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where
+	type Morphing (Rotate Up) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) =
+		Maybe <::> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))
+	morphing (premorph -> z) = TT <---- restruct <-|- identity @(->) <<- pop @List <~ run (view <-- sub @(Up Forest) <-- z) where
+
+		-- TODO: Add type declaration
+		restruct (parents :*: parent) =
+			let child_node = extract <--- view <-- sub @Root <-- z in
+			let central_children = run <--- view <-- sub @(Down Forest) <-- z in
+			let left_children = run @(->) <---- run <--- view <-- sub @(Left Forest) <-- z in
+			let right_children = run <--- view <-- sub @(Right Forest) <-- z in
+			view <-- sub @Root <-- parent
 				<:*:> unite <-- left_children + point (Construct child_node central_children) + right_children
-				<:*:> view <-- sub @Left <-- parent
-				<:*:> view <-- sub @Right <-- parent
+				<:*:> view <--- sub @Left <--- view <-- sub @Rest <-- parent
+				<:*:> view <--- sub @Right <--- view <-- sub @Rest <-- 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,23 +2,30 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
 module Pandora.Paradigm.Structure.Some.Splay where
 
-import Pandora.Core.Functor (type (~>), type (>))
+import Pandora.Core.Functor (type (~>), type (>), type (>>>), type (>>>>>>))
+import Pandora.Core.Interpreted (run)
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category ((<--), (<---), (<----), identity)
+import Pandora.Pattern.Kernel (constant)
+import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|---)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<), (===<<)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<), (===<<), (====<<)))
+import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Hoistable ((/|\))
-import Pandora.Paradigm.Algebraic ((<-*-), extract)
+import Pandora.Paradigm.Algebraic.Functor ((<-*-), extract, point, void)
 import Pandora.Paradigm.Algebraic.Product (type (<:*:>), (<:*:>))
+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)
+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>), wrap)
 import Pandora.Paradigm.Inventory.Some.Optics (view, mutate)
+import Pandora.Paradigm.Inventory.Some.State (State, change, current)
+import Pandora.Paradigm.Inventory (zoom, overlook)
 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.Modification.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Substructure (Segment (Root, Branch), sub)
+import Pandora.Paradigm.Structure.Ability.Slidable (Slidable (Sliding, slide))
 import Pandora.Paradigm.Structure.Ability.Monotonic (resolve)
 import Pandora.Paradigm.Structure.Some.Binary (Binary)
 
@@ -75,6 +82,31 @@
 					(run <--- view <-- sub @(Right Branch) <-- tree)
 				)
 			)
+
+-- TODO: Slidable (Left Zig) (Construction (Maybe <:*:> Maybe))
+-- TODO: Slidable (Left > Zig Zig) (Construction (Maybe <:*:> Maybe))
+-- TODO: Slidable (Right > Zig Zig) (Construction (Maybe <:*:> Maybe))
+-- TODO: Slidable (Left > Zig Zag) (Construction (Maybe <:*:> Maybe))
+-- TODO: Slidable (Right > Zig Zag) (Construction (Maybe <:*:> Maybe))
+-- TODO: Slidable (Left Zig) Binary
+-- TODO: Slidable (Right Zig) Binary
+-- TODO: Slidable (Left > Zig Zig) Binary
+-- TODO: Slidable (Right > Zig Zig) Binary
+-- TODO: Slidable (Left > Zig Zag) Binary
+-- TODO: Slidable (Right > Zig Zag) Binary
+
+instance Slidable (Right Zig) (Construction (Maybe <:*:> Maybe)) where
+	type Sliding (Right Zig) (Construction (Maybe <:*:> Maybe)) = Maybe
+	slide :: forall element . State > Nonempty Binary element :> Maybe >>> ()
+	slide = void . point
+		===<< adapt . zoom @(Nonempty Binary element) (sub @(Right Branch)) .
+			zoom (sub @(Left Branch)) . change . constant
+		===<< adapt . zoom @(Nonempty Binary element) (sub @(Right Branch))
+			. change @(Binary element) . constant . lift
+		===<< change . constant ===<< adapt . run
+		===<< adapt <--- zoom @(Nonempty Binary element)
+			<-- sub @(Left Branch)
+			<-- current @(Binary element)
 
 -- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary
 instance Morphable (Rotate > Left > Zig Zig) (Construction (Maybe <:*:> Maybe)) where
diff --git a/Pandora/Paradigm/Structure/Some/Stream.hs b/Pandora/Paradigm/Structure/Some/Stream.hs
--- a/Pandora/Paradigm/Structure/Some/Stream.hs
+++ b/Pandora/Paradigm/Structure/Some/Stream.hs
@@ -2,43 +2,63 @@
 module Pandora.Paradigm.Structure.Some.Stream where
 
 import Pandora.Core.Impliable (imply)
-import Pandora.Core.Functor (type (>), type (:=>))
+import Pandora.Core.Functor (type (>), type (>>>), type (:=>))
+import Pandora.Core.Interpreted (run)
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((<--), (<---), (<----), (-->))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|--)))
+import Pandora.Pattern.Kernel (constant)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (====<<)))
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>))
-import Pandora.Paradigm.Algebraic (extract)
+import Pandora.Paradigm.Algebraic.Functor (extract, void, (.-*-))
+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))
 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.Construction (Construction (Construct), deconstruct, constitute)
 import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))
+import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)
+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate), premorph, rotate)
+import Pandora.Paradigm.Structure.Ability.Substructure (sub, Segment (Root, Rest))
+import Pandora.Paradigm.Structure.Ability.Slidable (Slidable (Sliding, slide))
 import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs))
+import Pandora.Paradigm.Structure.Interface.Stack (Stack (Topping, push, pop, top))
 import Pandora.Paradigm.Structure.Modification.Tape (Tape)
+import Pandora.Paradigm.Inventory.Some.State (State, change, current)
+import Pandora.Paradigm.Inventory.Some.Store (Store (Store))
+import Pandora.Paradigm.Inventory.Some.Optics (transwrap)
+import Pandora.Paradigm.Inventory (zoom, overlook)
+import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
 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
 
+-- TODO: Try to generalize to Extendable (Tape structure)
+instance {-# OVERLAPS #-} Extendable (->) (Tape Stream) where
+	f <<= z = let move rtt = extract . deconstruct <---- constitute <-- point . rtt <-- z in
+		f <-|- imply @(Tape Stream _) <-- z <-- move (rotate @Left) <-- move (rotate @Right)
+
+instance Stack (Construction Exactly) where
+	type Topping (Construction Exactly) = Exactly
+	top = P_Q_T <-- \xs -> Store <--- Exactly (extract xs) :*: \(Exactly new) -> Construct new <--- deconstruct xs
+	pop = (\(Construct x xs) -> constant <-- Exactly x <-|- change @(Stream _) . constant <<- xs) =<< current
+	push x = point x .-*- (change <-- Construct x . Exactly)
+
 instance Morphable (Rotate Left) (Tape Stream) where
 	type Morphing (Rotate Left) (Tape Stream) = Tape Stream
-	morphing (run . lower . premorph -> Exactly x :*: T_U (Reverse ls :*: rs)) =
+	morphing (run . premorph -> Exactly x :*: T_U (Reverse ls :*: rs)) =
 		imply @(Tape Stream _) <--- extract ls <--- extract (deconstruct ls) <--- Construct x --> point rs
 
 instance Morphable (Rotate Right) (Tape Stream) where
 	type Morphing (Rotate Right) (Tape Stream) = Tape Stream
-	morphing (run . lower . premorph -> Exactly x :*: T_U (Reverse ls :*: rs)) =
+	morphing (run . premorph -> Exactly x :*: T_U (Reverse ls :*: rs)) =
 		imply @(Tape Stream _) <--- extract rs <--- Construct x (point ls) <--- extract (deconstruct rs)
-
-instance {-# OVERLAPS #-} Extendable (->) (Tape Stream) where
-	f <<= z = let move rtt = extract . deconstruct <---- point . rtt .-+ z in
-		f <-|-- imply @(Tape Stream _) <-- z <-- move (rotate @Left) <-- move (rotate @Right)
 
 repeat :: a :=> Stream
 repeat x = Construct x . Exactly <-- repeat x
diff --git a/Pandora/Pattern/Morphism/Flip.hs b/Pandora/Pattern/Morphism/Flip.hs
--- a/Pandora/Pattern/Morphism/Flip.hs
+++ b/Pandora/Pattern/Morphism/Flip.hs
@@ -8,7 +8,7 @@
 newtype Flip (v :: * -> * -> *) a e = Flip (v e a)
 
 instance Semigroupoid m => Semigroupoid (Flip m) where
-  Flip g . Flip f = Flip (f . g)
+	Flip g . Flip f = Flip (f . g)
 
 instance Category m => Category (Flip m) where
 	identity = Flip identity
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.5.3
+version:             0.5.4
 synopsis:            A box of patterns and paradigms
 description:         Humble attempt to define a library for problem solving based on math abstractions.
 homepage:            https://github.com/iokasimov/pandora
@@ -23,6 +23,7 @@
     Pandora.Core
     Pandora.Core.Functor
     Pandora.Core.Impliable
+    Pandora.Core.Interpreted
 
     Pandora.Paradigm
     -- Basic constructions
@@ -34,6 +35,7 @@
     Pandora.Paradigm.Algebraic.Zero
     Pandora.Paradigm.Algebraic.One
     Pandora.Paradigm.Primary
+    Pandora.Paradigm.Primary.Auxiliary
     Pandora.Paradigm.Primary.Object
     Pandora.Paradigm.Primary.Object.Boolean
     Pandora.Paradigm.Primary.Object.Ordering
@@ -86,7 +88,6 @@
     Pandora.Paradigm.Controlflow
     -- Typeclassess about functor junctions
     Pandora.Paradigm.Controlflow.Effect
-    Pandora.Paradigm.Controlflow.Effect.Interpreted
     Pandora.Paradigm.Controlflow.Effect.Transformer
     Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic
     Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic
@@ -114,11 +115,12 @@
     Pandora.Paradigm.Structure.Ability.Accessible
     Pandora.Paradigm.Structure.Ability.Possible
     Pandora.Paradigm.Structure.Ability.Substructure
-    Pandora.Paradigm.Structure.Ability.Nonempty
     Pandora.Paradigm.Structure.Ability.Monotonic
+    Pandora.Paradigm.Structure.Ability.Slidable
     Pandora.Paradigm.Structure.Modification
     Pandora.Paradigm.Structure.Modification.Combinative
     Pandora.Paradigm.Structure.Modification.Comprehension
+    Pandora.Paradigm.Structure.Modification.Nonempty
     Pandora.Paradigm.Structure.Modification.Prefixed
     Pandora.Paradigm.Structure.Modification.Turnover
     Pandora.Paradigm.Structure.Modification.Tape
@@ -189,4 +191,4 @@
     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes, ViewPatterns
     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators
   default-language: Haskell2010
-  ghc-options: -Wall -fno-warn-tabs -fno-warn-unticked-promoted-constructors
+  ghc-options: -Wall -fno-warn-tabs -fno-warn-unticked-promoted-constructors -fprint-potential-instances