std.monad

[src]

Implementation of the Monad type

Types

#[implicit]
type Monad m = {
    applicative : Applicative m,
    flat_map : forall a b . (a -> m b) -> m a -> m b
}

A generalised interface for imperatively sequencing actions

Values

let flat_map ?m : forall b a m . [Monad m] -> (a -> m b) -> m a -> m b

[src]

This can be seen as akin to sequential variable binding in an imperative language. For example in Javascript:

var x = call_fallible("hello");
do_something(x);

In gluon this would look like:

result.monad.flat_map (\x -> do_something x) (call_fallible "hello")

Note that it is sometimes more ergonomic to use the (>>=) operator:

let { (>>=) } = import! std.prelude

call_fallible "hello" >>= (\x -> do_something x)
Note
  • Known as (=<<) or flip (>>=)` in Haskell
  • Known as Option::and_then and Result::and_then in Rust

#[infix(left, 1)]
let >>= x f : forall b a m . [Monad m] -> m a -> (a -> m b) -> m b

[src] 

#[infix(right, 1)]
let =<< : forall b a m . [Monad m] -> (a -> m b) -> m a -> m b

[src] 

let join mm : forall a m . [Monad m] -> m (m a) -> m a

[src] 

#[infix(right, 9)]
let <=< g f x : forall a c b m . [Monad m] -> (b -> m c) -> (a -> m b) -> a -> m c

[src] 

#[infix(left, 9)]
let >=> f g x : forall c b a m . [Monad m] -> (a -> m b) -> (b -> m c) -> a -> m c

[src]