diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,3 +16,14 @@
 * Define `Graph` concrete structure
 * Define infix `:-.` type operator for Lens
 * Define `Object` instances for `Product` datatype
+
+# 0.1.3
+* Define `Object` instances for `Cofree` datatype
+* Define all `Object` pattern instances for `Constant` datatype
+* Define `reset` and `shift` methods for `Continuation` datatype
+* Define `Endo` datatype in `Basis` module
+* Define `Object` instances for transformer schemes
+* Define `Binary` tree concrete structure
+* Define some `Object` instances for `Jack` datatype
+* Remove `Hollow` ad-hoc typeclass
+* Merge `Property` and `Concrete` modules back
diff --git a/Pandora/Paradigm/Basis.hs b/Pandora/Paradigm/Basis.hs
--- a/Pandora/Paradigm/Basis.hs
+++ b/Pandora/Paradigm/Basis.hs
@@ -10,6 +10,7 @@
 import Pandora.Paradigm.Basis.Edges as Exports
 import Pandora.Paradigm.Basis.Conclusion as Exports
 import Pandora.Paradigm.Basis.Maybe as Exports
+import Pandora.Paradigm.Basis.Endo as Exports
 import Pandora.Paradigm.Basis.Jack as Exports
 import Pandora.Paradigm.Basis.Product as Exports
 import Pandora.Paradigm.Basis.Constant as Exports
diff --git a/Pandora/Paradigm/Basis/Cofree.hs b/Pandora/Paradigm/Basis/Cofree.hs
--- a/Pandora/Paradigm/Basis/Cofree.hs
+++ b/Pandora/Paradigm/Basis/Cofree.hs
@@ -13,6 +13,9 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Object.Setoid (Setoid ((==)), (&&))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((<>)))
+import Pandora.Pattern.Object.Monoid (Monoid (unit))
 
 data Cofree t a = a :< (t :.: Cofree t) a
 
@@ -41,6 +44,15 @@
 instance (Exclusive t, Alternative t) => Monad (Cofree t) where
 
 instance Covariant t => Comonad (Cofree t) where
+
+instance (Setoid a, forall b . Setoid b => Setoid (t b)) => Setoid (Cofree t a) where
+	(x :< xs) == (y :< ys) = x == y && xs == ys
+
+instance (Semigroup a, forall b . Semigroup b => Semigroup (t b)) => Semigroup (Cofree t a) where
+	(x :< xs) <> (y :< ys) = (x <> y) :< (xs <> ys)
+
+instance (Monoid a, forall b . Semigroup b => Monoid (t b)) => Monoid (Cofree t a) where
+	unit = unit :< unit
 
 unwrap :: Cofree t a -> (t :.: Cofree t) a
 unwrap (_ :< xs) = xs
diff --git a/Pandora/Paradigm/Basis/Constant.hs b/Pandora/Paradigm/Basis/Constant.hs
--- a/Pandora/Paradigm/Basis/Constant.hs
+++ b/Pandora/Paradigm/Basis/Constant.hs
@@ -6,6 +6,14 @@
 import Pandora.Pattern.Functor.Invariant (Invariant (invmap))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((<>)))
+import Pandora.Pattern.Object.Monoid (Monoid (unit))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((><)))
+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
+import Pandora.Pattern.Object.Lattice (Lattice)
+import Pandora.Pattern.Object.Group (Group (inverse))
 
 newtype Constant a b = Constant a
 
@@ -20,3 +28,29 @@
 
 instance Traversable (Constant a) where
 	Constant x ->> _ = point (Constant x)
