diff --git a/seqid.cabal b/seqid.cabal
--- a/seqid.cabal
+++ b/seqid.cabal
@@ -1,5 +1,5 @@
 name:                seqid
-version:             0.3.2
+version:             0.4.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,3 +1,5 @@
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
 module Data.SequenceId
        ( checkSeqId
        , incrementSeqId
@@ -6,29 +8,44 @@
        , checkSeqIdM
        , incrementSeqIdM
        , lastSeqIdM
-       , SequenceIdT
+       , SequenceIdT (..)
+       , runSequenceIdT
+       , execSequenceIdT
        , evalSequenceIdT
 
          -- * Types
        , SequenceIdError (..)
        , SequenceIdErrorType (..)
-       , SequenceId
+       , SequenceId (..)
        ) where
 
 
-import           Control.Monad.Trans.State (StateT, evalStateT, get, modify',
-                                            put)
+import           Control.Applicative       (Applicative)
+import           Control.Monad.State.Class (MonadState, get, modify', put)
+import           Control.Monad.Trans.Class (MonadTrans)
+import           Control.Monad.Trans.State (StateT (..), evalStateT, execStateT)
 import           Data.Word                 (Word32)
 
 
-type SequenceIdT  = StateT SequenceId
-type SequenceId   = Word32
+newtype SequenceIdT m a = SequenceIdT { unSequenceIdT :: StateT SequenceId m a }
+                        deriving (Monad, Applicative, Functor, MonadState SequenceId, MonadTrans)
 
+newtype SequenceId = SequenceId { unSequenceId :: Word32 }
+                   deriving (Show, Eq, Ord, Num, Integral, Real, Enum)
 
+
 evalSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m b
-evalSequenceIdT = evalStateT
+evalSequenceIdT = evalStateT . unSequenceIdT
 
 
+execSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m SequenceId
+execSequenceIdT = execStateT . unSequenceIdT
+
+
+runSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m (b, SequenceId)
+runSequenceIdT = runStateT . unSequenceIdT
+
+
 data SequenceIdError =
     SequenceIdError
     { errType   :: !SequenceIdErrorType
@@ -43,8 +60,8 @@
     deriving (Eq, Show)
 
 
-------------------------------------------------------------------------------
--- | If the current sequence ID is greater than 1 more than the last sequence ID then the appropriate error is returned.
+-- | 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
@@ -53,8 +70,8 @@
     return $ checkSeqId lastSeq currSeq
 
 
-------------------------------------------------------------------------------
--- | If the difference between the sequence IDs is not 1 then the appropriate error is returned.
+-- | 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
@@ -64,24 +81,21 @@
     | otherwise                 = Nothing
 
 
-delta :: SequenceId -> SequenceId -> Integer
-delta lastSeq currSeq = toInteger currSeq - toInteger lastSeq
+delta :: SequenceId -> SequenceId -> Int
+delta lastSeq currSeq = fromIntegral currSeq - fromIntegral lastSeq
 
 
-------------------------------------------------------------------------------
 -- | Update to the next sequense ID
 incrementSeqIdM :: Monad m => SequenceIdT m SequenceId -- ^ Next sequence ID
 incrementSeqIdM = modify' incrementSeqId >> get
 
 
-------------------------------------------------------------------------------
 -- | Increment to the next sequense ID
 incrementSeqId :: SequenceId -- ^ Last sequence ID
                -> SequenceId -- ^ Next sequence ID
 incrementSeqId = (+1)
 
 
-------------------------------------------------------------------------------
 -- | Last seen sequense ID
 lastSeqIdM :: Monad m => SequenceIdT m SequenceId -- ^ Last sequence ID
 lastSeqIdM = get