diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -185,3 +185,18 @@
 * Remove `not` method of `Boolean`, (use `invert` instead)
 * Remove `Injective` and `Has` type families
 * Change superclasseses for `Liftable` and `Lowerable` classes to provide a law
+
+# 0.2.6
+* Change order of arguments for `TUT` joint schema
+* `Binary` trees can be empty
+* Define `left_sub_tree` and `right_sub_tree` lenses of `Binary` tree
+* Fix `insert` function: `Binary` tree should not contain duplicate values
+* Remove `Cartesian` type class
+* Move `Nonempty` module to `Variation` submodule
+* Remove `Specific` module
+* Add functional dependency to `Nonempty` type family and distribute instances
+* Define `left` and `right` natural transformations from `Wye` to `Maybe`
+* Define experimental `Substructure` type class
+* Remove `left_sub_tree` and `right_sub_tree` lenses of `Binary` tree
+* Define `this` and `that` methods from `Variation` to `Maybe`
+* Define `Backwards` type to run `Applicative` actions in reverse order
diff --git a/Pandora/Paradigm/Basis.hs b/Pandora/Paradigm/Basis.hs
--- a/Pandora/Paradigm/Basis.hs
+++ b/Pandora/Paradigm/Basis.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Basis (module Exports, note, hush) where
+module Pandora.Paradigm.Basis (module Exports, note, hush, left, right, this, that) where
 
 import Pandora.Paradigm.Basis.Twister as Exports
 import Pandora.Paradigm.Basis.Free as Exports
@@ -20,6 +20,7 @@
 import Pandora.Paradigm.Basis.Tagged as Exports
 import Pandora.Paradigm.Basis.Product as Exports
 import Pandora.Paradigm.Basis.Constant as Exports
+import Pandora.Paradigm.Basis.Backwards as Exports
 import Pandora.Paradigm.Basis.Identity as Exports
 
 import Pandora.Core.Morphism ((!))
@@ -30,3 +31,25 @@
 
 hush :: Conclusion e ~> Maybe
 hush = conclusion (Nothing !) Just
+
+left :: Wye ~> Maybe
+left (Both ls _) = Just ls
+left (Left ls) = Just ls
+left (Right _) = Nothing
+left End = Nothing
+
+right :: Wye ~> Maybe
+right (Both _ rs) = Just rs
+right (Left _) = Nothing
+right (Right rs) = Just rs
+right End = Nothing
+
+this :: Variation e ~> Maybe
+this (This x) = Just x
+this (That _) = Nothing
+this (These _ x) = Just x
+
+that :: Variation e a -> Maybe e
+that (This _) = Nothing
+that (That x) = Just x
+that (These y _) = Just y
diff --git a/Pandora/Paradigm/Basis/Backwards.hs b/Pandora/Paradigm/Basis/Backwards.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Basis/Backwards.hs
@@ -0,0 +1,40 @@
+module Pandora.Paradigm.Basis.Backwards (Backwards (..)) where
+
+import Pandora.Core.Morphism ((&))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
+
+newtype Backwards t a = Backwards (t a)
+
+instance Covariant t => Covariant (Backwards t) where
+	f <$> Backwards x = Backwards $ f <$> x
+
+instance Pointable t => Pointable (Backwards t) where
+	point = Backwards . point
+
+instance Extractable t => Extractable (Backwards t) where
+	extract (Backwards x) = extract x
+
+instance Applicative t => Applicative (Backwards t) where
+	Backwards f <*> Backwards x = Backwards ((&) <$> x <*> f)
+
+instance Traversable t => Traversable (Backwards t) where
+	Backwards x ->> f = Backwards <$> x ->> f
+
+instance Distributive t => Distributive (Backwards t) where
+	x >>- f = Backwards $ x >>- run . f
+
+instance Contravariant t => Contravariant (Backwards t) where
+	f >$< Backwards x = Backwards $ f >$< x
+
+instance Interpreted (Backwards t) where
+	type Primary (Backwards t) a = t a
+	run (Backwards x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
@@ -3,8 +3,8 @@
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
-newtype TUT ct cu cv t u t' a = TUT (t :. u :. t' := a)
+newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a)
 
