diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -327,3 +327,21 @@
 * Define `match` method to chain predicates
 
 # 0.3.6
+* Define `Walk` datatype to define different tree/graph traversals
+* Make `a` paremeter in `:~.` to be existentially qualified
+* Rename type operators: `|->` to `:=>` and `<-|` to `<:=`
+* Define experimental `||=` method to apply a function inside transformer
+* Define `subview`, `subplace` and `substitute` methods in `Substructure` typeclass
+* Put `sub` method into `Substructure` typeclass
+* Remove `^.`, `.~` and `%~` infix optics methods
+* Generalize `T_U` and `U_T` schemes over some `p` (`Bifunctor`/`Profunctor`)
+* Define experimental `Deletable` typeclass
+* Define experimental `adjust`, `magnify`, `=<>`, `~<>`
+* Define experimental `Accessible` type class
+* Rename `access` method to `look` in `Optics` module
+* Rename `Convertible` type class to `Morphable`
+* Remove `Rotatable` type class in favor of `Morphable`
+* Define `<:.:>`, `>:.:>`, `<:.:<`, `>:.:<` type synonyms
+* Delete `Delta` datatype in favor of `(:*:) <:.:> t`
+
+# 0.3.7
diff --git a/Pandora/Core/Functor.hs b/Pandora/Core/Functor.hs
--- a/Pandora/Core/Functor.hs
+++ b/Pandora/Core/Functor.hs
@@ -1,6 +1,6 @@
 module Pandora.Core.Functor where
 
-infixr 0 :=, <-|, |->, ~>
+infixr 0 :=, <:=, :=>, ~>
 infixr 1 .:, :.
 infixr 2 ::|:., ::|.:, ::|::
 
@@ -14,10 +14,10 @@
 type (.:) t u a = u (t a)
 
 -- | Coalgebra's type operator
-type (|->) a t = a -> t a
+type (:=>) a t = a -> t a
 
 -- | Algebra's type operator
-type (<-|) a t = t a -> a
+type (<:=) a t = t a -> a
 
 -- | Numerator transformation
 type (~>) t u = forall a . t a -> u a
diff --git a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
@@ -12,6 +12,9 @@
 	run :: t a -> Primary t a
 	unite :: Primary t a -> t a
 
+	(||=) :: (Primary t a -> Primary t b) -> t a -> t b
+	(||=) f = unite . f . run
+
 (-=:) :: (Liftable t, Interpreted (t u), Interpreted (t v), Covariant u)
 	=> (t u a -> t v b) -> u a -> Primary (t v) b
 (-=:) f = run . f . lift
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -1,6 +1,7 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Inventory (module Exports, zoom) where
+module Pandora.Paradigm.Inventory (module Exports, zoom, magnify, (=<>), (~<>), adjust) where
 
 import Pandora.Paradigm.Inventory.Optics as Exports
 import Pandora.Paradigm.Inventory.Store as Exports
@@ -12,11 +13,14 @@
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((.), ($), identity)
-import Pandora.Pattern.Functor (Adjoint ((-|), (|-)), extract, (<->))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Pattern.Functor.Extractable (extract)
+import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Paradigm.Primary.Functor.Function ((!), (%))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)
+import Pandora.Paradigm.Structure.Ability.Accessible (Accessible (access))
 
 instance Adjoint (Store s) (State s) where
 	(-|) :: a -> (Store s a -> b) -> State s b
@@ -35,3 +39,15 @@
 zoom :: Stateful bg t => Lens bg ls -> State ls ~> t
 zoom lens less = let restruct f v = f <-> identity $ run less v
 	in adapt . State $ (|- restruct) . run . lens
+
+(=<>) :: Stateful src t => src :-. tgt -> tgt -> t ()
+lens =<> new = modify $ set lens new
+
+(~<>) :: Stateful src t => src :-. tgt -> (tgt -> tgt) -> t ()
+lens ~<> f = modify $ over lens f
+
+magnify :: forall bg ls t . (Accessible ls bg, Stateful bg t) => t ls
+magnify = zoom @bg (access @ls @bg) current
+
+adjust :: forall bg ls t . (Accessible ls bg, Stateful bg t) => (ls -> ls) -> t ()
+adjust = zoom @bg (access @ls @bg) . modify
diff --git a/Pandora/Paradigm/Inventory/Optics.hs b/Pandora/Paradigm/Inventory/Optics.hs
--- a/Pandora/Paradigm/Inventory/Optics.hs
+++ b/Pandora/Paradigm/Inventory/Optics.hs
@@ -2,7 +2,7 @@
 
 module Pandora.Paradigm.Inventory.Optics where
 
-import Pandora.Core.Functor (type (|->))
+import Pandora.Core.Functor (type (:=>))
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant ((<$))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
@@ -10,16 +10,18 @@
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
 import Pandora.Paradigm.Primary.Object.Boolean ((?))
-import Pandora.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)
+import Pandora.Paradigm.Inventory.Store (Store (Store), position, look, retrofit)
 
 infixr 0 :-.
+infixr 0 :~.
+
 type (:-.) src tgt = Lens src tgt
 
 -- Reference to taret within some source
-type Lens src tgt = src |-> Store tgt
+type Lens src tgt = src :=> Store tgt
 
--- Lens as Numerator transformation
-type (:~.) t u a = Lens (t a) (u a)
+-- Lens as natural transformation
+type (:~.) src tgt = forall a . Lens (src a) (tgt a)
 
 -- | Lens composition infix operator
 (|>) :: Lens src old -> Lens old new -> Lens src new
@@ -29,25 +31,13 @@
 view :: Lens src tgt -> src -> tgt
 view lens = position . lens
 
--- | Infix version of `view`
-(^.) :: Lens src tgt -> src -> tgt
-(^.) = view
-
 -- | Replace the target of a lens
 set :: Lens src tgt -> tgt -> src -> src
-set lens new = access new . lens
-
--- | Infix version of `set`
-(.~) :: Lens src tgt -> tgt -> src -> src
-lens .~ new = set lens new
+set lens new = look new . lens
 
 -- | Modify the target of a lens
 over :: Lens src tgt -> (tgt -> tgt) -> src -> src
 over lens f = extract . retrofit f . lens
-
--- | Infix version of `over`
-(%~) :: Lens src tgt -> (tgt -> tgt) -> src -> src
-lens %~ f = over lens f
 
 -- | Representable based lens
 represent :: (Representable t, Setoid (Representation t)) => Representation t -> t a :-. a
diff --git a/Pandora/Paradigm/Inventory/Store.hs b/Pandora/Paradigm/Inventory/Store.hs
--- a/Pandora/Paradigm/Inventory/Store.hs
+++ b/Pandora/Paradigm/Inventory/Store.hs
@@ -2,7 +2,7 @@
 
 module Pandora.Paradigm.Inventory.Store where
 
