Monad instance for (->).

Examples

let h = {
  use f <- function_monad().bind(fn(x) { fn(y) { x * y } })
  use x <- function_monad().map(fn(x) { x + 5 })
  f(x)
}
h(2)
// -> 14

Monad instance for Identity.

Examples

{
  use x <- identity_monad().bind(Identity("res: "))
  use y <- identity_monad().bind(Identity(7))
  identity_monad().return(x <> int.to_string(y))
}
// -> Identity("res: 7")

// Or without use expressions:
identity_monad().bind(Identity("res: "), fn(x) {
  identity_monad().bind(Identity(7), fn(y) {
    identity_monad().return(x <> int.to_string(y))
  })
})
// -> Identity("res: 7")

Monad instance for List.

Examples

let lm = list_monad()
{
  use x <- lm.bind([1, 2, 3])
  use y <- lm.bind([4, 5])
  lm.return(x * y)
}
// -> [4, 5, 8, 10, 12, 15]

Monad instance for NonEmpty.

Examples

{
  use x <- non_empty_monad().bind(Next(2, Leaf(3)))
  use y <- non_empty_monad().bind(Next("apples", Leaf("pears")))
  non_empty_monad().return(int.to_string(x) <> " " <> y)
}
// -> Next("2 apples", Next("2 pears", Next("3 apples", Leaf("3 pears"))))

Monad instance for Option.

Examples

let op = option_monad()

{
  use x <- op.bind(Some(2))
  use y <- op.map(Some(3))
  x + y
}
// -> Some(5)

{
  use x <- op.bind(None)
  use y <- op.map(Some(3))
  x + y
}
// -> None

{
  use x <- op.bind(Some(2))
  use y <- op.map(None)
  x + y
}
// -> None

Monad instance for Reader.

instance Monad ((->) r) where
  f >>= k = \ r -> k (f r) r

Examples

let r = {
  use t1 <- reader_monad().bind(Reader(fn(x) { x % 2 == 0 }))
  use t2 <- reader_monad().map(Reader(fn(x) { x % 3 == 0 }))
  t1 || t2
}
r.apply(5)
// -> False
r.apply(6)
// -> True

Monad instance for Result.

Examples

let rm = result_monad()

{
  use x <- rm.bind(Ok(2))
  use y <- rm.map(Ok(3))
  x + y
}
// -> Ok(5)

{
  use x <- rm.bind(Error("Nan"))
  use y <- rm.map(Ok(3))
  x + y
}
// -> Error("Nan")

{
  use x <- rm.bind(Ok(2))
  use y <- rm.map(Error("Nan"))
  x + y
}
// -> Error("Nan")

State monad.

Examples

let count = State(fn(x) { #(x, x + 1) })
{
  use x <- state_monad().bind(count) // 1
  use y <- state_monad().bind(count) // 2
  use z <- state_monad().map(count)  // 3
  x + y + z                          // 1 + 2 + 3
}.run(1)
// -> #(6, 4)

Monad instance for Writer.

instance Monad Writer where
 ma >>= k = 
  let (va, log1) = runWriter ma
      (vb, log2) = runWriter (k va)
  in  Writer (vb, log1 ++ log2)

Examples

{
  use x <- writer_monad().bind(Writer(2, "two + "))
  use y <- writer_monad().map(Writer(3, "three"))
  x + y
}
// -> Writer(5, "two + three")