diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -95,7 +95,7 @@
 * Remove `a` parameter from `Layout` to be able to use natural transformations in methods
 * Return `filter` method to `Stack` data structure
 * Rename `unwrap` to `untwist` method in `Twister` module
-* Rename `composition` to `unwrap` and `Outline` to `Primary` in `Composition` typeclass
+* Rename `composition` to `unwrap` and `Outline` to `Primary` in `Composition` type class
 * Rename `equip` to `wrap` and `Layout` to `Schema` in `Transformer` typeclass
 * Make `Composition` a superclass for `Transformer` typeclass
 * Move all `Junction` modules to `Pattern` submodule except `Kan`
@@ -125,3 +125,20 @@
 * Create `:#` type synonymous for `Tagged` datatype
 * Remove `untag` in favor of `extract` method
 * Rename `Tagged` constructor of `Tagged` to `Tag`
+
+# 0.2.2
+* Change types of `lay` and `wrap` methods of `Transformer` class
+* Define `Adaptable` type class for fitting effects in schemas
+* Define `Failable` and `failure` for adaptable `Conclusion`
+* Define `Optional` and `nothing` for adaptable `Maybe`
+* Rename `Stateful` to `State`, `get` to `current`, `put` to `replace`
+* Define `Stateful` adaptable constraint and adapt `get`, `modify` and `put`
+* Rename `Environmental` to `Environment`
+* Make `env` adaptable effect and remove `local`
+* Define `Accumulator` effect and it's adaptable `gather` method
+* Define `|->` (Coalgebra) and `<-|` (Algebra) type synonyms
+* Remove `oblige` in favor of `Liftable` instance of `Continuation`
+* Remove `environmentally` in favor of `Interpreted` instance for `Environment`
+* Remove `statefully` in favor of `Interpreted` instance for `State`
+
+# 0.2.3
diff --git a/Pandora/Core/Functor.hs b/Pandora/Core/Functor.hs
--- a/Pandora/Core/Functor.hs
+++ b/Pandora/Core/Functor.hs
@@ -1,17 +1,26 @@
 module Pandora.Core.Functor where
 
+infixr 0 :=, <-|, |->
+infixr 1 .:, :.
+infixr 2 ::|:., ::|.:, ::|::
+
 data Variant = Co | Contra
 
-infixr 1 :.
+-- | Parameter application
+type (:=) t a = t a
+
+-- | Functors composition
 type (:.) t u a = t (u a)
 
-infixr 1 .:
+-- | Flipped functors composition
 type (.:) t u a = u (t a)
 
-infixr 0 :=
-type (:=) t a = t a
+-- | Coalgebra's type operator
+type (|->) a t = a -> t a
 
-infixr 2 ::|:., ::|.:, ::|::
+-- | Algebra's type operator
+type (<-|) a t = t a -> a
+
 type (::|:.) p a b = p (p a b) b
 type (::|.:) p a b = p a (p a b)
 type (::|::) p a b = p (p a b) (p a b)
diff --git a/Pandora/Core/Transformation.hs b/Pandora/Core/Transformation.hs
--- a/Pandora/Core/Transformation.hs
+++ b/Pandora/Core/Transformation.hs
@@ -2,6 +2,8 @@
 
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
+infixr 0 ~>
+
 type Natural t u = forall a . (Covariant t, Covariant u) => t a -> u a
 
 type (~>) t u = Natural t u
diff --git a/Pandora/Paradigm/Basis/Conclusion.hs b/Pandora/Paradigm/Basis/Conclusion.hs
--- a/Pandora/Paradigm/Basis/Conclusion.hs
+++ b/Pandora/Paradigm/Basis/Conclusion.hs
@@ -1,9 +1,10 @@
-module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), conclusion, fail) where
+module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where
 
 import Pandora.Core.Functor (Variant (Co))
 import Pandora.Core.Morphism ((.))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap))
+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>)(T))
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -44,29 +45,6 @@
 
 instance Monad (Conclusion e) where
 
-instance Interpreted (Conclusion e) where
-	type Primary (Conclusion e) a = Conclusion e a
-	unwrap x = x
-
-instance Transformer (Conclusion e) where
-	type Schema (Conclusion e) u = UT 'Co 'Co (Conclusion e) u
-	lay x = UT $ Success <$> x
-	wrap x = UT . point $ x
-
-instance Covariant u => Covariant (UT 'Co 'Co (Conclusion e) u) where
-	f <$> UT x = UT $ f <$$> x
-
-instance Applicative u => Applicative (UT 'Co 'Co (Conclusion e) u) where
-	UT f <*> UT x = UT $ apply <$> f <*> x
-
-instance Pointable u => Pointable (UT 'Co 'Co (Conclusion e) u) where
-	point = UT . point . point
-
-instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co (Conclusion e) u) where
-	UT x >>= f = UT $ x >>= conclusion (point . Failure) (unwrap . f)
-
-instance Monad u => Monad (UT 'Co 'Co (Conclusion e) u) where
-
 instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where
 	Success x == Success y = x == y
 	Failure x == Failure y = x == y
@@ -91,3 +69,31 @@
 fail :: (e -> r) -> Conclusion e a -> Conclusion r a
 fail f (Failure x) = Failure $ f x
 fail _ (Success y) = Success y
