Command.Param is intended to be used with the [%map_open] syntax defined in ppx_let, like so:
let command =
Command.basic ~summary:"..."
(let%map_open count = anon ("COUNT" %: int)
and port = flag "port" (optional int) ~doc:"N listen on this port"
and person = person_param
in
(* ... 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%map_open name =
flag "name" (required string) ~doc:"X name of the person"
and age = flag "age" (required int) ~doc:"N how many years old"
in
{name; age})
The right-hand sides of [%map_open] definitions have Command.Param in scope.
val flag :
?aliases:Base.string Base.list->?full_flag_required:Base.unit ->Base.string ->'aFlag.t->doc:Base.string ->'at
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:Base.string Base.list->?full_flag_required:Base.unit ->Base.string ->'aArg_type.t->('a->Base.Sexp.t)->default:'a->doc:Base.string ->'at
flag_optional_with_default_doc name arg_type sexp_of_default ~default ~doc is a shortcut for flag, where:
The Flag.t is optional_with_default default arg_type
The doc is passed through with an explanation of what the default value appended.
anon spec specifies a command that, among other things, takes the anonymous arguments specified by spec.
val escape_anon : final_anon:'aAnons.t->('a * Base.string Base.list)t
escape_anon ~final_anon parses anon and then stops parsing. Remaining command line arguments are collected in the string list, even if they start with dashes.
See escape for the flag version of this behavior.
The final anon is required to indicate when to stop parsing.
val choose_one :
'aBase.optiontBase.list->if_nothing_chosen:('a, 'b)If_nothing_chosen.t->'bt
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 _.
val choose_one_non_optional :
'atBase.list->if_nothing_chosen:('a, 'b)If_nothing_chosen.t->'bt
choose_one_non_optional clauses ~if_nothing_chosen expresses a sum type. It raises if more than one of the clauses has any flags given on the command-line, and returns the value parsed from the clause that's given.
When if_nothing_chosen = Raise, it also raises if none of the clauses are given.
val and_arg_names : 'at->('a * Base.string Base.list)t
and_arg_names t returns both the value of t and the names of the arguments that went into t. Useful for errors that reference multiple params.
Beware that an anonymous argument of type int cannot be specified as negative, as it is ambiguous whether -1 is a negative number or a flag. (The same applies to float, time_span, etc.) You can use the special built-in "-anon" flag to force a string starting with a hyphen to be interpreted as an anonymous argument rather than as a flag, or you can just make it a parameter to a flag to avoid the issue.
no_arg_required value is like no_arg, but the argument is required. This is useful in combination with choose_one_non_optional.
val no_arg_abort : exit:(Base.unit ->Base.Nothing.t)->Base.unit Flag.t
no_arg_abort ~exit is like no_arg, but aborts command-line parsing by calling exit. This flag type is useful for "help"-style flags that just print something and exit.
val escape : Base.string Base.listBase.optionFlag.t
escape flags may be passed at most once. They cause the command line parser to abort and pass through all remaining command line arguments as the value of the flag.
A standard choice of flag name to use with escape is "--".
(name %: typ) specifies a required anonymous argument of type typ.
The name must not be surrounded by whitespace; if it is, an exn will be raised.
If the name is surrounded by a special character pair (<>, {}, [] or (),) name will remain as-is, otherwise, name will be uppercased.
In the situation where name is only prefixed or only suffixed by one of the special character pairs, or different pairs are used (e.g., "<ARG]"), an exn will be raised.
The (possibly transformed) name is mentioned in the generated help for the command.
sequence anons specifies a sequence of anonymous arguments. An exception will be raised if anons matches anything other than a fixed number of anonymous arguments.
val non_empty_sequence_as_pair : 'aAnons.t->('a * 'aBase.list)Anons.t
non_empty_sequence_as_pair anons and non_empty_sequence_as_list anons are like sequence anons except that an exception will be raised if there is not at least one anonymous argument given.
val non_empty_sequence_as_list : 'aAnons.t->'aBase.listAnons.t
(maybe_with_default default anons) indicates an optional anonymous argument with a default value.
t2, t3, and t4 each concatenate multiple anonymous argument specs into a single one. The purpose of these combinators is to allow for optional sequences of anonymous arguments. Consider a command with usage:
main.exe FOO [BAR BAZ]
where the second and third anonymous arguments must either both be there or both not be there. This can be expressed as: