dynamic-pipeline 0.1.0.4 → 0.1.0.5
raw patch · 2 files changed
+33/−35 lines, 2 filesPVP: minor bump suggested
API additions: PVP suggests at least a minor version bump
API changes (from Hackage documentation)
+ DynamicPipeline.Channel: data ReadChannel a
+ DynamicPipeline.Channel: data WriteChannel a
+ DynamicPipeline.Channel: end :: WriteChannel a -> IO ()
+ DynamicPipeline.Channel: foldM :: MonadIO m => ReadChannel a -> (a -> m ()) -> m ()
+ DynamicPipeline.Channel: foldM' :: MonadIO m => ReadChannel a -> m () -> (a -> m ()) -> m ()
+ DynamicPipeline.Channel: newChannel :: forall a. IO (WriteChannel a, ReadChannel a)
+ DynamicPipeline.Channel: pull :: MonadIO m => ReadChannel a -> m (Maybe a)
+ DynamicPipeline.Channel: push :: MonadIO m => a -> WriteChannel a -> m ()
+ DynamicPipeline.Channel: unfoldFile :: MonadIO m => FilePath -> WriteChannel b -> (ByteString -> b) -> m ()
+ DynamicPipeline.Channel: unfoldM :: forall m a b. MonadIO m => m a -> (a -> b) -> m Bool -> WriteChannel b -> m ()
+ DynamicPipeline.Channel: unfoldT :: (MonadIO m, Foldable t) => t a -> WriteChannel b -> (a -> b) -> m ()
+ DynamicPipeline.Flow: (:<+>) :: chann1 -> chann2 -> (:<+>) chann1 chann2
+ DynamicPipeline.Flow: (:>>) :: a -> b -> (:>>) a b
+ DynamicPipeline.Flow: class MkCh (a :: Type) where {
+ DynamicPipeline.Flow: class MkChans (a :: Type) where {
+ DynamicPipeline.Flow: data ChanIn (a :: Type)
+ DynamicPipeline.Flow: data ChanOut (a :: Type)
+ DynamicPipeline.Flow: data ChanOutIn (a :: Type) (b :: Type)
+ DynamicPipeline.Flow: data ChanReadOut (a :: Type)
+ DynamicPipeline.Flow: data ChanReadWriteGen (a :: Type)
+ DynamicPipeline.Flow: data ChanWriteSource (a :: Type)
+ DynamicPipeline.Flow: data Channel (a :: Type)
+ DynamicPipeline.Flow: data ChansFilter (a :: Type)
+ DynamicPipeline.Flow: data Eof
+ DynamicPipeline.Flow: data Generator (a :: Type)
+ DynamicPipeline.Flow: data Sink
+ DynamicPipeline.Flow: data Source (a :: Type)
+ DynamicPipeline.Flow: data a :>> b
+ DynamicPipeline.Flow: data chann1 :<+> chann2
+ DynamicPipeline.Flow: getFilterChannels :: FilterChans r b t a => r t -> (a, b)
+ DynamicPipeline.Flow: inGenOut :: AllChans r2 r3 l1 r4 l2 t2 s t1 s2 t5 l3 l4 => r3 t2 -> (HList l3, HList (HAppendListR l1 l2), HList l4)
+ DynamicPipeline.Flow: infixr 5 :<+>
+ DynamicPipeline.Flow: instance (DynamicPipeline.Flow.MkCh inToGen, DynamicPipeline.Flow.MkCh genToOut) => DynamicPipeline.Flow.MkChans (DynamicPipeline.Flow.Source (DynamicPipeline.Flow.Channel inToGen) DynamicPipeline.Flow.:>> (DynamicPipeline.Flow.Generator (DynamicPipeline.Flow.Channel genToOut) DynamicPipeline.Flow.:>> DynamicPipeline.Flow.Sink))
+ DynamicPipeline.Flow: instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (a DynamicPipeline.Flow.:>> b)
+ DynamicPipeline.Flow: instance (GHC.Classes.Eq chann1, GHC.Classes.Eq chann2) => GHC.Classes.Eq (chann1 DynamicPipeline.Flow.:<+> chann2)
+ DynamicPipeline.Flow: instance (GHC.Enum.Bounded a, GHC.Enum.Bounded b) => GHC.Enum.Bounded (a DynamicPipeline.Flow.:>> b)
+ DynamicPipeline.Flow: instance (GHC.Enum.Bounded chann1, GHC.Enum.Bounded chann2) => GHC.Enum.Bounded (chann1 DynamicPipeline.Flow.:<+> chann2)
+ DynamicPipeline.Flow: instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (a DynamicPipeline.Flow.:>> b)
+ DynamicPipeline.Flow: instance (GHC.Show.Show chann1, GHC.Show.Show chann2) => GHC.Show.Show (chann1 DynamicPipeline.Flow.:<+> chann2)
+ DynamicPipeline.Flow: instance Data.Foldable.Foldable ((DynamicPipeline.Flow.:<+>) chann1)
+ DynamicPipeline.Flow: instance Data.Foldable.Foldable ((DynamicPipeline.Flow.:>>) a)
+ DynamicPipeline.Flow: instance Data.Traversable.Traversable ((DynamicPipeline.Flow.:<+>) chann1)
+ DynamicPipeline.Flow: instance Data.Traversable.Traversable ((DynamicPipeline.Flow.:>>) a)
+ DynamicPipeline.Flow: instance DynamicPipeline.Flow.MkCh DynamicPipeline.Flow.Eof
+ DynamicPipeline.Flow: instance DynamicPipeline.Flow.MkCh inToGen => DynamicPipeline.Flow.MkChans (DynamicPipeline.Flow.ChansFilter (DynamicPipeline.Flow.Source (DynamicPipeline.Flow.Channel inToGen) DynamicPipeline.Flow.:>> (DynamicPipeline.Flow.Generator (DynamicPipeline.Flow.Channel genToOut) DynamicPipeline.Flow.:>> DynamicPipeline.Flow.Sink)))
+ DynamicPipeline.Flow: instance DynamicPipeline.Flow.MkCh more => DynamicPipeline.Flow.MkCh (a DynamicPipeline.Flow.:<+> more)
+ DynamicPipeline.Flow: instance GHC.Base.Functor ((DynamicPipeline.Flow.:<+>) chann1)
+ DynamicPipeline.Flow: instance GHC.Base.Functor ((DynamicPipeline.Flow.:>>) a)
+ DynamicPipeline.Flow: makeChans :: forall (a :: Type). MkChans a => IO (HChan a)
+ DynamicPipeline.Flow: mkCh :: MkCh a => Proxy a -> IO (HList (HChI a), HList (HChO a))
+ DynamicPipeline.Flow: mkChans :: MkChans a => Proxy a -> IO (HChan a)
+ DynamicPipeline.Flow: type AllChans r2 r3 l1 r4 l2 t2 s t1 s2 t5 l3 l4 = (LabeledOpticTo (LabelableTy r2) "in-ch" (->), LabeledOpticF (LabelableTy r3) (Const (HList l3)), LabeledOpticP (LabelableTy r3) (->), LabeledOpticTo (LabelableTy r3) "Source" (->), LabeledOpticF (LabelableTy r2) (Const (HList l1)), LabeledOpticP (LabelableTy r2) (->), LabeledOpticTo (LabelableTy r2) "out-ch" (->), LabeledOpticTo (LabelableTy r4) "in-ch" (->), LabeledOpticF (LabelableTy r3) (Const (HList l2)), LabeledOpticTo (LabelableTy r3) "generator" (->), LabeledOpticF (LabelableTy r3) (Const (HList l1)), LabeledOpticF (LabelableTy r2) (Const (HList l3)), LabeledOpticF (LabelableTy r4) (Const (HList l4)), LabeledOpticP (LabelableTy r4) (->), LabeledOpticTo (LabelableTy r4) "out-ch" (->), LabeledOpticF (LabelableTy r3) (Const (HList l4)), LabeledOpticF (LabelableTy r4) (Const (HList l2)), HAppendList l1 l2, Labelable "generator" r3 t2 t2 (r4 s) (r4 t1), Labelable "in-ch" r2 s2 t5 (HList l3) (HList l3), Labelable "in-ch" r4 s t1 (HList l2) (HList l2), Labelable "Source" r3 t2 t2 (r2 s2) (r2 t5), Labelable "out-ch" r2 s2 t5 (HList l1) (HList l1), Labelable "out-ch" r4 s t1 (HList l4) (HList l4))
+ DynamicPipeline.Flow: type ExpandFilterToCh a param = ExpandGenToCh a param
+ DynamicPipeline.Flow: type ExpandGenToCh a filter = ExpandToHList (ChanReadWriteGen a) filter
+ DynamicPipeline.Flow: type ExpandSinkToCh a = ExpandToHList (ChanReadOut a) Void
+ DynamicPipeline.Flow: type ExpandSourceToCh a = ExpandToHList (ChanWriteSource a) Void
+ DynamicPipeline.Flow: type FilterChans r b t a = (LabeledOpticF (LabelableTy r) (Const b), LabeledOpticTo (LabelableTy r) "out-ch" (->), Labelable "out-ch" r t t b b, LabeledOpticF (LabelableTy r) (Const a), LabeledOpticP (LabelableTy r) (->), LabeledOpticTo (LabelableTy r) "in-ch" (->), Labelable "in-ch" r t t a a)
+ DynamicPipeline.Flow: type family HChan a :: Type;
+ DynamicPipeline.Flow: }
+ DynamicPipeline.Stage: (|>>) :: forall dpDefinition filterState filterParam st. Actor dpDefinition filterState filterParam (StateT filterState (DP st)) -> Actor dpDefinition filterState filterParam (StateT filterState (DP st)) -> Filter dpDefinition filterState filterParam st
+ DynamicPipeline.Stage: (|>>>) :: forall dpDefinition filterState filterParam st. Actor dpDefinition filterState filterParam (StateT filterState (DP st)) -> Filter dpDefinition filterState filterParam st -> Filter dpDefinition filterState filterParam st
+ DynamicPipeline.Stage: actor :: forall dpDefinition filterState filterParam st. WithFilter dpDefinition filterParam (StateT filterState (DP st)) -> Actor dpDefinition filterState filterParam (StateT filterState (DP st))
+ DynamicPipeline.Stage: data Actor dpDefinition filterState filterParam monadicAction
+ DynamicPipeline.Stage: data DP st a
+ DynamicPipeline.Stage: data DynamicPipeline dpDefinition filterState filterParam st
+ DynamicPipeline.Stage: data Filter dpDefinition filterState filterParam st
+ DynamicPipeline.Stage: data GeneratorStage dpDefinition filterState filterParam st
+ DynamicPipeline.Stage: data Stage a
+ DynamicPipeline.Stage: data UnFoldFilter dpDefinition readElem st filterState filterParam l
+ DynamicPipeline.Stage: infixr 5 |>>
+ DynamicPipeline.Stage: instance (DynamicPipeline.Stage.IsClosable x, DynamicPipeline.Stage.CloseList xs) => DynamicPipeline.Stage.CloseList (x : xs)
+ DynamicPipeline.Stage: instance (a GHC.Types.~ b) => DynamicPipeline.Stage.EvalC (DynamicPipeline.Stage.Stage a) b
+ DynamicPipeline.Stage: instance DynamicPipeline.Stage.CloseList '[]
+ DynamicPipeline.Stage: instance DynamicPipeline.Stage.IsClosable (DynamicPipeline.Channel.ReadChannel a)
+ DynamicPipeline.Stage: instance DynamicPipeline.Stage.IsClosable (DynamicPipeline.Channel.WriteChannel a)
+ DynamicPipeline.Stage: instance forall dpDefinition filterState filterParam k (st :: k). GHC.Generics.Generic (DynamicPipeline.Stage.Filter dpDefinition filterState filterParam st)
+ DynamicPipeline.Stage: instance forall k (st :: k). Control.Monad.IO.Class.MonadIO (DynamicPipeline.Stage.DP st)
+ DynamicPipeline.Stage: instance forall k (st :: k). GHC.Base.Applicative (DynamicPipeline.Stage.DP st)
+ DynamicPipeline.Stage: instance forall k (st :: k). GHC.Base.Functor (DynamicPipeline.Stage.DP st)
+ DynamicPipeline.Stage: instance forall k (st :: k). GHC.Base.Monad (DynamicPipeline.Stage.DP st)
+ DynamicPipeline.Stage: instance forall k s' s a (param :: k). Control.Lens.Wrapped.Wrapped (DynamicPipeline.Stage.Filter s' s a param)
+ DynamicPipeline.Stage: mkDP :: forall dpDefinition filterState st filterParam filter iparams gparams oparams r2 r3 l1 r4 l2 t2 s1 t1 s2 t5 l3 l4. DPConstraint dpDefinition filterState st filterParam filter iparams gparams oparams r2 r3 l1 r4 l2 t2 s1 t1 s2 t5 l3 l4 => Stage (WithSource dpDefinition (DP st)) -> GeneratorStage dpDefinition filterState filterParam st -> Stage (WithSink dpDefinition (DP st)) -> DP st ()
+ DynamicPipeline.Stage: mkFilter :: forall dpDefinition filterState filterParam st. WithFilter dpDefinition filterParam (StateT filterState (DP st)) -> Filter dpDefinition filterState filterParam st
+ DynamicPipeline.Stage: mkGenerator :: Stage (WithGenerator dpDefinition (Filter dpDefinition filterState filterParam st) (DP st)) -> Filter dpDefinition filterState filterParam st -> GeneratorStage dpDefinition filterState filterParam st
+ DynamicPipeline.Stage: mkUnfoldFilter :: (readElem -> Bool) -> (readElem -> DP st ()) -> Filter dpDefinition filterState filterParam st -> (readElem -> filterState) -> ReadChannel readElem -> HList l -> UnFoldFilter dpDefinition readElem st filterState filterParam l
+ DynamicPipeline.Stage: mkUnfoldFilter' :: (readElem -> Bool) -> Filter dpDefinition filterState filterParam st -> (readElem -> filterState) -> ReadChannel readElem -> HList l -> UnFoldFilter dpDefinition readElem st filterState filterParam l
+ DynamicPipeline.Stage: mkUnfoldFilterForAll :: Filter dpDefinition filterState filterParam st -> (readElem -> filterState) -> ReadChannel readElem -> HList l -> UnFoldFilter dpDefinition readElem st filterState filterParam l
+ DynamicPipeline.Stage: mkUnfoldFilterForAll' :: (readElem -> DP st ()) -> Filter dpDefinition filterState filterParam st -> (readElem -> filterState) -> ReadChannel readElem -> HList l -> UnFoldFilter dpDefinition readElem st filterState filterParam l
+ DynamicPipeline.Stage: runDP :: (forall st. DP st a) -> IO a
+ DynamicPipeline.Stage: single :: forall dpDefinition filterState filterParam st. WithFilter dpDefinition filterParam (StateT filterState (DP st)) -> NonEmpty (Actor dpDefinition filterState filterParam (StateT filterState (DP st)))
+ DynamicPipeline.Stage: type family IsDP (dpDefinition :: k) :: Bool
+ DynamicPipeline.Stage: unfoldF :: forall dpDefinition readElem st filterState filterParam l r t l1 b0 l2 l3 b2 b3 l4. SpawnFilterConstraint dpDefinition readElem st filterState filterParam l r t l1 b0 l2 l3 b2 b3 l4 => UnFoldFilter dpDefinition readElem st filterState filterParam l -> DP st (HList l)
+ DynamicPipeline.Stage: withDP :: IO a -> DP s a
+ DynamicPipeline.Stage: withGenerator :: forall (dpDefinition :: Type) (filter :: Type) st. WithGenerator dpDefinition filter (DP st) -> Stage (WithGenerator dpDefinition filter (DP st))
+ DynamicPipeline.Stage: withSink :: forall (dpDefinition :: Type) st. WithSink dpDefinition (DP st) -> Stage (WithSink dpDefinition (DP st))
+ DynamicPipeline.Stage: withSource :: forall (dpDefinition :: Type) st. WithSource dpDefinition (DP st) -> Stage (WithSource dpDefinition (DP st))
Files
- dynamic-pipeline.cabal +1/−1
- src/DynamicPipeline/Channel.hs +32/−34
dynamic-pipeline.cabal view
@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: dynamic-pipeline-version: 0.1.0.4+version: 0.1.0.5 synopsis: Library Type Safe implementation of Dynamic Pipeline Paradigm (DPP). description: @dynamic-pipeline@ is a __/Type Safe/__ Dynamic and Parallel Streaming Library, which is an implementation of __Dynamic Pipeline Paradigm (DPP)__ proposed in this paper [DPP](https://biblioteca.sistedes.es/articulo/the-dynamic-pipeline-paradigm/).
src/DynamicPipeline/Channel.hs view
@@ -9,27 +9,29 @@ -- Stability : experimental -- Portability : GHC ---module DynamicPipeline.Channel - ( ReadChannel,- WriteChannel,- DynamicPipeline.Channel.foldM,- foldM',- push,- pull,- unfoldM,- unfoldFile,- unfoldT, - newChannel,- end+module DynamicPipeline.Channel+ ( ReadChannel+ , WriteChannel+ , DynamicPipeline.Channel.foldM+ , foldM'+ , push+ , pull+ , unfoldM+ , unfoldFile+ , unfoldT+ , newChannel+ , end ) where -import qualified Control.Concurrent as CC+import qualified Control.Concurrent as CC import Control.Concurrent.Chan.Unagi.NoBlocking-import Control.Lens hiding ((<|))-import Data.ByteString as B-import Data.Foldable as F+import Control.Lens hiding ( (<|)+ )+import Data.ByteString as B+import Data.Foldable as F import Data.HList-import Relude as R+import GHC.IO.Handle as H+import Relude as R -- | 'WriteChannel' can only write values into some Channel Queue@@ -44,7 +46,7 @@ -- | 'foldM' is a /Catamorphism/ for consuming a 'ReadChannel' and do some Monadic @m@ computation with each element {-# INLINE foldM #-}-foldM :: MonadIO m +foldM :: MonadIO m => ReadChannel a -- ^'ReadChannel' -> (a -> m ()) -- ^Computation to do with read element -> m ()@@ -52,15 +54,12 @@ -- | Idem 'foldM' but allows pass a monadic computation to perform at the end of the Channel {-# INLINE foldM' #-}-foldM' :: MonadIO m +foldM' :: MonadIO m => ReadChannel a -- ^'ReadChannel' -> m () -- ^Computation to do at the end of the channel -> (a -> m ()) -- ^Computation to do with read element -> m ()-foldM' = loop'- where- loop' c onNothing io = - maybe onNothing (\e -> io e >> loop' c onNothing io) =<< liftIO (pull c)+foldM' = loop' where loop' c onNothing io = maybe onNothing (\e -> io e >> loop' c onNothing io) =<< liftIO (pull c) -- | Push element @a@ into 'WriteChannel' {-# INLINE push #-}@@ -80,27 +79,26 @@ -- -- | unfold from a Monadic seed @m a@ to a 'WriteChannel' {-# INLINE unfoldM #-}-unfoldM :: forall m a b. MonadIO m +unfoldM :: forall m a b+ . MonadIO m => m a -- ^Monadic Seed -> (a -> b) -- ^Map input from seed to something to be written in Channel -> m Bool -- ^When stop unfolding -> WriteChannel b -- ^'WriteChannel' to write input seed elements -> m ()-unfoldM = loop' - where- loop' seed fn stopIfM writeChannel = ifM stopIfM- (pure ())- (seed >>= flip push writeChannel . fn >> loop' seed fn stopIfM writeChannel)+unfoldM = loop'+ where+ loop' seed fn stopIfM writeChannel =+ ifM stopIfM (pure ()) (seed >>= flip push writeChannel . fn >> loop' seed fn stopIfM writeChannel) -- | Using 'unfoldM', unfold from file {-# INLINE unfoldFile #-}-unfoldFile :: MonadIO m +unfoldFile :: MonadIO m => FilePath -- ^Seed 'FilePath' to read from -> WriteChannel b -- ^'WriteChannel' to write File contents -> (ByteString -> b) -- ^Transform 'ByteString' read from File to something meaningful for your App -> m ()-unfoldFile file writeChannel fn = liftIO $- R.withFile file ReadMode $ \h ->- unfoldM (B.hGetLine h) fn (R.hIsEOF h) writeChannel+unfoldFile file writeChannel fn =+ liftIO $ R.withFile file ReadMode $ \h -> unfoldM (B.hGetLine h) fn (H.hIsEOF h) writeChannel -- | Idem 'unfoldM' but for 'Foldable', for example a List @[a]@. Useful for testing purpose {-# INLINE unfoldT #-}@@ -109,7 +107,7 @@ {-# WARNING newChannel "INTERNAL USE" #-} {-# NOINLINE newChannel #-}-newChannel :: forall a. IO (WriteChannel a, ReadChannel a)+newChannel :: forall a . IO (WriteChannel a, ReadChannel a) newChannel = bimap WriteChannel ReadChannel <$> newChan {-# WARNING end "INTERNAL USE" #-}