+
+instance Interpreted (Conclusion e) where
+	type Primary (Conclusion e) a = Conclusion e a
+	unwrap x = x
+
+instance Transformer (Conclusion e) where
+	type Schema (Conclusion e) u = UT 'Co 'Co (Conclusion e) u
+	lay x = T . UT $ Success <$> x
+	wrap x = T . UT . point $ x
+
+type Failable e = Adaptable (Conclusion e)
+
+instance Covariant u => Covariant (UT 'Co 'Co (Conclusion e) u) where
+	f <$> UT x = UT $ f <$$> x
+
+instance Applicative u => Applicative (UT 'Co 'Co (Conclusion e) u) where
+	UT f <*> UT x = UT $ apply <$> f <*> x
+
+instance Pointable u => Pointable (UT 'Co 'Co (Conclusion e) u) where
+	point = UT . point . point
+
+instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co (Conclusion e) u) where
+	UT x >>= f = UT $ x >>= conclusion (point . Failure) (unwrap . f)
+
+instance Monad u => Monad (UT 'Co 'Co (Conclusion e) u) where
+
+failure :: (Covariant t, Failable e t) => e -> t a
+failure = adapt . Failure
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, reset, shift) where
+module Pandora.Paradigm.Basis.Continuation (Continuation (..), cwcc, reset, shift) where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
 import Pandora.Core.Morphism ((.), (!), (%))
@@ -7,6 +7,7 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor.Liftable (Liftable (lift))
 import Pandora.Pattern.Functor.Divariant (($))
 
 newtype Continuation r t a = Continuation { continue :: (->) ::|:. a :. t := r }
@@ -25,17 +26,16 @@
 
 instance Monad t => Monad (Continuation r t) where
 
--- | Make any bindable action continue
-oblige :: Bindable t => t a -> Continuation r t a
-oblige x = Continuation (x >>=)
+instance (forall u . Bindable u) => Liftable (Continuation r) where
+	lift = Continuation . (>>=)
 
 -- | 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
+reset :: (forall u . Bindable u, Bindable t, Pointable t) => Continuation r t r -> Continuation s t r
+reset = lift . 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
diff --git a/Pandora/Paradigm/Basis/Free.hs b/Pandora/Paradigm/Basis/Free.hs
--- a/Pandora/Paradigm/Basis/Free.hs
+++ b/Pandora/Paradigm/Basis/Free.hs
@@ -8,6 +8,7 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Liftable (Liftable (lift))
 import Pandora.Pattern.Functor.Divariant (($))
 
 data Free t a = Pure a | Impure (t :. Free t := a)
@@ -39,3 +40,6 @@
 instance Traversable t => Traversable (Free t) where
 	Pure x ->> f = Pure <$> f x
 	Impure xs ->> f = Impure <$> xs ->>> f
+
+instance Liftable Free where
+	lift x = Impure $ Pure <$> x
diff --git a/Pandora/Paradigm/Basis/Maybe.hs b/Pandora/Paradigm/Basis/Maybe.hs
--- a/Pandora/Paradigm/Basis/Maybe.hs
+++ b/Pandora/Paradigm/Basis/Maybe.hs
@@ -1,9 +1,10 @@
-module Pandora.Paradigm.Basis.Maybe (Maybe (..), maybe) where
+module Pandora.Paradigm.Basis.Maybe (Maybe (..), Optional, maybe, nothing) where
 
 import Pandora.Core.Functor (Variant (Co))
 import Pandora.Core.Morphism ((.))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap))
+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>)(T))
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
@@ -51,29 +52,6 @@
 
 instance Monad Maybe where
 
-instance Interpreted Maybe where
-	type Primary Maybe a = Maybe a
-	unwrap x = x
-
-instance Transformer Maybe where
-	type Schema Maybe u = UT 'Co 'Co Maybe u
-	lay x = UT $ Just <$> x
-	wrap x = UT . point $ x
-
-instance Covariant u => Covariant (UT 'Co 'Co Maybe u) where
-	f <$> UT x = UT $ f <$$> x
-
-instance Applicative u => Applicative (UT 'Co 'Co Maybe u) where
-	UT f <*> UT x = UT $ apply <$> f <*> x
-
-instance Pointable u => Pointable (UT 'Co 'Co Maybe u) where
-	point = UT . point . point
-
-instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co Maybe u) where
-	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f)
-
-instance Monad u => Monad (UT 'Co 'Co Maybe u) where
-
 instance Setoid a => Setoid (Maybe a) where
 	Just x == Just y = x == y
 	Nothing == Nothing = True
@@ -108,3 +86,31 @@
 maybe :: b -> (a -> b) -> Maybe a -> b
 maybe x _ Nothing = x
 maybe _ f (Just y) = f y
+
+instance Interpreted Maybe where
+	type Primary Maybe a = Maybe a
+	unwrap x = x
+
+instance Transformer Maybe where
+	type Schema Maybe u = UT 'Co 'Co Maybe u
+	lay x = T . UT $ Just <$> x
+	wrap x = T. UT . point $ x
+
+type Optional = Adaptable Maybe
+
+instance Covariant u => Covariant (UT 'Co 'Co Maybe u) where
+	f <$> UT x = UT $ f <$$> x
+
+instance Applicative u => Applicative (UT 'Co 'Co Maybe u) where
+	UT f <*> UT x = UT $ apply <$> f <*> x
+
+instance Pointable u => Pointable (UT 'Co 'Co Maybe u) where
+	point = UT . point . point
+
+instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co Maybe u) where
+	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f)
+
+instance Monad u => Monad (UT 'Co 'Co Maybe u) where
+
+nothing :: (Covariant t, Optional t) => t a
+nothing = adapt Nothing
diff --git a/Pandora/Paradigm/Basis/Twister.hs b/Pandora/Paradigm/Basis/Twister.hs
--- a/Pandora/Paradigm/Basis/Twister.hs
+++ b/Pandora/Paradigm/Basis/Twister.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Basis.Twister (Twister (..), untwist, coiterate, section) where
 
