diff --git a/Control/Monad/Operational/Mini.hs b/Control/Monad/Operational/Mini.hs
--- a/Control/Monad/Operational/Mini.hs
+++ b/Control/Monad/Operational/Mini.hs
@@ -21,7 +21,7 @@
 
 import Control.Monad.Operational.Class
 import Control.Monad.Operational.TH
-import Data.OpenUnion1.Clean
+import Data.Extensible
 import Control.Elevator
 import Control.Applicative
 import Data.Functor.Identity
@@ -51,8 +51,11 @@
 cloneProgram (Program m) = m return ((>>=) . elevate)
 
 instance Tower (Program t) where
-    type Floors (Program t) = t :> ReifiedProgram t :> Identity :> Empty
-    toLoft = (\t -> Program $ \p i -> i t p) ||> fromReified ||> pure . runIdentity ||> exhaust
+    type Floors (Program t) = '[t, ReifiedProgram t, Identity]
+    stairs = (\t -> Program $ \p i -> i t p)
+        `rung` fromReified
+        `rung` pure . runIdentity
+        `rung` Nil
 
 -- | Reified version of 'Program'. It is useful for testing.
 data ReifiedProgram t a where
@@ -83,5 +86,8 @@
     (t :>>= m) >>= k = t :>>= (>>= k) . m
 
 instance Tower (ReifiedProgram t) where
-    type Floors (ReifiedProgram t) = t :> Program t :> Identity :> Empty
-    toLoft = (:>>= Return) ||> (\(Program m) -> m Return (:>>=)) ||> pure . runIdentity ||> exhaust
+    type Floors (ReifiedProgram t) = '[t, Program t, Identity]
+    stairs = (:>>= Return)
+        `rung` (\(Program m) -> m Return (:>>=))
+        `rung` pure . runIdentity
+        `rung` Nil
diff --git a/Control/Monad/Trans/Operational/Mini.hs b/Control/Monad/Trans/Operational/Mini.hs
--- a/Control/Monad/Trans/Operational/Mini.hs
+++ b/Control/Monad/Trans/Operational/Mini.hs
@@ -32,7 +32,6 @@
 import Control.Applicative
 import Control.Monad.Trans.Class
 import Control.Elevator
-import Data.OpenUnion1.Clean
 import qualified Control.Monad.Operational.Mini as P
 
 newtype ProgramT t m a = ProgramT
@@ -61,15 +60,15 @@
 
 instance (Monad m, Tower m) => Tower (ProgramT t m) where
     type Floors (ProgramT t m) = t
-      :> ReifiedProgramT t m
-      :> P.Program t
-      :> P.ReifiedProgram t
-      :> Floors1 m
-    toLoft = (\t -> ProgramT $ \p _ i -> i t p)
-      ||> fromReifiedT
-      ||> (\(P.Program m) -> ProgramT $ \r _ b -> m r b) 
-      ||> (\(P.Program m) -> ProgramT $ \r _ b -> m r b) . P.fromReified
-      ||> lift . toLoft1
+      ': ReifiedProgramT t m
+      ': P.Program t
+      ': P.ReifiedProgram t
+      ': Floors1 m
+    stairs = (\t -> ProgramT $ \p _ i -> i t p)
+      `rung` fromReifiedT
+      `rung` (\(P.Program m) -> ProgramT $ \r _ b -> m r b)
+      `rung` (\(P.Program m) -> ProgramT $ \r _ b -> m r b) . P.fromReified
+      `rung` liftGondolas
 
 instance MonadTrans (ProgramT t) where
     lift m = ProgramT $ \p l _ -> l (liftM p m)
@@ -120,14 +119,14 @@
 
 instance (Monad m, Tower m) => Tower (ReifiedProgramT t m) where
     type Floors (ReifiedProgramT t m) = t
-      :> ProgramT t m
-      :> P.Program t
-      :> P.ReifiedProgram t
-      :> Floors1 m
-    toLoft = (:>>= Return)
-      ||> (\(ProgramT m) -> m Return (flip Lift id) (:>>=))
-      ||> (\(P.Program m) -> m Return (:>>=))
-      ||> (\(P.Program m) -> m Return (:>>=)) . P.fromReified
-      ||> lift . toLoft1
+      ': ProgramT t m
+      ': P.Program t
+      ': P.ReifiedProgram t
+      ': Floors1 m
+    stairs = (:>>= Return)
+      `rung` (\(ProgramT m) -> m Return (flip Lift id) (:>>=))
+      `rung` (\(P.Program m) -> m Return (:>>=))
+      `rung` (\(P.Program m) -> m Return (:>>=)) . P.fromReified
+      `rung` liftGondolas
 
 instance MonadTrans (ReifiedProgramT t) where lift = flip Lift Return
diff --git a/minioperational.cabal b/minioperational.cabal
--- a/minioperational.cabal
+++ b/minioperational.cabal
@@ -1,5 +1,5 @@
 name:                minioperational
-version:             0.4.8.1
+version:             0.4.9
 synopsis:            fast and simple operational monad
 description:         This package provides tiny implementation of operational monad.
 homepage:            https://github.com/fumieval/minioperational
@@ -23,5 +23,5 @@
     , Control.Monad.Trans.Operational.Mini
     , Control.Monad.Operational.Class
     , Control.Monad.Operational.TH
-  -- other-modules:       
-  build-depends:       base ==4.*, transformers >= 0.2.0 && <0.6, template-haskell, containers, elevator, clean-unions
+  -- other-modules:
+  build-depends:       base ==4.*, transformers >= 0.2.0 && <0.6, template-haskell, containers, elevator >= 0.2 && <0.3, extensible >= 0.2.6 && <3, mtl >= 2.0