Module Csv_tool_lib.Csv_param

include Csv_param_intf.Csv_param
module Open_on_rhs_intf = Csv_param_intf.Open_on_rhs_intf
include Open_on_rhs_intf.S
include module type of struct include Async.Command.Param end
include sig ... end
include module type of Command.Param with module Arg_type := Command.Param.Arg_type
module type S = Async.Command.Param.S
type +'a t = 'a Command.Param.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%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.

See example/command/main.ml for more examples.

include Base.Applicative.S with type 'a t := 'a t
val return : 'a 'p 'q. 'a -> 'a t

Convert a value to a t.

val apply : 'a 'b 'p 'q. ('a -> 'b) t -> 'a t -> 'b t

Applies the functions in one t to the values in another. Well-behaved applicatives satisfy these "laws", using <*> as infix apply:

  • return Fn.id <*> t is equivalent to t
  • return Fn.compose <*> tf <*> tg <*> tx is equivalent to tf <*> (tg <*> tx)
  • return f <*> return x is equivalent to return (f x)
  • tf <*> return x is equivalent to return (fun f -> f x) <*> tf
val both : 'a 'b 'p 'q. 'a t -> 'b t -> ('a * 'b) t

Combines values in two ts as tuples. Using <*> as infix apply, equivalent to return (fun a b -> a, b) <*> ta <*> tb.

val map : 'a 'b 'p 'q. 'a t -> f:('a -> 'b) -> 'b t

Transforms the contents of a t. Using <*> as infix apply, equivalent to return f <*> t.

val map2 : 'a 'b 'c 'p 'q. 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t

Combines the contents of two ts. Using <*> as infix apply, equivalent to return f <*> ta <*> tb.

val map3 : 'a 'b 'c 'd 'p 'q. 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t

Combines the contents of three ts. Using <*> as infix apply, equivalent to return f <*> ta <*> tb <*> tc.

val all : 'a 'p 'q. 'a t list -> 'a list t

Combines a list of t.

val all_unit : 'p 'q. unit t list -> unit t

Combines a list of t whose contents are unimportant.

val (<*>) : 'a 'b 'p 'q. ('a -> 'b) t -> 'a t -> 'b t
val (<*) : 'a 'p 'q. 'a t -> unit t -> 'a t
val (*>) : 'a 'p 'q. unit t -> 'a t -> 'a t
val (>>|) : 'a 'b 'p 'q. 'a t -> ('a -> 'b) -> 'b t
module Applicative_infix = Async.Command.Param.Applicative_infix

Various internal values

The help text for the command.

The subcommand path of the command.

The arguments passed to the command.

val flag : ?aliases:Base.string Base.list -> ?full_flag_required:Base.unit -> Base.string -> 'a Command.Flag.t -> doc:Base.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_sexp : ?aliases:Base.string Base.list -> ?full_flag_required:Base.unit -> Base.string -> 'a Command.Arg_type.t -> ('a -> Base.Sexp.t) -> default:'a -> doc:Base.string -> 'a t

flag_optional_with_default_doc_sexp 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 flag_optional_with_default_doc_string : ?aliases:Base.string Base.list -> ?full_flag_required:Base.unit -> Base.string -> 'a Command.Arg_type.t -> ('a -> Base.string) -> default:'a -> doc:Base.string -> 'a t

flag_optional_with_default_doc_string name arg_type string_of_default ~default ~doc is similar to flag_optional_with_default_doc_sexp but uses string_of_default rather than converting via sexp.

val anon : 'a Command.Anons.t -> 'a t

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

val escape_anon : final_anon:'a Command.Anons.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.

module If_nothing_chosen = Async.Command.Param.If_nothing_chosen
val choose_one : 'a Base.option t Base.list -> if_nothing_chosen:('a, 'b) If_nothing_chosen.t -> 'b 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 _.

val choose_one_non_optional : 'a t Base.list -> if_nothing_chosen:('a, 'b) If_nothing_chosen.t -> 'b t

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 : 'a t -> ('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.

val and_arg_name : 'a t -> ('a * Base.string) t

Like and_arg_names, but asserts that there is exactly one name.

val arg_names : 'a t -> Base.string Base.list
val optional_to_required : 'a Base.option t -> 'a t

If None is returned, then the param acts as a required flag that was omitted. This is intended to be used with choose_one_non_optional.

Values included for convenience so you can specify all command line parameters inside a single local open of Param.

include module type of Command.Param.Arg_type.Export
include module type of Command.Flag with type 'a t := 'a Command.Flag.t
val required : 'a Command.Arg_type.t -> 'a Command.Flag.t