-import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Core.Functor (type (:.), type (:=), type (|->))
 import Pandora.Core.Transformation (type (~>))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), comap))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
@@ -59,7 +59,7 @@
 untwist :: Twister t a -> (t :. Twister t) a
 untwist (_ :< xs) = xs
 
-coiterate :: Covariant t => (a -> t a) -> a -> Twister t a
+coiterate :: Covariant t => a |-> t -> a -> Twister t a
 coiterate coalgebra x = x :< (coiterate coalgebra <$> coalgebra x)
 
 section :: Comonad t => t ~> Twister t
diff --git a/Pandora/Paradigm/Basis/Yoneda.hs b/Pandora/Paradigm/Basis/Yoneda.hs
--- a/Pandora/Paradigm/Basis/Yoneda.hs
+++ b/Pandora/Paradigm/Basis/Yoneda.hs
@@ -1,13 +1,14 @@
 module Pandora.Paradigm.Basis.Yoneda (Yoneda (..)) where
 
 import Pandora.Core.Morphism ((.), (!), identity)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Pattern.Functor.Liftable (Liftable (lift))
 import Pandora.Pattern.Functor.Divariant (($))
 
 newtype Yoneda t a = Yoneda
@@ -31,6 +32,9 @@
 instance Extractable t => Extractable (Yoneda t) where
 	extract (Yoneda f) = extract $ f identity
 
+instance Liftable Yoneda where
+	lift x = Yoneda (\f -> f <$> x)
+
 instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where
-	phi f = point . f . point
-	psi f = extract . extract . comap f
+	x -| f = point . f . point $ x
+	x |- g = extract . extract $ g <$> x
diff --git a/Pandora/Paradigm/Controlflow/Joint.hs b/Pandora/Paradigm/Controlflow/Joint.hs
--- a/Pandora/Paradigm/Controlflow/Joint.hs
+++ b/Pandora/Paradigm/Controlflow/Joint.hs
@@ -3,3 +3,4 @@
 import Pandora.Paradigm.Controlflow.Joint.Schemes as Exports
 import Pandora.Paradigm.Controlflow.Joint.Transformer as Exports
 import Pandora.Paradigm.Controlflow.Joint.Interpreted as Exports
