# 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