Up

module Deprecated_fcommand

: sig

DEPRECATED: use Core.Std.Command instead

#
type ('main_in, 'main_out) t

('main_in, 'main_out) t is a type of composable command-line specifications.

Every combinator for building t-values is polymorphic in 'main_out. In the final specification expected by cmd used to construct a command, 'main_out is specialized to unit). Various primitive specifications add parameters one at a time, so the resulting type of main is

arg1 -> ... -> argN -> unit

It may help to think of ('a, 'b) t as a function space 'a -> 'b embellished with extra information about how to parse command line, including documentation about what various flags are for.

argument parsing

#
type 'a parse = string -> 'a
#
val string : string parse
#
val int : int parse
#
val float : float parse
#
val date : Core.Std.Date.t parse
#
val sexp : Core.Std.Sexp.t parse

flags

#
module Flag : sig
#
type 'a t

a flag specification

#
val map : f:('a -> 'b) -> 'a t -> 'b t
end
#
val required : 'a parse -> 'a Flag.t
#
val optional : 'a parse -> 'a option Flag.t
#
val optional_with_default : 'a -> 'a parse -> 'a Flag.t
#
val listed : 'a parse -> 'a list Flag.t
#
val no_arg : [
| `Present
| `Absent
] Flag.t
#
val no_arg_bool : bool Flag.t
#
val capture_remaining_command_line : string list option Flag.t
#
val flag : string -> 'a Flag.t -> doc:string -> ('a -> 'm, 'm) t

anonymous arguments

#
module Anons : sig
#
type 'a t

anonymous args specification

#
val map : f:('a -> 'b) -> 'a t -> 'b t
end
#
val (%:) : string -> 'a parse -> 'a Anons.t
#
val many : string -> 'a parse -> 'a list Anons.t
#
val maybe : 'a Anons.t -> 'a option Anons.t
#
val maybe_with_default : 'a -> 'a Anons.t -> 'a Anons.t
#
val zero : unit Anons.t
#
val t2 : 'a Anons.t -> 'b Anons.t -> ('a * 'b) Anons.t
#
val t3 : 'a Anons.t -> 'b Anons.t -> 'c Anons.t -> ('a * 'b * 'c) Anons.t
#
val t4 : 'a Anons.t -> 'b Anons.t -> 'c Anons.t -> 'd Anons.t -> ('a * 'b * 'c * 'd) Anons.t
#
val anon : 'a Anons.t -> ('a -> 'm, 'm) t

various combinators

#
val empty : unit -> ('a, 'a) t
#
val const : 'a -> ('a -> 'm, 'm) t
#
val either : string -> ('a option -> 'b, 'a option -> 'a option -> 'b) t
#
val (++) : ('m1, 'm2) t -> ('m2, 'm3) t -> ('m1, 'm3) t

spec1 ++ spec2 composes command-line specifications spec1 and spec2. Parameters specified by spec1 will come before those specified by spec2 in the eventual main function.

#
val step : ('m1 -> 'm2) -> ('m1, 'm2) t

constructing the command we've specified

#
val cmd : summary:string -> ?readme:(unit -> string) -> ?autocomplete:Deprecated_command.Autocomplete.t -> ?global_flags:unit Deprecated_command.Flag.t list -> ('main, unit) t -> 'main -> Deprecated_command.t
end