+import Pandora.Paradigm.Controlflow.Joint.Adaptable as Exports
diff --git a/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs b/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
@@ -0,0 +1,148 @@
+module Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (..)) where
+
+import Pandora.Core.Morphism (identity, (.))
+import Pandora.Core.Transformation (type (~>))
+import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Functor.Pointable (Pointable)
+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>))
+
+class Adaptable eff schema where
+	{-# MINIMAL adapt #-}
+	adapt :: eff ~> schema
+
+type Layable t u = (Transformer t, Covariant u)
+type Wrappable t u = (Transformer t, Pointable u)
+
+instance Adaptable t t where
+	adapt = identity
+
+instance Layable t u => Adaptable u (t :> u) where
+	adapt = lay
+
+instance Wrappable t u => Adaptable t (t :> u) where
+	adapt = wrap
+
+instance
+	( Layable t (Schema u v)
+	, Wrappable u v
+	) => Adaptable u (t :> u :> v) where
+	adapt = lay . wrap
+
+instance
+	( Layable t (Schema u v)
+	, Layable u v
+	) => Adaptable v (t :> u :> v) where
+	adapt = lay . lay
+
+instance
+	( Layable t (Schema u (v :> w))
+	, Layable u (Schema v w)
+	, Wrappable v w
+	) => Adaptable v (t :> u :> v :> w) where
+	adapt = lay . lay . wrap
+
+instance
+	( Layable t (Schema u v)
+	, Layable t (Schema u (v :> w))
+	, Layable u (Schema v w)
+	, Layable v w
+	) => Adaptable w (t :> u :> v :> w) where
+	adapt = lay . lay . lay
+
+instance (Layable t (Schema u (v :> w :> x))
+	, Layable u (Schema v (w :> x))
+	, Layable v (Schema w x)
+	, Layable w x
+	) => Adaptable x (t :> u :> v :> w :> x) where
+	adapt = lay . lay . lay . lay
+
+instance (Layable t (Schema u (v :> w :> x))
+	, Layable u (Schema v (w :> x))
+	, Layable v (Schema w x)
+	, Wrappable w x
+	) => Adaptable w (t :> u :> v :> w :> x) where
+	adapt = lay . lay . lay . wrap
+
+instance
+	( Layable t (Schema u (v :> w :> x :> y))
+	, Layable u (Schema v (w :> x :> y))
+	, Layable v (Schema w (x :> y))
+	, Layable w (Schema x y)
+	, Layable x y
+	) => Adaptable y (t :> u :> v :> w :> x :> y) where
+	adapt = lay . lay . lay . lay . lay
+
+instance
+	( Layable t (Schema u (v :> w :> x :> y))
+	, Layable u (Schema v (w :> x :> y))
+	, Layable v (Schema w (x :> y))
+	, Layable w (Schema x y)
+	, Wrappable x y
+	) => Adaptable x (t :> u :> v :> w :> x :> y) where
+	adapt = lay . lay . lay . lay . wrap
+
+instance
+	( Layable t (Schema u (v :> w :> x :> y :> z))
+	, Layable u (Schema v (w :> x :> y :> z))
+	, Layable v (Schema w (x :> y :> z))
+	, Layable w (Schema x (y :> z))
+	, Layable x (Schema y z)
+	, Layable y z
+	) => Adaptable z (t :> u :> v :> w :> x :> y :> z) where
+	adapt = lay . lay . lay . lay . lay . lay
+
+instance
+	( Layable t (Schema u (v :> w :> x :> y :> z))
+	, Layable u (Schema v (w :> x :> y :> z))
+	, Layable v (Schema w (x :> y :> z))
+	, Layable w (Schema x (y :> z))
+	, Layable x (Schema y z)
+	, Wrappable y z
+	) => Adaptable y (t :> u :> v :> w :> x :> y :> z) where
+	adapt = lay . lay . lay . lay . lay . wrap
+
+instance
+	( Layable t (Schema u (v :> w :> x :> y :> z :> f))
+	, Layable u (Schema v (w :> x :> y :> z :> f))
+	, Layable v (Schema w (x :> y :> z :> f))
+	, Layable w (Schema x (y :> z :> f))
+	, Layable x (Schema y (z :> f))
+	, Layable y (Schema z f)
+	, Layable z f
+	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f) where
+	adapt = lay . lay . lay . lay . lay . lay . lay
+
+instance
+	( Layable t (Schema u (v :> w :> x :> y :> z :> f))
+	, Layable u (Schema v (w :> x :> y :> z :> f))
+	, Layable v (Schema w (x :> y :> z :> f))
+	, Layable w (Schema x (y :> z :> f))
+	, Layable x (Schema y (z :> f))
+	, Layable y (Schema z f)
+	, Wrappable z f
+	) => Adaptable z (t :> u :> v :> w :> x :> y :> z :> f) where
+	adapt = lay . lay . lay . lay . lay . lay . wrap
+
+instance
+	( Layable t (Schema u (v :> w :> x :> y :> z :> f :> h))
+	, Layable u (Schema v (w :> x :> y :> z :> f :> h))
+	, Layable v (Schema w (x :> y :> z :> f :> h))
+	, Layable w (Schema x (y :> z :> f :> h))
+	, Layable x (Schema y (z :> f :> h))
+	, Layable y (Schema z (f :> h))
+	, Layable z (Schema f h)
+	, Layable f h
+	) => Adaptable h (t :> u :> v :> w :> x :> y :> z :> f :> h) where
+	adapt = lay . lay . lay . lay . lay . lay . lay . lay
+
+instance
+	( Layable t (Schema u (v :> w :> x :> y :> z :> f :> h))
+	, Layable u (Schema v (w :> x :> y :> z :> f :> h))
+	, Layable v (Schema w (x :> y :> z :> f :> h))
+	, Layable w (Schema x (y :> z :> f :> h))
+	, Layable x (Schema y (z :> f :> h))
+	, Layable y (Schema z (f :> h))
+	, Layable z (Schema f h)
+	, Wrappable f h
+	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where
+	adapt = lay . lay . lay . lay . lay . lay . lay . wrap
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer.hs
@@ -1,18 +1,55 @@
-module Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (..), type (:>)) where
+module Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (..), (:>) (..)) where
 
+import Pandora.Core.Morphism ((.))
 import Pandora.Core.Transformation (type (~>))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted)
