package base

  1. Overview
  2. Docs
package base
Legend:
Library
Module
Module type
Parameter
Class
Class type
  • deprecated [since 2018-09] Use [ppx_let] instead.
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 x -> f ~foo: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
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct