diff --git a/Control/Joint.hs b/Control/Joint.hs
new file mode 100644
--- /dev/null
+++ b/Control/Joint.hs
@@ -0,0 +1,6 @@
+module Control.Joint (module Exports) where
+
+import Control.Joint.Schemes as Exports
+import Control.Joint.Effects as Exports
+import Control.Joint.Abilities as Exports
+import Control.Joint.Core as Exports
diff --git a/Control/Joint/Abilities.hs b/Control/Joint/Abilities.hs
--- a/Control/Joint/Abilities.hs
+++ b/Control/Joint/Abilities.hs
@@ -3,4 +3,4 @@
 import Control.Joint.Abilities.Liftable as Exports
 import Control.Joint.Abilities.Adaptable as Exports
 import Control.Joint.Abilities.Transformer as Exports
-import Control.Joint.Abilities.Composition as Exports
+import Control.Joint.Abilities.Interpreted as Exports
diff --git a/Control/Joint/Abilities/Composition.hs b/Control/Joint/Abilities/Composition.hs
deleted file mode 100644
--- a/Control/Joint/Abilities/Composition.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module Control.Joint.Abilities.Composition (Composition (..)) where
-
-class Composition t where
-	{-# MINIMAL run #-}
-	type Primary t a :: *
-	run :: t a -> Primary t a
diff --git a/Control/Joint/Abilities/Interpreted.hs b/Control/Joint/Abilities/Interpreted.hs
new file mode 100644
--- /dev/null
+++ b/Control/Joint/Abilities/Interpreted.hs
@@ -0,0 +1,6 @@
+module Control.Joint.Abilities.Interpreted (Interpreted (..)) where
+
+class Interpreted t where
+	{-# MINIMAL run #-}
+	type Primary t a :: *
+	run :: t a -> Primary t a
diff --git a/Control/Joint/Abilities/Liftable.hs b/Control/Joint/Abilities/Liftable.hs
--- a/Control/Joint/Abilities/Liftable.hs
+++ b/Control/Joint/Abilities/Liftable.hs
@@ -1,7 +1,7 @@
 module Control.Joint.Abilities.Liftable where
 
 import Control.Joint.Core (type (~>))
-import Control.Joint.Abilities.Composition (Composition (run))
+import Control.Joint.Abilities.Interpreted (Interpreted (run))
 import Control.Joint.Abilities.Transformer (Transformer (Schema, build, embed), (:>) (T, trans))
 
 class Liftable (eff :: * -> *) (schema :: * -> *) where
@@ -10,6 +10,9 @@
 
 type Embedding t u = (Transformer t, Functor u)
 type Building t u = (Transformer t, Applicative u)
+
+instance Liftable t t where
+	lift = id
 
 instance Embedding t u => Liftable u (t :> u) where
 	lift = embed
diff --git a/Control/Joint/Abilities/Transformer.hs b/Control/Joint/Abilities/Transformer.hs
--- a/Control/Joint/Abilities/Transformer.hs
+++ b/Control/Joint/Abilities/Transformer.hs
@@ -1,16 +1,16 @@
 module Control.Joint.Abilities.Transformer (Transformer (..), (:>) (..)) where
 
 import Control.Joint.Core (type (~>))
-import Control.Joint.Abilities.Composition (Composition (Primary, run))
+import Control.Joint.Abilities.Interpreted (Interpreted (Primary, run))
 
-class Composition t => Transformer t where
+class Interpreted t => Transformer t where
 	{-# MINIMAL embed, build, unite #-}
 	type Schema (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> t u
 	embed :: Functor u => u ~> t :> u
 	build :: Applicative u => t ~> t :> u
 	unite :: Primary (Schema t u) a -> (t :> u) a
 
-infixr 0 :>
+infixr 3 :>
 newtype (:>) t u a = T { trans :: Transformer t => Schema t u a }
 
 instance Functor (Schema t u) => Functor (t :> u) where
@@ -23,6 +23,6 @@
 instance (Transformer t, Monad (Schema t u)) => Monad (t :> u) where
 	T x >>= f = T $ x >>= trans . f
 
-instance (Composition (Schema t u), Transformer t) => Composition (t :> u) where
+instance (Interpreted (Schema t u), Transformer t) => Interpreted (t :> u) where
 	type Primary (t :> u) a = Primary (Schema t u) a
 	run (T x) = run x
diff --git a/Control/Joint/Effects/Either.hs b/Control/Joint/Effects/Either.hs
--- a/Control/Joint/Effects/Either.hs
+++ b/Control/Joint/Effects/Either.hs
@@ -1,10 +1,11 @@
 module Control.Joint.Effects.Either where
 
-import Control.Joint.Abilities (Composition (Primary, run)
-	, Transformer (Schema, embed, build, unite), (:>) (T), Liftable)
+import Control.Joint.Abilities.Interpreted (Interpreted (Primary, run))
+import Control.Joint.Abilities.Transformer (Transformer (Schema, embed, build, unite), (:>) (T))
+import Control.Joint.Abilities.Liftable (Liftable (lift))
 import Control.Joint.Schemes (UT (UT))
 
-instance Composition (Either e) where
+instance Interpreted (Either e) where
 	type Primary (Either e) a = Either e a
 	run x = x
 
@@ -24,7 +25,7 @@
 instance (Applicative u, Monad u) => Monad (UT (Either e) u) where
 	UT x >>= f = UT $ x >>= either (pure . Left) (run . f)
 
-failure :: e -> Either e a
-failure = Left
-
 type Failable e = Liftable (Either e)
+
+failure :: Failable e t => e -> t a
+failure = lift . Left
diff --git a/Control/Joint/Effects/Maybe.hs b/Control/Joint/Effects/Maybe.hs
--- a/Control/Joint/Effects/Maybe.hs
+++ b/Control/Joint/Effects/Maybe.hs
@@ -1,10 +1,12 @@
 module Control.Joint.Effects.Maybe where
 
-import Control.Joint.Abilities (Composition (Primary, run)
-	, Transformer (Schema, embed, build, unite), (:>) (T), Adaptable (adapt), Liftable)
+import Control.Joint.Abilities.Adaptable (Adaptable (adapt))
+import Control.Joint.Abilities.Interpreted (Interpreted (Primary, run))
+import Control.Joint.Abilities.Transformer (Transformer (Schema, embed, build, unite), (:>) (T))
+import Control.Joint.Abilities.Liftable (Liftable (lift))
 import Control.Joint.Schemes (UT (UT))
 
-instance Composition Maybe where
+instance Interpreted Maybe where
 	type Primary Maybe a = Maybe a
 	run x = x
 
@@ -28,3 +30,6 @@
 	adapt = either (const Nothing) Just
 
 type Optional = Liftable Maybe
+
+nothing :: Optional t => t a
+nothing = lift Nothing
diff --git a/Control/Joint/Effects/Reader.hs b/Control/Joint/Effects/Reader.hs
--- a/Control/Joint/Effects/Reader.hs
+++ b/Control/Joint/Effects/Reader.hs
@@ -1,7 +1,8 @@
 module Control.Joint.Effects.Reader where
 
-import Control.Joint.Abilities (Composition (Primary, run)
-	, Transformer (Schema, embed, build, unite), (:>) (T), Liftable)
+import Control.Joint.Abilities.Interpreted (Interpreted (Primary, run))
+import Control.Joint.Abilities.Transformer (Transformer (Schema, embed, build, unite), (:>) (T))
+import Control.Joint.Abilities.Liftable (Liftable (lift))
 import Control.Joint.Schemes (TU (TU))
 
 newtype Reader e a = Reader (e -> a)
@@ -16,7 +17,7 @@
 instance Monad (Reader e) where
 	Reader g >>= f = Reader $ \e -> run (f (g e)) e
 
-instance Composition (Reader e) where
+instance Interpreted (Reader e) where
 	type Primary (Reader e) a = (->) e a
 	run (Reader x) = x
 
@@ -36,7 +37,7 @@
 instance (Applicative u, Monad u) => Monad (TU ((->) e) u) where
 	TU x >>= f = TU $ \e -> x e >>= ($ e) . run . f
 
-get :: Reader e e
-get = Reader $ \e -> e
-
 type Configured e = Liftable (Reader e)
+
+get :: Configured e t => t e
+get = lift $ Reader $ \e -> e
diff --git a/Control/Joint/Effects/State.hs b/Control/Joint/Effects/State.hs
--- a/Control/Joint/Effects/State.hs
+++ b/Control/Joint/Effects/State.hs
@@ -1,8 +1,10 @@
 module Control.Joint.Effects.State where
 
 import Control.Joint.Core (type (:.), type (:=))
-import Control.Joint.Abilities (Composition (Primary, run)
-	, Transformer (Schema, embed, build, unite), (:>) (T), Adaptable (adapt), Liftable)
+import Control.Joint.Abilities.Adaptable (Adaptable (adapt))
+import Control.Joint.Abilities.Interpreted (Interpreted (Primary, run))
+import Control.Joint.Abilities.Transformer (Transformer (Schema, embed, build, unite), (:>) (T))
+import Control.Joint.Abilities.Liftable (Liftable (lift))
 import Control.Joint.Schemes (TUT (TUT))
 import Control.Joint.Effects.Reader (Reader (Reader))
 import Control.Joint.Effects.Writer (Writer (Writer))
@@ -25,7 +27,7 @@
 	State x >>= f = State $ \old ->
 		uncurry statefully $ f <$> x old
 
-instance Composition (State s) where
+instance Interpreted (State s) where
 	type Primary (State s) a = (->) s :. (,) s := a
 	run (State x) = x
 
@@ -45,9 +47,6 @@
 instance Monad u => Monad (TUT ((->) s) u ((,) s)) where
 	TUT x >>= f = TUT $ \old -> x old >>= \(new, y) -> ($ new) . run . f $ y
 
-modify :: (s -> s) -> State s ()
-modify f = State $ \s -> (f s, ())
-
 instance Adaptable (Reader e) (State e) where
 	adapt (Reader f) = State (\e -> (e, f e))
 
@@ -55,3 +54,9 @@
 	adapt (Writer (e, x)) = State (\e -> (e, x))
 
 type Stateful e = Liftable (State e)
+
+modify :: Stateful s t => (s -> s) -> t ()
+modify f = lift $ State $ \s -> (f s, ())
+
+current :: Stateful s t => t s
+current = lift $ State $ \s -> (s, s)
diff --git a/Control/Joint/Effects/Writer.hs b/Control/Joint/Effects/Writer.hs
--- a/Control/Joint/Effects/Writer.hs
+++ b/Control/Joint/Effects/Writer.hs
@@ -1,7 +1,8 @@
 module Control.Joint.Effects.Writer where
 
-import Control.Joint.Abilities (Composition (Primary, run)
-	, Transformer (Schema, embed, build, unite), (:>) (T), Liftable)
+import Control.Joint.Abilities.Interpreted (Interpreted (Primary, run))
+import Control.Joint.Abilities.Transformer (Transformer (Schema, embed, build, unite), (:>) (T))
+import Control.Joint.Abilities.Liftable (Liftable (lift))
 import Control.Joint.Schemes (UT (UT))
 
 newtype Writer e a = Writer (e, a)
@@ -18,7 +19,7 @@
 	Writer (e, x) >>= f = let (e', b) = run $ f x in
 		Writer (e <> e', b)
 
-instance Composition (Writer e) where
+instance Interpreted (Writer e) where
 	type Primary (Writer e) a = (e, a)
 	run (Writer x) = x
 
@@ -38,7 +39,7 @@
 instance (Monoid e, Applicative u, Monad u) => Monad (UT ((,) e) u) where
 	UT x >>= f = UT $ x >>= \(acc, v) -> (\(acc', y) -> (acc <> acc', y)) <$> run (f v)
 
-put :: e -> Writer e ()
-put s = Writer (s, ())
-
 type Accumulated e t = Liftable (Writer e) t
+
+add :: Accumulated e t => e -> t ()
+add s = lift $ Writer (s, ())
diff --git a/Control/Joint/Schemes/TU.hs b/Control/Joint/Schemes/TU.hs
--- a/Control/Joint/Schemes/TU.hs
+++ b/Control/Joint/Schemes/TU.hs
@@ -1,10 +1,10 @@
 module Control.Joint.Schemes.TU (TU (..)) where
 
 import Control.Joint.Core (type (:.), type (:=))
-import Control.Joint.Abilities (Composition (Primary, run))
+import Control.Joint.Abilities (Interpreted (Primary, run))
 
 newtype TU t u a = TU (t :. u := a)
 
-instance Composition (TU t u) where
+instance Interpreted (TU t u) where
 	type Primary (TU t u) a = t :. u := a
 	run (TU x) = x
diff --git a/Control/Joint/Schemes/TUT.hs b/Control/Joint/Schemes/TUT.hs
--- a/Control/Joint/Schemes/TUT.hs
+++ b/Control/Joint/Schemes/TUT.hs
@@ -1,11 +1,11 @@
 module Control.Joint.Schemes.TUT (TUT (..)) where
 
 import Control.Joint.Core (type (:.), type (:=))
-import Control.Joint.Abilities.Composition (Composition (Primary, run))
+import Control.Joint.Abilities.Interpreted (Interpreted (Primary, run))
 
 -- TODO: think about decomposing it on UT and TU
 newtype TUT t u t' a = TUT (t :. u :. t' := a)
 
-instance Composition (TUT t u t') where
+instance Interpreted (TUT t u t') where
 	type Primary (TUT t u t') a = t :. u :. t' := a
 	run (TUT x) = x
diff --git a/Control/Joint/Schemes/UT.hs b/Control/Joint/Schemes/UT.hs
--- a/Control/Joint/Schemes/UT.hs
+++ b/Control/Joint/Schemes/UT.hs
@@ -1,10 +1,10 @@
 module Control.Joint.Schemes.UT (UT (..)) where
 
 import Control.Joint.Core (type (:.), type (:=))
-import Control.Joint.Abilities.Composition (Composition (Primary, run))
+import Control.Joint.Abilities.Interpreted (Interpreted (Primary, run))
 
 newtype UT t u a = UT (u :. t := a)
 
-instance Composition (UT t u) where
+instance Interpreted (UT t u) where
 	type Primary (UT t u) a = u :. t := a
 	run (UT x) = x
diff --git a/joint.cabal b/joint.cabal
--- a/joint.cabal
+++ b/joint.cabal
@@ -1,5 +1,5 @@
 name:                joint
-version:             0.1.5
+version:             0.1.6
 synopsis:            Trying to compose non-composable
 homepage:            https://github.com/iokasimov/joint
 license:             BSD3
@@ -17,9 +17,10 @@
 
 library
   exposed-modules:
+    Control.Joint
     Control.Joint.Core
     Control.Joint.Abilities
-    Control.Joint.Abilities.Composition
+    Control.Joint.Abilities.Interpreted
     Control.Joint.Abilities.Transformer
     Control.Joint.Abilities.Adaptable
     Control.Joint.Abilities.Liftable