package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type

This module is meant to eventually replace Command.Spec, because the types are easier to understand.

This module is meant to eventually replace Command.Spec, because the types are easier to understand.

module type S = sig ... end
include 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:"..."
    [%map_open
      let 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 =
  [%map_open
    let 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.

Alternatively, you can say:

let open Foo.Let_syntax in
[%map_open
  let x ...
]

if Foo follows the same conventions as Command.Param.

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

include Core_kernel.Applicative.S with type 'a t := '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_ignore : unit t list -> unit t
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_kernel.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 Command.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 anon : 'a Command.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 _.

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

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

values to include in other namespaces

val string : string Arg_type.t
val int : int Arg_type.t

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 char : char Arg_type.t
val float : float Arg_type.t
val bool : bool Arg_type.t
val time_ofday : Core__.Core_time_float.Ofday.Zoned.t Arg_type.t

requires a time zone

for when zone is implied

val file : string Arg_type.t

uses bash autocompletion

val ip_address : Unix.inet_addr Arg_type.t
val sexp_conv : (Core_kernel.Sexp.t -> 'a) -> 'a Arg_type.t
include module type of Command.Flag with type 'a t := 'a Command.Flag.t

flag specifications

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

required flags must be passed exactly once

val optional : 'a Command.Arg_type.t -> 'a option Command.Flag.t

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

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

listed flags may be passed zero or more times

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

one_or_more flags must be passed one or more times

val no_arg : bool Command.Flag.t

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 Core_kernel.Univ_map.With_default.Key.t -> value:'a -> bool Command.Flag.t

no_arg_register ~key ~value is like no_arg, but associates value with key in the in the auto-completion environment

val no_arg_abort : exit:(unit -> Core_kernel.Nothing.t) -> 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.

val escape : string list option Command.Flag.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 "--".

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

anonymous argument specifications

val (%:) : string -> 'a Command.Arg_type.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 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 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 list Command.Anons.t
val maybe : 'a Command.Anons.t -> 'a option 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
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events Blog 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