module Arg: Argtype | | | Unit of  | (* | Call the function with unit argument | *) | 
| | | Bool of  | (* | Call the function with a bool argument | *) | 
| | | Set of  | (* | Set the reference to true | *) | 
| | | Clear of  | (* | Set the reference to false | *) | 
| | | String of  | (* | Call the function with a string argument | *) | 
| | | Set_string of  | (* | Set the reference to the string argument | *) | 
| | | Int of  | (* | Call the function with an int argument | *) | 
| | | Set_int of  | (* | Set the reference to the int argument | *) | 
| | | Float of  | (* | Call the function with a float argument | *) | 
| | | Set_float of  | (* | Set the reference to the float argument | *) | 
| | | Tuple of  | (* | Take several arguments according to the spec list | *) | 
| | | Symbol of  | (* | Take one of the symbols as argument and call the function with the symbol | *) | 
| | | Rest of  | (* | Stop interpreting keywords and call the function with each remaining argument | *) | 
| | | Rest_all of  | (* | Stop interpreting keywords and call the function with all remaining arguments | *) | 
| | | Expand of  | (* | If the remaining arguments to process
                                           are of the form
                                            | *) | 
The concrete type describing the behavior associated with a keyword.
typekey =string
typedoc =string
typeusage_msg =string
typeanon_fun =string -> unit
val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unitArg.parse speclist anon_fun usage_msg parses the command line.
    speclist is a list of triples (key, spec, doc).
    key is the option keyword, it must start with a '-' character.
    spec gives the option type and the function to call when this option
    is found on the command line.
    doc is a one-line description of this option.
    anon_fun is called on anonymous arguments.
    The functions in spec and anon_fun are called in the same order
    as their arguments appear on the command line.
If an error occurs, Arg.parse exits the program, after printing
    to standard error an error message as follows:
usage_msgdoc string.
    Beware: options that have an empty doc string will not be included in the
    list.For the user to be able to specify anonymous arguments starting with a
    -, include for example ("-", String anon_fun, doc) in speclist.
By default, parse recognizes two unit options, -help and --help,
    which will print to standard output usage_msg and the list of
    options, and exit the program.  You can override this behaviour
    by specifying your own -help and --help options in speclist.
val parse_dynamic : (key * spec * doc) list ref ->
       anon_fun -> usage_msg -> unitSame as Arg.parse, except that the speclist argument is a reference
    and may be updated during the parsing. A typical use for this feature
    is to parse command lines of the form:
options
    where the list of options depends on the value of the subcommand argument.val parse_argv : ?current:int ref ->
       string array ->
       (key * spec * doc) list -> anon_fun -> usage_msg -> unitArg.parse_argv ~current args speclist anon_fun usage_msg parses
  the array args as if it were the command line.  It uses and updates
  the value of ~current (if given), or Arg.current.  You must set
  it before calling parse_argv.  The initial value of current
  is the index of the program name (argument 0) in the array.
  If an error occurs, Arg.parse_argv raises Arg.Bad with
  the error message as argument.  If option -help or --help is
  given, Arg.parse_argv raises Arg.Help with the help message
  as argument.
val parse_argv_dynamic : ?current:int ref ->
       string array ->
       (key * spec * doc) list ref ->
       anon_fun -> string -> unitSame as Arg.parse_argv, except that the speclist argument is a
    reference and may be updated during the parsing.
    See Arg.parse_dynamic.
val parse_and_expand_argv_dynamic : int ref ->
       string array ref ->
       (key * spec * doc) list ref ->
       anon_fun -> string -> unitSame as Arg.parse_argv_dynamic, except that the argv argument is a
    reference and may be updated during the parsing of Expand arguments.
    See Arg.parse_argv_dynamic.
val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unitSame as Arg.parse, except that the Expand arguments are allowed and
    the Arg.current reference is not updated.
exception Help of string
Raised by Arg.parse_argv when the user asks for help.
exception Bad of string
Functions in spec or anon_fun can raise Arg.Bad with an error
    message to reject invalid arguments.
    Arg.Bad is also raised by Arg.parse_argv in case of an error.
val usage : (key * spec * doc) list -> usage_msg -> unitval usage_string : (key * spec * doc) list -> usage_msg -> stringReturns the message that would have been printed by Arg.usage,
    if provided with the same parameters.
val align : ?limit:int ->
       (key * spec * doc) list -> (key * spec * doc) listAlign the documentation strings by inserting spaces at the first alignment
    separator (tab or, if tab is not found, space), according to the length of
    the keyword.  Use a alignment separator as the first character in a doc
    string if you want to align the whole string.  The doc strings corresponding
    to Symbol arguments are aligned on the next line.
limit : options with keyword and message longer than limit will not
    be used to compute the alignment.val current : int refPosition (in Sys.argv) of the argument being processed.  You can
    change this value, e.g. to force Arg.parse to skip some arguments.
    Arg.parse uses the initial value of Arg.current as the index of
    argument 0 (the program name) and starts parsing arguments
    at the next element.
val read_arg : string -> string arrayArg.read_arg file reads newline-terminated command line arguments from
    file file.
val read_arg0 : string -> string arrayIdentical to Arg.read_arg but assumes null character terminated command
    line arguments.
val write_arg : string -> string array -> unitArg.write_arg file args writes the arguments args newline-terminated
    into the file file. If the any of the arguments in args contains a
    newline, use Arg.write_arg0 instead.
val write_arg0 : string -> string array -> unitIdentical to Arg.write_arg but uses the null character for terminator
    instead of newline.