Streaming.Linear

yields is like lift for items in the streamed functor. It makes a singleton or one-layer succession.

lift :: (Control.Monad m, Control.Functor f)    => m r %1-> Stream f m r
yields ::  (Control.Monad m, Control.Functor f) => f r %1-> Stream f m r

Viewed in another light, it is like a functor-general version of yield:

S.yield a = yields (a :> ())

Wrap an effect that returns a stream

effect = join . lift

Wrap a new layer of a stream. So, e.g.

S.cons :: Control.Monad m => a -> Stream (Of a) m r %1-> Stream (Of a) m r
S.cons a str = wrap (a :> str)

and, recursively:

S.each' :: Control.Monad m =>  [a] -> Stream (Of a) m ()
S.each' = foldr (\a b -> wrap (a :> b)) (return ())

The two operations

wrap :: (Control.Monad m, Control.Functor f) =>
  f (Stream f m r) %1-> Stream f m r
effect :: (Control.Monad m, Control.Functor f) =>
  m (Stream f m r) %1-> Stream f m r

are fundamental. We can define the parallel operations yields and lift in terms of them

yields :: (Control.Monad m, Control.Functor f) => f r %1-> Stream f m r
yields = wrap . Control.fmap Control.return
lift ::  (Control.Monad m, Control.Functor f)  => m r %1-> Stream f m r
lift = effect . Control.fmap Control.return

Repeat a functorial layer, command or instruction a fixed number of times.

replicatesM n repeats an effect containing a functorial layer, command or instruction n times.

Reflect a church-encoded stream; cp. GHC.Exts.build

streamFold return_ effect_ step_ (streamBuild psi) = psi return_ effect_ step_

Map layers of one functor to another with a transformation.

maps id = id
maps f . maps g = maps (f . g)

Map layers of one functor to another with a transformation.

mapsPost id = id
mapsPost f . mapsPost g = mapsPost (f . g)
mapsPost f = maps f

mapsPost is essentially the same as maps, but it imposes a Control.Functor constraint on its target functor rather than its source functor. It should be preferred if Control.fmap is cheaper for the target functor than for the source functor.

Map layers of one functor to another with a transformation involving the base monad. maps is more fundamental than mapsM, which is best understood as a convenience for effecting this frequent composition:

mapsM phi = decompose . maps (Compose . phi)

The streaming prelude exports the same function under the better name mapped, which overlaps with the lens libraries.

Map layers of one functor to another with a transformation involving the base monad. mapsMPost is essentially the same as mapsM, but it imposes a Control.Functor constraint on its target functor rather than its source functor. It should be preferred if Control.fmap is cheaper for the target functor than for the source functor.

mapsPost is more fundamental than mapsMPost, which is best understood as a convenience for effecting this frequent composition:

mapsMPost phi = decompose . mapsPost (Compose . phi)

The streaming prelude exports the same function under the better name mappedPost, which overlaps with the lens libraries.

Map layers of one functor to another with a transformation involving the base monad. This could be trivial, e.g.

let noteBeginning text x = (fromSystemIO (System.putStrLn text)) Control.>> (Control.return x)

this is completely functor-general

maps and mapped obey these rules:

maps id              = id
mapped return        = id
maps f . maps g      = maps (f . g)
mapped f . mapped g  = mapped (f <=< g)
maps f . mapped g    = mapped (fmap f . g)
mapped f . maps g    = mapped (f <=< fmap g)

maps is more fundamental than mapped, which is best understood as a convenience for effecting this frequent composition:

mapped phi = decompose . maps (Compose . phi)

A version of mapped that imposes a Control.Functor constraint on the target functor rather than the source functor. This version should be preferred if Control.fmap on the target functor is cheaper.

A less-efficient version of hoist that works properly even when its argument is not a monad morphism.

Group layers in an alternating stream into adjoining sub-streams of one type or another.

Inspect the first stage of a freely layered sequence. Compare Pipes.next and the replica Streaming.Prelude.next. This is the uncons for the general unfold.

unfold inspect = id
Streaming.Prelude.unfoldr StreamingPrelude.next = id

Split a succession of layers after some number, returning a streaming or effectful pair.

>>> rest <- S.print $ S.splitAt 1 $ each' [1..3] 1 >>> S.print rest 2 3

splitAt 0 = return
(\stream -> splitAt n stream >>= splitAt m) = splitAt (m+n)

Thus, e.g.

>>> rest S.print $ (s - splitsAt 2 s >>= splitsAt 2) each' [1..5] 1 2 3 4 >>> S.print rest 5

Break a stream into substreams each with n functorial layers.

