concurrent-machines 0.2.1 → 0.2.3

raw patch · 7 files changed

+23/−23 lines, 7 filesdep ~basedep ~machinesdep ~timePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base, machines, time, transformers, transformers-base

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• concurrent-machines.cabal +7/−6
• src/Data/Machine/Concurrent.hs +3/−6
• src/Data/Machine/Concurrent/Buffer.hs +2/−2
• src/Data/Machine/Concurrent/Fanout.hs +3/−3
• src/Data/Machine/Concurrent/Scatter.hs +2/−4
• src/Data/Machine/Concurrent/Tee.hs +1/−2

@@ -1,3 +1,8 @@+# 0.2.3++- GHC-8.0.1 compatibility+- Dropped support for GHC-7.8+ # 0.2.0  - Fix fanout behavior (Ben SInclair)

@@ -1,5 +1,5 @@ name:                concurrent-machines-version:             0.2.1+version:             0.2.3 synopsis:            Concurrent networked stream transducers  description: A simple use-case for this library is to run the stages@@ -31,6 +31,7 @@ build-type:          Simple extra-source-files:  README.md, CHANGELOG.md cabal-version:       >=1.10+tested-with:         GHC == 7.10.3, GHC == 8.0.1  source-repository head   type:     git@@ -48,13 +49,13 @@   -- other-modules:          other-extensions:    GADTs, FlexibleContexts, RankNTypes, TupleSections,                         ScopedTypeVariables-  build-depends:       base >= 4.6 && < 5,+  build-depends:       base >= 4.6 && < 4.10,                        monad-control >= 1.0 && < 1.1,-                       transformers >= 0.4 && < 0.5,-                       time >= 1.4 && < 1.6,+                       transformers >= 0.4 && < 0.6,+                       time >= 1.4 && < 1.7,                        containers >= 0.5 && < 0.6,-                       transformers-base >= 0.4 && < 0.5,-                       machines >= 0.5 && < 0.6,+                       transformers-base >= 0.4 && < 0.6,+                       machines >= 0.5 && < 0.7,                        async >= 2.0.1 && < 2.2,                        lifted-async >= 0.1 && < 0.9,                        semigroups >= 0.8 && < 0.19

@@ -77,8 +77,7 @@        => MachineT m k a -> ProcessT m a b -> MachineT m k b racers src snk = MachineT . join $                  go <$> (Just <$> asyncRun src) <*> asyncRun snk-  where go :: MonadBaseControl IO m-           => Maybe (AsyncStep m k a)+  where go :: Maybe (AsyncStep m k a)            -> AsyncStep m (Is a) b            -> m (MachineStep m k b)         go srcA snkA =@@ -106,8 +105,7 @@                        go <$> (Just <$> asyncRun k) <*> asyncRun (f o)         -- If we have an upstream source value ready, we must flush         -- all available values yielded by downstream until it awaits.-        flushDown :: Monad m-                  => ProcessT m a b+        flushDown :: ProcessT m a b                   -> ((a -> ProcessT m a b) -> m (MachineStep m k b))                   -> m (MachineStep m k b)         flushDown m k = runMachineT m >>= \s -> case s of@@ -117,8 +115,7 @@         -- If downstream is awaiting an input, we must pull in all         -- necessary upstream awaits until we have a yielded value to         -- push downstream.-        feedUp :: MonadBaseControl IO m-               => MachineT m k a+        feedUp :: MachineT m k a                -> (a -> MachineT m k a -> m (MachineStep m k b))                -> m (MachineStep m k b)         feedUp m k = runMachineT m >>= \s -> case s of

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP, FlexibleContexts, GADTs, ScopedTypeVariables, TupleSections #-}+ {-# LANGUAGE CPP, FlexibleContexts, GADTs, ScopedTypeVariables, TupleSections #-} -- | Place buffers between two machines. This is most useful with -- irregular production rates. module Data.Machine.Concurrent.Buffer (@@ -25,7 +25,7 @@  -- | Drain downstream until it awaits a value, then pass the awaiting -- step to the given function.-drain :: (Functor m, Monad m)+drain :: Monad m       => MachineStep m k a       -> (MachineStep m k a -> m (MachineStep m k' a))       -> m (MachineStep m k' a)

@@ -31,7 +31,7 @@  -- | Like 'Data.List.mapAccumL' but with a monadic accumulating -- function.-mapAccumLM :: (Functor m, MonadBaseControl IO m)+mapAccumLM :: MonadBaseControl IO m            => (acc -> x -> m (acc, y)) -> acc -> [Async (StM m x)]            -> m (acc, [y]) mapAccumLM f z = fmap (second ($ [])) . foldM aux (z,id)@@ -51,7 +51,7 @@ -- | Share inputs with each of a list of processes in lockstep. Any -- values yielded by the processes for a given input are combined into -- a single yield from the composite process.-fanout :: (Functor m, MonadBaseControl IO m, Semigroup r)+fanout :: (MonadBaseControl IO m, Semigroup r)        => [ProcessT m a r] -> ProcessT m a r fanout xs = encased $ Await (MachineT . aux) Refl (fanout xs)   where aux y = do (rs,xs') <- mapM (feed y) xs >>= mapAccumLM yields []@@ -70,7 +70,7 @@ -- run a collection of 'ProcessT's that await but don't yield some -- number of times, you can use 'fanOutSteps . map (fmap (const ()))' -- followed by a 'taking' process.-fanoutSteps :: (Functor m, MonadBaseControl IO m, Monoid r)+fanoutSteps :: (MonadBaseControl IO m, Monoid r)             => [ProcessT m a r] -> ProcessT m a r fanoutSteps xs = encased $ Await (MachineT . aux) Refl (fanoutSteps xs)   where aux y = do (rs,xs') <- mapM (feed y) xs >>= mapAccumLM yields []

@@ -92,8 +92,7 @@ mergeSum snkL snkR = MachineT $ do sl <- asyncRun snkL                                    sr <- asyncRun snkR                                    go sl sr-  where go :: MonadBaseControl IO m-           => AsyncStep m (Is a) r+  where go :: AsyncStep m (Is a) r            -> AsyncStep m (Is b) r            -> m (MachineStep m (Is (Either a b)) r)         go sl sr = waitEither sl sr >>= @@ -137,8 +136,7 @@         lft = Left         rgt :: d -> Either b d         rgt = Right-        go :: MonadBaseControl IO m-           => AsyncStep m (Is a) (Either b d)+        go :: AsyncStep m (Is a) (Either b d)            -> AsyncStep m (Is c) (Either b d)            -> m (MachineStep m (Is (Either a c)) (Either b d))         go sl sr = waitEither sl sr >>=

@@ -14,8 +14,7 @@ tee ma mb m = MachineT $ do srcL <- asyncRun ma                             srcR <- asyncRun mb                             go m (Just srcL) (Just srcR)-  where go :: MonadBaseControl IO m-           => TeeT m a' b' c+  where go :: TeeT m a' b' c            -> Maybe (AsyncStep m (Is a) a')            -> Maybe (AsyncStep m (Is b) b')            -> m (MachineStep m (T a b) c)