-import Pandora.Core (type (:.), type (:=), type (<-|), type (~>))
+import Pandora.Core (type (:.), type (:=), type (<:=), type (~>))
 import Pandora.Pattern ((.|..))
 import Pandora.Pattern.Category (identity, (.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
@@ -49,8 +49,8 @@
 position = attached . run @(Store _) . adapt
 
 -- | Given an index return value
-access :: Storable s t => s -> a <-| t
-access s = extract % s . run @(Store _) . adapt
+look :: Storable s t => s -> a <:= t
+look s = extract % s . run @(Store _) . adapt
 
 -- | Change index with function
 retrofit :: (s -> s) -> Store s ~> Store s
diff --git a/Pandora/Paradigm/Primary/Functor.hs b/Pandora/Paradigm/Primary/Functor.hs
--- a/Pandora/Paradigm/Primary/Functor.hs
+++ b/Pandora/Paradigm/Primary/Functor.hs
@@ -16,7 +16,6 @@
 import Pandora.Paradigm.Primary.Functor.Proxy as Exports
 import Pandora.Paradigm.Primary.Functor.Tagged as Exports
 import Pandora.Paradigm.Primary.Functor.Product as Exports
-import Pandora.Paradigm.Primary.Functor.Delta as Exports
 import Pandora.Paradigm.Primary.Functor.Constant as Exports
 import Pandora.Paradigm.Primary.Functor.Identity as Exports
 import Pandora.Paradigm.Primary.Functor.Function as Exports
diff --git a/Pandora/Paradigm/Primary/Functor/Delta.hs b/Pandora/Paradigm/Primary/Functor/Delta.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Primary/Functor/Delta.hs
+++ /dev/null
@@ -1,51 +0,0 @@
-module Pandora.Paradigm.Primary.Functor.Delta where
-
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
-import Pandora.Pattern.Object.Setoid (Setoid ((==)))
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
-import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
-
-infixr 1 :^:
-
-data Delta a = a :^: a
-
-instance Covariant Delta where
-	f <$> (x :^: y) = f x :^: f y
-
-instance Pointable Delta where
-	point x = x :^: x
-
-instance Applicative Delta where
-	(f :^: g) <*> (x :^: y) = f x :^: g y
-
-instance Distributive Delta where
-	t >>- f = (True <#>) . f <$> t :^: (False <#>) . f <$> t
-
-instance Traversable Delta where
-	(x :^: y) ->> f = (:^:) <$> f x <*> f y
-
-instance Extendable Delta where
-	x =>> f = f x :^: f x
-
-instance Representable Delta where
-	type Representation Delta = Boolean
-	True <#> (x :^: _) = x
-	False <#> (_ :^: y) = y
-	tabulate f = f True :^: f False
-
-instance Setoid a => Setoid (Delta a) where
-	(x :^: y) == (x' :^: y') = (x == x') * (y == y')
-
-instance Semigroup a => Semigroup (Delta a) where
-	(x :^: y) + (x' :^: y') = (x + x') :^: (y + y')
-
-instance Ringoid a => Ringoid (Delta a) where
-	(x :^: y) * (x' :^: y') = (x * x') :^: (y * y')
diff --git a/Pandora/Paradigm/Primary/Functor/Fix.hs b/Pandora/Paradigm/Primary/Functor/Fix.hs
--- a/Pandora/Paradigm/Primary/Functor/Fix.hs
+++ b/Pandora/Paradigm/Primary/Functor/Fix.hs
@@ -1,16 +1,16 @@
 module Pandora.Paradigm.Primary.Functor.Fix where
 
-import Pandora.Core.Functor (type (<-|), type (|->))
+import Pandora.Core.Functor (type (<:=), type (:=>))
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant (comap))
 
 newtype Fix t = Fix { unfix :: t (Fix t) }
 
-cata :: Covariant t => (a <-| t) -> Fix t -> a
+cata :: Covariant t => (a <:= t) -> Fix t -> a
 cata f = f . comap (cata f) . unfix
 
-ana :: Covariant t => (a |-> t) -> a -> Fix t
+ana :: Covariant t => (a :=> t) -> a -> Fix t
 ana f = Fix . comap (ana f) . f
 
-hylo :: Covariant t => (b <-| t) -> (a |-> t) -> (a -> b)
+hylo :: Covariant t => (b <:= t) -> (a :=> t) -> (a -> b)
 hylo phi psi = cata phi . ana psi
diff --git a/Pandora/Paradigm/Primary/Functor/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,6 @@
 module Pandora.Paradigm.Primary.Functor.Predicate where
 
-import Pandora.Core.Functor (type (~>), type (|->))
+import Pandora.Core.Functor (type (~>), type (:=>))
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Divisible (Divisible ((>*<)))
@@ -24,7 +24,7 @@
 instance Determinable Predicate where
 	determine = Predicate (True !)
 
-equate :: Setoid a => a |-> Predicate
+equate :: Setoid a => a :=> Predicate
 equate x = Predicate (== x)
 
 satisfy :: (Pointable t, Avoidable t) => Predicate a -> a -> t a
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,6 @@
 module Pandora.Paradigm.Primary.Functor.Tagged where
 
-import Pandora.Core.Functor (type (|->), type (~>))
+import Pandora.Core.Functor (type (:=>), type (~>))
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
@@ -91,5 +91,5 @@
 retag :: forall new old . Tagged old ~> Tagged new
 retag (Tag x) = Tag x
 
-tagself :: a |-> Tagged a
+tagself :: a :=> Tagged a
 tagself = Tag
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,6 +1,6 @@
 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.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
@@ -70,7 +70,7 @@
 deconstruct ~(Construct _ xs) = xs
 
 -- Generate a construction from seed using effectful computation
-(.-+) :: Covariant t => a |-> t -> a |-> Construction t
+(.-+) :: Covariant t => a :=> t -> a :=> Construction t
 f .-+ x = Construct x $ (f .-+) <$> f x
 
 section :: Comonad t => t ~> Construction t
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,36 +1,23 @@
 module Pandora.Paradigm.Schemes.T_U where
 
-import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
-newtype T_U ct cu t u a = T_U (t a :*: u a)
+newtype T_U ct cu t p u a = T_U (p (t a) (u a))
 
-type (<:*:>) = T_U Covariant Covariant
-type (>:*:>) = T_U Contravariant Covariant
-type (<:*:<) = T_U Covariant Contravariant
-type (>:*:<) = T_U Contravariant Contravariant
+type (<:.:>) p t = T_U Covariant Covariant t p t
+type (>:.:>) p t = T_U Contravariant Covariant t p t
+type (<:.:<) p t = T_U Covariant Contravariant t p t
+type (>:.:<) p t = T_U Contravariant Contravariant t p t
 
-instance Interpreted (T_U ct cu t u) where
-	type Primary (T_U ct cu t u) a = t a :*: u a
+instance Interpreted (T_U ct cu t p u) where
+	type Primary (T_U ct cu t p u) a = p (t a) (u a)
 	run ~(T_U x) = x
 	unite = T_U
 
-instance Avoidable t => Liftable (T_U Covariant Covariant t) where
-	lift :: Covariant u => u ~> t <:*:> u
-	lift x = T_U $ empty :*: x
-
-instance Lowerable (T_U Covariant Covariant t) where
-	lower :: t <:*:> u ~> u
-	lower ~(T_U (_ :*: y)) = y
-
-instance Covariant t => Hoistable (T_U Covariant Covariant t) where
-	hoist :: u ~> v -> (t <:*:> u ~> t <:*:> v)
-	hoist f (T_U (x :*: y)) = T_U $ x :*: f y
+instance (Bivariant p, Covariant t, Covariant u)
+	=> Covariant (T_U Covariant Covariant t p u) where
+		f <$> (T_U x) = T_U $ (f <$>) <-> (f <$>) $ x
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,36 +1,10 @@
 module Pandora.Paradigm.Schemes.U_T where
 
-import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category (($))
-import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Contravariant (Contravariant)
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
-import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
 
-newtype U_T ct cu t u a = U_T (u a :*: t a)
-
-type (<.:.>) = U_T Covariant Covariant
-type (>.:.>) = U_T Contravariant Covariant
-type (<.:.<) = U_T Covariant Contravariant
-type (>.:.<) = U_T Contravariant Contravariant
+newtype U_T ct cu t p u a = U_T (p (u a) (t a))
 
-instance Interpreted (U_T ct cu t u) where
-	type Primary (U_T ct cu t u) a = u a :*: t a
+instance Interpreted (U_T ct cu t p u) where
+	type Primary (U_T ct cu t p u) a = p (u a) (t a)
 	run ~(U_T x) = x
 	unite = U_T
-
-instance Avoidable t => Liftable (U_T Covariant Covariant t) where
-	lift :: Covariant u => u ~> t <.:.> u
-	lift x = U_T $ x :*: empty
-
-instance Lowerable (U_T Covariant Covariant t) where
-	lower :: t <.:.> u ~> u
-	lower (U_T (x :*: _)) = x
-
-instance Covariant t => Hoistable (U_T Covariant Covariant t) where
-	hoist :: u ~> v -> (t <.:.> u ~> t <.:.> v)
-	hoist f (U_T (x :*: y)) = U_T $ f x :*: y
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -10,16 +10,24 @@
 import Pandora.Paradigm.Structure.Stack as Exports
 import Pandora.Paradigm.Structure.Stream as Exports
 
-import Pandora.Pattern (($), (.), extract)
+import Pandora.Pattern.Category (($), (.))
+import Pandora.Pattern.Functor.Covariant (Covariant (comap))
+import Pandora.Pattern.Functor.Extractable (extract)
+import Pandora.Pattern.Functor.Pointable (point)
+import Pandora.Pattern.Transformer.Liftable (lift)
+import Pandora.Pattern.Object.Semigroup ((+))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite)
+import Pandora.Paradigm.Inventory.Optics ((|>))
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
-import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))
-import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
+-- import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))
+import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
 import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