Required flags must be passed exactly once.

Optional flags may be passed at most once.

val optional_with_default : 'a -> 'a Command.Arg_type.t -> 'a Command.Flag.t

optional_with_default flags may be passed at most once, and default to a given value.

listed flags may be passed zero or more times.

val one_or_more_as_pair : 'a Command.Arg_type.t -> ('a * 'a Base.list) Command.Flag.t

one_or_more_as_pair flags must be passed one or more times.

val one_or_more_as_list : 'a Command.Arg_type.t -> 'a Base.list Command.Flag.t

Like one_or_more_as_pair, but returns the flag values as a list.

no_arg flags may be passed at most once. The boolean returned is true iff the flag is passed on the command line.

val no_arg_register : key:'a Univ_map.With_default.Key.t -> value:'a -> Base.bool Command.Flag.t

no_arg_register ~key ~value is like no_arg, but associates value with key in the autocomplete environment.

val no_arg_some : 'a -> 'a Base.option Command.Flag.t

no_arg_some value is like no_arg, but will return Some value if the flag is passed on the command line, and return None otherwise.

val no_arg_required : 'a -> 'a Command.Flag.t

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 Command.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.

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 "--".

val map_flag : 'a Command.Flag.t -> f:('a -> 'b) -> 'b Command.Flag.t

map_flag flag ~f transforms the parsed result of flag by applying f.

include module type of Command.Anons with type 'a t := 'a Command.Anons.t

(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.

val sequence : 'a Command.Anons.t -> 'a Base.list Command.Anons.t

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 : 'a Command.Anons.t -> ('a * 'a Base.list) Command.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 : 'a Command.Anons.t -> 'a Base.list Command.Anons.t

(maybe anons) indicates that some anonymous arguments are optional.

val maybe_with_default : 'a -> 'a Command.Anons.t -> 'a Command.Anons.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:

  t2 ("FOO" %: foo) (maybe (t2 ("BAR" %: bar) ("BAZ" %: baz)))]

Sequences of 5 or more anonymous arguments can be built up using nested tuples:

  maybe (t3 a b (t3 c d e))
val t2 : 'a Command.Anons.t -> 'b Command.Anons.t -> ('a * 'b) Command.Anons.t
val t3 : 'a Command.Anons.t -> 'b Command.Anons.t -> 'c Command.Anons.t -> ('a * 'b * 'c) Command.Anons.t
val t4 : 'a Command.Anons.t -> 'b Command.Anons.t -> 'c Command.Anons.t -> 'd Command.Anons.t -> ('a * 'b * 'c * 'd) Command.Anons.t
val map_anons : 'a Command.Anons.t -> f:('a -> 'b) -> 'b Command.Anons.t

map_anons anons ~f transforms the parsed result of anons by applying f.

val parse : 'a t -> Base.string Base.list -> 'a Base.Or_error.t

parse t cmdline will attempt to parse t out of cmdline. Beware there is nothing stopping effectful operations in t from being performed.

include module type of struct include Arg_type.Export end
include module type of struct include Command.Arg_type.Export end

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.

val sexp_conv : ?complete:(Univ_map.t -> part:Base.string -> Base.string Base.list) -> (Base.Sexp.t -> 'a) -> 'a Command.Arg_type.t
val file_stdin_anon : Csv_common.Or_file.t t
val file_stdin_flag : Csv_common.Or_file.t t
val files : string list t
val reverse : bool t
val reverse_fields : string list t
val field : string t
val field' : aliases:string list -> string t
val time_field : string t
val start_time : Core.Time_float.t t
val stop_time : Core.Time_float.t t
val grid_step : Core.Time_float.Span.t t
val max_width : int option t
val prefer_split_on_spaces : bool t
val regexp_arg : Re2.t Arg_type.t
val regexp : Re2.t t
val invert : bool t
val skip_lines : int option t
val sep_arg : char Arg_type.t
val sep : char t
val key_specifier : string t
val no_header : bool t
val no_headers_use_indices_instead : bool t
val space : int t
val suppress_header : bool t
val utf8 : bool t
val fields_gen : doc:string -> string list t
val fields : string list t
val fields_backward_compat : string list t
val pop_fields : string list t
val exclude_fields : bool t
val table_attrs : (string * string option) list t
val th_attrs : (string * string option) list t
val tr_attrs : (string * string option) list t
val td_attrs : (string * string option) list t
val border : bool t
include Core.Applicative.Let_syntax with type 'a t := 'a Async.Command.Param.t with module Open_on_rhs_intf := Open_on_rhs_intf
module Let_syntax : sig ... end