-instance Interpreted (TUT ct cu cv t u t') where
-	type Primary (TUT ct cu cv t u t') a = t :. u :. t' := a
+instance Interpreted (TUT ct ct' cu t t' u) where
+	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' := a
 	run (TUT x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
@@ -53,6 +53,8 @@
 instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where
 	TC x =>> f = TC $ x =>> f . TC
 
+instance (Extractable (t :< u), Extendable (t :< u)) => Comonad (t :< u) where
+
 instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where
 	type Primary (t :< u) a = Primary (Schematic Comonad t u) a
 	run (TC x) = run x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
@@ -53,6 +53,8 @@
 instance Extendable (Schematic Monad t u) => Extendable (t :> u) where
 	TM x =>> f = TM $ x =>> f . TM
 
+instance (Pointable (t :> u), Bindable (t :> u)) => Monad (t :> u) where
+
 instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where
 	type Primary (t :> u) a = Primary (Schematic Monad t u) a
 	run (TM x) = run x
diff --git a/Pandora/Paradigm/Inventory/State.hs b/Pandora/Paradigm/Inventory/State.hs
--- a/Pandora/Paradigm/Inventory/State.hs
+++ b/Pandora/Paradigm/Inventory/State.hs
@@ -55,7 +55,7 @@
 	run (State x) = x
 
 type instance Schematic Monad (State s) u =
-	TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)
+	TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u
 
 instance Monadic (State s) where
 	lay x = TM . TUT $ \s -> (s :*:) <$> x
@@ -63,19 +63,19 @@
 
 type Stateful s = Adaptable (State s)
 
-instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
 	f <$> TUT x = TUT $ \old -> f <$$> x old
 
-instance Bindable u => Applicative (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+instance Bindable u => Applicative (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
 	TUT f <*> TUT x = TUT $ \old -> f old >>= \(new :*: g) -> g <$$> x new
 
-instance Pointable u => Pointable (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+instance Pointable u => Pointable (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
 	point x = TUT $ \s -> point $ s :*: x
 
-instance Bindable u => Bindable (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+instance Bindable u => Bindable (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
 	TUT x >>= f = TUT $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y
 
-instance Monad u => Monad (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+instance Monad u => Monad (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where
 
 current :: Stateful s t => t s
 current = adapt $ State delta
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
@@ -36,7 +36,7 @@
 	run (Store x) = x
 
 type instance Schematic Comonad (Store p) u =
-	TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)
+	TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u
 
 instance Comonadic (Store p) where
 	flick (TC (TUT (p :*: f))) = ($ p) <$> f
@@ -44,13 +44,13 @@
 
 type Storable s x = Adaptable x (Store s)
 
-instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
+instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where
 	f <$> TUT (p :*: x) = TUT . (:*:) p $ f <$$> x
 
-instance Extractable u => Extractable (TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
+instance Extractable u => Extractable (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where
 	extract (TUT (p :*: x)) = extract x p
 
-instance Extendable u => Extendable (TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
+instance Extendable u => Extendable (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where
 	TUT (old :*: x) =>> f = TUT . (:*:) old $ x =>> (\x' new -> f . TUT . (:*:) new $ x')
 
 position :: Storable s t => t a -> s
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -1,6 +1,7 @@
 module Pandora.Paradigm.Structure (module Exports) where
 
-import Pandora.Paradigm.Structure.Nonempty as Exports
-import Pandora.Paradigm.Structure.Specific.Binary as Exports
-import Pandora.Paradigm.Structure.Specific.Graph as Exports
-import Pandora.Paradigm.Structure.Specific.Stack as Exports
+import Pandora.Paradigm.Structure.Variation.Substructure as Exports
+import Pandora.Paradigm.Structure.Variation.Nonempty as Exports
+import Pandora.Paradigm.Structure.Binary as Exports
+import Pandora.Paradigm.Structure.Graph as Exports
+import Pandora.Paradigm.Structure.Stack as Exports
diff --git a/Pandora/Paradigm/Structure/Binary.hs b/Pandora/Paradigm/Structure/Binary.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Binary.hs
@@ -0,0 +1,86 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Structure.Binary (Binary, insert) where
+
+import Pandora.Core.Morphism ((&), (%), (!))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
+import Pandora.Pattern.Functor.Extractable (extract)
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)), order)
+import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing), maybe)
+import Pandora.Paradigm.Basis.Product (Product ((:*:)))
+import Pandora.Paradigm.Basis.Wye (Wye (End, Left, Right, Both))
+import Pandora.Paradigm.Basis.Twister (Twister (Twister))
+import Pandora.Paradigm.Basis.Tagged (Tagged (Tag), type (:#))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
+import Pandora.Paradigm.Inventory.Store (Store (Store))
+import Pandora.Paradigm.Inventory.Optics ((%~))
+import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)
+import Pandora.Paradigm.Structure.Variation.Substructure (Substructure (Output, sub))
+
+type Binary = UT Covariant Covariant (Twister Wye) Maybe
+
+instance Covariant Binary where
+	f <$> UT g = UT $ f <$$> g
+
+instance Pointable Binary where
+	point x = UT . Just . Twister x $ End
+
+instance Traversable Binary where
+	UT g ->> f = UT <$> g ->>> f
+
+insert :: Chain a => a -> Binary a -> Binary a
+insert x (UT Nothing) = point x
+insert x tree@(UT (Just (Twister y _))) = x <=> y & order
+	(sub @'Left %~ (insert x <$>) $ tree) tree
+	(sub @'Right %~ (insert x <$>) $ tree)
+
+instance Substructure 'Left Binary where
+	type Output 'Left Binary a = 'Left :# Binary a
+	sub (UT Nothing) = Store $ (:*:) (Tag $ UT Nothing) $ (UT Nothing !)
+	sub  t@(UT (Just (Twister x End))) = Store $ (:*:) (Tag $ UT Nothing) $
+		maybe t (UT . Just . Twister x . Left) . run . extract
+	sub (UT (Just (Twister x (Left lst)))) = Store $ (:*:) (Tag . UT . Just $ lst) $
+		maybe (point x) (UT . Just . Twister x . Left) . run . extract
+	sub t@(UT (Just (Twister x (Right rst)))) = Store $ (:*:) (Tag $ UT Nothing) $
+		maybe t (UT . Just . Twister x . Both % rst) . run . extract
+	sub  (UT (Just (Twister x (Both lst rst)))) = Store $ (:*:) (Tag . UT . Just $ lst) $
+		maybe (UT (Just (Twister x (Right rst)))) (UT . Just . Twister x . Both % rst) . run . extract
+
+instance Substructure 'Right Binary where
+	type Output 'Right Binary a = 'Right :# Binary a
+	sub (UT Nothing) = Store $ Tag (UT Nothing) :*: (!) (UT Nothing)
+	sub t@(UT (Just (Twister x End))) = Store $ (:*:) (Tag $ UT Nothing) $
+		maybe t (UT . Just . Twister x . Right) . run . extract
+	sub t@(UT (Just (Twister x (Left lst)))) = Store $ (:*:) (Tag $ UT Nothing) $
+		maybe t (UT . Just . Twister x . Both lst) . run . extract
+	sub (UT (Just (Twister x (Right rst)))) = Store $ (:*:) (Tag . UT . Just $ rst) $
+		maybe (point x) (UT . Just . Twister x . Right) . run . extract
+	sub (UT (Just (Twister x (Both lst rst)))) = Store $ (:*:) (Tag . UT . Just $ rst) $
+		maybe (UT (Just (Twister x (Left lst)))) (UT . Just . Twister x . Both lst) . run . extract
+
+type instance Nonempty Binary = Twister Wye
+
+instance Substructure 'Left (Twister Wye) where
+	type Output 'Left (Twister Wye) a = Maybe ('Left :# Twister Wye a)
+	sub (Twister x End) = Store $ (:*:) Nothing $ (Twister x End !)
+	sub (Twister x (Left lst)) = Store $ (:*:) (Just . Tag $ lst) $
+		maybe (Twister x End) (Twister x . Left . extract)
+	sub tree@(Twister x (Right rst)) = Store $ (:*:) Nothing $
+		maybe tree (Twister x . Both % rst . extract)
+	sub (Twister x (Both lst rst)) = Store $ (:*:) (Just . Tag $ lst) $
+		maybe (Twister x $ Right rst) (Twister x . Both % rst . extract)
+
+instance Substructure 'Right (Twister Wye) where
+	type Output 'Right (Twister Wye) a = Maybe ('Right :# Twister Wye a)
+	sub (Twister x End) = Store $ (:*:) Nothing $ (Twister x End !)
+	sub tree@(Twister x (Left lst)) = Store $ (:*:) Nothing $
+		maybe tree (Twister x . Both lst . extract)
+	sub (Twister x (Right rst)) = Store $ (:*:) (Just . Tag $ rst) $
+		maybe (Twister x End) (Twister x . Right . extract)
+	sub (Twister x (Both lst rst)) = Store $ (:*:) (Just . Tag $ rst) $
+		maybe (Twister x $ Left lst) (Twister x . Both lst . extract)
diff --git a/Pandora/Paradigm/Structure/Cartesian.hs b/Pandora/Paradigm/Structure/Cartesian.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Cartesian.hs
+++ /dev/null
@@ -1,7 +0,0 @@
-module Pandora.Paradigm.Structure.Cartesian (Cartesian (..)) where
-
-import Pandora.Paradigm.Basis.Product (type (:*:))
-
-class Cartesian (t :: * -> *) where
-	{-# MINIMAL (-:*:-) #-}
-	(-:*:-) :: t a -> t b -> t (a :*: b)
diff --git a/Pandora/Paradigm/Structure/Graph.hs b/Pandora/Paradigm/Structure/Graph.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Graph.hs
@@ -0,0 +1,29 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Structure.Graph (Graph, loose) where
+
+import Pandora.Core.Functor (type (~>))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
+import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))
+import Pandora.Paradigm.Basis.Twister (Twister (Twister))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+import Pandora.Paradigm.Inventory.State (fold)
+import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)
+
+-- | Directed acyclic graph structure
+type Graph = UT Covariant Covariant (Twister Edges) Edges
+
+type instance Nonempty Graph = Twister Edges
+
+instance Covariant Graph where
+	f <$> UT g = UT $ f <$$> g
+
+instance Traversable Graph where
+	UT g ->> f = UT <$> g ->>> f
+
+-- | Transform any traversable structure into all loose edges graph
+loose :: Traversable t => t ~> Graph
+loose = UT . fold Empty (\x -> Overlay . Twister x)
diff --git a/Pandora/Paradigm/Structure/Nonempty.hs b/Pandora/Paradigm/Structure/Nonempty.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Nonempty.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-module Pandora.Paradigm.Structure.Nonempty (Nonempty) where
-
-import Pandora.Paradigm.Basis.Maybe (Maybe)
-import Pandora.Paradigm.Basis.Edges (Edges)
-import Pandora.Paradigm.Basis.Twister (Twister)
-import Pandora.Paradigm.Structure.Specific.Stack (Stack)
-import Pandora.Paradigm.Structure.Specific.Graph (Graph)
-
--- | Type synonymous for at least one element data structure
-type family Nonempty (structure :: * -> *) where
-	Nonempty Stack = Twister Maybe
-	Nonempty Graph = Twister Edges
diff --git a/Pandora/Paradigm/Structure/Specific.hs b/Pandora/Paradigm/Structure/Specific.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Specific.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module Pandora.Paradigm.Structure.Specific (module Exports) where
-
-import Pandora.Paradigm.Structure.Specific.Stream as Exports
-import Pandora.Paradigm.Structure.Specific.Stack as Exports
-import Pandora.Paradigm.Structure.Specific.Graph as Exports
-import Pandora.Paradigm.Structure.Specific.Binary as Exports
diff --git a/Pandora/Paradigm/Structure/Specific/Binary.hs b/Pandora/Paradigm/Structure/Specific/Binary.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Specific/Binary.hs
+++ /dev/null
@@ -1,20 +0,0 @@
-module Pandora.Paradigm.Structure.Specific.Binary (Binary, insert) where
-
-import Pandora.Core.Morphism ((&))
-import Pandora.Paradigm.Basis.Wye (Wye (End, Left, Right, Both))
-import Pandora.Paradigm.Basis.Twister (Twister (Twister))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Object.Chain (Chain ((<=>)), order)
-
-type Binary = Twister Wye
-
-insert :: Chain a => a -> Binary a -> Binary a
-insert x (Twister y End) = x <=> y & order (Twister y . Right $ Twister x End)
-	(Twister y . Right $ Twister x End) (Twister y . Left $ Twister x End)
-insert x (Twister y (Left ls)) = x <=> y & order (Twister y . Both ls $ Twister x End)
-	(Twister y $ Both ls $ Twister x End) (Twister y . Left $ insert x ls)
-insert x (Twister y (Right rs)) = x <=> y & order (Twister y . Right $ insert x rs)
-	(Twister y $ Right (insert x rs)) (Twister y $ Both (Twister x End) rs)
-insert x (Twister y (Both ls rs)) = x <=> y & order (Twister y . Both ls $ insert x rs)
-	(Twister y . Both ls $ insert x rs) (Twister y $ Both (insert x ls) rs)
diff --git a/Pandora/Paradigm/Structure/Specific/Graph.hs b/Pandora/Paradigm/Structure/Specific/Graph.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Specific/Graph.hs
+++ /dev/null
@@ -1,26 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Pandora.Paradigm.Structure.Specific.Graph (Graph, loose) where
-
-import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))
-import Pandora.Paradigm.Basis.Twister (Twister (Twister))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
-import Pandora.Paradigm.Inventory.State (fold)
-
--- | Directed acyclic graph structure
-type Graph = UT Covariant Covariant (Twister Edges) Edges
-
-instance Covariant Graph where
-	f <$> UT g = UT $ f <$$> g
-
-instance Traversable Graph where
-	UT g ->> f = UT <$> g ->>> f
-
--- | Transform any traversable structure into all loose edges graph
-loose :: Traversable t => t ~> Graph
-loose = UT . fold Empty (\x -> Overlay . Twister x)
diff --git a/Pandora/Paradigm/Structure/Specific/Stack.hs b/Pandora/Paradigm/Structure/Specific/Stack.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Specific/Stack.hs
+++ /dev/null
@@ -1,79 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Pandora.Paradigm.Structure.Specific.Stack (Stack, push, top, pop, filter, linearize) where
-
-import Pandora.Core.Functor (type (~>))
-import Pandora.Core.Morphism ((&))
-import Pandora.Pattern.Category ((.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Object.Setoid (Setoid ((==)), (?))
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Pattern.Object.Monoid (Monoid (zero))
-import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
-import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))
-import Pandora.Paradigm.Basis.Product (Product ((:*:)))
-import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)
-import Pandora.Paradigm.Inventory.State (fold)
-import Pandora.Paradigm.Inventory.Store (Store (Store))
-import Pandora.Paradigm.Inventory.Optics (type (:-.))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
-
--- | Linear data structure that serves as a collection of elements
-type Stack = UT Covariant Covariant (Twister Maybe) Maybe
-
-instance Covariant Stack where
-	f <$> UT stack = UT $ f <$$> stack
-
-instance Pointable Stack where
-	point = UT . Just . point
-
-instance Alternative Stack where
-	UT x <+> UT y = UT $ x <+> y
-
-instance Avoidable Stack where
-	empty = UT Nothing
-
-instance Applicative Stack where
-	UT f <*> UT x = UT $ f <**> x
-
-instance Traversable Stack where
-	UT stack ->> f = UT <$> stack ->>> f
-
-instance Setoid a => Setoid (Stack a) where
-	UT ls == UT rs = ls == rs
-
-instance Semigroup (Stack a) where
-	UT Nothing + UT ys = UT ys
-	UT (Just (Twister x xs)) + UT ys = UT . Just . Twister x . run
-		$ UT @Covariant @Covariant xs + UT @Covariant @Covariant ys
-
-instance Monoid (Stack a) where
-	zero = UT Nothing
-
-top :: Stack a :-. Maybe a
-top stack = Store $ (:*:) (extract <$> run stack) $ \case
-    Just x -> stack & pop & push x
-    Nothing -> pop stack
-
-push :: a -> Stack a -> Stack a
-push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x
-
-pop :: Stack ~> Stack
-pop (UT stack) = UT $ stack >>= untwist
-
-filter :: Predicate a -> Stack a -> Stack a
-filter (Predicate p) = UT . fold empty
-	(\now new -> p now ? Just (Twister now new) $ new)
-
--- | Transform any traversable structure into a stack
-linearize :: Traversable t => t ~> Stack
-linearize = UT . fold Nothing (\x -> Just . Twister x)
diff --git a/Pandora/Paradigm/Structure/Specific/Stream.hs b/Pandora/Paradigm/Structure/Specific/Stream.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Specific/Stream.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module Pandora.Paradigm.Structure.Specific.Stream (Stream) where
-
-import Pandora.Paradigm.Basis.Identity (Identity)
-import Pandora.Paradigm.Basis.Twister (Twister)
-
-type Stream = Twister Identity
diff --git a/Pandora/Paradigm/Structure/Stack.hs b/Pandora/Paradigm/Structure/Stack.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Stack.hs
@@ -0,0 +1,82 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Structure.Stack (Stack, push, top, pop, filter, linearize) where
+
+import Pandora.Core.Functor (type (~>))
+import Pandora.Core.Morphism ((&))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)), (?))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
+import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))
+import Pandora.Paradigm.Basis.Product (Product ((:*:)))
+import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)
+import Pandora.Paradigm.Inventory.State (fold)
+import Pandora.Paradigm.Inventory.Store (Store (Store))
+import Pandora.Paradigm.Inventory.Optics (type (:-.))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)
+
+-- | Linear data structure that serves as a collection of elements
+type Stack = UT Covariant Covariant (Twister Maybe) Maybe
+
+type instance Nonempty Stack = Twister Maybe
+
+instance Covariant Stack where
+	f <$> UT stack = UT $ f <$$> stack
+
+instance Pointable Stack where
+	point = UT . Just . point
+
+instance Alternative Stack where
+	UT x <+> UT y = UT $ x <+> y
+
+instance Avoidable Stack where
+	empty = UT Nothing
+
+instance Applicative Stack where
+	UT f <*> UT x = UT $ f <**> x
+
+instance Traversable Stack where
+	UT stack ->> f = UT <$> stack ->>> f
+
+instance Setoid a => Setoid (Stack a) where
+	UT ls == UT rs = ls == rs
+
+instance Semigroup (Stack a) where
+	UT Nothing + UT ys = UT ys
+	UT (Just (Twister x xs)) + UT ys = UT . Just . Twister x . run
+		$ UT @Covariant @Covariant xs + UT @Covariant @Covariant ys
+
+instance Monoid (Stack a) where
+	zero = UT Nothing
+
+top :: Stack a :-. Maybe a
+top stack = Store $ (:*:) (extract <$> run stack) $ \case
+    Just x -> stack & pop & push x
+    Nothing -> pop stack
+
+push :: a -> Stack a -> Stack a
+push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x
+
+pop :: Stack ~> Stack
+pop (UT stack) = UT $ stack >>= untwist
+
+filter :: Predicate a -> Stack a -> Stack a
+filter (Predicate p) = UT . fold empty
+	(\now new -> p now ? Just (Twister now new) $ new)
+
+-- | Transform any traversable structure into a stack
+linearize :: Traversable t => t ~> Stack
+linearize = UT . fold Nothing (\x -> Just . Twister x)
diff --git a/Pandora/Paradigm/Structure/Stream.hs b/Pandora/Paradigm/Structure/Stream.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Stream.hs
@@ -0,0 +1,6 @@
+module Pandora.Paradigm.Structure.Stream (Stream) where
+
+import Pandora.Paradigm.Basis.Identity (Identity)
+import Pandora.Paradigm.Basis.Twister (Twister)
+
+type Stream = Twister Identity
diff --git a/Pandora/Paradigm/Structure/Variation/Nonempty.hs b/Pandora/Paradigm/Structure/Variation/Nonempty.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Variation/Nonempty.hs
@@ -0,0 +1,4 @@
+module Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty) where
+
+-- | Type synonymous for at least one element data structure
+type family Nonempty (s :: * -> *) = (r :: * -> *) | r -> s
diff --git a/Pandora/Paradigm/Structure/Variation/Substructure.hs b/Pandora/Paradigm/Structure/Variation/Substructure.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Variation/Substructure.hs
@@ -0,0 +1,7 @@
+module Pandora.Paradigm.Structure.Variation.Substructure (Substructure (..)) where
+
+import Pandora.Paradigm.Inventory.Optics (type (:-.))
+
+class Substructure f t where
+	type Output (f :: * -> k) (t :: * -> *) a = r | r -> f t a
+	sub :: t a :-. Output f t a
diff --git a/Pandora/Pattern/Transformer/Hoistable.hs b/Pandora/Pattern/Transformer/Hoistable.hs
--- a/Pandora/Pattern/Transformer/Hoistable.hs
+++ b/Pandora/Pattern/Transformer/Hoistable.hs
@@ -2,5 +2,11 @@
 
 import Pandora.Core.Functor (type (~>))
 