+import Pandora.Paradigm.Primary.Functor.Wye (Wye (Both, Left, Right, End))
+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
 import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap))
 import Pandora.Paradigm.Schemes.TU (type (<:.>))
 
@@ -29,30 +37,74 @@
 instance Nullable Maybe where
 	null = Predicate $ \case { Just _ -> True ; _ -> False }
 
-instance Substructure Left (Product s) a where
-	type Substructural Left (Product s) a = s
-	substructure (extract -> s :*: x) = Store $ s :*: Tag . (:*: x)
+instance Substructure Right (Product s) where
+	type Substructural Right (Product s) = Identity
+	substructure (extract . run -> s :*: x) =
+		Store $ Identity x :*: lift . (s :*:) . extract
 
-instance Substructure Right (Product s) a where
-	type Substructural Right (Product s) a = a
-	substructure (extract -> s :*: x) = Store $ x :*: Tag . (s :*:)
+-- instance Substructure Left Delta where
+-- 	type Substructural Left Delta = Identity
+-- 	substructure (extract . run -> l :^: r) =
+-- 		Store $ Identity l :*: lift . (:^: r) . extract
+--
+-- instance Substructure Right Delta where
+-- 	type Substructural Right Delta = Identity
+-- 	substructure (extract . run -> l :^: r) =
+-- 		Store $ Identity r :*: lift . (l :^:) . extract
+--
+-- instance Covariant t => Substructure Left (Delta <:.> t) where
+-- 	type Substructural Left (Delta <:.> t) = t
+-- 	substructure (run . extract . run -> l :^: r) =
+-- 		Store $ r :*: lift . unite . (l :^:)
+--
+-- instance Covariant t => Substructure Right (Delta <:.> t) where
+-- 	type Substructural Right (Delta <:.> t) = t
+-- 	substructure (run . extract . run -> l :^: r) =
+-- 		Store $ l :*: lift . unite . (:^: r)
 
-instance Substructure Left Delta a where
-	type Substructural Left Delta a = a
-	substructure (extract -> l :^: r) = Store $ l :*: Tag . (:^: r)
+instance Covariant t => Substructure Tail (Tap t) where
+	type Substructural Tail (Tap t) = t
+	substructure (extract . run -> Tap x xs) =
+		Store $ xs :*: lift . Tap x
 
-instance Substructure Right Delta a where
-	type Substructural Right Delta a = a
-	substructure (extract -> l :^: r) = Store $ r :*: Tag . (l :^:)
+instance Morphable Preorder (Construction Wye) where
+	type Morphing Preorder (Construction Wye) = Construction Maybe
+	morphing (extract . run -> Construct x End) = Construct x Nothing
+	morphing (extract . run -> Construct x (Left lst)) = Construct x . Just $ morph @Preorder lst
+	morphing (extract . run -> Construct x (Right rst)) = Construct x . Just $ morph @Preorder rst
+	morphing (extract . run -> Construct x (Both lst rst)) = Construct x . Just $ morph @Preorder lst + morph @Preorder rst
 
-instance Substructure Left (Delta <:.> t) a where
-	type Substructural Left (Delta <:.> t) a = t a
-	substructure (run . extract -> l :^: r) = Store $ r :*: Tag . unite . (l :^:)
+instance Morphable Inorder (Construction Wye) where
+	type Morphing Inorder (Construction Wye) = Construction Maybe
+	morphing (extract . run -> Construct x End) = point x
+	morphing (extract . run -> Construct x (Left lst)) = morph @Inorder lst + point x
+	morphing (extract . run -> Construct x (Right rst)) = point x + morph @Inorder rst
+	morphing (extract . run -> Construct x (Both lst rst)) = morph @Inorder lst + point x + morph @Inorder rst
 
-instance Substructure Right (Delta <:.> t) a where
-	type Substructural Right (Delta <:.> t) a = t a
-	substructure (run . extract -> l :^: r) = Store $ l :*: Tag . unite . (:^: r)
+instance Morphable Postorder (Construction Wye) where
+	type Morphing Postorder (Construction Wye) = Construction Maybe
+	morphing (extract . run -> Construct x End) = point x
+	morphing (extract . run -> Construct x (Left lst)) = morph @Postorder lst + point x
+	morphing (extract . run -> Construct x (Right rst)) = morph @Postorder rst + point x
+	morphing (extract . run -> Construct x (Both lst rst)) = morph @Postorder lst + morph @Postorder rst + point x
 
-instance Substructure Tail (Tap t) a where
-	type Substructural Tail (Tap t) a = t a
-	substructure (extract -> Tap x xs) = Store $ xs :*: Tag . Tap x
+instance Morphable o (Construction Wye) => Morphable o Binary where
+	type Morphing o Binary = Maybe <:.> Morphing o (Construction Wye)
+	morphing = unite . comap (morph @o) . run . extract . run
+
+instance Focusable Left (Product s) where
+	type Focusing Left (Product s) a = s
+	focusing (extract -> s :*: x) = Store $ s :*: Tag . (:*: x)
+
+instance Focusable Right (Product s) where
+	type Focusing Right (Product s) a = a
+	focusing (extract -> s :*: x) = Store $ x :*: Tag . (s :*:)
+
+instance Accessible s (s :*: a) where
+	access ~(s :*: x) = Store $ s :*: (:*: x)
+
+instance Accessible a (s :*: a) where
+	access ~(s :*: x) = Store $ x :*: (s :*:)
+
+instance {-# OVERLAPS #-} Accessible b a => Accessible b (s :*: a) where
+	access = access @a |> access @b
diff --git a/Pandora/Paradigm/Structure/Ability.hs b/Pandora/Paradigm/Structure/Ability.hs
--- a/Pandora/Paradigm/Structure/Ability.hs
+++ b/Pandora/Paradigm/Structure/Ability.hs
@@ -3,11 +3,12 @@
 import Pandora.Paradigm.Structure.Ability.Monotonic as Exports
 import Pandora.Paradigm.Structure.Ability.Zipper as Exports
 import Pandora.Paradigm.Structure.Ability.Substructure as Exports
-import Pandora.Paradigm.Structure.Ability.Rotatable as Exports
 import Pandora.Paradigm.Structure.Ability.Insertable as Exports
 import Pandora.Paradigm.Structure.Ability.Measurable as Exports
 import Pandora.Paradigm.Structure.Ability.Focusable as Exports
-import Pandora.Paradigm.Structure.Ability.Convertible as Exports
+import Pandora.Paradigm.Structure.Ability.Deletable as Exports
+import Pandora.Paradigm.Structure.Ability.Morphable as Exports
+import Pandora.Paradigm.Structure.Ability.Accessible as Exports
 import Pandora.Paradigm.Structure.Ability.Nullable as Exports
 import Pandora.Paradigm.Structure.Ability.Nonempty as Exports
 import Pandora.Paradigm.Structure.Ability.Comprehension as Exports
diff --git a/Pandora/Paradigm/Structure/Ability/Accessible.hs b/Pandora/Paradigm/Structure/Ability/Accessible.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Ability/Accessible.hs
@@ -0,0 +1,6 @@
+module Pandora.Paradigm.Structure.Ability.Accessible where
+
+import Pandora.Paradigm.Inventory.Optics (type (:-.))
+
+class Accessible tgt src where
+	access :: src :-. tgt
diff --git a/Pandora/Paradigm/Structure/Ability/Convertible.hs b/Pandora/Paradigm/Structure/Ability/Convertible.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Ability/Convertible.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# LANGUAGE AllowAmbiguousTypes #-}
-
-module Pandora.Paradigm.Structure.Ability.Convertible where
-
-import Pandora.Pattern.Category ((.))
-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
-
-class Convertible f t u a where
-	conversion :: Tagged f (t a) -> u a
-
-convert :: forall f t u a . Convertible f t u a => t a -> u a
-convert = conversion . Tag @f
diff --git a/Pandora/Paradigm/Structure/Ability/Deletable.hs b/Pandora/Paradigm/Structure/Ability/Deletable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Ability/Deletable.hs
@@ -0,0 +1,6 @@
+module Pandora.Paradigm.Structure.Ability.Deletable where
+
+import Pandora.Pattern.Object.Setoid (Setoid)
+
+class Deletable t where
+	delete :: Setoid a => a -> t a -> t a
diff --git a/Pandora/Paradigm/Structure/Ability/Morphable.hs b/Pandora/Paradigm/Structure/Ability/Morphable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Ability/Morphable.hs
@@ -0,0 +1,19 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+
+module Pandora.Paradigm.Structure.Ability.Morphable where
+
+import Pandora.Core.Functor (type (~>))
+import Pandora.Pattern.Category ((.))
+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+
+class Morphable f t where
+	type Morphing (f :: k) (t :: * -> *) :: * -> *
+	morphing :: Tagged f <:.> t ~> Morphing f t
+
+morph :: forall f t . Morphable f t => t ~> Morphing f t
+morph = morphing . TU . Tag @f
+
+data Walk a = Preorder a | Inorder a | Postorder a | Levelorder a
+
+data Morph a = Rotate a
diff --git a/Pandora/Paradigm/Structure/Ability/Rotatable.hs b/Pandora/Paradigm/Structure/Ability/Rotatable.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Ability/Rotatable.hs
+++ /dev/null
@@ -1,13 +0,0 @@
-{-# LANGUAGE AllowAmbiguousTypes #-}
-
-module Pandora.Paradigm.Structure.Ability.Rotatable where
-
-import Pandora.Pattern.Category ((.))
-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
-
-class Rotatable f t where
-	type Rotational (f :: k) (t :: * -> *) a
-	rotation :: Tagged f (t a) -> Rotational f t a
-
-rotate :: forall f t a . Rotatable f t => t a -> Rotational f t a
-rotate = rotation . Tag @f
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,18 +2,30 @@
 
 module Pandora.Paradigm.Structure.Ability.Substructure where
 
+import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (comap)
 import Pandora.Pattern.Functor.Extractable (extract)
-import Pandora.Paradigm.Inventory.Optics (type (:-.))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Inventory.Optics (type (:~.), view, over, set)
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 
-class Substructure f t a where
-	type Substructural (f :: k) (t :: * -> *) a
-	substructure :: Tagged f (t a) :-. Substructural f t a
+class Substructure f t where
+	type Substructural (f :: k) (t :: * -> *) :: * -> *
+	substructure :: Tagged f <:.> t :~. Substructural f t
 
-sub :: forall f t a . Substructure f t a => t a :-. Substructural f t a
-sub = comap extract . substructure . Tag @f
+	sub :: t :~. Substructural f t
+	sub = comap (extract . run) . substructure . TU . Tag @f
+
+	subview :: t ~> Substructural f t
+	subview = view (sub @f)
+
+	substitute :: (Substructural f t a -> Substructural f t a) -> t a -> t a
+	substitute = over (sub @f)
+
+	subplace :: (Substructural f t) a -> t a -> t a
+	subplace = set (sub @f)
 
 data Command a = Delete a
 
diff --git a/Pandora/Paradigm/Structure/Binary.hs b/Pandora/Paradigm/Structure/Binary.hs
--- a/Pandora/Paradigm/Structure/Binary.hs
+++ b/Pandora/Paradigm/Structure/Binary.hs
@@ -19,23 +19,23 @@
 import Pandora.Paradigm.Primary.Functor.Function ((!), (%), (&))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), attached)
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both))
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
-import Pandora.Paradigm.Schemes (TU (TU), T_ (T_), T_U (T_U), type (<:.>), type (<:*:>))
+import Pandora.Paradigm.Schemes (TU (TU), T_ (T_), T_U (T_U), type (<:.>))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Inventory.State (State, modify)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
-import Pandora.Paradigm.Inventory.Optics (type (:-.), (|>), (%~))
+import Pandora.Paradigm.Inventory.Optics (over)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null))
 import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Root))
 import Pandora.Paradigm.Structure.Ability.Measurable (Measurable (Measural, measurement), Scale (Heighth), measure)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (resolve))
 import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert))