+
+instance Setoid a => Setoid (Constant a b) where
+	Constant x == Constant y = x == y
+
+instance Chain a => Chain (Constant a b) where
+	Constant x <=> Constant y = x <=> y
+
+instance Semigroup a => Semigroup (Constant a b) where
+	Constant x <> Constant y = Constant $ x <> y
+
+instance Monoid a => Monoid (Constant a b) where
+	 unit = Constant unit
+
+instance Ringoid a => Ringoid (Constant a b) where
+	Constant x >< Constant y = Constant $ x >< y
+
+instance Infimum a => Infimum (Constant a b) where
+	Constant x /\ Constant y = Constant $ x /\ y
+
+instance Supremum a => Supremum (Constant a b) where
+	Constant x \/ Constant y = Constant $ x \/ y
+
+instance Lattice a => Lattice (Constant a b) where
+
+instance Group a => Group (Constant a b) where
+	inverse (Constant x) = Constant $ inverse x
diff --git a/Pandora/Paradigm/Basis/Continuation.hs b/Pandora/Paradigm/Basis/Continuation.hs
--- a/Pandora/Paradigm/Basis/Continuation.hs
+++ b/Pandora/Paradigm/Basis/Continuation.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Basis.Continuation (Continuation (..), oblige, cwcc) where
+module Pandora.Paradigm.Basis.Continuation (Continuation (..), oblige, cwcc, reset, shift) where
 
 import Pandora.Core.Morphism ((.), ($), (!), (?))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
@@ -30,3 +30,11 @@
 -- | Call with current continuation
 cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a
 cwcc f = Continuation $ \g -> continue ? g . f $ Continuation . (!) . g
+
+-- | Delimit the continuation of any 'shift'
+reset :: (Bindable t, Pointable t) => Continuation r t r -> Continuation s t r
+reset = oblige . continue ? point
+
+-- | Capture the continuation up to the nearest enclosing 'reset' and pass it
+shift :: Pointable t => ((a -> t r) -> Continuation r t r) -> Continuation r t a
+shift f = Continuation $ continue ? point . f
diff --git a/Pandora/Paradigm/Basis/Endo.hs b/Pandora/Paradigm/Basis/Endo.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Basis/Endo.hs
@@ -0,0 +1,17 @@
+module Pandora.Paradigm.Basis.Endo (Endo (..)) where
+
+import Pandora.Core.Morphism ((.), identity)
+import Pandora.Pattern.Functor.Invariant (Invariant (invmap))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((<>)))
+import Pandora.Pattern.Object.Monoid (Monoid (unit))
+
+newtype Endo a = Endo { endo :: a -> a }
+
+instance Invariant Endo where
+	invmap f g (Endo x) = Endo (f . x . g)
+
+instance Semigroup (Endo a) where
+	Endo f <> Endo g = Endo (g . f)
+
+instance Monoid (Endo a) where
+	unit = Endo identity
diff --git a/Pandora/Paradigm/Basis/Jack.hs b/Pandora/Paradigm/Basis/Jack.hs
--- a/Pandora/Paradigm/Basis/Jack.hs
+++ b/Pandora/Paradigm/Basis/Jack.hs
@@ -10,6 +10,8 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), traverse))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
 import Pandora.Pattern.Functor.Liftable (Liftable (lift))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)), Boolean (False))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
 
 data Jack t a = It a | Other (t a)
 
@@ -28,6 +30,10 @@
 instance Exclusive t => Exclusive (Jack t) where
 	exclusive = Other exclusive
 
+instance Extractable t => Extractable (Jack t) where
+	extract (It x) = x
+	extract (Other y) = extract y
+
 instance Applicative t => Applicative (Jack t) where
 	It f <*> It x = It $ f x
 	It f <*> Other y = Other $ f <$> y
@@ -43,6 +49,17 @@
 
 instance Liftable Jack where
 	lift = Other
+
+instance (Setoid a, Setoid (t a)) => Setoid (Jack t a) where
+	It x == It y = x == y
+	Other x == Other y = x == y
+	_ == _ = False
+
+instance (Chain a, Chain (t a)) => Chain (Jack t a) where
+	It _ <=> Other _ = Less
+	Other _ <=> It _ = Greater
+	It x <=> It y = x <=> y
+	Other x <=> Other y = x <=> y
 
 jack :: (a -> r) -> (t a -> r) -> Jack t a -> r
 jack f _ (It x) = f x
diff --git a/Pandora/Paradigm/Junction/Transformer.hs b/Pandora/Paradigm/Junction/Transformer.hs
--- a/Pandora/Paradigm/Junction/Transformer.hs
+++ b/Pandora/Paradigm/Junction/Transformer.hs
@@ -13,6 +13,10 @@
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), bind))
 import Pandora.Pattern.Functor.Liftable (Liftable (lift))
 import Pandora.Pattern.Functor.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((<>)))
