Module type Core.Command.Param.S

type +'a t

Command.Param is intended to be used with the [%map_open] syntax defined in ppx_let, like so:

          let command =
            Command.basic ~summary:"..."
                let count  = anon ("COUNT" %: int)
                and port   = flag "port" (optional int) ~doc:"N listen on this port"
                and person = person_param
                (* ... Command-line validation code, if any, goes here ... *)
                fun () ->
                  (* The body of the command *)
                  do_stuff count port person

One can also use [%map_open] to define composite command line parameters, like person_param in the previous snippet:

          type person = { name : string; age : int }

          let person_param : person Command.Param.t =
              let name = flag "name" (required string) ~doc:"X name of the person"
              and age  = flag "age"  (required int)    ~doc:"N how many years old"
              {name; age}

The right-hand sides of [%map_open] definitions have Command.Param in scope.

Alternatively, you can say:

          let open Foo.Let_syntax in
            let x ...

if Foo follows the same conventions as Command.Param.

See example/command/ for more examples.

include Core__.Import.Applicative.S with type t := a t
type 'a t
val return : 'a ‑> 'a t
val apply : ('a ‑> 'b) t ‑> 'a t ‑> 'b t
val map : 'a t ‑> f:('a ‑> 'b) ‑> 'b t
val map2 : 'a t ‑> 'b t ‑> f:('a ‑> 'b ‑> 'c) ‑> 'c t
val map3 : 'a t ‑> 'b t ‑> 'c t ‑> f:('a ‑> 'b ‑> 'c ‑> 'd) ‑> 'd t
val all : 'a t list ‑> 'a list t
val all_unit : unit t list ‑> unit t
val all_ignore : unit t list ‑> unit t
  • Deprecated [since 2018-02] Use [all_unit]
val both : 'a t ‑> 'b t ‑> ('a * 'b) t
module Applicative_infix : sig ... end
include module type of Applicative_infix
val (<*>) : ('a ‑> 'b) t ‑> 'a t ‑> 'b t

same as apply

val (<*) : 'a t ‑> unit t ‑> 'a t
val (*>) : unit t ‑> 'a t ‑> 'a t

Various internal values

val help : string Core__.Import.Lazy.t t

The help text for the command.

val path : string list t

The subcommand path of the command.

val args : string list t

The arguments passed to the command.

val flag : ?⁠aliases:string list ‑> ?⁠full_flag_required:unit ‑> string ‑> 'a Flag.t ‑> doc:string ‑> 'a t

flag name spec ~doc specifies a command that, among other things, takes a flag named name on its command line. doc indicates the meaning of the flag.

All flags must have a dash at the beginning of the name. If name is not prefixed by "-", it will be normalized to "-" ^ name.

Unless full_flag_required is used, one doesn't have to pass name exactly on the command line, but only an unambiguous prefix of name (i.e., a prefix which is not a prefix of any other flag's name).

NOTE: the doc for a flag which takes an argument should be of the form arg_name ^ " " ^ description where arg_name describes the argument and description describes the meaning of the flag.

NOTE: flag names (including aliases) containing underscores will be rejected. Use dashes instead.

NOTE: "-" by itself is an invalid flag name and will be rejected.

val flag_optional_with_default_doc : ?⁠aliases:string list ‑> ?⁠full_flag_required:unit ‑> string ‑> 'a Arg_type.t ‑> ('a ‑> Core__.Import.Sexp.t) ‑> default:'a ‑> doc:string ‑> 'a t

flag_optional_with_default_doc name arg_type sexp_of_default ~default ~doc is a shortcut for flag, where:

  1. The Flag.t is optional_with_default default arg_type
  2. The doc is passed through with an explanation of what the default value appended.
val anon : 'a Anons.t ‑> 'a t

anon spec specifies a command that, among other things, takes the anonymous arguments specified by spec.

val choose_one : 'a option t list ‑> if_nothing_chosen:[ `Default_to of 'a | `Raise ] ‑> 'a t

choose_one clauses ~if_nothing_chosen expresses a sum type. It raises if more than one of clauses is Some _. When if_nothing_chosen = `Raise, it also raises if none of clauses is Some _.