-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (Rotational, rotation))
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), sub)
+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing))
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), sub, substitute)
 import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)
 
 type Binary = Maybe <:.> Construction Wye
@@ -49,7 +49,7 @@
 instance (forall a . Chain a) => Insertable Binary where
 	insert x (run -> Nothing) = lift . Construct x $ End
 	insert x tree@(run -> Just nonempty) = x <=> extract nonempty & order
-		(sub @Left %~ insert x $ tree) tree (sub @Right %~ insert x $ tree)
+		(tree & substitute @Left (insert x) ) tree (tree & substitute @Right (insert x))
 
 instance (forall a . Chain a) => Focusable Root Binary where
 	type Focusing Root Binary a = Maybe a
@@ -64,18 +64,15 @@
 instance Nullable Binary where
 	null = Predicate $ \case { TU Nothing -> True ; _ -> False }
 
-instance Substructure Left Binary a where
-	type Substructural Left Binary a = Binary a
-	substructure empty_tree@(run . extract -> Nothing) = Store $ extract empty_tree :*: (!) empty_tree
-	substructure (run . extract -> Just tree) = Tag . lift <$> (sub @Left |> can_be_empty) tree
-
-instance Substructure Right Binary a where
-	type Substructural Right Binary a = Binary a
-	substructure empty_tree@(run . extract -> Nothing) = Store $ extract empty_tree :*: (!) empty_tree
-	substructure (run . extract -> Just tree) = Tag . lift <$> (sub @Right |> can_be_empty) tree
+instance Substructure Left Binary where
+	type Substructural Left Binary = Binary
+	substructure empty_tree@(run . extract . run -> Nothing) = Store $ extract (run empty_tree) :*: (!) empty_tree
+	substructure (run . extract . run -> Just tree) = lift . lift <$> sub @Left tree
 
-can_be_empty :: Maybe (Construction Wye a) :-. Binary a
-can_be_empty maybe_tree = Store $ TU maybe_tree :*: run
+instance Substructure Right Binary where
+	type Substructural Right Binary = Binary
+	substructure empty_tree@(run . extract . run -> Nothing) = Store $ extract (run empty_tree) :*: (!) empty_tree
+	substructure (run . extract . run -> Just tree) = lift . lift <$> sub @Right tree
 
 binary :: forall t a . (Traversable t, Chain a) => t a -> Binary a
 binary struct = attached $ run @(State (Binary a)) % empty $ struct ->> modify @(Binary a) . insert' where
@@ -83,7 +80,7 @@
 	insert' :: a -> Binary a -> Binary a
 	insert' x (run -> Nothing) = lift . Construct x $ End
 	insert' x tree@(run -> Just nonempty) = x <=> extract nonempty & order
-		(sub @Left %~ insert' x $ tree) tree (sub @Right %~ insert' x $ tree)
+		(tree & substitute @Left (insert' x)) tree (tree & substitute @Right (insert' x))
 
 type instance Nonempty Binary = Construction Wye
 
@@ -92,8 +89,8 @@
 	focusing (extract -> Construct x xs) = Store $ x :*: Tag . Construct % xs
 
 instance (forall a . Chain a) => Insertable (Construction Wye) where
-	insert x nonempty = let change = Just . resolve (insert x) (Construct x End) in
-		x <=> extract nonempty & order (sub @Left %~ change $ nonempty) nonempty (sub @Right %~ change $ nonempty)
+	insert x b = let change = lift . resolve (insert x) (Construct x End) . run in
+		x <=> extract b & order (over (sub @Left) change $ b) b (over (sub @Right) change $ b)
 
 instance Measurable Heighth (Construction Wye) where
 	type Measural Heighth (Construction Wye) a = Denumerator
@@ -104,51 +101,62 @@
 		let (lm :*: rm) = measure @Heighth lst :*: measure @Heighth rst
 		in lm <=> rm & order rm lm lm
 
-instance Substructure Left (Construction Wye) a where
-	type Substructural Left (Construction Wye) a = Maybe :. Construction Wye := a
-	substructure empty_tree@(extract -> Construct _ End) = Store $ Nothing :*: (empty_tree !)
-	substructure (extract -> Construct x (Left lst)) = Store $ Just lst :*: Tag . Construct x . resolve Left End
-	substructure (extract -> Construct x (Right rst)) = Store $ Nothing :*: Tag . Construct x . resolve (Both % rst) (Right rst)
-	substructure (extract -> Construct x (Both lst rst)) = Store $ Just lst :*: Tag . Construct x . resolve (Both % rst) (Right rst)
+instance Substructure Left (Construction Wye) where
+	type Substructural Left (Construction Wye) = Binary
+	substructure empty_tree@(extract . run -> Construct _ End) =
+		Store $ TU Nothing :*: (empty_tree !)
+	substructure (extract . run -> Construct x (Left lst)) =
+		Store $ lift lst :*: lift . Construct x . resolve Left End . run
+	substructure (extract . run -> Construct x (Right rst)) =
+		Store $ empty :*: lift . Construct x . resolve (Both % rst) (Right rst) . run
+	substructure (extract . run -> Construct x (Both lst rst)) =
+		Store $ lift lst :*: lift . Construct x . resolve (Both % rst) (Right rst) . run
 
