Module Core_extended.Deprecated_fcommand

This module is a wrapper around Command that allows you to do away with accumulators. Here's an example:

Fcommand.cmd ~summary:"Frobnicate something" Fcommand.( flag "-n" (required int) ~doc:"N number of times to frobnicate" ++ anon (args "item" string)) (fun n items -> ...)

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.Date.t parse
val sexp : Core.Sexp.t parse

flags

module Flag : sig ... 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'mt

anonymous arguments

module Anons : sig ... 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'mt

various combinators

val empty : unit ‑> ('a'at
val const : 'a ‑> ('a ‑> 'm'mt
val either : string ‑> ('a option ‑> 'b'a option ‑> 'a option ‑> 'bt
val (++) : ('m1'm2t ‑> ('m2'm3t ‑> ('m1'm3t

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'm2t

step allows you to transform the way parameters are applied. For example, if you want labelled arguments, you can do:

Fcommand.cmd ~summary:"..." Fcommand.( step (fun main x y z -> main ~x ~y ~z) ++ flag "-x" (optional string) ~doc:"..." ++ flag "-y" (required string) ~doc:"..." ++ flag "-z" (optional int) ~doc:"..." ) (fun ~x ~y ~z -> ... )

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