packages feed

seqid 0.5.3 → 0.6.0

raw patch · 2 files changed

+22/−28 lines, 2 filesnew-uploaderPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

- Data.SequenceId: SequenceId :: Word32 -> SequenceId
- Data.SequenceId: [unSequenceId] :: SequenceId -> Word32
- Data.SequenceId: instance Control.Monad.Trans.Class.MonadTrans Data.SequenceId.SequenceIdT
- Data.SequenceId: instance GHC.Base.Functor m => GHC.Base.Functor (Data.SequenceId.SequenceIdT m)
- Data.SequenceId: instance GHC.Base.Monad m => Control.Monad.State.Class.MonadState Data.SequenceId.SequenceId (Data.SequenceId.SequenceIdT m)
- Data.SequenceId: instance GHC.Base.Monad m => GHC.Base.Applicative (Data.SequenceId.SequenceIdT m)
- Data.SequenceId: instance GHC.Base.Monad m => GHC.Base.Monad (Data.SequenceId.SequenceIdT m)
- Data.SequenceId: instance GHC.Classes.Eq Data.SequenceId.SequenceId
- Data.SequenceId: instance GHC.Classes.Eq Data.SequenceId.SequenceIdError
- Data.SequenceId: instance GHC.Classes.Ord Data.SequenceId.SequenceId
- Data.SequenceId: instance GHC.Enum.Enum Data.SequenceId.SequenceId
- Data.SequenceId: instance GHC.Num.Num Data.SequenceId.SequenceId
- Data.SequenceId: instance GHC.Real.Integral Data.SequenceId.SequenceId
- Data.SequenceId: instance GHC.Real.Real Data.SequenceId.SequenceId
- Data.SequenceId: instance GHC.Show.Show Data.SequenceId.SequenceId
- Data.SequenceId: instance GHC.Show.Show Data.SequenceId.SequenceIdError
- Data.SequenceId: newtype SequenceId
+ Data.SequenceId: instance Control.Monad.Trans.Class.MonadTrans (Data.SequenceId.SequenceIdT s)
+ Data.SequenceId: instance GHC.Base.Functor m => GHC.Base.Functor (Data.SequenceId.SequenceIdT s m)
+ Data.SequenceId: instance GHC.Base.Monad m => Control.Monad.State.Class.MonadState s (Data.SequenceId.SequenceIdT s m)
+ Data.SequenceId: instance GHC.Base.Monad m => GHC.Base.Applicative (Data.SequenceId.SequenceIdT s m)
+ Data.SequenceId: instance GHC.Base.Monad m => GHC.Base.Monad (Data.SequenceId.SequenceIdT s m)
+ Data.SequenceId: instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.SequenceId.SequenceIdError a)
+ Data.SequenceId: instance GHC.Show.Show a => GHC.Show.Show (Data.SequenceId.SequenceIdError a)
- Data.SequenceId: SequenceIdError :: !SequenceIdErrorType -> !SequenceId -> !SequenceId -> SequenceIdError
+ Data.SequenceId: SequenceIdError :: !SequenceIdErrorType -> !a -> !a -> SequenceIdError a
- Data.SequenceId: SequenceIdT :: StateT SequenceId m a -> SequenceIdT m a
+ Data.SequenceId: SequenceIdT :: StateT s m a -> SequenceIdT s m a
- Data.SequenceId: [currSeqId] :: SequenceIdError -> !SequenceId
+ Data.SequenceId: [currSeqId] :: SequenceIdError a -> !a
- Data.SequenceId: [errType] :: SequenceIdError -> !SequenceIdErrorType
+ Data.SequenceId: [errType] :: SequenceIdError a -> !SequenceIdErrorType
- Data.SequenceId: [lastSeqId] :: SequenceIdError -> !SequenceId
+ Data.SequenceId: [lastSeqId] :: SequenceIdError a -> !a
- Data.SequenceId: [unSequenceIdT] :: SequenceIdT m a -> StateT SequenceId m a
+ Data.SequenceId: [unSequenceIdT] :: SequenceIdT s m a -> StateT s m a
- Data.SequenceId: checkSeqId :: SequenceId -> SequenceId -> Maybe SequenceIdError
+ Data.SequenceId: checkSeqId :: Integral s => s -> s -> Maybe (SequenceIdError s)
- Data.SequenceId: checkSeqIdM :: Monad m => SequenceId -> (SequenceIdT m) (Maybe SequenceIdError)
+ Data.SequenceId: checkSeqIdM :: (Integral s, Monad m) => s -> SequenceIdT s m (Maybe (SequenceIdError s))
- Data.SequenceId: data SequenceIdError
+ Data.SequenceId: data SequenceIdError a
- Data.SequenceId: evalSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m b
+ Data.SequenceId: evalSequenceIdT :: Monad m => SequenceIdT s m b -> s -> m b
- Data.SequenceId: execSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m SequenceId
+ Data.SequenceId: execSequenceIdT :: Monad m => SequenceIdT s m b -> s -> m s
- Data.SequenceId: incrementSeqId :: SequenceId -> SequenceId
+ Data.SequenceId: incrementSeqId :: Integral s => s -> s
- Data.SequenceId: incrementSeqIdM :: Monad m => SequenceIdT m SequenceId
+ Data.SequenceId: incrementSeqIdM :: (Monad m, Integral s) => SequenceIdT s m s
- Data.SequenceId: lastSeqIdM :: Monad m => SequenceIdT m SequenceId
+ Data.SequenceId: lastSeqIdM :: Monad m => SequenceIdT s m s
- Data.SequenceId: newtype SequenceIdT m a
+ Data.SequenceId: newtype SequenceIdT s m a
- Data.SequenceId: runSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m (b, SequenceId)
+ Data.SequenceId: runSequenceIdT :: Monad m => SequenceIdT s m b -> s -> m (b, s)

Files

seqid.cabal view
@@ -1,5 +1,5 @@ name:                seqid-version:             0.5.3+version:             0.6.0 synopsis:            Sequence ID production and consumption description:         Uniquely identify elements in a sequence. License:             BSD3
src/Data/SequenceId.hs view
@@ -16,7 +16,6 @@          -- * Types        , SequenceIdError (..)        , SequenceIdErrorType (..)-       , SequenceId (..)        ) where  @@ -24,36 +23,28 @@ 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)  -newtype SequenceIdT m a = SequenceIdT { unSequenceIdT :: StateT SequenceId m a }-                        deriving (Monad, Applicative, Functor, MonadState SequenceId, MonadTrans)--newtype SequenceId = SequenceId { unSequenceId :: Word32 }-                   deriving (Eq, Ord, Num, Integral, Real, Enum)--instance Show SequenceId where-    show (SequenceId n) = show n+newtype SequenceIdT s m a = SequenceIdT { unSequenceIdT :: StateT s m a }+    deriving (Monad, Applicative, Functor, MonadState s, MonadTrans)  -evalSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m b+evalSequenceIdT :: Monad m => SequenceIdT s m b -> s -> m b evalSequenceIdT = evalStateT . unSequenceIdT  -execSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m SequenceId+execSequenceIdT :: Monad m => SequenceIdT s m b -> s -> m s execSequenceIdT = execStateT . unSequenceIdT  -runSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m (b, SequenceId)+runSequenceIdT :: Monad m => SequenceIdT s m b -> s -> m (b, s) runSequenceIdT = runStateT . unSequenceIdT  -data SequenceIdError =-    SequenceIdError+data SequenceIdError a = SequenceIdError     { errType   :: !SequenceIdErrorType-    , lastSeqId :: !SequenceId-    , currSeqId :: !SequenceId+    , lastSeqId :: !a+    , currSeqId :: !a     } deriving (Eq, Show)  @@ -65,8 +56,9 @@  -- | 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 :: (Integral s, Monad m)+            => s -- ^ Current sequence ID+            -> SequenceIdT s m (Maybe (SequenceIdError s)) checkSeqIdM currSeq = do     lastSeq <- get     put $ max lastSeq currSeq@@ -75,30 +67,32 @@  -- | 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 :: Integral s+           => s -- ^ Last sequence ID+           -> s -- ^ Current sequence ID+           -> Maybe (SequenceIdError s) checkSeqId lastSeq currSeq     | delta lastSeq currSeq > 1 = Just $ SequenceIdError SequenceIdDropped    lastSeq currSeq     | delta lastSeq currSeq < 1 = Just $ SequenceIdError SequenceIdDuplicated lastSeq currSeq     | otherwise                 = Nothing  -delta :: SequenceId -> SequenceId -> Int+delta :: Integral s => s -> s -> Int delta lastSeq currSeq = fromIntegral currSeq - fromIntegral lastSeq   -- | Update to the next sequense ID-incrementSeqIdM :: Monad m => SequenceIdT m SequenceId -- ^ Next sequence ID+incrementSeqIdM :: (Monad m, Integral s) => SequenceIdT s m s -- ^ Next sequence ID incrementSeqIdM = modify' incrementSeqId >> get   -- | Increment to the next sequense ID-incrementSeqId :: SequenceId -- ^ Last sequence ID-               -> SequenceId -- ^ Next sequence ID+incrementSeqId :: Integral s+               => s -- ^ Last sequence ID+               -> s -- ^ Next sequence ID incrementSeqId = (+1)   -- | Last seen sequense ID-lastSeqIdM :: Monad m => SequenceIdT m SequenceId -- ^ Last sequence ID+lastSeqIdM :: Monad m => SequenceIdT s m s -- ^ Last sequence ID lastSeqIdM = get