-instance Substructure Right (Construction Wye) a where
-	type Substructural Right (Construction Wye) a = Maybe :. Construction Wye := a
-	substructure emtpy_tree@(extract -> Construct _ End) = Store $ Nothing :*: (emtpy_tree !)
-	substructure (extract -> Construct x (Left lst)) = Store $ Nothing :*: Tag . Construct x . resolve (Both lst) (Left lst)
-	substructure (extract -> Construct x (Right rst)) = Store $ Just rst :*: Tag . Construct x . resolve Right End
-	substructure (extract -> Construct x (Both lst rst)) = Store $ Just rst :*: Tag . Construct x . resolve (Both lst) (Left lst)
+instance Substructure Right (Construction Wye) where
+	type Substructural Right (Construction Wye) = Binary
+	substructure emtpy_tree@(extract . run -> Construct _ End) =
+		Store $ empty :*: (emtpy_tree !)
+	substructure (extract . run -> Construct x (Left lst)) =
+		Store $ empty :*: lift . Construct x . resolve (Both lst) (Left lst) . run
+	substructure (extract . run -> Construct x (Right rst)) =
+		Store $ lift rst :*: lift . Construct x . resolve Right End . run
+	substructure (extract . run -> Construct x (Both lst rst)) =
+		 Store $ lift rst :*: lift . Construct x . resolve (Both lst) (Left lst) . run
 
 data Biforked a = Top | Leftward a | Rightward a
 
-type instance Zipper (Construction Wye) = Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))
+type instance Zipper (Construction Wye) = T_U Covariant Covariant (Construction Wye) (:*:)
+	((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))
 
 data Vertical a = Up a | Down a
 
-instance Rotatable Up (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where
-	type Rotational Up (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) a
-		= Maybe :. (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) := a
-	rotation (run . extract -> focused :*: TU (TU (Leftward (Construct (T_ (parent :*: TU (Just rst))) next)))) =
-		Just . T_U $ Construct parent (Both focused rst) :*: TU (TU next)
-	rotation (run . extract -> focused :*: TU (TU (Leftward (Construct (T_ (parent :*: TU Nothing)) next)))) =
-		Just . T_U $ Construct parent (Left focused) :*: TU (TU next)
-	rotation (run . extract -> focused :*: TU (TU (Rightward (Construct (T_ (parent :*: TU (Just lst))) next)))) =
-		Just . T_U $ Construct parent (Both lst focused) :*: TU (TU next)
-	rotation (run . extract -> focused :*: TU (TU (Rightward (Construct (T_ (parent :*: TU Nothing)) next)))) =
-		Just . T_U $ Construct parent (Right focused) :*: TU (TU next)
-	rotation (extract -> T_U (_ :*: TU (TU Top))) = Nothing
+instance Morphable Up (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where
+	type Morphing Up (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))
+		= Maybe <:.> (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))
+	morphing (run . extract . run -> focused :*: TU (TU (Leftward (Construct (T_ (parent :*: TU (Just rst))) next)))) =
+		TU . Just . T_U $ Construct parent (Both focused rst) :*: TU (TU next)
+	morphing (run . extract . run -> focused :*: TU (TU (Leftward (Construct (T_ (parent :*: TU Nothing)) next)))) =
+		TU . Just . T_U $ Construct parent (Left focused) :*: TU (TU next)
+	morphing (run . extract . run -> focused :*: TU (TU (Rightward (Construct (T_ (parent :*: TU (Just lst))) next)))) =
+		TU . Just . T_U $ Construct parent (Both lst focused) :*: TU (TU next)
+	morphing (run . extract . run -> focused :*: TU (TU (Rightward (Construct (T_ (parent :*: TU Nothing)) next)))) =
+		TU . Just . T_U $ Construct parent (Right focused) :*: TU (TU next)
+	morphing (extract . run -> T_U (_ :*: TU (TU Top))) = TU Nothing
 
-instance Rotatable (Down Left) (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where
-	type Rotational (Down Left) (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) a
-		= Maybe :. (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) := a
-	rotation (run . extract -> Construct x (Left lst) :*: TU (TU next)) = Just . T_U . (:*:) lst . TU . TU . Leftward . Construct (T_ $ x :*: TU Nothing) $ next
-	rotation (run . extract -> Construct x (Both lst rst) :*: TU (TU next)) = Just . T_U . (:*:) lst . TU . TU . Leftward . Construct (T_ $ x :*: TU (Just rst)) $ next
-	rotation (run . extract -> Construct _ (Right _) :*: _) = Nothing
-	rotation (run . extract -> Construct _ End :*: _) = Nothing
+instance Morphable (Down Left) (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where
+	type Morphing (Down Left) (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))
+		= Maybe <:.> (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))
+	morphing (run . extract . run -> Construct x (Left lst) :*: TU (TU next)) =
+		TU . Just . T_U . (:*:) lst . TU . TU . Leftward . Construct (T_ $ x :*: TU Nothing) $ next
+	morphing (run . extract . run -> Construct x (Both lst rst) :*: TU (TU next)) =
+		TU . Just . T_U . (:*:) lst . TU . TU . Leftward . Construct (T_ $ x :*: TU (Just rst)) $ next
+	morphing (run . extract . run -> Construct _ (Right _) :*: _) = TU Nothing
+	morphing (run . extract . run -> Construct _ End :*: _) = TU Nothing
 
-instance Rotatable (Down Right) (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where
-	type Rotational (Down Right) (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) a
-		= Maybe :. (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) := a
-	rotation (run . extract -> Construct x (Right rst) :*: TU (TU next)) = Just . T_U . (:*:) rst . TU . TU . Rightward . Construct (T_ $ x :*: TU Nothing) $ next
-	rotation (run . extract -> Construct x (Both lst rst) :*: TU (TU next)) = Just . T_U . (:*:) rst . TU . TU . Rightward . Construct (T_ $ x :*: TU (Just lst)) $ next
-	rotation (run . extract -> Construct _ (Left _) :*: _) = Nothing
-	rotation (run . extract -> Construct _ End :*: _) = Nothing
+instance Morphable (Down Right) (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where
+	type Morphing (Down Right) (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))
+		= Maybe <:.> (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))
+	morphing (run . extract . run -> Construct x (Right rst) :*: TU (TU next)) = TU . Just . T_U . (:*:) rst . TU . TU . Rightward . Construct (T_ $ x :*: TU Nothing) $ next
+	morphing (run . extract . run -> Construct x (Both lst rst) :*: TU (TU next)) = TU . Just . T_U . (:*:) rst . TU . TU . Rightward . Construct (T_ $ x :*: TU (Just lst)) $ next
+	morphing (run . extract . run -> Construct _ (Left _) :*: _) = TU Nothing
+	morphing (run . extract . run -> Construct _ End :*: _) = TU Nothing
diff --git a/Pandora/Paradigm/Structure/Rose.hs b/Pandora/Paradigm/Structure/Rose.hs
--- a/Pandora/Paradigm/Structure/Rose.hs
+++ b/Pandora/Paradigm/Structure/Rose.hs
@@ -2,7 +2,6 @@
 
 module Pandora.Paradigm.Structure.Rose where
 
-import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant (comap))
 import Pandora.Pattern.Functor.Extractable (extract)
@@ -31,15 +30,17 @@
 	type Focusing Root Rose a = Maybe a
 	focusing (run . extract -> Nothing) = Store $ Nothing :*: Tag . TU . comap (Construct % empty)
 	focusing (run . extract -> Just rose) = Store $ Just (extract rose)
-		:*: Tag . resolve (lift . Construct % deconstruct rose) (TU Nothing)
+		:*: Tag . resolve (lift . Construct % deconstruct rose) empty
 
 instance Nullable Rose where
 	null = Predicate $ \case { TU Nothing -> True ; _ -> False }
 