-import Pandora.Pattern.Functor.Covariant (Covariant)
-import Pandora.Pattern.Functor.Pointable (Pointable)
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Divariant (($))
 
 class Interpreted t => Transformer t where
 	{-# MINIMAL lay, wrap #-}
 	type Schema (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> t u
-	lay :: Covariant u => u ~> Schema t u
-	wrap :: Pointable u => t ~> Schema t u
-
--- infixr 1 :>
--- type (:>) t u a = Transformer t => Schema t u a
+	lay :: Covariant u => u ~> t :> u
+	wrap :: Pointable u => t ~> t :> u
 
 infixr 3 :>
-newtype (:>) t u a = T { trans :: Transformer t => Schema t u a }
+newtype (:>) t u a = T { trans :: Schema t u a }
+
+instance Covariant (Schema t u) => Covariant (t :> u) where
+	f <$> T x = T $ f <$> x
+
+instance Pointable (Schema t u) => Pointable (t :> u) where
+	point = T . point
+
+instance Extractable (Schema t u) => Extractable (t :> u) where
+	extract = extract . trans
+
+instance Applicative (Schema t u) => Applicative (t :> u) where
+	T f <*> T x = T $ f <*> x
+
+instance Alternative (Schema t u) => Alternative (t :> u) where
+	T x <+> T y = T $ x <+> y
+
+instance Traversable (Schema t u) => Traversable (t :> u) where
+	T x ->> f = T <$> x ->> f
+
+instance Distributive (Schema t u) => Distributive (t :> u) where
+	x >>- f = T $ x >>- trans . f
+
+instance Bindable (Schema t u) => Bindable (t :> u) where
+	T x >>= f = T $ x >>= trans . f
+
+instance Extendable (Schema t u) => Extendable (t :> u) where
+	T x =>> f = T $ x =>> f . T
+
+instance (Interpreted (Schema t u), Transformer t) => Interpreted (t :> u) where
+	type Primary (t :> u) a = Primary (Schema t u) a
+	unwrap (T x) = unwrap x
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -2,5 +2,6 @@
 
 import Pandora.Paradigm.Inventory.Optics as Exports
 import Pandora.Paradigm.Inventory.Storage as Exports
-import Pandora.Paradigm.Inventory.Stateful as Exports
-import Pandora.Paradigm.Inventory.Environmental as Exports
+import Pandora.Paradigm.Inventory.State as Exports
+import Pandora.Paradigm.Inventory.Environment as Exports
+import Pandora.Paradigm.Inventory.Accumulator as Exports
diff --git a/Pandora/Paradigm/Inventory/Accumulator.hs b/Pandora/Paradigm/Inventory/Accumulator.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Inventory/Accumulator.hs
@@ -0,0 +1,61 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where
+
+import Pandora.Core.Functor (Variant (Co))
+import Pandora.Core.Morphism ((.))
+import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>) (T))
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+
+newtype Accumulator e a = Accumulator (e :*: a)
+
+instance Covariant (Accumulator e) where
+	f <$> Accumulator x = Accumulator $ f <$> x
+
+instance Semigroup e => Applicative (Accumulator e) where
+	f <*> v = Accumulator $ k (unwrap f) (unwrap v) where
+		k ~(e :*: g) ~(e' :*: w) = e + e' :*: g w
+
+instance Monoid e => Pointable (Accumulator e) where
+	point = Accumulator . (zero :*:)
+
+instance Semigroup e => Bindable (Accumulator e) where
+	Accumulator (e :*: x) >>= f = let (e' :*: b) = unwrap $ f x in
+		Accumulator $ e + e':*: b
+
+instance Interpreted (Accumulator e) where
+	type Primary (Accumulator e) a = e :*: a
+	unwrap (Accumulator x) = x
+
+instance Monoid e => Transformer (Accumulator e) where
+	type Schema (Accumulator e) u = UT 'Co 'Co ((:*:) e) u
+	lay x = T . UT $ (zero :*:) <$> x
+	wrap = T . UT . point . unwrap
+
+type Accumulated e t = Adaptable (Accumulator e) t
+
+instance Covariant u => Covariant (UT 'Co 'Co ((:*:) e) u) where
+	f <$> UT x = UT $ f <$$> x
+
+instance (Semigroup e, Applicative u) => Applicative (UT 'Co 'Co ((:*:) e) u) where
+	UT f <*> UT x = UT $ k <$> f <*> x where
+		k ~(u :*: g) ~(v :*: y) = u + v :*: g y
+
+instance (Pointable u, Monoid e) => Pointable (UT 'Co 'Co ((:*:) e) u) where
+	point = UT . point . (zero :*:)
+
+instance (Semigroup e, Pointable u, Bindable u) => Bindable (UT 'Co 'Co ((:*:) e) u) where
+	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> unwrap (f v)
+
+gather :: (Covariant t, Accumulated e t) => e -> t ()
+gather x = adapt . Accumulator $ x :*: ()
diff --git a/Pandora/Paradigm/Inventory/Environment.hs b/Pandora/Paradigm/Inventory/Environment.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Inventory/Environment.hs
@@ -0,0 +1,62 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where
+
+import Pandora.Core.Functor (Variant (Co))
+import Pandora.Core.Morphism (identity, (.), (!), (%))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>) (T))
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
+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.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor.Divariant (($))
+
+newtype Environment e a = Environment (e -> a)
+
+instance Covariant (Environment e) where
+	f <$> Environment x = Environment $ f . x
+
+instance Pointable (Environment e) where
+	point x = Environment (x !)
+
+instance Applicative (Environment e) where
+	f <*> x = Environment $ \e -> unwrap f e $ unwrap x e
+
+instance Distributive (Environment e) where
+	g >>- f = Environment $ g >>- (unwrap <$> f)
+
+instance Bindable (Environment e) where
+	Environment x >>= f = Environment $ \e -> unwrap % e . f . x $ e
+
+instance Monad (Environment e) where
+
+instance Interpreted (Environment e) where
+	type Primary (Environment e) a = (->) e a
+	unwrap (Environment x) = x
+
+instance Transformer (Environment e) where
+	type Schema (Environment e) u = TU 'Co 'Co ((->) e) u
+	lay = T . TU . (!)
+	wrap x = T. TU $ point <$> unwrap x
+
+type Configured e = Adaptable (Environment e)
+
+instance Covariant u => Covariant (TU 'Co 'Co ((->) e) u) where
+	f <$> TU x = TU $ \r -> f <$> x r
+
+instance (Covariant u, Pointable u) => Pointable (TU 'Co 'Co ((->) e) u) where
+	point = TU . point . point
+
+instance Applicative u => Applicative (TU 'Co 'Co ((->) e) u) where
+	TU f <*> TU x = TU $ \r -> f r <*> x r
+
+instance Bindable u => Bindable (TU 'Co 'Co ((->) e) u) where
+	TU x >>= f = TU $ \e -> x e >>= ($ e) . unwrap . f
+
+env :: (Covariant t, Configured e t) => t e
+env = adapt $ Environment identity
diff --git a/Pandora/Paradigm/Inventory/Environmental.hs b/Pandora/Paradigm/Inventory/Environmental.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Inventory/Environmental.hs
+++ /dev/null
@@ -1,34 +0,0 @@
-module Pandora.Paradigm.Inventory.Environmental (Environmental (..), env, local) where
-
-import Pandora.Core.Morphism (identity, (.), (!))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Divariant (($))
-
-newtype Environmental e a = Environmental (e -> a)
-
-environmentally :: e -> Environmental e a -> a
-environmentally e (Environmental f) = f e
-
-instance Covariant (Environmental e) where
-	f <$> Environmental x = Environmental $ f . x
-
-instance Pointable (Environmental e) where
-	point x = Environmental (x !)
-
-instance Applicative (Environmental e) where
-	f <*> x = Environmental $ \e -> environmentally e f $ environmentally e x
-
-instance Bindable (Environmental e) where
-	Environmental x >>= f = Environmental $ \e -> environmentally e . f . x $ e
-
-instance Monad (Environmental e) where
-
-env :: Environmental e e
-env = Environmental identity
-
-local :: (e -> e) -> Environmental e a -> Environmental e a
-local f (Environmental x) = Environmental $ x . f
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
@@ -1,18 +1,20 @@
-module Pandora.Paradigm.Inventory.Optics
-	(Lens, type (:-.), (|>), view, set, over, (^.), (.~), (%~)) where
+{-# OPTIONS_GHC -fno-warn-orphans #-}
 
-import Pandora.Core.Morphism ((.), (!))
+module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, (^.), (.~), (%~)) where
+
+import Pandora.Core.Morphism ((.), (!), (%))
 import Pandora.Paradigm.Basis.Product (Product ((:*:)))
