# Prelude.Applicative

(*>) : Applicative f => f a -> f b -> f b
  Fixity
    Left associative, precedence 3
(<*) : Applicative f => f a -> f b -> f a
  Fixity
    Left associative, precedence 3
interface Alternative
  empty : Alternative f => f a
  (<|>) : Alternative f => f a -> f a -> f a
    Fixity
      Left associative, precedence 2
interface Applicative
  pure : Applicative f => a -> f a
  (<*>) : Applicative f => f (a -> b) -> f a -> f b
    Fixity
      Left associative, precedence 3
choice : Foldable t => Alternative f => t (f a) -> f a

  Fold using Alternative

  If you have a left-biased alternative operator `<|>`, then `choice`
  performs left-biased choice from a list of alternatives, which means that
  it evaluates to the left-most non-`empty` alternative.

  If the list is empty, or all values in it are `empty`, then it
  evaluates to `empty`.

  Example:

      -- given a parser expression like:
      expr = literal <|> keyword <|> funcall

      -- choice lets you write this as:
      expr = choice [literal, keyword, funcall]

  Note: In Haskell, `choice` is called `asum`.

choiceMap : Foldable t => Alternative f => (a -> f b) -> t a -> f b

  A fused version of choice and map.

guard : Alternative f => Bool -> f ()

  `guard a` is `pure ()` if `a` is `True` and `empty` if `a` is `False`

liftA : Applicative f => (a -> b) -> f a -> f b

  Lift a function to an applicative

liftA2 : Applicative f => (a -> b -> c) -> f a -> f b -> f c

  Lift a two-argument function to an applicative

liftA3 : Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d

  Lift a three-argument function to an applicative

when : Applicative f => Bool -> Lazy (f ()) -> f ()

  Conditionally execute an applicative expression