+import Pandora.Pattern.Object.Monoid (Monoid (unit))
 
 infixr 0 :!:, :>:
 type (:!:) t u = T t u
@@ -51,6 +55,18 @@
 instance (Distributive t, Distributive u) => Distributive (T t u) where
 	x >>- f = T . comap distribute . distribute $ t . f <$> x
 
+instance Setoid ((u :.: t) a) => Setoid (T t u a) where
+	T x == T y = x == y
+
+instance Chain ((u :.: t) a) => Chain (T t u a) where
+	T x <=> T y = x <=> y
+
+instance Semigroup ((u :.: t) a) => Semigroup (T t u a) where
+	T x <> T y = T $ x <> y
+
+instance Monoid ((u :.: t) a) => Monoid (T t u a) where
+	unit = T unit
+
 up :: Pointable u => t a -> T t u a
 up = T . point
 
@@ -86,3 +102,15 @@
 
 instance (forall u . Extractable u, Lowerable t) => Lowerable (Y t) where
 	lower = lower . extract . y
+
+instance (forall u . Setoid ((u :.: t u) a)) => Setoid (Y t u a) where
+	Y x == Y y = x == y
+
+instance (forall u . Chain ((u :.: t u) a)) => Chain (Y t u a) where
+	Y x <=> Y y = x <=> y
+
+instance (forall u . Semigroup ((u :.: t u) a)) => Semigroup (Y t u a) where
+	Y x <> Y y = Y $ x <> y
+
+instance (forall u . Monoid ((u :.: t u) a)) => Monoid (Y t u a) where
+	unit = Y unit
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -1,4 +1,12 @@
-module Pandora.Paradigm.Structure (module Exports) where
+module Pandora.Paradigm.Structure (module Exports, Nonempty) where
 
