Module Applicative_intf

module Applicative_intf: sig .. end

Applicatives model computations in which values computed by subcomputations cannot affect what subsequent computations will take place. Relative to monads, this restriction takes power away from the user of the interface and gives it to the implementation. In particular, because the structure of the entire computation is known, one can augment its definition with some description of that structure.

For more information, see:

      Applicative Programming with Effects.
      Conor McBride and Ross Paterson.
      Journal of Functional Programming 18:1 (2008), pages 1-13.
      http://staff.city.ac.uk/~ross/papers/Applicative.pdf

For more information, see:

      Applicative Programming with Effects.
      Conor McBride and Ross Paterson.
      Journal of Functional Programming 18:1 (2008), pages 1-13.
      http://staff.city.ac.uk/~ross/papers/Applicative.pdf

module type Basic = sig .. end

module type S = sig .. end

module type Args = sig .. end

argument lists and associated N-ary map and apply functions

module type Basic2 = sig .. end

module type S2 = sig .. end

module S_to_S2: functor (X : S) -> sig .. end

This module serves mostly as a partial check that S2 and S are in sync, but actually calling it is occasionally useful.

module S2_to_S: functor (X : S2) -> sig .. end

module type Args2 = sig .. end

module Args_to_Args2: functor (X : Args) -> sig .. end

For more information, see:

      Applicative Programming with Effects.
      Conor McBride and Ross Paterson.
      Journal of Functional Programming 18:1 (2008), pages 1-13.
      http://staff.city.ac.uk/~ross/papers/Applicative.pdf

The following identities ought to hold for every Applicative (for some value of =):

return Fn.id <*> t = t
return Fn.compose <*> tf <*> tg <*> tx = tf <*> (tg <*> tx)
return f <*> return x = return (f x)
tf <*> return x = return (fun f -> f x) <*> tf

Note: <*> is the infix notation for apply.

The map argument to Applicative.Make says how to implement the applicative's map function. `Define_using_apply means to define map t ~f = return f <*> t. `Custom overrides the default implementation, presumably with something more efficient.

Some other functions returned by Applicative.Make are defined in terms of map, so passing in a more efficient map will improve their efficiency as well.

same as apply

argument lists and associated N-ary map and apply functions

the underlying applicative

'f is the type of a function that consumes the list of arguments and returns an 'r.

the empty argument list *

prepend an argument

infix operator for cons

Transform argument values in some way. For example, one can label a function argument like so:

        step ~f:(fun f ~foo:x -> f x) : ('a -> 'r1, 'r2) t -> (foo:'a -> 'r1, 'r2) t

The preferred way to factor out an Args sub-sequence:

        let args =
          Foo.Args.(
            bar "A"
            (* TODO: factor out the common baz qux sub-sequence *)
            @> baz "B"
            @> qux "C"
            @> zap "D"
            @> nil
          )

is to write a function that prepends the sub-sequence:

        let baz_qux remaining_args =
          Foo.Args.(
            baz "B"
            @> qux "C"
            @> remaining_args
          )

and splice it back into the original sequence using @@ so that things line up nicely:

        let args =
          Foo.Args.(
            bar "A"
            @> baz_qux
            @@ zap "D"
            @> nil
          )

This module serves mostly as a partial check that S2 and S are in sync, but actually calling it is occasionally useful.