-instance Substructure Just Rose a where
-	type Substructural Just Rose a = Stack :. Construction Stack := a
-	substructure (run . extract -> Nothing) = Store $ TU Nothing :*: (Tag (TU Nothing) !)
-	substructure (run . extract -> Just (Construct x xs)) = Store $ xs :*: Tag . lift . Construct x
+instance Substructure Just Rose where
+	type Substructural Just Rose = Stack <:.> Construction Stack
+	substructure (run . extract . run -> Nothing) =
+		Store $ empty :*: (lift empty !)
+	substructure (run . extract . run -> Just (Construct x xs)) =
+		Store $ TU xs :*: lift . lift . Construct x . run
 
 type instance Nonempty Rose = Construction Stack
 
@@ -47,6 +48,6 @@
 	type Focusing Root (Construction Stack) a = a
 	focusing (Tag rose) = Store $ extract rose :*: Tag . Construct % deconstruct rose
 
-instance Substructure Just (Construction Stack) a where
-	type Substructural Just (Construction Stack) a = Stack :. Construction Stack := a
-	substructure (extract -> Construct x xs) = Store $ xs :*: Tag . Construct x
+instance Substructure Just (Construction Stack) where
+	type Substructural Just (Construction Stack) = Stack <:.> Construction Stack
+	substructure (extract . run -> Construct x xs) = Store $ TU xs :*: lift . Construct x . run
diff --git a/Pandora/Paradigm/Structure/Splay.hs b/Pandora/Paradigm/Structure/Splay.hs
--- a/Pandora/Paradigm/Structure/Splay.hs
+++ b/Pandora/Paradigm/Structure/Splay.hs
@@ -1,8 +1,8 @@
 {-# LANGUAGE UndecidableInstances #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
 
 module Pandora.Paradigm.Structure.Splay where
 
-import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Category ((.), ($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Extractable (extract)
@@ -11,54 +11,41 @@
 import Pandora.Paradigm.Primary.Functor.Function ((%))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag), type (:#))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
-import Pandora.Paradigm.Inventory.Optics ((%~))
-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (Rotational, rotation), rotate)
-import Pandora.Paradigm.Structure.Ability.Substructure (sub)
-import Pandora.Paradigm.Structure.Binary ()
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (||=))
+import Pandora.Paradigm.Schemes (TU (TU))
+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), morph)
+import Pandora.Paradigm.Structure.Ability.Substructure (substitute)
+import Pandora.Paradigm.Structure.Binary (Binary)
 
 data Splay a = Zig a | Zag a
 
-instance Rotatable (Left Zig) (Construction Wye) where
-	type Rotational (Left Zig) (Construction Wye) a = Maybe (Construction Wye a)
-	rotation :: forall a . Left Zig :# Construction Wye a -> Maybe :. Construction Wye := a
-	rotation (extract -> Construct parent st) = Construct % subtree <$> found where
-
-		found :: Maybe a
-		found = extract <$> left st
-
-		subtree :: Wye :. Construction Wye := a
-		subtree = branches (deconstruct <$> left st >>= left)
-			. Just . Construct parent $ branches
-				(deconstruct <$> left st >>= right) (right st)
+instance Morphable (Left Zig) (Construction Wye) where
+	type Morphing (Left Zig) (Construction Wye) = Binary
+	morphing (extract . run -> Construct parent st) = TU $ Construct % subtree . extract <$> left st where
 
-instance Rotatable (Right Zig) (Construction Wye) where
-	type Rotational (Right Zig) (Construction Wye) a = Maybe (Construction Wye a)
-	rotation :: forall a . Right Zig :# Construction Wye a -> Maybe :. Construction Wye := a
-	rotation (extract -> Construct parent st) = Construct % subtree <$> found where
+		subtree = branches (deconstruct <$> left st >>= left) . Just . Construct parent
+			$ branches (deconstruct <$> left st >>= right) (right st)
 
-		found :: Maybe a
-		found = extract <$> right st
+instance Morphable (Right Zig) (Construction Wye) where
+	type Morphing (Right Zig) (Construction Wye) = Binary
+	morphing (extract . run -> Construct parent st) = TU $ Construct % subtree . extract <$> right st where
 
-		subtree :: Wye :. Construction Wye := a
-		subtree = branches (left st)
-			. Just . Construct parent $ branches
-				(deconstruct <$> right st >>= left)
-				(deconstruct <$> right st >>= right)
+		subtree = branches (left st) . Just . Construct parent
+			$ branches (deconstruct <$> right st >>= left) (deconstruct <$> right st >>= right)
 
-instance Rotatable (Left (Zig Zig)) (Construction Wye) where
-	type Rotational (Left (Zig Zig)) (Construction Wye) a = Maybe (Construction Wye a)
-	rotation (Tag tree) = rotate @(Left Zig) tree >>= rotate @(Left Zig)
+instance Morphable (Left (Zig Zig)) (Construction Wye) where
+	type Morphing (Left (Zig Zig)) (Construction Wye) = Binary
+	morphing (extract . run -> tree) = TU $ run (morph @(Left Zig) tree) >>= run . morph @(Left Zig)
 
-instance Rotatable (Right (Zig Zig)) (Construction Wye) where
-	type Rotational (Right (Zig Zig)) (Construction Wye) a = Maybe (Construction Wye a)
-	rotation (Tag tree) = rotate @(Right Zig) tree >>= rotate @(Right Zig)
+instance Morphable (Right (Zig Zig)) (Construction Wye) where
+	type Morphing (Right (Zig Zig)) (Construction Wye) = Binary
+	morphing (extract . run -> tree) = TU $ run (morph @(Right Zig) tree) >>= run . morph @(Right Zig)
 
-instance Rotatable (Left (Zig Zag)) (Construction Wye) where
-	type Rotational (Left (Zig Zag)) (Construction Wye) a = Maybe (Construction Wye a)
-	rotation (Tag tree) = rotate @(Left Zig) $ sub @Left %~ (>>= rotate @(Right Zig)) $ tree
+instance Morphable (Left (Zig Zag)) (Construction Wye) where
+	type Morphing (Left (Zig Zag)) (Construction Wye) = Binary
+	morphing = morph @(Left Zig) . substitute @Left ((>>= run . morph @(Right Zig)) ||=) . extract . run
 
-instance Rotatable (Right (Zig Zag)) (Construction Wye) where
-	type Rotational (Right (Zig Zag)) (Construction Wye) a = Maybe (Construction Wye a)
-	rotation (Tag tree) = rotate @(Right Zig) $ sub @Right %~ (>>= rotate @(Left Zig)) $ tree
+instance Morphable (Right (Zig Zag)) (Construction Wye) where
+	type Morphing (Right (Zig Zag)) (Construction Wye) = Binary
+	morphing = morph @(Right Zig) . substitute @Right ((>>= run . morph @(Left Zig)) ||=) . extract . run
diff --git a/Pandora/Paradigm/Structure/Stack.hs b/Pandora/Paradigm/Structure/Stack.hs
--- a/Pandora/Paradigm/Structure/Stack.hs
+++ b/Pandora/Paradigm/Structure/Stack.hs
@@ -2,16 +2,16 @@
 
 module Pandora.Paradigm.Structure.Stack where
 
-import Pandora.Core.Functor (type (:.), type (:=), type (|->))
+import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern ((.|..))
 import Pandora.Pattern.Category ((.), ($), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Alternative ((<+>))
 import Pandora.Pattern.Functor.Pointable (point)
 import Pandora.Pattern.Functor.Extractable (extract)
+import Pandora.Pattern.Functor.Avoidable (empty)
 import Pandora.Pattern.Functor.Traversable (Traversable)
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Pattern.Functor.Bindable (Bindable (join))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
@@ -19,29 +19,30 @@
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?))
 import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Numerator))
 import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (One))
-import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))
-import Pandora.Paradigm.Primary.Functor.Function ((!), (%), (&))
+import Pandora.Paradigm.Primary.Functor.Function ((%), (&))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
 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.Tap (Tap (Tap))
 import Pandora.Paradigm.Inventory.State (State, fold)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
-import Pandora.Paradigm.Inventory.Optics (view, (^.))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite)
+import Pandora.Paradigm.Inventory.Optics (view)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
 import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null))
 import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)
 import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Head), focus)
+import Pandora.Paradigm.Structure.Ability.Deletable (Deletable (delete))
 import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert))
 import Pandora.Paradigm.Structure.Ability.Measurable (Measurable (Measural, measurement), Scale (Length), measure)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (Rotational, rotation), rotate)