-import Pandora.Paradigm.Inventory.Stateful (Stateful (Stateful), statefully)
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (unwrap))
+import Pandora.Paradigm.Inventory.State (State (State))
 import Pandora.Paradigm.Inventory.Storage (Storage (Storage), access, position, retrofit)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Functor.Divariant (($))
 
-instance Adjoint (Storage s) (Stateful s) where
-	v -| f = Stateful $ \s -> (:*:) s . f . Storage $ s :*: (v !)
-	Storage (s :*: f) |- g = extract . statefully s . g $ f s
+instance Adjoint (Storage s) (State s) where
+	v -| f = State $ \s -> (:*:) s . f . Storage $ s :*: (v !)
+	Storage (s :*: f) |- g = extract . unwrap % s . g $ f s
 
 infixr 0 :-.
 type (:-.) src tgt = Lens src tgt
diff --git a/Pandora/Paradigm/Inventory/State.hs b/Pandora/Paradigm/Inventory/State.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Inventory/State.hs
@@ -0,0 +1,83 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Inventory.State (State (..), Stateful, current, modify, replace, fold, find) where
+
+import Pandora.Core.Functor (Variant (Co), type (:.), type (:=))
+import Pandora.Core.Morphism ((.), (%))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>) (T))
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))
+import Pandora.Paradigm.Basis.Predicate (Predicate (predicate))
+import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
+import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Object.Setoid (bool)
+
+newtype State s a = State ((->) s :. (:*:) s := a)
+
+instance Covariant (State s) where
+	f <$> State x = State $ \old -> f <$> x old
+
+instance Applicative (State s) where
+	State f <*> State x = State $ \old ->
+		let latest = attached . x $ old in
+			latest :*: (extract (f old) . extract . x $ old)
+
+instance Pointable (State s) where
+	point x = State $ \s -> s :*: x
+
+instance Bindable (State s) where
+	State x >>= f = State $ \old ->
+		uncurry (unwrap %) $ f <$> x old
+
+instance Monad (State s) where
+
+fold :: Traversable t => s -> (a -> s -> s) -> t a -> s
+fold start op struct = extract . unwrap @(State _) % start $
+	struct ->> modify . op $> () *> current
+
+find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a
+find p struct = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x) struct
+
+instance Interpreted (State s) where
+	type Primary (State s) a = (->) s :. (:*:) s := a
+	unwrap (State x) = x
+
+instance Transformer (State s) where
+	type Schema (State s) u = TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)
+	lay x = T . TUV $ \s -> (s :*:) <$> x
+	wrap x = T . TUV $ point <$> unwrap x
+
+type Stateful s = Adaptable (State s)
+
+instance Covariant u => Covariant (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+	f <$> TUV x = TUV $ \old -> f <$$> x old
+
+instance Bindable u => Applicative (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+	TUV f <*> TUV x = TUV $ \old -> f old >>= \(new :*: g) -> g <$$> x new
+
+instance Pointable u => Pointable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+	point x = TUV $ \s -> point $ s :*: x
+
+instance Bindable u => Bindable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . unwrap . f $ y
+
+instance Monad u => Monad (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
+
+current :: (Covariant t, Stateful s t) => t s
+current = adapt $ State delta
+
+modify :: (Covariant t, Stateful s t) => (s -> s) -> t ()
+modify f = adapt $ State $ \s -> f s :*: ()
+
+replace :: (Covariant t, Stateful s t) => s -> t ()
+replace s = adapt $ State $ \_ -> s :*: ()
diff --git a/Pandora/Paradigm/Inventory/Stateful.hs b/Pandora/Paradigm/Inventory/Stateful.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Inventory/Stateful.hs
+++ /dev/null
@@ -1,82 +0,0 @@
-module Pandora.Paradigm.Inventory.Stateful
-	(Stateful (..), statefully, get, modify, put, fold, find) where
-
-import Pandora.Core.Functor (Variant (Co), type (:.), type (:=))
-import Pandora.Core.Morphism ((.))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap))
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))
-import Pandora.Paradigm.Basis.Predicate (Predicate (predicate))
-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>)))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Object.Setoid (bool)
-
-newtype Stateful s a = Stateful ((->) s :. (:*:) s := a)
-
-statefully :: s -> Stateful s a -> s :*: a
-statefully initial (Stateful state) = state initial
-
-instance Covariant (Stateful s) where
-	f <$> Stateful x = Stateful $ \old -> f <$> x old
-
-instance Applicative (Stateful s) where
-	Stateful f <*> Stateful x = Stateful $ \old ->
-		let latest = attached . x $ old in
-			latest :*: (extract (f old) . extract . x $ old)
-
-instance Pointable (Stateful s) where
-	point x = Stateful $ \s -> s :*: x
-
-instance Bindable (Stateful s) where
-	Stateful x >>= f = Stateful $ \old ->
-		uncurry statefully $ f <$> x old
-
-instance Monad (Stateful s) where
-
-get :: Stateful s s
-get = Stateful delta
-
-modify :: (s -> s) -> Stateful s ()
-modify f = Stateful $ \s -> f s :*: ()
-
-put :: s -> Stateful s ()
-put s = Stateful $ \_ -> s :*: ()
-
-fold :: Traversable t => s -> (a -> s -> s) -> t a -> s
-fold start op struct = extract . statefully start $
-	struct ->> modify . op $> () *> get
-
-find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a
-find p struct = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x) struct
-
-instance Interpreted (Stateful s) where
-	type Primary (Stateful s) a = (->) s :. (:*:) s := a
-	unwrap (Stateful x) = x
-
-instance Transformer (Stateful s) where
-	type Schema (Stateful s) u = TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)
-	lay x = TUV $ \s -> (s :*:) <$> x
-	wrap x = TUV $ point <$> unwrap x
-
-instance Covariant u => Covariant (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
-	f <$> TUV x = TUV $ \old -> f <$$> x old
-
-instance Bindable u => Applicative (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
-	TUV f <*> TUV x = TUV $ \old -> f old >>= \(new :*: g) -> g <$$> x new
-
-instance Pointable u => Pointable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
-	point x = TUV $ \s -> point $ s :*: x
-
-instance Bindable u => Bindable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
-	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . unwrap . f $ y
-
-instance Monad u => Monad (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where
diff --git a/Pandora/Paradigm/Structure/Cartesian.hs b/Pandora/Paradigm/Structure/Cartesian.hs
--- a/Pandora/Paradigm/Structure/Cartesian.hs
+++ b/Pandora/Paradigm/Structure/Cartesian.hs
@@ -1,8 +1,7 @@
-module Pandora.Paradigm.Structure.Cartesian (Cartesian) where
+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)
-	cartesian :: t a -> t b -> t (a :*: b)
diff --git a/Pandora/Paradigm/Structure/Specific/Graph.hs b/Pandora/Paradigm/Structure/Specific/Graph.hs
--- a/Pandora/Paradigm/Structure/Specific/Graph.hs
+++ b/Pandora/Paradigm/Structure/Specific/Graph.hs
@@ -5,7 +5,7 @@
 import Pandora.Core.Morphism ((.))
 import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))
 import Pandora.Paradigm.Basis.Twister (Twister ((:<)))
