cat/instances/applicative

Applicative instances: Option, List, Reader, Writer.

Functions

pub fn list_applicative() -> Applicative(
  Functor(ListF, a, b, List(a), List(b)),
  a,
  List(fn(a) -> b),
  List(a),
  List(b),
)

Instance for Applicative List.

instance Applicative [] where
    // pure :: a -> [a]
    pure x = [x]
    // (<*>) :: [a -> b] -> [a] -> [b]
    fs <*> xs = [f x | f <- fs, x <- xs]

Examples

[1, 2, 3]
|> {
    [fn(x) { x * 2 }, fn(x) { x + 10 }]
    |> apply(list_applicative())
}
// -> [2, 4, 6, 11, 12, 13]
pub fn option_applicative() -> Applicative(
  Functor(OptionF, a, b, Option(a), Option(b)),
  a,
  Option(fn(a) -> b),
  Option(a),
  Option(b),
)

Instance for Applicative Option.

instance Applicative Maybe where
    // pure :: a -> Maybe a
    pure x = Just x
    // (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b 
    Nothing <*> _ = Nothing
    Just(f) <*> m = fmap f m

Examples

9
|> { option_applicative() |> pure() }
// -> Some(9)
let option_f =
    int.to_string
    |> { option_applicative() |> pure() }
    |> { option_applicative() |> apply() }
None 
|> option_f()
// -> None
Some(12) 
|> option_f()
// -> Some("12")
pub fn reader_applicative() -> Applicative(
  Functor(ReaderF(a), b, c, Reader(a, b), Reader(a, c)),
  b,
  Reader(a, fn(b) -> c),
  Reader(a, b),
  Reader(a, c),
)

Applicative instance for Reader.

pub fn writer_applicative() -> Applicative(
  Functor(WriterF, a, b, Writer(a), Writer(b)),
  a,
  Writer(fn(a) -> b),
  Writer(a),
  Writer(b),
)

Applicative instance for Writer.

Search Document