package core_unix

You can search for identifiers within the package.

in-package search v0.2.0

core_unix
- Core_unix
core_unix.bigbuffer_blocking
- Core_unix_bigbuffer_blocking
core_unix.bigstring_unix
- Core_unix_bigstring_unix
core_unix.command_unix
- Command_unix
core_unix.core_thread
- Core_thread
core_unix.daemon
- Core_unix_daemon
core_unix.date_unix
- Date_unix
core_unix.error_checking_mutex
- Core_unix_error_checking_mutex
core_unix.filename_unix
- Filename_unix
core_unix.interval_lib
- Interval_lib
core_unix.iobuf_unix
- Core_unix_iobuf_unix
core_unix.linux_ext
- Core_unix_linux_ext
core_unix.lock_file_blocking
- Core_unix_lock_file_blocking
core_unix.nano_mutex
- Core_unix_nano_mutex
core_unix.process_env
- Core_unix_process_env
core_unix.signal_unix
- Signal_unix
core_unix.squeue
- Core_unix_squeue
core_unix.sys_unix
- Sys_unix
core_unix.syslog
- Core_unix_syslog
core_unix.time_interface
- Time_interface
core_unix.time_ns_unix
- Time_ns_unix
core_unix.time_stamp_counter
- Core_unix_time_stamp_counter
core_unix.time_unix
- Time_unix
core_unix.uuid_unix
- Core_unix_uuid_unix

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Core.Command end

include module type of Core_kernel.Command
  with module Shape := Core_kernel.Command.Shape
  with module Deprecated := Core_kernel.Command.Deprecated

module Auto_complete = Core.Command.Auto_complete

module Arg_type = Core.Command.Arg_type

Argument types.

module Flag = Core.Command.Flag

Command-line flag specifications.

module Anons = Core.Command.Anons

Anonymous command-line argument specification.

module Param = Core.Command.Param

Command-line parameter specification.

module Let_syntax = Core.Command.Let_syntax

module Spec = Core.Command.Spec

The old interface for command-line specifications -- Do Not Use.

type t = Core.Command.t

Commands which can be combined into a hierarchy of subcommands.

type ('main, 'result) basic_spec_command =
  summary:Base.String.t ->
  ?readme:(Base.Unit.t -> Base.String.t) ->
  ('main, Base.Unit.t -> 'result) Spec.t ->
  'main ->
  t

val basic_spec : ('main, Base.Unit.t) basic_spec_command

basic_spec ~summary ?readme spec main is a basic command that executes a function main which is passed parameters parsed from the command line according to spec. summary is to contain a short one-line description of its behavior. readme is to contain any longer description of its behavior that will go on that command's help screen.

type 'result basic_command =
  summary:Base.String.t ->
  ?readme:(Base.Unit.t -> Base.String.t) ->
  (Base.Unit.t -> 'result) Param.t ->
  t

val basic : Base.Unit.t basic_command

Same general behavior as basic_spec, but takes a command line specification built up using Params instead of Spec.

val group : 
  summary:Base.String.t ->
  ?readme:(Base.Unit.t -> Base.String.t) ->
  ?preserve_subcommand_order:Base.Unit.t ->
  ?body:(path:Base.String.t Base.List.t -> Base.Unit.t) ->
  (Base.String.t * t) Base.List.t ->
  t

group ~summary subcommand_alist is a compound command with named subcommands, as found in subcommand_alist. summary is to contain a short one-line description of the command group. readme is to contain any longer description of its behavior that will go on that command's help screen.

NOTE: subcommand names containing underscores will be rejected; use dashes instead.

body is called when no additional arguments are passed -- in particular, when no subcommand is passed. Its path argument is the subcommand path by which the group command was reached.

val lazy_group : 
  summary:Base.String.t ->
  ?readme:(Base.Unit.t -> Base.String.t) ->
  ?preserve_subcommand_order:Base.Unit.t ->
  ?body:(path:Base.String.t Base.List.t -> Base.Unit.t) ->
  (Base.String.t * t) Base.List.t Core_kernel.Lazy.t ->
  t

lazy_group is the same as group, except that the list of subcommands may be generated lazily.

val exec : 
  summary:Base.String.t ->
  ?readme:(Base.Unit.t -> Base.String.t) ->
  ?child_subcommand:Base.String.t Base.List.t ->
  path_to_exe:
    [ `Absolute of Base.String.t
    | `Relative_to_argv0 of Base.String.t
    | `Relative_to_me of Base.String.t ] ->
  Base.Unit.t ->
  t

exec ~summary ~path_to_exe runs exec on the executable at path_to_exe. If path_to_exe is `Absolute path then path is executed without any further qualification. If it is `Relative_to_me path then Filename.dirname Sys.executable_name ^ "/" ^ path is executed instead. All of the usual caveats about Sys.executable_name apply: specifically, it may only return an absolute path in Linux. On other operating systems it will return Sys.argv.(0). If it is `Relative_to_argv0 path then Sys.argv.(0) ^ "/" ^ path is executed.

The child_subcommand argument allows referencing a subcommand one or more levels below the top-level of the child executable. It should not be used to pass flags or anonymous arguments to the child.

Care has been taken to support nesting multiple executables built with Command. In particular, recursive help and autocompletion should work as expected.

NOTE: Non-Command executables can be used with this function but will still be executed when help -recursive is called or autocompletion is attempted (despite the fact that neither will be particularly helpful in this case). This means that if you have a shell script called "reboot-everything.sh" that takes no arguments and reboots everything no matter how it is called, you shouldn't use it with exec.

Additionally, no loop detection is attempted, so if you nest an executable within itself, help -recursive and autocompletion will hang forever (although actually running the subcommand will work).

val of_lazy : t Core_kernel.Lazy.t -> t

of_lazy thunk constructs a lazy command that is forced only when necessary to run it or extract its shape.

val summary : t -> Base.String.t

Extracts the summary string for a command.

val exit : Base.Int.t -> _

call this instead of Core.exit if in command-related code that you want to run in tests. For example, in the body of Command.Param.no_arg_abort

val run : 
  ?verbose_on_parse_error:bool ->
  ?version:string ->
  ?build_info:string ->
  ?argv:string list ->
  ?extend:(string list -> string list) ->
  ?when_parsing_succeeds:(unit -> unit) ->
  t ->
  unit

Runs a command against Sys.argv, or argv if it is specified.

extend can be used to add extra command line arguments to basic subcommands of the command. extend will be passed the (fully expanded) path to a command, and its output will be appended to the list of arguments being processed. For example, suppose a program like this is compiled into exe:

let bar = Command.basic ___
let foo = Command.group ~summary:___ ["bar", bar]
let main = Command.group ~summary:___ ["foo", foo]
let () = Command.run ~extend:(fun _ -> ["-baz"]) main

Then if a user ran exe f b, extend would be passed ["foo"; "bar"] and "-baz" would be appended to the command line for processing by bar. This can be used to add a default flags section to a user config file.

verbose_on_parse_error controls whether to print a line suggesting the user try the "-help" flag when an exception is raised while parsing the arguments. By default it is true.

when_parsing_succeeds is invoked after argument parsing has completed successfully, but before the main function of the associated command has run. One use-case is for performing logging when a command is being invoked, where there's no reason to log incorrect invocations or -help calls.

module Path = Core.Command.Path

module Shape = Core.Command.Shape

val shape : t -> Shape.t

Exposes the shape of a command.

module Deprecated = Core.Command.Deprecated

Deprecated should be used only by Deprecated_command. At some point it will go away.