>>> S.print $ mapped S.sum $ chunksOf 2 $ each' [1,1,1,1,1] 2 2 1

Dissolves the segmentation into layers of Stream f m layers.

Interpolate a layer at each segment. This specializes to e.g.

intercalates :: Stream f m () -> Stream (Stream f m) m r %1-> Stream f m r

Given a stream on a sum of functors, make it a stream on the left functor, with the streaming on the other functor as the governing monad. This is useful for acting on one or the other functor with a fold, leaving the other material for another treatment. It generalizes partitionEithers, but actually streams properly.

>>> let odd_even = S.maps (S.distinguish even) $ S.each' [1..10::Int] >>> :t separate odd_even separate odd_even :: Monad m => Stream (Of Int) (Stream (Of Int) m) ()

Now, for example, it is convenient to fold on the left and right values separately:

>>> S.toList $ S.toList $ separate odd_even [2,4,6,8,10] :> ([1,3,5,7,9] :> ())

Or we can write them to separate files or whatever:

>>> S.writeFile "even.txt" . S.show $ S.writeFile "odd.txt" . S.show $ S.separate odd_even >>> :! cat even.txt 2 4 6 8 10 >>> :! cat odd.txt 1 3 5 7 9

Of course, in the special case of Stream (Of a) m r, we can achieve the above effects more simply by using Streaming.Prelude.copy

>>> S.toList . S.filter even $ S.toList . S.filter odd $ S.copy $ each [1..10::Int] [2,4,6,8,10] :> ([1,3,5,7,9] :> ())

But separate and unseparate are functor-general.

Rearrange a succession of layers of the form Compose m (f x).

we could as well define decompose by mapsM:

decompose = mapped getCompose

but mapped is best understood as:

mapped phi = decompose . maps (Compose . phi)

since maps and hoist are the really fundamental operations that preserve the shape of the stream:

maps  :: (Control.Monad m, Control.Functor f) => (forall x. f x %1-> g x) -> Stream f m r %1-> Stream g m r
hoist :: (Control.Monad m, Control.Functor f) => (forall a. m a %1-> n a) -> Stream f m r %1-> Stream f n r

If Of had a Comonad instance, then we'd have

copy = expand extend

See expandPost for a version that requires a Control.Functor g instance instead.

If Of had a Comonad instance, then we'd have

copy = expandPost extend

See expand for a version that requires a Control.Functor f instance instead.

Map each layer to an effect, and run them all.

Run the effects in a stream that merely layers effects.

streamFold reorders the arguments of destroy to be more akin to foldr It is more convenient to query in ghci to figure out what kind of 'algebra' you need to write.

>>> :t streamFold Control.return Control.join (Control.Monad m, Control.Functor f) => (f (m a) %1-> m a) -> Stream f m a %1-> m a -- iterT

>>> :t streamFold Control.return (Control.join . Control.lift) (Control.Monad m, Control.Monad (t m), Control.Functor f, Control.MonadTrans t) => (f (t m a) %1-> t m a) -> Stream f m a %1-> t m a -- iterTM

>>> :t streamFold Control.return effect (Control.Monad m, Control.Functor f, Control.Functor g) => (f (Stream g m r) %1-> Stream g m r) -> Stream f m r %1-> Stream g m r

>>> :t f -> streamFold Control.return effect (wrap . f) (Control.Monad m, Control.Functor f, Control.Functor g) => (f (Stream g m a) %1-> g (Stream g m a)) -> Stream f m a %1-> Stream g m a -- maps

>>> :t f -> streamFold Control.return effect (effect . Control.fmap wrap . f) (Control.Monad m, Control.Functor f, Control.Functor g) => (f (Stream g m a) %1-> m (g (Stream g m a))) -> Stream f m a %1-> Stream g m a -- mapped

   streamFold done eff construct
      = eff . iterT (Control.return . construct . Control.fmap eff) . Control.fmap done

Specialized fold following the usage of Control.Monad.Trans.Free

iterTM alg = streamFold Control.return (Control.join . Control.lift)
iterTM alg = iterT alg . hoist Control.lift

Specialized fold following the usage of Control.Monad.Trans.Free

iterT alg = streamFold Control.return Control.join alg
iterT alg = runIdentityT . iterTM (IdentityT . alg . Control.fmap runIdentityT)

Map a stream to its church encoding; compare Data.List.foldr. destroyExposed may be more efficient in some cases when applicable, but it is less safe.

   destroy s construct eff done
     = eff .
       iterT (Control.return . construct . Control.fmap eff) .
       Control.fmap done $ s