package devkit

You can search for identifiers within the package.

in-package search v0.2.0

package devkit

devkit
- Devkit
devkit.core
- Devkit_core
  - Action
    
    timer
    
    timer_start
  - Async
    
    Internal
    
    Peer
  - Bit_struct_list
    
    Make
    
    S
    
    S
  - Cache
    
    Assoc
    
    Count
    
    Group
    
    LRU
    
    K
    
    Lists
    
    Lock
    
    NoLock
    
    Reuse
    
    T
    
    TimeLimited2
    
    E
    
    Lock
    
    cache
  - Control
  - Daemon
  - Devkit_ragel
  - Digest_auth
  - Exn
  - Exn_lwt
  - ExtArg
  - ExtEnum
  - ExtEnum_merge
  - ExtThread
    
    Async_fin
    
    LockMutex
    
    Pool
    
    WorkerT
    
    Workers
    
    T
  - Factor
    
    Float
    
    Int
  - FastBase64
  - Files
  - Gzip_io
  - Gzip_stream
  - HtmlStream
  - HtmlStream_ragel
    
    Raw
  - Httpev
    
    Answer
    
    Args
    
    T
    
    BuffersCache
    
    Hidden
    
    Param
    
    ReqBuffersCache
    
    Tcp
  - Httpev_common
  - Idn
    
    CONV
    
    Make
    
    CONV
  - Log
    
    State
    
    M
    
    Put
    
    logger
  - Logger
    
    Make
    
    T
    
    Put
    
    PutLimited
    
    T
    
    PutSimple
    
    T
    
    Target
  - Logstash
    
    Dyn
  - Lwt_engines
    
    libevent
    
    poll
  - Lwt_flag
  - Lwt_mark
  - Lwt_util
  - MVar
  - Memory
  - Mtq
  - Network
    
    IPv4
  - Nix
  - Parallel
    
    Forks
    
    T
    
    Services
    
    WorkerT
    
    Workers
  - Persist
    
    Marshal
    
    V
    
    Marshal_ext
    
    V
    
    Value
    
    Value_ext
  - Pid
  - Possibly_otel
    
    Traceparent
  - Prelude
    
    Fresh
    
    T
  - Reader
  - Signal
  - Static_config
    
    base
  - Stre
    
    ASCII
  - Systemd
    
    Daemon
  - Time
  - UnsafeBitSet
  - Var
    
    typ
  - Web
    
    CURL
    
    CurlCache
    
    Curl_blocking
    
    Curl_lwt_for_http
    
    HTTP
    
    IO
    
    Http
    
    Curl_IO
    
    IO
    
    Http_blocking
    
    IO
    
    Http_lwt
    
    IO
    
    IO_TYPE
    
    IO_blocking
    
    IO_lwt
devkit.ocamlnet_lite
- Ocamlnet_lite
  - Netaux
    
    ArrayAux
  - Netbuffer
  - Netconversion
  - Netencoding
    
    Html
    
    Url
  - Netstring_str
  - Netstring_tstring
  - Netsys_types

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Arg end

type spec = Arg.spec =

| Unit of unit -> unit
(*
Call the function with unit argument
*)
| Bool of bool -> unit
(*
Call the function with a bool argument
*)
| Set of bool ref
(*
Set the reference to true
*)
| Clear of bool ref
(*
Set the reference to false
*)
| String of string -> unit
(*
Call the function with a string argument
*)
| Set_string of string ref
(*
Set the reference to the string argument
*)
| Int of int -> unit
(*
Call the function with an int argument
*)
| Set_int of int ref
(*
Set the reference to the int argument
*)
| Float of float -> unit
(*
Call the function with a float argument
*)
| Set_float of float ref
(*
Set the reference to the float argument
*)
| Tuple of spec list
(*
Take several arguments according to the spec list
*)
| Symbol of string list * string -> unit
(*
Take one of the symbols as argument and call the function with the symbol
*)
| Rest of string -> unit
(*
Stop interpreting keywords and call the function with each remaining argument
*)
| Rest_all of string list -> unit
(*
Stop interpreting keywords and call the function with all remaining arguments
*)
| Expand of string -> string array
(*
If the remaining arguments to process are of the form ["-foo"; "arg"] @ rest where "foo" is registered as Expand f, then the arguments f "arg" @ rest are processed. Only allowed in parse_and_expand_argv_dynamic.
*)