-import Pandora.Paradigm.Inventory.Stateful (fold)
+import Pandora.Paradigm.Inventory.State (fold)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
diff --git a/Pandora/Paradigm/Structure/Specific/Stack.hs b/Pandora/Paradigm/Structure/Specific/Stack.hs
--- a/Pandora/Paradigm/Structure/Specific/Stack.hs
+++ b/Pandora/Paradigm/Structure/Specific/Stack.hs
@@ -6,7 +6,7 @@
 import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))
 import Pandora.Paradigm.Basis.Twister (Twister ((:<)), untwist)
-import Pandora.Paradigm.Inventory.Stateful (fold)
+import Pandora.Paradigm.Inventory.State (fold)
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
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 (Covariant (..)) where
 
-import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Core.Functor (type (:.), type (:=), type (<-|))
 import Pandora.Core.Morphism (fix, (.), (!), (%))
 
 infixl 4 <$>, <$, $>
@@ -29,7 +29,7 @@
 	void :: t a -> t ()
 	void x = () <$ x
 	-- | Computing a value from a structure of values
-	loeb :: t (t a -> a) -> t a
+	loeb :: t (a <-| t) -> t a
 	loeb tt = fix (\f -> (\g -> g f) <$> tt)
 	-- | Flipped infix version of 'comap'
 	(<&>) :: t a -> (a -> b) -> t b
diff --git a/Pandora/Pattern/Functor/Distributive.hs b/Pandora/Pattern/Functor/Distributive.hs
--- a/Pandora/Pattern/Functor/Distributive.hs
+++ b/Pandora/Pattern/Functor/Distributive.hs
@@ -14,27 +14,27 @@
 
 infixl 5 >>-, >>>-, >>>>-, >>>>>-
 
