std.applicative

Implementation of the Applicative type

Types

type Applicative f = {
    functor : std.functor.Functor f,
    apply : forall a b . f (a -> b) -> f a -> f b,
    wrap : forall a . a -> f a
}

A Functor with application.

The following laws should hold:

  • wrap id <*> v = v
  • wrap (<<) <> u <> v <> w = u <> (v <*> w)
  • wrap f <*> wrap x = wrap (f x)
  • u <> wrap y = wrap (\g -> g x) <> u

Values

let apply ?app : forall a a0 a1 . [std.applicative.Applicative a] -> a (a0 -> a1) -> a a0 -> a a1

Like functor.map, but this time the supplied function is embedded in f

Note
  • Known as (<*>) in Haskell

let wrap ?app : forall a a0 . [std.applicative.Applicative a] -> a0 -> a a0

Wrap the supplied value in f

Examples
  • option.applicative.wrap 1 == Some 1
  • result.applicative.wrap 1 == Ok 1
  • list.applicative.wrap 1 == list.of [1]
Note
  • Known as pure in Haskell

let <*> : forall a a0 a1 . [std.applicative.Applicative a] -> a (a0 -> a1) -> a a0 -> a a1

Alias of <*>

let <* l r : forall a a0 a1 . [std.applicative.Applicative a] -> a a0 -> a a1 -> a a0

Sequence actions, discarding the value of the second argument

let *> l r : forall a a0 a1 . [std.applicative.Applicative a] -> a a0 -> a a1 -> a a1

Sequence actions, discarding the value of the first argument

let map2 fn a b : forall a a0 a1 a2 .
    [std.applicative.Applicative a] -> (a0 -> a1 -> a2) -> a a0 -> a a1 -> a a2

Maps over two actions

let map3 fn a b c : forall a a0 a1 a2 a3 .
    [std.applicative.Applicative a]
        -> (a0 -> a1 -> a2 -> a3)
        -> a a0
        -> a a1
        -> a a2
        -> a a3

Maps over three actions

let map4 fn a b c d : forall a a0 a1 a2 a3 a4 .
    [std.applicative.Applicative a]
        -> (a0 -> a1 -> a2 -> a3 -> a4)
        -> a a0
        -> a a1
        -> a a2
        -> a a3
        -> a a4

let map5 fn a b c d e : forall a a0 a1 a2 a3 a4 a5 .
    [std.applicative.Applicative a]
        -> (a0 -> a1 -> a2 -> a3 -> a4 -> a5)
        -> a a0
        -> a a1
        -> a a2
        -> a a3
        -> a a4
        -> a a5

let map6 fn a b c d e f : forall a a0 a1 a2 a3 a4 a5 a6 .
    [std.applicative.Applicative a]
        -> (a0 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6)
        -> a a0
        -> a a1
        -> a a2
        -> a a3
        -> a a4
        -> a a5
        -> a a6

let map7 fn a b c d e f g : forall a a0 a1 a2 a3 a4 a5 a6 a7 .
    [std.applicative.Applicative a]
        -> (a0 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7)
        -> a a0
        -> a a1
        -> a a2
        -> a a3
        -> a a4
        -> a a5
        -> a a6
        -> a a7

let map8 fn a b c d e f g h : forall a a0 a1 a2 a3 a4 a5 a6 a7 a8 .
    [std.applicative.Applicative a]
        -> (a0 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8)
        -> a a0
        -> a a1
        -> a a2
        -> a a3
        -> a a4
        -> a a5
        -> a a6
        -> a a7
        -> a a8

let map9 fn a b c d e f g h i : forall a a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 .
    [std.applicative.Applicative a]
        -> (a0 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9)
        -> a a0
        -> a a1
        -> a a2
        -> a a3
        -> a a4
        -> a a5
        -> a a6
        -> a a7
        -> a a8
        -> a a9

let map10 fn a b c d e f g h i j : forall a a0 a1 a10 a2 a3 a4 a5 a6 a7 a8 a9 .
    [std.applicative.Applicative a]
        -> (a0 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10)
        -> a a0
        -> a a1
        -> a a2
        -> a a3
        -> a a4
        -> a a5
        -> a a6
        -> a a7
        -> a a8
        -> a a9
        -> a a10