Module type Applicative_intf.Args

module type Args = sig .. end
argument lists and associated N-ary map and apply functions

type 'a arg 
the underlying applicative
type ('f, 'r) t 
'f is the type of a function that consumes the list of arguments and returns an 'r.
val nil : ('r, 'r) t
the empty argument list *
val cons : 'a arg ->
('f, 'r) t -> ('a -> 'f, 'r) t
prepend an argument
val (@>) : 'a arg ->
('f, 'r) t -> ('a -> 'f, 'r) t
infix operator for cons
val step : ('f1, 'r) t ->
f:('f2 -> 'f1) -> ('f2, 'r) t
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
          )
      

val mapN : f:'f -> ('f, 'r) t -> 'r arg
val applyN : 'f arg ->
('f, 'r) t -> 'r arg