Safe Haskell	None
Language	Haskell2010

Bluefin.Consume

Contents

Description

This is an old interface and will be deprecated in the future. You are encouraged to use Bluefin.Capability.Await instead.

Synopsis

type Consume a = Coroutine () a
consumeEach :: forall b (es :: Effects) r. (forall (e :: Effects). Consume b e -> Eff (e :& es) r) -> Eff es b -> Eff es r
consumeStream :: forall a (es :: Effects) r. (forall (e :: Effects). Consume a e -> Eff (e :& es) r) -> (forall (e :: Effects). Stream a e -> Eff (e :& es) r) -> Eff es r
streamConsume :: forall a (es :: Effects) r. (forall (e :: Effects). Stream a e -> Eff (e :& es) r) -> (forall (e :: Effects). Consume a e -> Eff (e :& es) r) -> Eff es r
await :: forall (e :: Effects) (es :: Effects) a. e <: es => Consume a e -> Eff es a
takeConsume :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) a. (e1 <: es, e2 <: es) => Int -> Consume a e1 -> Stream a e2 -> Eff es ()

Documentation

Consume allows you to await values during the execution of a Bluefin operation. It provides similar functionality to await from Conduit or Pipes.

For information about prompt finalization/resource safety when using Bluefin Consumes, see Bluefin.Coroutine.

Handle

Arguments

:: forall b (es :: Effects) r. (forall (e :: Effects). Consume b e -> Eff (e :& es) r)	Body
-> Eff es b	Value to send to each `await` in the body.
-> Eff es r

A version of forEach specialized to Consume. Every time the Consume is used to await a b, feed it the one created by the handler.

Arguments

:: forall a (es :: Effects) r. (forall (e :: Effects). Consume a e -> Eff (e :& es) r)	Each `await` from the `Consume` ...
-> (forall (e :: Effects). Stream a e -> Eff (e :& es) r)	... receives the value `yield`ed from the `Stream`
-> Eff es r

Arguments

:: forall a (es :: Effects) r. (forall (e :: Effects). Stream a e -> Eff (e :& es) r)
-> (forall (e :: Effects). Consume a e -> Eff (e :& es) r)
-> Eff es r	͘

Argument-flipped version of consumeStream

await :: forall (e :: Effects) (es :: Effects) a. e <: es => Consume a e -> Eff es a #

Arguments

:: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) a. (e1 <: es, e2 <: es)
=> Int
-> Consume a e1
-> Stream a e2
-> Eff es ()	͘

runPureEff $ yieldToList $ yOut -> do
  consumeStream
    (\c -> takeConsume 4 c yOut)
    (\yIn -> inFoldable [1..10] yIn)
([1,2,3,4],())