+{- |
+> When providing a new instance, you should ensure it satisfies one law:
+> * Identity morphism: hoist identity ≡ identity
+> * Interpreted of morphisms: hoist (f . g) ≡ hoist f . hoist g
+-}
+
 class Hoistable t where
 	hoist :: u ~> v -> t u ~> t v
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.2.5
+version:             0.2.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
@@ -27,6 +27,7 @@
     Pandora.Paradigm
     -- Basic constructions
     Pandora.Paradigm.Basis
+    Pandora.Paradigm.Basis.Backwards
     Pandora.Paradigm.Basis.Conclusion
     Pandora.Paradigm.Basis.Constant
     Pandora.Paradigm.Basis.Continuation
@@ -77,13 +78,12 @@
     Pandora.Paradigm.Inventory.Store
     -- Tree-based datastructures
     Pandora.Paradigm.Structure
-    Pandora.Paradigm.Structure.Cartesian
-    Pandora.Paradigm.Structure.Nonempty
-    Pandora.Paradigm.Structure.Specific
-    Pandora.Paradigm.Structure.Specific.Stream
-    Pandora.Paradigm.Structure.Specific.Stack
-    Pandora.Paradigm.Structure.Specific.Graph
-    Pandora.Paradigm.Structure.Specific.Binary
+    Pandora.Paradigm.Structure.Stream
+    Pandora.Paradigm.Structure.Stack
+    Pandora.Paradigm.Structure.Graph
+    Pandora.Paradigm.Structure.Binary
+    Pandora.Paradigm.Structure.Variation.Nonempty
+    Pandora.Paradigm.Structure.Variation.Substructure
 
     Pandora.Pattern
     -- Category typeclass