| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Streaming
Contents
- data Stream f m r
- yields :: (Monad m, Functor f) => f r -> Stream f m r
- effect :: (Monad m, Functor f) => m (Stream f m r) -> Stream f m r
- wrap :: (Monad m, Functor f) => f (Stream f m r) -> Stream f m r
- replicates :: (Monad m, Functor f) => Int -> f () -> Stream f m ()
- repeats :: (Monad m, Functor f) => f () -> Stream f m r
- repeatsM :: (Monad m, Functor f) => m (f ()) -> Stream f m r
- unfold :: (Monad m, Functor f) => (s -> m (Either r (f s))) -> s -> Stream f m r
- never :: (Monad m, Applicative f) => Stream f m r
- untilJust :: (Monad m, Applicative f) => m (Maybe r) -> Stream f m r
- streamBuild :: (forall b. (r -> b) -> (m b -> b) -> (f b -> b) -> b) -> Stream f m r
- delays :: (MonadIO m, Applicative f) => Double -> Stream f m r
- maps :: (Monad m, Functor f) => (forall x. f x -> g x) -> Stream f m r -> Stream g m r
- mapsPost :: forall m f g r. (Monad m, Functor g) => (forall x. f x -> g x) -> Stream f m r -> Stream g m r
- mapsM :: (Monad m, Functor f) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r
- mapsMPost :: forall m f g r. (Monad m, Functor g) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r
- mapped :: (Monad m, Functor f) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r
- mappedPost :: (Monad m, Functor g) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r
- hoistUnexposed :: (Monad m, Functor f) => (forall a. m a -> n a) -> Stream f m r -> Stream f n r
- distribute :: (Monad m, Functor f, MonadTrans t, MFunctor t, Monad (t (Stream f m))) => Stream f (t m) r -> t (Stream f m) r
- groups :: (Monad m, Functor f, Functor g) => Stream (Sum f g) m r -> Stream (Sum (Stream f m) (Stream g m)) m r
- inspect :: Monad m => Stream f m r -> m (Either r (f (Stream f m r)))
- splitsAt :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m (Stream f m r)
- takes :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m ()
- chunksOf :: (Monad m, Functor f) => Int -> Stream f m r -> Stream (Stream f m) m r
- concats :: (Monad m, Functor f) => Stream (Stream f m) m r -> Stream f m r
- intercalates :: (Monad m, Monad (t m), MonadTrans t) => t m x -> Stream (t m) m r -> t m r
- cutoff :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m (Maybe r)
- zipsWith :: forall f g h m r. (Monad m, Functor h) => (forall x y. f x -> g y -> h (x, y)) -> Stream f m r -> Stream g m r -> Stream h m r
- zipsWith' :: forall f g h m r. Monad m => (forall x y p. (x -> y -> p) -> f x -> g y -> h p) -> Stream f m r -> Stream g m r -> Stream h m r
- zips :: (Monad m, Functor f, Functor g) => Stream f m r -> Stream g m r -> Stream (Compose f g) m r
- unzips :: (Monad m, Functor f, Functor g) => Stream (Compose f g) m r -> Stream f (Stream g m) r
- interleaves :: (Monad m, Applicative h) => Stream h m r -> Stream h m r -> Stream h m r
- separate :: (Monad m, Functor f, Functor g) => Stream (Sum f g) m r -> Stream f (Stream g m) r
- unseparate :: (Monad m, Functor f, Functor g) => Stream f (Stream g m) r -> Stream (Sum f g) m r
- decompose :: (Monad m, Functor f) => Stream (Compose m f) m r -> Stream f m r
- expand :: (Monad m, Functor f) => (forall a b. (g a -> b) -> f a -> h b) -> Stream f m r -> Stream g (Stream h m) r
- expandPost :: (Monad m, Functor g) => (forall a b. (g a -> b) -> f a -> h b) -> Stream f m r -> Stream g (Stream h m) r
- mapsM_ :: (Functor f, Monad m) => (forall x. f x -> m x) -> Stream f m r -> m r
- run :: Monad m => Stream m m r -> m r
- streamFold :: (Functor f, Monad m) => (r -> b) -> (m b -> b) -> (f b -> b) -> Stream f m r -> b
- iterTM :: (Functor f, Monad m, MonadTrans t, Monad (t m)) => (f (t m a) -> t m a) -> Stream f m a -> t m a
- iterT :: (Functor f, Monad m) => (f (m a) -> m a) -> Stream f m a -> m a
- destroy :: (Functor f, Monad m) => Stream f m r -> (f b -> b) -> (m b -> b) -> (r -> b) -> b
- data Of a b = !a :> b
- lazily :: Of a b -> (a, b)
- strictly :: (a, b) -> Of a b
- class MFunctor k t where
- class (MFunctor * t, MonadTrans t) => MMonad t where
- class MonadTrans t where
- class Monad m => MonadIO m where
- newtype Compose k k1 f g a :: forall k k1. (k1 -> *) -> (k -> k1) -> k -> * = Compose {
- getCompose :: f (g a)
- data Sum k f g a :: forall k. (k -> *) -> (k -> *) -> k -> *
- newtype Identity a :: * -> * = Identity {
- runIdentity :: a
- class Applicative f => Alternative f where
- class Bifunctor p where
- join :: Monad m => m (m a) -> m a
- liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- void :: Functor f => f a -> f ()
- (<>) :: Monoid m => m -> m -> m
An iterable streaming monad transformer
The Stream data type can be used to represent any effectful
succession of steps arising in some monad.
The form of the steps is specified by the first ("functor")
parameter in Stream f m r. The monad of the underlying effects
is expressed by the second parameter.
This module exports combinators that pertain to that general case. Some of these are quite abstract and pervade any use of the library, e.g.
maps :: (forall x . f x -> g x) -> Stream f m r -> Stream g m r mapped :: (forall x . f x -> m (g x)) -> Stream f m r -> Stream g m r hoist :: (forall x . m x -> n x) -> Stream f m r -> Stream f n r -- from the MFunctor instance concats :: Stream (Stream f m) m r -> Stream f m r
(assuming here and thoughout that m or n satisfies a Monad constraint, and
f or g a Functor constraint.)
Others are surprisingly determinate in content:
chunksOf :: Int -> Stream f m r -> Stream (Stream f m) m r splitsAt :: Int -> Stream f m r -> Stream f m (Stream f m r) zipsWith :: (forall x y. f x -> g y -> h (x, y))
- > Stream f m r -> Stream g m r -> Stream h m r > zipsWith' :: (forall x y p. (x -> y -> p) -> f x -> g y -> h p)
- > Stream f m r -> Stream g m r -> Stream h m r > intercalates :: Stream f m () -> Stream (Stream f m) m r -> Stream f m r > unzips :: Stream (Compose f g) m r -> Stream f (Stream g m) r > separate :: Stream (Sum f g) m r -> Stream f (Stream g) m r -- cp. partitionEithers > unseparate :: Stream f (Stream g) m r -> Stream (Sum f g) m r > groups :: Stream (Sum f g) m r -> Stream (Sum (Stream f m) (Stream g m)) m r
One way to see that any streaming library needs some such general type is
that it is required to represent the segmentation of a stream, and to
express the equivalents of Prelude/Data.List combinators that involve
'lists of lists' and the like. See for example this
post
on the correct expression of a streaming 'lines' function.
The module Streaming.Prelude exports combinators relating to
Stream (Of a) m r
where Of a r = !a :> r is a left-strict pair.
This expresses the concept of a Producer or Source or Generator and
easily inter-operates with types with such names in e.g. conduit,
iostreams and pipes.
Instances
Constructing a Stream on a given functor
yields :: (Monad m, Functor f) => f r -> Stream f m r Source #
yields is like lift for items in the streamed functor.
It makes a singleton or one-layer succession.
lift :: (Monad m, Functor f) => m r -> Stream f m r yields :: (Monad m, Functor f) => f r -> Stream f m r
Viewed in another light, it is like a functor-general version of yield:
S.yield a = yields (a :> ())
effect :: (Monad m, Functor f) => m (Stream f m r) -> Stream f m r Source #
Wrap an effect that returns a stream
effect = join . lift
wrap :: (Monad m, Functor f) => f (Stream f m r) -> Stream f m r Source #
Wrap a new layer of a stream. So, e.g.
S.cons :: Monad m => a -> Stream (Of a) m r -> Stream (Of a) m r S.cons a str = wrap (a :> str)
and, recursively:
S.each :: (Monad m, Foldable t) => t a -> Stream (Of a) m () S.each = foldr (\a b -> wrap (a :> b)) (return ())
The two operations
wrap :: (Monad m, Functor f ) => f (Stream f m r) -> Stream f m r effect :: (Monad m, Functor f ) => m (Stream f m r) -> Stream f m r
are fundamental. We can define the parallel operations yields and lift in
terms of them
yields :: (Monad m, Functor f ) => f r -> Stream f m r yields = wrap . fmap return lift :: (Monad m, Functor f ) => m r -> Stream f m r lift = effect . fmap return
replicates :: (Monad m, Functor f) => Int -> f () -> Stream f m () Source #
Repeat a functorial layer, command or instruction a fixed number of times.
replicates n = takes n . repeats
repeats :: (Monad m, Functor f) => f () -> Stream f m r Source #
Repeat a functorial layer (a "command" or "instruction") forever.
repeatsM :: (Monad m, Functor f) => m (f ()) -> Stream f m r Source #
Repeat an effect containing a functorial layer, command or instruction forever.
unfold :: (Monad m, Functor f) => (s -> m (Either r (f s))) -> s -> Stream f m r Source #
Build a Stream by unfolding steps starting from a seed. See also
the specialized unfoldr in the prelude.
unfold inspect = id -- modulo the quotient we work with unfold Pipes.next :: Monad m => Producer a m r -> Stream ((,) a) m r unfold (curry (:>) . Pipes.next) :: Monad m => Producer a m r -> Stream (Of a) m r
never :: (Monad m, Applicative f) => Stream f m r Source #
never interleaves the pure applicative action with the return of the monad forever.
It is the empty of the Alternative instance, thus
never <|> a = a a <|> never = a
and so on. If w is a monoid then never :: Stream (Of w) m r is
the infinite sequence of mempty, and
str1 <|> str2 appends the elements monoidally until one of streams ends.
Thus we have, e.g.
>>>S.stdoutLn $ S.take 2 $ S.stdinLn <|> S.repeat " " <|> S.stdinLn <|> S.repeat " " <|> S.stdinLn1<Enter> 2<Enter> 3<Enter> 1 2 3 4<Enter> 5<Enter> 6<Enter> 4 5 6
This is equivalent to
>>>S.stdoutLn $ S.take 2 $ foldr (<|>) never [S.stdinLn, S.repeat " ", S.stdinLn, S.repeat " ", S.stdinLn ]
Where f is a monad, (<|>) sequences the conjoined streams stepwise. See the
definition of paste here,
where the separate steps are bytestreams corresponding to the lines of a file.
Given, say,
data Branch r = Branch r r deriving Functor -- add obvious applicative instance
then never :: Stream Branch Identity r is the pure infinite binary tree with
(inaccessible) rs in its leaves. Given two binary trees, tree1 <|> tree2
intersects them, preserving the leaves that came first,
so tree1 <|> never = tree1
Stream Identity m r is an action in m that is indefinitely delayed. Such an
action can be constructed with e.g. untilJust.
untilJust :: (Monad m, Applicative f) => m (Maybe r) -> Stream f m r
Given two such items, <|> instance races them.
It is thus the iterative monad transformer specially defined in
Control.Monad.Trans.Iter
So, for example, we might write
>>>let justFour str = if length str == 4 then Just str else Nothing>>>let four = untilJust (fmap justFour getLine)>>>run fourone<Enter> two<Enter> three<Enter> four<Enter> "four"
The Alternative instance in
Control.Monad.Trans.Free
is avowedly wrong, though no explanation is given for this.
streamBuild :: (forall b. (r -> b) -> (m b -> b) -> (f b -> b) -> b) -> Stream f m r Source #
Reflect a church-encoded stream; cp. GHC.Exts.build
streamFold return_ effect_ step_ (streamBuild psi) = psi return_ effect_ step_
Transforming streams
maps :: (Monad m, Functor f) => (forall x. f x -> g x) -> Stream f m r -> Stream g m r Source #
Map layers of one functor to another with a transformation. Compare
hoist, which has a similar effect on the monadic parameter.
maps id = id maps f . maps g = maps (f . g)
mapsPost :: forall m f g r. (Monad m, Functor g) => (forall x. f x -> g x) -> Stream f m r -> Stream g m r Source #
Map layers of one functor to another with a transformation. Compare
hoist, which has a similar effect on the monadic parameter.
mapsPost id = id mapsPost f . mapsPost g = mapsPost (f . g) mapsPost f = mapsPost f
mapsPost is essentially the same as maps, but it imposes a Functor constraint on
its target functor rather than its source functor. It should be preferred if fmap
is cheaper for the target functor than for the source functor.
mapsM :: (Monad m, Functor f) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r Source #
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.
mapsMPost :: forall m f g r. (Monad m, Functor g) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r Source #
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 Functor constraint on
its target functor rather than its source functor. It should be preferred if 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.
mapped :: (Monad m, Functor f) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r Source #
Map layers of one functor to another with a transformation involving the base monad. This could be trivial, e.g.
let noteBeginning text x = putStrLn text >> return text
this puts the 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)
mappedPost :: (Monad m, Functor g) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r Source #
hoistUnexposed :: (Monad m, Functor f) => (forall a. m a -> n a) -> Stream f m r -> Stream f n r Source #
A less-efficient version of hoist that works properly even when its
argument is not a monad morphism.
hoistUnexposed = hoist . unexposed
distribute :: (Monad m, Functor f, MonadTrans t, MFunctor t, Monad (t (Stream f m))) => Stream f (t m) r -> t (Stream f m) r Source #
Make it possible to 'run' the underlying transformed monad.
groups :: (Monad m, Functor f, Functor g) => Stream (Sum f g) m r -> Stream (Sum (Stream f m) (Stream g m)) m r Source #
Group layers in an alternating stream into adjoining sub-streams of one type or another.
Inspecting a stream
inspect :: Monad m => Stream f m r -> m (Either r (f (Stream f m r))) Source #
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
Splitting and joining Streams
splitsAt :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m (Stream f m r) Source #
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 rest2 3
splitAt 0 = return splitAt n >=> splitAt m = splitAt (m+n)
Thus, e.g.
>>>rest <- S.print $ splitsAt 2 >=> splitsAt 2 $ each [1..5]1 2 3 4>>>S.print rest5
chunksOf :: (Monad m, Functor f) => Int -> Stream f m r -> Stream (Stream f m) m r Source #
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
concats :: (Monad m, Functor f) => Stream (Stream f m) m r -> Stream f m r Source #
Dissolves the segmentation into layers of Stream f m layers.
intercalates :: (Monad m, Monad (t m), MonadTrans t) => t m x -> Stream (t m) m r -> t m r Source #
Interpolate a layer at each segment. This specializes to e.g.
intercalates :: (Monad m, Functor f) => Stream f m () -> Stream (Stream f m) m r -> Stream f m r
Zipping, unzipping, separating and unseparating streams
zipsWith :: forall f g h m r. (Monad m, Functor h) => (forall x y. f x -> g y -> h (x, y)) -> Stream f m r -> Stream g m r -> Stream h m r Source #
Zip two streams together. The zipsWith' function should generally
be preferred for efficiency.
zipsWith' :: forall f g h m r. Monad m => (forall x y p. (x -> y -> p) -> f x -> g y -> h p) -> Stream f m r -> Stream g m r -> Stream h m r Source #
Zip two streams together.
zips :: (Monad m, Functor f, Functor g) => Stream f m r -> Stream g m r -> Stream (Compose f g) m r Source #
unzips :: (Monad m, Functor f, Functor g) => Stream (Compose f g) m r -> Stream f (Stream g m) r Source #
interleaves :: (Monad m, Applicative h) => Stream h m r -> Stream h m r -> Stream h m r Source #
Interleave functor layers, with the effects of the first preceding the effects of the second. When the first stream runs out, any remaining effects in the second are ignored.
interleaves = zipsWith (liftA2 (,))
>>>let paste = \a b -> interleaves (Q.lines a) (maps (Q.cons' '\t') (Q.lines b))>>>Q.stdout $ Q.unlines $ paste "hello\nworld\n" "goodbye\nworld\n"hello goodbye world world
separate :: (Monad m, Functor f, Functor g) => Stream (Sum f g) m r -> Stream f (Stream g m) r Source #
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_evenseparate 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:
>>>runResourceT $ S.writeFile "even.txt" . S.show $ S.writeFile "odd.txt" . S.show $ S.separate odd_even>>>:! cat even.txt2 4 6 8 10>>>:! cat odd.txt1 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 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.
unseparate :: (Monad m, Functor f, Functor g) => Stream f (Stream g m) r -> Stream (Sum f g) m r Source #
decompose :: (Monad m, Functor f) => Stream (Compose m f) m r -> Stream f m r Source #
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 :: (Monad m, Functor f) => (forall x. f x -> g x) -> Stream f m r -> Stream g m r hoist :: (Monad m, Functor f) => (forall a. m a -> n a) -> Stream f m r -> Stream f n r
expand :: (Monad m, Functor f) => (forall a b. (g a -> b) -> f a -> h b) -> Stream f m r -> Stream g (Stream h m) r Source #
If Of had a Comonad instance, then we'd have
copy = expand extend
See expandPost for a version that requires a Functor g
instance instead.
expandPost :: (Monad m, Functor g) => (forall a b. (g a -> b) -> f a -> h b) -> Stream f m r -> Stream g (Stream h m) r Source #
If Of had a Comonad instance, then we'd have
copy = expandPost extend
See expand for a version that requires a Functor f instance
instead.
Eliminating a Stream
mapsM_ :: (Functor f, Monad m) => (forall x. f x -> m x) -> Stream f m r -> m r Source #
Map each layer to an effect, and run them all.
run :: Monad m => Stream m m r -> m r Source #
Run the effects in a stream that merely layers effects.
streamFold :: (Functor f, Monad m) => (r -> b) -> (m b -> b) -> (f b -> b) -> Stream f m r -> b Source #
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 return join(Monad m, Functor f) => (f (m a) -> m a) -> Stream f m a -> m a -- iterT
>>>:t streamFold return (join . lift)(Monad m, Monad (t m), Functor f, MonadTrans t) => (f (t m a) -> t m a) -> Stream f m a -> t m a -- iterTM
>>>:t streamFold return effect(Monad m, Functor f, Functor g) => (f (Stream g m r) -> Stream g m r) -> Stream f m r -> Stream g m r
>>>:t \f -> streamFold return effect (wrap . f)(Monad m, Functor f, Functor g) => (f (Stream g m a) -> g (Stream g m a)) -> Stream f m a -> Stream g m a -- maps
>>>:t \f -> streamFold return effect (effect . fmap wrap . f)(Monad m, Functor f, Functor g) => (f (Stream g m a) -> m (g (Stream g m a))) -> Stream f m a -> Stream g m a -- mapped
streamFold done eff construct
= eff . iterT (return . construct . fmap eff) . fmap done
iterTM :: (Functor f, Monad m, MonadTrans t, Monad (t m)) => (f (t m a) -> t m a) -> Stream f m a -> t m a Source #
Specialized fold following the usage of Control.Monad.Trans.Free
iterTM alg = streamFold return (join . lift) iterTM alg = iterT alg . hoist lift
iterT :: (Functor f, Monad m) => (f (m a) -> m a) -> Stream f m a -> m a Source #
Specialized fold following the usage of Control.Monad.Trans.Free
iterT alg = streamFold return join alg iterT alg = runIdentityT . iterTM (IdentityT . alg . fmap runIdentityT)
destroy :: (Functor f, Monad m) => Stream f m r -> (f b -> b) -> (m b -> b) -> (r -> b) -> b Source #
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 (return . construct . fmap eff) . fmap done $ s
Base functor for streams of individual items
A left-strict pair; the base functor for streams of individual elements.
Constructors
| !a :> b infixr 5 |
Instances
| Eq2 Of Source # | |
| Ord2 Of Source # | |
| Show2 Of Source # | |
| Bifunctor Of Source # | |
| Monoid a => Monad (Of a) Source # | |
| Functor (Of a) Source # | |
| Monoid a => Applicative (Of a) Source # | |
| Foldable (Of a) Source # | |
| Traversable (Of a) Source # | |
| Generic1 (Of a) Source # | |
| Eq a => Eq1 (Of a) Source # | |
| Ord a => Ord1 (Of a) Source # | |
| Show a => Show1 (Of a) Source # | |
| (Eq b, Eq a) => Eq (Of a b) Source # | |
| (Data b, Data a) => Data (Of a b) Source # | |
| (Ord b, Ord a) => Ord (Of a b) Source # | |
| (Read b, Read a) => Read (Of a b) Source # | |
| (Show b, Show a) => Show (Of a b) Source # | |
| Generic (Of a b) Source # | |
| (Monoid a, Monoid b) => Monoid (Of a b) Source # | |
| type Rep1 (Of a) Source # | |
| type Rep (Of a b) Source # | |
lazily :: Of a b -> (a, b) Source #
Note that lazily, strictly, fst', and mapOf are all so-called natural transformations on the primitive Of a functor
If we write
type f ~~> g = forall x . f x -> g x
then we can restate some types as follows:
mapOf :: (a -> b) -> Of a ~~> Of b -- Bifunctor first lazily :: Of a ~~> (,) a Identity . fst' :: Of a ~~> Identity a
Manipulation of a Stream f m r by mapping often turns on recognizing natural transformations of f.
Thus maps is far more general the the map of the Streaming.Prelude, which can be
defined thus:
S.map :: (a -> b) -> Stream (Of a) m r -> Stream (Of b) m r S.map f = maps (mapOf f)
i.e.
S.map f = maps (\(a :> x) -> (f a :> x))
This rests on recognizing that mapOf is a natural transformation; note though
that it results in such a transformation as well:
S.map :: (a -> b) -> Stream (Of a) m ~> Stream (Of b) m
Thus we can maps it in turn.
re-exports
A functor in the category of monads, using hoist as the analog of fmap:
hoist (f . g) = hoist f . hoist g hoist id = id
Minimal complete definition
Methods
hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b #
Lift a monad morphism from m to n into a monad morphism from
(t m) to (t n)
Instances
| MFunctor * ListT | |
| MFunctor * Lift | |
| MFunctor * MaybeT | |
| MFunctor * (ErrorT e) | |
| MFunctor * (ExceptT e) | |
| MFunctor * (StateT s) | |
| MFunctor * (StateT s) | |
| MFunctor * (WriterT w) | |
| MFunctor * (WriterT w) | |
| MFunctor * (Backwards *) | |
| MFunctor * (IdentityT *) | |
| Functor f => MFunctor * (Stream f) # | |
| MFunctor * (Product * f) | |
| MFunctor * (ReaderT * r) | |
| Functor f => MFunctor * (Compose * * f) | |
| MFunctor * (RWST r w s) | |
| MFunctor * (RWST r w s) | |
class (MFunctor * t, MonadTrans t) => MMonad t where #
A monad in the category of monads, using lift from MonadTrans as the
analog of return and embed as the analog of (=<<):
embed lift = id embed f (lift m) = f m embed g (embed f t) = embed (\m -> embed g (f m)) t
Minimal complete definition
class MonadTrans t where #
The class of monad transformers. Instances should satisfy the
following laws, which state that lift is a monad transformation:
Minimal complete definition
Methods
lift :: Monad m => m a -> t m a #
Lift a computation from the argument monad to the constructed monad.
Instances
| MonadTrans ListT | |
| MonadTrans MaybeT | |
| MonadTrans (ErrorT e) | |
| MonadTrans (ExceptT e) | |
| MonadTrans (StateT s) | |
| MonadTrans (StateT s) | |
| Monoid w => MonadTrans (WriterT w) | |
| Monoid w => MonadTrans (WriterT w) | |
| MonadTrans (IdentityT *) | |
| Functor f => MonadTrans (Stream f) # | |
| MonadTrans (ContT * r) | |
| MonadTrans (ReaderT * r) | |
| Monoid w => MonadTrans (RWST r w s) | |
| Monoid w => MonadTrans (RWST r w s) | |
class Monad m => MonadIO m where #
Monads in which IO computations may be embedded.
Any monad built by applying a sequence of monad transformers to the
IO monad will be an instance of this class.
Instances should satisfy the following laws, which state that liftIO
is a transformer of monads:
Minimal complete definition
Instances
| MonadIO IO | |
| MonadIO m => MonadIO (ListT m) | |
| MonadIO m => MonadIO (MaybeT m) | |
| (Error e, MonadIO m) => MonadIO (ErrorT e m) | |
| MonadIO m => MonadIO (ExceptT e m) | |
| MonadIO m => MonadIO (StateT s m) | |
| MonadIO m => MonadIO (StateT s m) | |
| (Monoid w, MonadIO m) => MonadIO (WriterT w m) | |
| (Monoid w, MonadIO m) => MonadIO (WriterT w m) | |
| MonadIO m => MonadIO (IdentityT * m) | |
| (MonadIO m, Functor f) => MonadIO (Stream f m) # | |
| MonadIO m => MonadIO (ContT * r m) | |
| MonadIO m => MonadIO (ReaderT * r m) | |
| (Monoid w, MonadIO m) => MonadIO (RWST r w s m) | |
| (Monoid w, MonadIO m) => MonadIO (RWST r w s m) | |
newtype Compose k k1 f g a :: forall k k1. (k1 -> *) -> (k -> k1) -> k -> * infixr 9 #
Right-to-left composition of functors. The composition of applicative functors is always applicative, but the composition of monads is not always a monad.
Constructors
| Compose infixr 9 | |
Fields
| |
Instances
| Functor f => MFunctor * (Compose * * f) | |
| (Functor f, Functor g) => Functor (Compose * * f g) | |
| (Applicative f, Applicative g) => Applicative (Compose * * f g) | |
| (Foldable f, Foldable g) => Foldable (Compose * * f g) | |
| (Traversable f, Traversable g) => Traversable (Compose * * f g) | |
| Functor f => Generic1 (Compose * * f g) | |
| (Eq1 f, Eq1 g) => Eq1 (Compose * * f g) | |
| (Ord1 f, Ord1 g) => Ord1 (Compose * * f g) | |
| (Read1 f, Read1 g) => Read1 (Compose * * f g) | |
| (Show1 f, Show1 g) => Show1 (Compose * * f g) | |
| (Alternative f, Applicative g) => Alternative (Compose * * f g) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Compose * * f g a) | |
| (Data (f (g a)), Typeable * k, Typeable * k1, Typeable (k1 -> k) g, Typeable (k -> *) f, Typeable k1 a) => Data (Compose k1 k f g a) | |
| (Ord1 f, Ord1 g, Ord a) => Ord (Compose * * f g a) | |
| (Read1 f, Read1 g, Read a) => Read (Compose * * f g a) | |
| (Show1 f, Show1 g, Show a) => Show (Compose * * f g a) | |
| Generic (Compose k1 k f g a) | |
| type Rep1 (Compose * * f g) | |
| type Rep (Compose k1 k f g a) | |
data Sum k f g a :: forall k. (k -> *) -> (k -> *) -> k -> * #
Lifted sum of functors.
Instances
| (Functor f, Functor g) => Functor (Sum * f g) | |
| (Foldable f, Foldable g) => Foldable (Sum * f g) | |
| (Traversable f, Traversable g) => Traversable (Sum * f g) | |
| Generic1 (Sum * f g) | |
| (Eq1 f, Eq1 g) => Eq1 (Sum * f g) | |
| (Ord1 f, Ord1 g) => Ord1 (Sum * f g) | |
| (Read1 f, Read1 g) => Read1 (Sum * f g) | |
| (Show1 f, Show1 g) => Show1 (Sum * f g) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Sum * f g a) | |
| (Data (g a), Data (f a), Typeable * k, Typeable (k -> *) g, Typeable (k -> *) f, Typeable k a) => Data (Sum k f g a) | |
| (Ord1 f, Ord1 g, Ord a) => Ord (Sum * f g a) | |
| (Read1 f, Read1 g, Read a) => Read (Sum * f g a) | |
| (Show1 f, Show1 g, Show a) => Show (Sum * f g a) | |
| Generic (Sum k f g a) | |
| type Rep1 (Sum * f g) | |
| type Rep (Sum k f g a) | |
newtype Identity a :: * -> * #
Identity functor and monad. (a non-strict monad)
Since: 4.8.0.0
Constructors
| Identity | |
Fields
| |
Instances
class Applicative f => Alternative f where #
A monoid on applicative functors.
If defined, some and many should be the least solutions
of the equations:
Instances
Formally, the class Bifunctor represents a bifunctor
from Hask -> Hask.
Intuitively it is a bifunctor where both the first and second arguments are covariant.
You can define a Bifunctor by either defining bimap or by
defining both first and second.
If you supply bimap, you should ensure that:
bimapidid≡id
If you supply first and second, ensure:
firstid≡idsecondid≡id
If you supply both, you should also ensure:
bimapf g ≡firstf.secondg
These ensure by parametricity:
bimap(f.g) (h.i) ≡bimapf h.bimapg ifirst(f.g) ≡firstf.firstgsecond(f.g) ≡secondf.secondg
Since: 4.8.0.0
join :: Monad m => m (m a) -> m a #
The join function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r #
Promote a function to a monad, scanning the monadic arguments from left to right. For example,
liftM2 (+) [0,1] [0,2] = [0,2,1,3] liftM2 (+) (Just 1) Nothing = Nothing
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c #
Lift a binary function to actions.
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d #
Lift a ternary function to actions.
void :: Functor f => f a -> f () #
void valueIO action.
Examples
Replace the contents of a Maybe Int
>>>void NothingNothing>>>void (Just 3)Just ()
Replace the contents of an Either Int IntEither Int '()'
>>>void (Left 8675309)Left 8675309>>>void (Right 8675309)Right ()
Replace every element of a list with unit:
>>>void [1,2,3][(),(),()]
Replace the second element of a pair with unit:
>>>void (1,2)(1,())
Discard the result of an IO action:
>>>mapM print [1,2]1 2 [(),()]>>>void $ mapM print [1,2]1 2