-class Covariant u => Distributive u where
+class Covariant t => Distributive t where
 	{-# MINIMAL (>>-) #-}
 	-- | Infix and flipped version of 'collect'
-	(>>-) :: Covariant t => t a -> (a -> u b) -> u :. t := b
+	(>>-) :: Covariant u => u a -> (a -> t b) -> t :. u := b
 
 	-- | Prefix version of '>>-'
-	collect :: Covariant t => (a -> u b) -> t a -> u :. t := b
+	collect :: Covariant u => (a -> t b) -> u a -> t :. u := b
 	collect f t = t >>- f
 	-- | The dual of 'sequence'
-	distribute :: Covariant t => t :. u := a -> u :. t := a
+	distribute :: Covariant u => u :. t := a -> t :. u := a
 	distribute t = t >>- identity
 
 	-- | Infix versions of `collect` with various nesting levels
-	(>>>-) :: (Covariant t, Covariant v)
-		=> t :. v := a -> (a -> u b) -> u :. t :. v := b
+	(>>>-) :: (Covariant u, Covariant v)
+		=> u :. v := a -> (a -> t b) -> t :. u :. v := b
 	x >>>- f = (collect . collect) f x
-	(>>>>-) :: (Covariant t, Covariant v, Covariant w)
-		=> t :. v :. w := a -> (a -> u b) -> u :. t :. v :. w := b
+	(>>>>-) :: (Covariant u, Covariant v, Covariant w)
+		=> u :. v :. w := a -> (a -> t b) -> t :. u :. v :. w := b
 	x >>>>- f = (collect . collect . collect) f x
-	(>>>>>-) :: (Covariant t, Covariant v, Covariant w, Covariant j)
-		=> t :. v :. w :. j := a -> (a -> u b) -> u :. t :. v :. w :. j := b
+	(>>>>>-) :: (Covariant u, Covariant v, Covariant w, Covariant j)
+		=> u :. v :. w :. j := a -> (a -> t b) -> t :. u :. v :. w :. j := b
 	x >>>>>- f = (collect . collect . collect . collect) f x
 
 instance Distributive ((->) e) where
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,6 +1,7 @@
 module Pandora.Pattern.Functor.Extractable (Extractable (..)) where
 
+import Pandora.Core.Functor (type (<-|))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 class Covariant t => Extractable t where
-	extract :: t a -> a
+	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,10 +1,11 @@
 module Pandora.Pattern.Functor.Pointable (Pointable (..)) where
 
+import Pandora.Core.Functor (type (|->))
 import Pandora.Core.Morphism ((!))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 class Covariant t => Pointable t where
-	point :: a -> t a
+	point :: a |-> t
 
 instance Pointable ((->) e) where
 	point = (!)
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,5 +1,6 @@
 module Pandora.Pattern.Functor.Representable (Representable (..)) where
 
+import Pandora.Core.Functor (type (<-|))
 import Pandora.Core.Morphism (identity, (%))
 import Pandora.Pattern.Functor.Pointable (Pointable)
 
@@ -15,7 +16,7 @@
 	{-# MINIMAL (<#>), tabulate #-}
 	type Representation t :: *
 	-- | Infix and flipped version of 'index'
-	(<#>) :: Representation t -> t a -> a
+	(<#>) :: 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/Pattern/Functor/Traversable.hs b/Pandora/Pattern/Functor/Traversable.hs
--- a/Pandora/Pattern/Functor/Traversable.hs
+++ b/Pandora/Pattern/Functor/Traversable.hs
@@ -28,7 +28,7 @@
 	traverse :: (Pointable u, Applicative u) => (a -> u b) -> t a -> u :. t := b
 	traverse f t = t ->> f
 	-- | The dual of 'distribute'
-	sequence :: (Pointable u, Applicative u) => (t :. u) a -> u :. t := a
+	sequence :: (Pointable u, Applicative u) => t :. u := a -> u :. t := a
 	sequence t = t ->> identity
 
 	-- | Infix versions of `traverse` with various nesting levels
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.2.1
+version:             0.2.2
 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
@@ -55,6 +55,7 @@
     Pandora.Paradigm.Controlflow.Joint
     Pandora.Paradigm.Controlflow.Joint.Interpreted
     Pandora.Paradigm.Controlflow.Joint.Transformer
+    Pandora.Paradigm.Controlflow.Joint.Adaptable
     Pandora.Paradigm.Controlflow.Joint.Schemes
     Pandora.Paradigm.Controlflow.Joint.Schemes.TU
     Pandora.Paradigm.Controlflow.Joint.Schemes.TUV
@@ -65,9 +66,10 @@
     Pandora.Paradigm.Controlflow.Pipeline
     -- Tools for datastructures
     Pandora.Paradigm.Inventory
-    Pandora.Paradigm.Inventory.Environmental
+    Pandora.Paradigm.Inventory.Accumulator
+    Pandora.Paradigm.Inventory.Environment
     Pandora.Paradigm.Inventory.Optics
-    Pandora.Paradigm.Inventory.Stateful
+    Pandora.Paradigm.Inventory.State
     Pandora.Paradigm.Inventory.Storage
     -- Tree-based datastructures
     Pandora.Paradigm.Structure
@@ -117,5 +119,6 @@
     FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms
     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes
     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators
+    UndecidableInstances
   default-language: Haskell2010
   ghc-options: -Wall -fno-warn-tabs