Relude.Monad

Reexporting useful monadic stuff.

Documentation

module Relude.Monad.Reexport

Reexports functions to work with different monads.

module Relude.Monad.Maybe

Provided new combinators to work with Maybe data type.

module Relude.Monad.Either

Provided new combinators to work with Either data type.

module Relude.Monad.Trans

Monad transformers functions and combinators.

chainedTo :: Monad m => (a -> m b) -> m a -> m b

For chaining monadic operations in forward applications using (&) Named version of =<<.

>>> Just [ 1 :: Int ] & chainedTo (viaNonEmpty head)
Just 1
>>> Nothing & chainedTo (viaNonEmpty head)
Nothing

Since: 0.5.0

infinitely :: Applicative f => f a -> f Void

Repeat a monadic action indefinitely.

This is a more type safe version of forever, which has a convenient but unsafe type.

Consider the following two examples. In the getIntForever functions, it falsely expects Int as the result of the forever function. But it would need to wait *forever* to get that, and this mistake won't be caught by the type system and compiler:

getIntForever :: IO Int
getIntForever = do
    i <- forever $ do ...
    pure i

In contrast, using infinitely instead of forever in foo is a type error.

Since: 1.0.0.0