-import Pandora.Paradigm.Structure.Concrete as Exports
-import Pandora.Paradigm.Structure.Property as Exports
+import Pandora.Paradigm.Structure.Binary as Exports
+import Pandora.Paradigm.Structure.Graph as Exports
+import Pandora.Paradigm.Structure.Stack as Exports
+
+import Pandora.Paradigm.Basis.Cofree (Cofree)
+import Pandora.Paradigm.Junction.Transformer (type (:>:))
+
+-- | Type synonymous for at least one element data structure
+type family Nonempty structure a :: * where
+	Nonempty (Cofree :>: t) a = Cofree t a
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,15 @@
+module Pandora.Paradigm.Structure.Binary (Binary, insert) where
+
+import Pandora.Core.Morphism ((&))
+import Pandora.Paradigm.Basis.Wye (Wye (End, Left, Right, Both))
+import Pandora.Paradigm.Basis.Cofree (Cofree ((:<)))
+import Pandora.Paradigm.Junction.Transformer (Y (Y), type (:>:))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)), order)
+
+type Binary = Cofree Wye
+
+insert :: Chain a => a -> Binary a -> Binary a
+insert x (y :< End) = x <=> y & order (y :< Right (x :< End)) (y :< Right (x :< End)) (y :< Left (x :< End))
+insert x (y :< Left ls) = x <=> y & order (y :< Both ls (x :< End)) (y :< Both ls (x :< End)) (y :< Left (insert x ls))
+insert x (y :< Right rs) = x <=> y & order (y :< Right (insert x rs)) (y :< Right (insert x rs)) (y :< Both (x :< End) rs)
+insert x (y :< Both ls rs) = x <=> y & order (y :< Both ls (insert x rs)) (y :< Both ls (insert x rs)) (y :< Both (insert x ls) rs)
diff --git a/Pandora/Paradigm/Structure/Concrete.hs b/Pandora/Paradigm/Structure/Concrete.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Concrete.hs
+++ /dev/null
@@ -1,4 +0,0 @@
-module Pandora.Paradigm.Structure.Concrete (module Exports) where
-
-import Pandora.Paradigm.Structure.Concrete.Graph as Exports
-import Pandora.Paradigm.Structure.Concrete.Stack as Exports
diff --git a/Pandora/Paradigm/Structure/Concrete/Graph.hs b/Pandora/Paradigm/Structure/Concrete/Graph.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Concrete/Graph.hs
+++ /dev/null
@@ -1,21 +0,0 @@
-module Pandora.Paradigm.Structure.Concrete.Graph (Graph, loose) where
-
-import Pandora.Core.Morphism ((.))
-import Pandora.Paradigm.Basis.Edges (Edges (Empty, Connect, Overlay))
-import Pandora.Paradigm.Basis.Cofree (Cofree ((:<)))
-import Pandora.Paradigm.Junction.Transformer (Y (Y), type (:>:))
-import Pandora.Paradigm.Inventory.Stateful (fold)
-import Pandora.Paradigm.Structure.Property.Hollow (Hollow (hollow))
-import Pandora.Pattern.Functor.Traversable (Traversable)
-
--- | Acyclic graph structure without loops
-type Graph a = (Cofree :>: Edges) a
-
-instance Hollow Edges where
-	hollow result _ (Y Empty) = result
-	hollow _ f (Y (Connect struct)) = f struct
-	hollow _ f (Y (Overlay struct)) = f struct
-
--- | Transform any traversable structure into all loose edges graph
-loose :: Traversable t => t a -> Graph a
-loose = Y . fold Empty (\x -> Overlay . (:<) x)
diff --git a/Pandora/Paradigm/Structure/Concrete/Stack.hs b/Pandora/Paradigm/Structure/Concrete/Stack.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Concrete/Stack.hs
+++ /dev/null
@@ -1,34 +0,0 @@
-module Pandora.Paradigm.Structure.Concrete.Stack (Stack, push, top, pop, linearize) where
-
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Paradigm.Basis.Cofree (Cofree ((:<)), unwrap)
-import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
-import Pandora.Paradigm.Junction.Transformer (Y (Y, y), type (:>:))
-import Pandora.Paradigm.Inventory.Stateful (fold)
-import Pandora.Paradigm.Structure.Property.Hollow (Hollow (hollow))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Traversable (Traversable)
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-
--- | Linear data structure that serves as a collection of elements
-type Stack = (Cofree :>: Maybe)
-
-instance Hollow Maybe where
-	hollow result _ (Y Nothing) = result
-	hollow _ f (Y (Just struct)) = f struct
-
-push :: a -> Stack a -> Stack a
-push x (Y struct) = (Y $ (:<) x . Just <$> struct) <+> point x
-
-top :: Stack a -> Maybe a
-top (Y struct) = extract <$> struct
-
-pop :: Stack a -> Stack a
-pop (Y struct) = Y $ struct >>= unwrap
-
--- | Transform any traversable structure into a stack
-linearize :: Traversable t => t a -> Stack a
-linearize = Y . fold Nothing (\x -> Just . (:<) x)
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,15 @@
+module Pandora.Paradigm.Structure.Graph (Graph, loose) where
+
+import Pandora.Core.Morphism ((.))
+import Pandora.Paradigm.Basis.Edges (Edges (Empty, Connect, Overlay))
+import Pandora.Paradigm.Basis.Cofree (Cofree ((:<)))
+import Pandora.Paradigm.Junction.Transformer (Y (Y), type (:>:))
+import Pandora.Paradigm.Inventory.Stateful (fold)
+import Pandora.Pattern.Functor.Traversable (Traversable)
+
+-- | Acyclic graph structure without loops
+type Graph a = (Cofree :>: Edges) a
+
+-- | Transform any traversable structure into all loose edges graph
+loose :: Traversable t => t a -> Graph a
+loose = Y . fold Empty (\x -> Overlay . (:<) x)
diff --git a/Pandora/Paradigm/Structure/Property.hs b/Pandora/Paradigm/Structure/Property.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Property.hs
+++ /dev/null
@@ -1,4 +0,0 @@
-module Pandora.Paradigm.Structure.Property (module Exports) where
-
-import Pandora.Paradigm.Structure.Property.Nonempty as Exports
-import Pandora.Paradigm.Structure.Property.Hollow as Exports
diff --git a/Pandora/Paradigm/Structure/Property/Hollow.hs b/Pandora/Paradigm/Structure/Property/Hollow.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Property/Hollow.hs
+++ /dev/null
@@ -1,8 +0,0 @@
-module Pandora.Paradigm.Structure.Property.Hollow (Hollow (..)) where
-
-import Pandora.Paradigm.Basis.Cofree (Cofree)
-import Pandora.Paradigm.Junction.Transformer (type (:>:))
-
-class Hollow t where
-	-- | Destructor based on emptiness check
-	hollow :: r -> (Cofree t a -> r ) -> (Cofree :>: t) a -> r
diff --git a/Pandora/Paradigm/Structure/Property/Nonempty.hs b/Pandora/Paradigm/Structure/Property/Nonempty.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Structure/Property/Nonempty.hs
+++ /dev/null
@@ -1,8 +0,0 @@
-module Pandora.Paradigm.Structure.Property.Nonempty (Nonempty) where
-
-import Pandora.Paradigm.Basis.Cofree (Cofree)
-import Pandora.Paradigm.Junction.Transformer (type (:>:))
-
--- | Type synonymous for at least one element data structure
-type family Nonempty structure a :: * where
-	Nonempty (Cofree :>: t) a = Cofree t a
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,29 @@
+module Pandora.Paradigm.Structure.Stack (Stack, push, top, pop, linearize) where
+
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Paradigm.Basis.Cofree (Cofree ((:<)), unwrap)
+import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
+import Pandora.Paradigm.Junction.Transformer (Y (Y, y), type (:>:))
+import Pandora.Paradigm.Inventory.Stateful (fold)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Traversable (Traversable)
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+
+-- | Linear data structure that serves as a collection of elements
+type Stack = (Cofree :>: Maybe)
+
+push :: a -> Stack a -> Stack a
+push x (Y struct) = (Y $ (:<) x . Just <$> struct) <+> point x
+
+top :: Stack a -> Maybe a
+top (Y struct) = extract <$> struct
+
+pop :: Stack a -> Stack a
+pop (Y struct) = Y $ struct >>= unwrap
+
+-- | Transform any traversable structure into a stack
+linearize :: Traversable t => t a -> Stack a
+linearize = Y . fold Nothing (\x -> Just . (:<) x)
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,5 +1,19 @@
 # Pandora - the box of patterns and paradigms
 