-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), Command (Delete), Segment (All, First, Tail), sub)
+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate), morph)
+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), Segment (Tail), sub, subview)
 
 -- | Linear data structure that serves as a collection of elements
 type Stack = Maybe <:.> Construction Maybe
@@ -55,16 +56,16 @@
 		$ TU @Covariant @Covariant xs + TU @Covariant @Covariant ys
 
 instance Monoid (Stack a) where
-	zero = TU Nothing
+	zero = empty
 
 instance Focusable Head Stack where
 	type Focusing Head Stack a = Maybe a
 	focusing (extract -> stack) = Store $ extract <$> run stack :*: \case
-		Just x -> stack & view (sub @Tail) & insert x & Tag
-		Nothing -> Tag $ sub @Tail ^. stack
+		Just x -> stack & subview @Tail & insert x & Tag
+		Nothing -> stack & subview @Tail & Tag
 
 instance Insertable Stack where
-	insert x (run -> stack) = unite $ (Construct x . Just <$> stack) <+> (point . point) x
+	insert x (run -> stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x
 
 instance Measurable Length Stack where
 	type Measural Length Stack a = Numerator
@@ -74,19 +75,15 @@
 instance Nullable Stack where
 	null = Predicate $ \case { TU Nothing -> True ; _ -> False }
 
-instance Substructure Tail Stack a where
-	type Substructural Tail Stack a = Stack a
-	substructure (run . extract -> Just ns) = point . unite . Just <$> sub @Tail ns
-	substructure (run . extract -> Nothing) = Store $ unite Nothing :*: point . identity
-
-instance Setoid a => Substructure (Delete First) Stack a where
-	type Substructural (Delete First) Stack a = a |-> Stack
-	substructure (extract -> xs) = Store $ delete % xs :*: (point xs !) where
+instance Substructure Tail Stack where
+	type Substructural Tail Stack = Stack
+	substructure (run . extract . run -> Just ns) = lift . lift <$> sub @Tail ns
+	substructure (run . extract . run -> Nothing) = Store $ empty :*: lift . identity
 
-		delete :: Setoid a => a -> Stack a -> Stack a
-		delete _ (TU Nothing) = TU Nothing
-		delete x (TU (Just (Construct y ys))) = x == y ? TU ys
-			$ lift . Construct y . run . delete x $ TU ys
+instance Deletable Stack where
+	delete _ (TU Nothing) = TU Nothing
+	delete x (TU (Just (Construct y ys))) = x == y ? TU ys
+		$ lift . Construct y . run . delete @Stack x $ TU ys
 
 filter :: forall a . Predicate a -> Stack a -> Stack a
 filter (Predicate p) = TU . extract
@@ -99,6 +96,14 @@
 
 type instance Nonempty Stack = Construction Maybe
 
+instance {-# OVERLAPS #-} Semigroup (Construction Maybe a) where
+	Construct x Nothing + ys = Construct x $ Just ys
+	Construct x (Just xs) + ys = Construct x . Just $ xs + ys
+
+instance Morphable Stack (Construction Maybe) where
+	type Morphing Stack (Construction Maybe) = Stack
+	morphing = lift . extract . run
+
 instance Focusable Head (Construction Maybe) where
 	type Focusing Head (Construction Maybe) a = a
 	focusing (extract -> stack) = Store $ extract stack :*: Tag . Construct % deconstruct stack
@@ -114,50 +119,38 @@
 instance Monotonic a (Construction Maybe a) where
 	reduce f r ~(Construct x xs) = f x $ reduce f r xs
 
-instance Substructure Tail (Construction Maybe) a where
-	type Substructural Tail (Construction Maybe) a = Stack a
-	substructure (extract -> Construct x xs) = Store $ unite xs :*: point . Construct x . run
-
-instance Setoid a => Substructure (Delete First) (Construction Maybe) a where
-	type Substructural (Delete First) (Construction Maybe) a = a |-> Stack
-	substructure (extract -> xs) = Store $ delete % xs :*: (point xs !) where
-
-		delete :: Setoid a => a -> Nonempty Stack a -> Stack a
-		delete x (Construct y ys) = x == y ? unite ys
-			$ unite $ Construct y . run . delete x <$> ys
-
-instance Setoid a => Substructure (Delete All) (Construction Maybe) a where
-	type Substructural (Delete All) (Construction Maybe) a = a |-> Stack
-	substructure (extract -> xs) = Store $ delete % xs :*: (point xs !) where
-
-		delete :: Setoid a => a -> Nonempty Stack a -> Stack a
-		delete x (Construct y ys) = x == y
-			? (unite . join $ run . delete x <$> ys)
-			$ (unite $ Construct y . run . delete x <$> ys)
+instance Substructure Tail (Construction Maybe) where
+	type Substructural Tail (Construction Maybe) = Stack
+	substructure (extract . run -> Construct x xs) =
+		Store $ TU xs :*: lift . Construct x . run
 
-type instance Zipper Stack = Tap (Delta <:.> Stack)
+type instance Zipper Stack = Tap ((:*:) <:.:> Stack)
 
-instance {-# OVERLAPS #-} Extendable (Tap (Delta <:.> Stack)) where
+instance {-# OVERLAPS #-} Extendable (Tap ((:*:) <:.:> Stack)) where
 	z =>> f = let move rtt = TU . deconstruct $ rtt .-+ z
-		in f <$> Tap z (TU $ move (rotate @Left) :^: move (rotate @Right))
+		in f <$> Tap z (T_U $ move (run . morph @(Rotate Left)) :*: move (run . morph @(Rotate Right)))
 
-instance Rotatable Left (Tap (Delta <:.> Stack)) where
-	type Rotational Left (Tap (Delta <:.> Stack)) a = Maybe :. Zipper Stack := a
-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap % (TU $ sub @Tail ^. bs :^: insert x fs) <$> focus @Head ^. bs
+instance Morphable (Rotate Left) (Tap ((:*:) <:.:> Stack)) where
+	type Morphing (Rotate Left) (Tap ((:*:) <:.:> Stack)) = Maybe <:.> Zipper Stack
+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = TU
+		$ Tap % (T_U $ subview @Tail bs :*: insert x fs) <$> view (focus @Head) bs
 
-instance Rotatable Right (Tap (Delta <:.> Stack)) where
-	type Rotational Right (Tap (Delta <:.> Stack)) a = Maybe :. Zipper Stack := a
-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap % (TU $ insert x bs :^: sub @Tail ^. fs) <$> focus @Head ^. fs
+instance Morphable (Rotate Right) (Tap ((:*:) <:.:> Stack)) where
+	type Morphing (Rotate Right) (Tap ((:*:) <:.:> Stack)) = Maybe <:.> Zipper Stack
+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = TU
+		$ Tap % (T_U $ insert x bs :*: subview @Tail fs) <$> view (focus @Head) fs
 
-type instance Zipper (Construction Maybe) = Tap (Delta <:.> Construction Maybe)
+type instance Zipper (Construction Maybe) = Tap ((:*:) <:.:> Construction Maybe)
 
-instance Rotatable Left (Tap (Delta <:.> Construction Maybe)) where
-	type Rotational Left (Tap (Delta <:.> Construction Maybe)) a = Maybe :. Zipper (Construction Maybe) := a
-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap (extract bs) . TU . (:^: insert x fs) <$> deconstruct bs
+instance Morphable (Rotate Left) (Tap ((:*:) <:.:> Construction Maybe)) where
+	type Morphing (Rotate Left) (Tap ((:*:) <:.:> Construction Maybe)) = Maybe <:.> Zipper (Construction Maybe)
+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = TU
+		$ Tap (extract bs) . T_U . (:*: insert x fs) <$> deconstruct bs
 
-instance Rotatable Right (Tap (Delta <:.> Construction Maybe)) where
-	type Rotational Right (Tap (Delta <:.> Construction Maybe)) a = Maybe :. Zipper (Construction Maybe) := a
-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap (extract fs) . TU . (insert x bs :^:) <$> deconstruct fs
+instance Morphable (Rotate Right) (Tap ((:*:) <:.:> Construction Maybe)) where
+	type Morphing (Rotate Right) (Tap ((:*:) <:.:> Construction Maybe)) = Maybe <:.> Zipper (Construction Maybe)
+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = TU
+		$ Tap (extract fs) . T_U . (insert x bs :*:) <$> deconstruct fs
 
 instance Monotonic a (Maybe <:.> Construction Maybe := a) where
 	reduce f r = reduce f r . run
diff --git a/Pandora/Paradigm/Structure/Stream.hs b/Pandora/Paradigm/Structure/Stream.hs
--- a/Pandora/Paradigm/Structure/Stream.hs
+++ b/Pandora/Paradigm/Structure/Stream.hs
@@ -2,38 +2,39 @@
 
 module Pandora.Paradigm.Structure.Stream where
 
-import Pandora.Core.Functor (type (|->))
+import Pandora.Core.Functor (type (:=>))
 import Pandora.Pattern.Category ((.), ($))
-import Pandora.Pattern.Functor.Covariant ((<$>))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (point)
 import Pandora.Pattern.Functor.Extractable (extract)
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
-import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+))
 import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap))
