diff --git a/seqid.cabal b/seqid.cabal
--- a/seqid.cabal
+++ b/seqid.cabal
@@ -1,5 +1,5 @@
 name:                seqid
-version:             0.1.0
+version:             0.2.0
 synopsis:            Sequence ID production and consumption
 description:         Uniquely identify elements in a sequence.
 License:             BSD3
diff --git a/src/Data/SequenceId.hs b/src/Data/SequenceId.hs
--- a/src/Data/SequenceId.hs
+++ b/src/Data/SequenceId.hs
@@ -1,60 +1,80 @@
 module Data.SequenceId
-       ( checkSeqIdM
-       , checkSeqId
-       , nextSeqIdM
+       ( checkSeqId
        , nextSeqId
-       , SequenceError (..)
-       , SequenceIds (..)
+
+         -- * Monadic
+       , checkSeqIdM
+       , nextSeqIdM
+       , SequenceIdT
+       , evalSequenceIdT
+
+         -- * Types
+       , SequenceIdError (..)
+       , SequenceIdErrorType (..)
        , SequenceId
-       , SequenceT
-       , evalSequenceT
        ) where
 
 
-import           Control.Monad.Trans.State (StateT, evalStateT, gets, modify,
+import           Control.Monad.Trans.State (StateT, evalStateT, get, modify',
                                             put)
 import           Data.Word                 (Word32)
 
 
-newtype LastSeqId = LastSeqId { unLastSeqId :: SequenceId } deriving Show
-type SequenceT = StateT LastSeqId
-type SequenceId = Word32
+type SequenceIdT  = StateT SequenceId
+type SequenceId   = Word32
 
 
-evalSequenceT :: Monad m => SequenceId -> StateT LastSeqId m b -> m b
-evalSequenceT = flip evalStateT . LastSeqId
+evalSequenceIdT :: Monad m => SequenceId -> SequenceIdT m b -> m b
+evalSequenceIdT = flip evalStateT
 
 
-data SequenceIds =
-    SequenceIds
-    { lastSeqId :: SequenceId
-    , currSeqId :: SequenceId
+data SequenceIdError =
+    SequenceIdError
+    { errType   :: !SequenceIdErrorType
+    , lastSeqId :: !SequenceId
+    , currSeqId :: !SequenceId
     } deriving (Eq, Show)
 
 
-data SequenceError
-    = SequenceIdDropped SequenceIds
-    | SequenceIdDuplicated SequenceIds
+data SequenceIdErrorType
+    = SequenceIdDropped
+    | SequenceIdDuplicated
     deriving (Eq, Show)
 
 
-checkSeqIdM :: Monad m => SequenceId -> (SequenceT m) (Maybe SequenceError)
+------------------------------------------------------------------------------
+-- | If the current sequence ID is greater than 1 more than the last sequence ID then the appropriate error is returned.
+checkSeqIdM :: Monad m => SequenceId -- ^ Current sequence ID
+            -> (SequenceIdT m) (Maybe SequenceIdError)
 checkSeqIdM currSeq = do
-    lastSeq <- gets unLastSeqId
-    put $ LastSeqId currSeq
+    lastSeq <- get
+    put $ max lastSeq currSeq
     return $ checkSeqId lastSeq currSeq
 
 
-checkSeqId :: SequenceId -> SequenceId -> Maybe SequenceError
+------------------------------------------------------------------------------
+-- | If the difference between the sequence IDs is not 1 then the appropriate error is returned.
+checkSeqId :: SequenceId -- ^ Last sequence ID
+           -> SequenceId -- ^ Current sequence ID
+           -> Maybe SequenceIdError
 checkSeqId lastSeq currSeq
-    | (currSeq - lastSeq) > 1 = Just . SequenceIdDropped    $ SequenceIds lastSeq currSeq
-    | (currSeq - lastSeq) < 1 = Just . SequenceIdDuplicated $ SequenceIds lastSeq currSeq
-    | otherwise = Nothing
+    | delta lastSeq currSeq > 1 = Just $ SequenceIdError SequenceIdDropped    lastSeq currSeq
+    | delta lastSeq currSeq < 1 = Just $ SequenceIdError SequenceIdDuplicated lastSeq currSeq
+    | otherwise                 = Nothing
 
 
-nextSeqIdM :: Monad m => SequenceT m SequenceId
-nextSeqIdM = modify (LastSeqId . nextSeqId . unLastSeqId) >> gets unLastSeqId
+delta :: SequenceId -> SequenceId -> Integer
+delta lastSeq currSeq = toInteger currSeq - toInteger lastSeq
 
 
-nextSeqId :: SequenceId -> SequenceId
+------------------------------------------------------------------------------
+-- | Update to the next sequense ID
+nextSeqIdM :: Monad m => SequenceIdT m SequenceId -- ^ Next sequence ID
+nextSeqIdM = modify' nextSeqId >> get
+
+
+------------------------------------------------------------------------------
+-- | Update to the next sequense ID
+nextSeqId :: SequenceId -- ^ Last sequence ID
+          -> SequenceId -- ^ Next sequence ID
 nextSeqId = (+1)