Maintainer	gatlin@niltag.net
Stability	experimental
Safe Haskell	Safe-Inferred
Language	Haskell2010

Tubes

Contents

A series of tubes
- Construction and evaluation
- Combination
Utility

Description

My interest in stream processing was re-ignited by the excellent project https://github.com/iokasimov/pipeline

Pipeline casts the Pipes / Conduit-style of programming in terms of CPS.

Since I have my own special CPS I have plagiarized Pipeline's approach. My goal is to determine how this relates to Orc and then have one module subsume the other (or learn a valuable reason for why not).

Synopsis

type Series i o t a r = CPS r (Tube i o r t) a
deliver :: Monad t => Series i o t r r -> t r
yield :: o -> Series i o t () r
await :: Series i o t i r
finish :: Monad t => Series i o t () ()
embed :: Monad t => t a -> Series i o t a ()
type Generator t o = Series Void o t () ()
type Async t i = Series i Void t () ()
type AsyncGenerator t i o = Series i o t () ()
(><) :: forall i e a o t. Monad t => Series i e t () () -> Series e o t () () -> Series i o t a ()
newtype Tube i o r t a = Tube {
- flow :: Source i t r -> Sink o t r -> t r
}
newtype Source i t r = Source {
- play :: Sink i t r -> t r
}
newtype Sink o t r = Sink {
- resume :: o -> Source o t r -> t r
}
pause :: (() -> Tube i o r t a) -> Source i t r -> Source o t r
suspend :: (i -> Tube i o r t a) -> Sink o t r -> Sink i t r

A series of tubes

Construction and evaluation

type Series i o t a r = CPS r (Tube i o r t) a Source #

A Series of Tubes is the (delimited) continuation embedding into some base type t :: * -> *. Series may be connected into, well, a series via the (><) operator. When the series finishes evaluating it will result in a value of type r.

deliver :: Monad t => Series i o t r r -> t r Source #

"...deliver[s] vast amounts of information" from a Series of tubes. :)

yield :: o -> Series i o t () r Source #

Yield a value downstream in the Series.

await :: Series i o t i r Source #

Blocking-wait for an upstream value from the Series.

finish :: Monad t => Series i o t () () Source #

A Series which does nothing.

embed :: Monad t => t a -> Series i o t a () Source #

Embeds a value with side effects into an appropriate Series.

type Generator t o = Series Void o t () () Source #

type Async t i = Series i Void t () () Source #

type AsyncGenerator t i o = Series i o t () () Source #

Combination

(><) :: forall i e a o t. Monad t => Series i e t () () -> Series e o t () () -> Series i o t a () Source #

Constructs a Series of Tubes.

Utility

newtype Tube i o r t a Source #

An intermediate link in the series of tubes.

Constructors

Tube
Fields flow :: Source i t r -> Sink o t r -> t r

Instances

Instances details

Functor (Tube i o r t) Source #
Instance details Defined in Tubes Methods fmap :: (a -> b) -> Tube i o r t a -> Tube i o r t b Source # (<$) :: a -> Tube i o r t b -> Tube i o r t a Source #

newtype Source i t r Source #

The head of a stream processing series.

Constructors

Source
Fields play :: Sink i t r -> t r

newtype Sink o t r Source #

The reservoir at the end of a stream processing pipeline.

Constructors

Sink
Fields resume :: o -> Source o t r -> t r

pause :: (() -> Tube i o r t a) -> Source i t r -> Source o t r Source #

A covariant mapping of a 'Source i t r' into 'Source o t r'.

suspend :: (i -> Tube i o r t a) -> Sink o t r -> Sink i t r Source #

A contravariant mapping of a 'Sink o t r' into a 'Sink i t r'.