-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (Rotational, rotation), rotate)
+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate), morph)
 import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 
 type Stream = Construction Identity
 
-type instance Zipper Stream = Tap (Delta <:.> Stream)
+type instance Zipper Stream = Tap ((:*:) <:.:> Stream)
 
-instance Rotatable Left (Tap (Delta <:.> Stream)) where
-	type Rotational Left (Tap (Delta <:.> Stream)) a = Tap (Delta <:.> Stream) a
-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap (extract bs) . TU
-		$ extract (deconstruct bs) :^: Construct x (point fs)
+instance Morphable (Rotate Left) (Tap ((:*:) <:.:> Stream)) where
+	type Morphing (Rotate Left) (Tap ((:*:) <:.:> Stream)) = Tap ((:*:) <:.:> Stream)
+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = Tap (extract bs) . T_U
+		$ extract (deconstruct bs) :*: Construct x (point fs)
 
-instance Rotatable Right (Tap (Delta <:.> Stream)) where
-	type Rotational Right (Tap (Delta <:.> Stream)) a = Tap (Delta <:.> Stream) a
-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap (extract fs) . TU
-		$ Construct x (point bs) :^: extract (deconstruct fs)
+instance Morphable (Rotate Right) (Tap ((:*:) <:.:> Stream)) where
+	type Morphing (Rotate Right) (Tap ((:*:) <:.:> Stream)) = Tap ((:*:) <:.:> Stream)
+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = Tap (extract fs) . T_U
+		$ Construct x (point bs) :*: extract (deconstruct fs)
 
-instance {-# OVERLAPS #-} Extendable (Tap (Delta <:.> Stream)) where
+instance {-# OVERLAPS #-} Extendable (Tap ((:*:) <:.:> Stream)) where
 	z =>> f = let move rtt = extract . deconstruct $ point . rtt .-+ z
-		in f <$> Tap z (TU $ move (rotate @Left) :^: move (rotate @Right))
+		in f <$> Tap z (T_U $ move (morph @(Rotate Left)) :*: move (morph @(Rotate Right)))
 
-repeat :: a |-> Stream
+repeat :: a :=> Stream
 repeat x = Construct x . Identity $ repeat x
diff --git a/Pandora/Pattern/Functor/Bindable.hs b/Pandora/Pattern/Functor/Bindable.hs
--- a/Pandora/Pattern/Functor/Bindable.hs
+++ b/Pandora/Pattern/Functor/Bindable.hs
@@ -35,6 +35,3 @@
 
 	($>>=) :: Covariant u => u :. t := a -> (a -> t b) -> u :. t := b
 	x $>>= f = (>>= f) <$> x
-
-	-- (<>>=) :: (t b -> c) -> (a -> t b) -> t a -> c
-	-- f <>>= g = f <$> (>>= g)
diff --git a/Pandora/Pattern/Functor/Covariant.hs b/Pandora/Pattern/Functor/Covariant.hs
--- a/Pandora/Pattern/Functor/Covariant.hs
+++ b/Pandora/Pattern/Functor/Covariant.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Covariant where
 
-import Pandora.Core.Functor (type (:.), type (:=), type (<-|))
+import Pandora.Core.Functor (type (:.), type (:=), type (<:=))
 import Pandora.Pattern.Category (Category ((.), ($)))
 
 infixl 4 <$>, <$, $>
@@ -37,7 +37,7 @@
 	void :: t a -> t ()
 	void x = () <$ x
 	-- | Computing a value from a structure of values
-	loeb :: t (a <-| t) -> t a
+	loeb :: t (a <:= t) -> t a
 	loeb tt = let fix f = let x = f x in x in fix (\f -> ($ f) <$> tt)
 	-- | Flipped infix version of 'comap'
 	(<&>) :: t a -> (a -> b) -> t b
diff --git a/Pandora/Pattern/Functor/Extractable.hs b/Pandora/Pattern/Functor/Extractable.hs
--- a/Pandora/Pattern/Functor/Extractable.hs
+++ b/Pandora/Pattern/Functor/Extractable.hs
@@ -1,8 +1,8 @@
 module Pandora.Pattern.Functor.Extractable where
 
-import Pandora.Core.Functor (type (<-|))
+import Pandora.Core.Functor (type (<:=))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 class Covariant t => Extractable t where
 	{-# MINIMAL extract #-}
-	extract :: a <-| t
+	extract :: a <:= t
diff --git a/Pandora/Pattern/Functor/Pointable.hs b/Pandora/Pattern/Functor/Pointable.hs
--- a/Pandora/Pattern/Functor/Pointable.hs
+++ b/Pandora/Pattern/Functor/Pointable.hs
@@ -1,8 +1,8 @@
 module Pandora.Pattern.Functor.Pointable where
 
-import Pandora.Core.Functor (type (|->))
+import Pandora.Core.Functor (type (:=>))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 class Covariant t => Pointable t where
 	{-# MINIMAL point #-}
-	point :: a |-> t
+	point :: a :=> t
diff --git a/Pandora/Pattern/Functor/Representable.hs b/Pandora/Pattern/Functor/Representable.hs
--- a/Pandora/Pattern/Functor/Representable.hs
+++ b/Pandora/Pattern/Functor/Representable.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Representable where
 
-import Pandora.Core.Functor (type (<-|))
+import Pandora.Core.Functor (type (<:=))
 import Pandora.Pattern.Functor.Pointable (Pointable)
 
 {- |
@@ -15,7 +15,7 @@
 	{-# MINIMAL (<#>), tabulate #-}
 	type Representation t :: *
 	-- | Infix and flipped version of 'index'
-	(<#>) :: Representation t -> a <-| t
+	(<#>) :: Representation t -> a <:= t
 	-- Build with a function which describes value
 	tabulate :: (Representation t -> a) -> t a
 	-- | Prefix and flipped version of '<#>'
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.3.5
+version:             0.3.6
 synopsis:            A box of patterns and paradigms
 description:         Humble attempt to define a library for problem solving based on math abstractions.
 homepage:            https://github.com/iokasimov/pandora
@@ -35,7 +35,6 @@
     Pandora.Paradigm.Primary.Functor.Function
     Pandora.Paradigm.Primary.Functor.Conclusion
     Pandora.Paradigm.Primary.Functor.Constant
-    Pandora.Paradigm.Primary.Functor.Delta
     Pandora.Paradigm.Primary.Functor.Edges
     Pandora.Paradigm.Primary.Functor.Endo
     Pandora.Paradigm.Primary.Functor.Fix
@@ -102,11 +101,12 @@
     Pandora.Paradigm.Structure.Rose
     Pandora.Paradigm.Structure.Ability
     Pandora.Paradigm.Structure.Ability.Comprehension
-    Pandora.Paradigm.Structure.Ability.Convertible
+    Pandora.Paradigm.Structure.Ability.Morphable
+    Pandora.Paradigm.Structure.Ability.Deletable
+    Pandora.Paradigm.Structure.Ability.Accessible
     Pandora.Paradigm.Structure.Ability.Focusable
     Pandora.Paradigm.Structure.Ability.Insertable
     Pandora.Paradigm.Structure.Ability.Measurable
-    Pandora.Paradigm.Structure.Ability.Rotatable
     Pandora.Paradigm.Structure.Ability.Substructure
     Pandora.Paradigm.Structure.Ability.Nonempty
     Pandora.Paradigm.Structure.Ability.Nullable
@@ -160,7 +160,7 @@
     Pandora.Pattern.Transformer.Lowerable
   default-extensions:
     DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints, InstanceSigs
-    FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase
+    FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase, FunctionalDependencies
     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes, ViewPatterns
     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators
   default-language: Haskell2010