The concrete type describing the behavior associated with a keyword.

type key = string

type doc = string

type usage_msg = string

type anon_fun = string -> unit

val parse_dynamic : 
  (key * spec * doc) list ref ->
  anon_fun ->
  usage_msg ->
  unit

Same 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:

command subcommand options where the list of options depends on the value of the subcommand argument.

since 4.01

val parse_argv : 
  ?current:int ref ->
  string array ->
  (key * spec * doc) list ->
  anon_fun ->
  usage_msg ->
  unit

Arg.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 ->
  unit

Same as Arg.parse_argv, except that the speclist argument is a reference and may be updated during the parsing. See Arg.parse_dynamic.

since 4.01

val parse_and_expand_argv_dynamic : 
  int ref ->
  string array ref ->
  (key * spec * doc) list ref ->
  anon_fun ->
  string ->
  unit

Same 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.

since 4.05

val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit

Same as Arg.parse, except that the Expand arguments are allowed and the current reference is not updated.

since 4.05

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_string : (key * spec * doc) list -> usage_msg -> string

Returns the message that would have been printed by Arg.usage, if provided with the same parameters.

val current : int ref

Position (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 array

Arg.read_arg file reads newline-terminated command line arguments from file file.

since 4.05

val read_arg0 : string -> string array

Identical to Arg.read_arg but assumes null character terminated command line arguments.

since 4.05

val write_arg : string -> string array -> unit

Arg.write_arg file args writes the arguments args newline-terminated into the file file. If any of the arguments in args contains a newline, use Arg.write_arg0 instead.

since 4.05

val write_arg0 : string -> string array -> unit

Identical to Arg.write_arg but uses the null character for terminator instead of newline.

since 4.05

val describe : string -> string -> string -> string

val make_arg : 
  < kind : string ; show : 'a -> string ; store : 'a -> 'b.. > ->
  string ->
  'a ->
  string ->
  string * 'b * string

val test_int : 
  (int -> bool) ->
  < kind : string
  ; show : int ref -> string
  ; store : int ref -> Arg.spec >

val string : 
  < kind : string
  ; show : 'a ref -> 'a
  ; store : string ref -> Arg.spec >

val int_option : 
  < kind : string
  ; show : int option ref -> string
  ; store : int option ref -> Arg.spec >

val float_option : 
  < kind : string
  ; show : float option ref -> string
  ; store : float option ref -> Arg.spec >

val str_option : 
  < kind : string
  ; show : string option ref -> string
  ; store : string option ref -> Arg.spec >

val int : string -> int ref -> string -> string * Arg.spec * string

val float : string -> float ref -> string -> string * Arg.spec * string

val str : string -> string ref -> string -> string * Arg.spec * string

val duration : string -> float ref -> string -> string * Arg.spec * string

val may_int : string -> int option ref -> string -> string * Arg.spec * string

val may_float : 
  string ->
  float option ref ->
  string ->
  string * Arg.spec * string

val may_str : 
  string ->
  string option ref ->
  string ->
  string * Arg.spec * string

val positive_int : string -> int ref -> string -> string * Arg.spec * string

val bool : string -> bool ref -> string -> string * Arg.spec * string

val usage_header : string

val align : ?sep:string -> (key * spec * doc) list -> (key * spec * doc) list

val parse : ?f:anon_fun -> (key * spec * doc) list -> unit

val usage : (key * spec * doc) list -> unit

val two_strings : (string -> string -> unit) -> Arg.spec

val rest : unit -> string list