diff --git a/machines-binary.cabal b/machines-binary.cabal
--- a/machines-binary.cabal
+++ b/machines-binary.cabal
@@ -1,5 +1,5 @@
 name:                machines-binary
-version:             0.5.0.0
+version:             7.0.0.0
 synopsis:            Binary utilities for the machines library
 homepage:            http://github.com/aloiscochard/machines-binary
 license:             Apache-2.0
diff --git a/src/Data/Binary/Machine.hs b/src/Data/Binary/Machine.hs
--- a/src/Data/Binary/Machine.hs
+++ b/src/Data/Binary/Machine.hs
@@ -1,48 +1,24 @@
 {-# LANGUAGE Rank2Types #-}
 
-module Data.Binary.Machine
-  ( -- * Get
-    processGet,
-    processDecoder,
-    processGetL,
-    stackGet,
-    streamGet,
-    streamGetL,
-
-    -- * Put
-    processPut,
-
-    -- * Types
-    DecodingError (..),
-  )
-where
+module Data.Binary.Machine (
+  -- * Get
+    processGet
+  , processGetL
+  , streamGet
+  , streamGetL
+  -- * Put
+  , processPut
+  -- * Types
+  , DecodingError(..)
+  ) where
 
-import Data.Binary.Get (ByteOffset, Decoder (..), Get, pushChunk, runGetIncremental)
-import Data.Binary.Put (Put, runPut)
 import Data.ByteString (ByteString)
-import qualified Data.ByteString.Lazy as Lazy
-import Data.Machine (Is (Refl), MachineT (..), Plan, Process, ProcessT, Step (Await, Yield), auto, echo, repeatedly, stopped, yield)
-import Data.Machine.Stack (Stack (..), pop, push, stack)
-
-processPut :: Monad m => (a -> Put) -> ProcessT m a ByteString
-processPut f = auto $ Lazy.toStrict . runPut . f
-
-processGet :: Monad m => Get a -> ProcessT m ByteString (Either String a)
-processGet getA = processDecoder (runGetIncremental getA)
-
-processDecoder :: Monad m => Decoder a -> ProcessT m ByteString (Either String a)
-processDecoder decA = processDecoder' decA stopped
-
-processDecoder' :: Monad m => Decoder a -> ProcessT m ByteString (Either String a) -> ProcessT m ByteString (Either String a)
-processDecoder' decA r = MachineT . return $ Await f Refl stopped
-  where
-    f xs = case pushChunk decA xs of
-      Fail _ _ e -> yield' $ Left e
-      Done _ _ a -> yield' $ Right a
-      decA' -> processDecoder' decA' r
-    yield' ea = MachineT . return $ Yield ea r
+import Data.Binary.Get (Decoder(..), Get, ByteOffset, pushChunk, runGetIncremental)
+import Data.Binary.Put (Put, runPut)
+import Data.Machine (Plan, ProcessT, Process, auto, repeatedly, yield, echo)
+import Data.Machine.Stack (Stack(..), stack, push, pop)
 
---------------------------------------------------------------------------
+import qualified Data.ByteString.Lazy as Lazy
 
 -- |
 -- Construct a Plan that run a 'Get' until it fails or it return a parsed result.
@@ -55,7 +31,7 @@
 -- @
 -- -- construct the machine
 -- myMachine :: 'Machine' ('Stack' ByteString) (Either DecodingError Word8)
--- myMachine = 'construct' $ 'stackGet' 'getWord8'
+-- myMachine = 'construct' $ 'processGet' 'getWord8'
 --
 -- -- run the machine
 -- run $ 'stack' ('source' ["abc", "d", "efgh"]) myMachine
@@ -68,16 +44,16 @@
 -- --run m2 after m1
 -- myMachine = m1 <> m2
 --   where
---     m1 = construct $ stackGet (getByteString 5)
---     m2 = construct $ stackGet (getByteString 1)
+--     m1 = construct $ processGet (getByteString 5)
+--     m2 = construct $ processGet (getByteString 1)
 --
 -- run $ stack (source ["abc", "d", "efgh"]) myMachine
 -- > [Right "abcde",Right "f"]
 -- @
-stackGet :: Get a -> Plan (Stack ByteString) (Either DecodingError a) ()
-stackGet getA = _getPlan getA >>= pure . fmap snd >>= yield
+processGet :: Get a -> Plan (Stack ByteString) (Either DecodingError a) ()
+processGet getA = _getPlan getA >>= pure . fmap snd >>= yield
 
--- | Same as 'stackGet' with additional information about the number
+-- | Same as 'processGet' with additional information about the number
 -- of bytes consumed by the 'Get'
 processGetL :: Get a -> Plan (Stack ByteString) (Either DecodingError (ByteOffset, a)) ()
 processGetL getA = _getPlan getA >>= yield
@@ -89,21 +65,24 @@
 -- > [Right "ab",Right "cd",Right "ef",Right "gh"]
 -- @
 streamGet :: Get a -> Process ByteString (Either DecodingError a)
-streamGet getA = stack echo (repeatedly $ stackGet getA)
+streamGet getA = stack echo (repeatedly $ processGet getA)
 
 -- | Same as 'streamGet' with additional information about the number
 -- of bytes consumed by the 'Get'
 streamGetL :: Get a -> Process ByteString (Either DecodingError (ByteOffset, a))
 streamGetL getA = stack echo (repeatedly $ processGetL getA)
 
+-- | Encode evrery input object with a 'Put'
+processPut :: Monad m => (a -> Put) -> ProcessT m a ByteString
+processPut f = auto $ Lazy.toStrict . runPut . f
+
 -- | A 'Get' decoding error.
 data DecodingError = DecodingError
-  { -- | Number of bytes consumed before the error
-    deConsumed :: {-# UNPACK #-} !ByteOffset,
-    -- | Error message
-    deMessage :: !String
-  }
-  deriving (Show, Read, Eq)
+  { deConsumed :: {-# UNPACK #-} !ByteOffset
+    -- ^ Number of bytes consumed before the error
+  , deMessage  :: !String
+    -- ^ Error message
+  } deriving (Show, Read, Eq)
 
 --------------------------------------------------------------------------
 -- Internals
@@ -113,9 +92,8 @@
   case pushChunk decA xs of
     Fail leftovers consumed e -> push leftovers >> pure (Left (DecodingError consumed e))
     Done leftovers consumed a -> push leftovers >> pure (Right (consumed, a))
-    decA' -> _decoderPlan decA'
+    decA'                     -> _decoderPlan decA'
 
 _getPlan :: Get a -> Plan (Stack ByteString) o (Either DecodingError (ByteOffset, a))
 _getPlan getA = _decoderPlan $ runGetIncremental getA
-
 --------------------------------------------------------------------------