+This is humble attempt to define pure core library for problem solving.
+
+Used materials:
+
+* Paper: `Fast Coroutine Pipelines`
+* Twit: https://twitter.com/xgrommx/status/964307440517963776
+* Library: http://hackage.haskell.org/package/base
+* Library: http://hackage.haskell.org/package/adjunctions
+* Library: http://hackage.haskell.org/package/distributive
+* Library: http://hackage.haskell.org/package/comonad
+* Library: http://hackage.haskell.org/package/semigroupoids
+* Library: http://hackage.haskell.org/package/transformers
+* Library: http://hackage.haskell.org/package/invariant
+
 ## Diagram of functor patterns:
 ![Functors diagram](/Diagrams/Functors.png)
 
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.1.2
+version:             0.1.3
 synopsis:            A box of patterns and paradigms
 description:         Humble attempt to define a library for problem solving based on math abstractions.
 homepage:            https://github.com/iokasimov/pandora
@@ -29,6 +29,7 @@
     Pandora.Paradigm.Basis.Constant
     Pandora.Paradigm.Basis.Continuation
     Pandora.Paradigm.Basis.Edges
+    Pandora.Paradigm.Basis.Endo
     Pandora.Paradigm.Basis.Fix
     Pandora.Paradigm.Basis.Free
     Pandora.Paradigm.Basis.Identity
@@ -55,12 +56,9 @@
     Pandora.Paradigm.Inventory.Storage
     -- Tree-based datastructures
     Pandora.Paradigm.Structure
-    Pandora.Paradigm.Structure.Concrete
-    Pandora.Paradigm.Structure.Property
-    Pandora.Paradigm.Structure.Concrete.Stack
-    Pandora.Paradigm.Structure.Concrete.Graph
-    Pandora.Paradigm.Structure.Property.Hollow
-    Pandora.Paradigm.Structure.Property.Nonempty
+    Pandora.Paradigm.Structure.Stack
+    Pandora.Paradigm.Structure.Graph
+    Pandora.Paradigm.Structure.Binary
     -- Functor typeclassess
     Pandora.Pattern.Functor
     Pandora.Pattern.Functor.Adjoint