A | |
| acc [CamlinternalFormat] | |
| acc_formatting_gen [CamlinternalFormat] | |
| access_permission [UnixLabels] |
Flags for the
UnixLabels.access call.
|
| access_permission [Unix] |
Flags for the
Unix.access call.
|
| addr_info [UnixLabels] |
Address information returned by
UnixLabels.getaddrinfo.
|
| addr_info [Unix] |
Address information returned by
Unix.getaddrinfo.
|
| alarm [Gc] |
An alarm is a piece of data that calls a user function at the end of
major GC cycle.
|
| allocation [Gc.Memprof] |
The type of metadata associated with allocations.
|
| allocation_source [Gc.Memprof] | |
| anon_fun [Arg] | |
B | |
| backend_type [Sys] |
Currently, the official distribution only supports
Native and
Bytecode, but it can be other backends with alternative
compilers, for example, javascript.
|
| backtrace_slot [Printexc] |
The abstract type
backtrace_slot represents a single slot of
a backtrace.
|
| block_type [CamlinternalFormatBasics] | |
C | |
| c_layout [Bigarray] | |
| channel [Event] |
The type of communication channels carrying values of type
'a.
|
| char_set [CamlinternalFormatBasics] | |
| closure [CamlinternalOO] | |
| complex32_elt [Bigarray] | |
| complex64_elt [Bigarray] | |
| continuation [Effect.Shallow] | ('a,'b) continuation is a delimited continuation that expects a 'a
value and returns a 'b value.
|
| continuation [Effect.Deep] | ('a,'b) continuation is a delimited continuation that expects a 'a
value and returns a 'b value.
|
| control [Gc] |
The GC parameters are given as a
control record.
|
| counter [CamlinternalFormatBasics] | |
| cursor [Runtime_events] |
Type of the cursor used when consuming.
|
| custom_arity [CamlinternalFormatBasics] | |
D | |
| data [Weak.S] |
The type of the elements stored in the table.
|
| dir_handle [UnixLabels] |
The type of descriptors over opened directories.
|
| dir_handle [Unix] |
The type of descriptors over opened directories.
|
| doc [Arg] | |
E | |
| effect_handler [Effect.Deep] | 'a effect_handler is a deep handler with an identity value handler
fun x -> x and an exception handler that raises any exception
fun e -> raise e.
|
| elt [Set.S] |
The type of the set elements.
|
| elt [Pqueue.MaxPoly] | |
| elt [Pqueue.MinPoly] | |
| elt [Pqueue.Max] | |
| elt [Pqueue.Min] |
The type of priority queue elements.
|
| elt [MoreLabels.Set.S] |
The type of the set elements.
|
| eq [Type] |
The purpose of
eq is to represent type equalities that may not otherwise
be known by the type checker (e.g.
|
| error [UnixLabels] |
The type of error codes.
|
| error [Unix] |
The type of error codes.
|
| error [Dynlink] | |
| event [Event] |
The type of communication events returning a result of type
'a.
|
| extern_flags [Marshal] | |
| extra_info [Sys] | |
| extra_prefix [Sys] | |
F | |
| file_descr [UnixLabels] |
The abstract type of file descriptors.
|
| file_descr [Unix] |
The abstract type of file descriptors.
|
| file_kind [UnixLabels] | |
| file_kind [Unix] | |
| file_name [Scanf.Scanning] |
A convenient alias to designate a file name.
|
| file_perm [UnixLabels] |
The type of file access rights, e.g.
|
| file_perm [Unix] |
The type of file access rights, e.g.
|
| float16_elt [Bigarray] | |
| float32_elt [Bigarray] | |
| float64_elt [Bigarray] | |
| float_conv [CamlinternalFormatBasics] | |
| float_flag_conv [CamlinternalFormatBasics] | |
| float_kind_conv [CamlinternalFormatBasics] | |
| flow_action [UnixLabels] | |
| flow_action [Unix] | |
| flush_queue [UnixLabels] | |
| flush_queue [Unix] | |
| fmt [CamlinternalFormatBasics] |
List of format elements.
|
| fmt_ebb [CamlinternalFormat] | |
| fmtty [CamlinternalFormatBasics] | |
| fmtty_rel [CamlinternalFormatBasics] | |
| format [Stdlib] | |
| format4 [Stdlib] | |
| format6 [CamlinternalFormatBasics] | |
| format6 [Stdlib] | |
| formatter [Format] |
Abstract data corresponding to a pretty-printer (also called a
formatter) and all its machinery.
|
| formatter_out_functions [Format] |
The set of output functions specific to a formatter: the
out_string function performs all the pretty-printer string output.
It is called with a string s, a start position p, and a number of
characters n; it is supposed to output characters p to p + n - 1 of
s., the out_width function informs the formatting engine of the width of the
substring as rendered on the output device. Explicit width information as
provided by @<n>, Format.pp_print_as or Format.pp_print_substring_as takes priority
over this function. Moreover, the formatting engine evaluates the width of the
string arguments of Format.pp_print_string and substring arguments of
Format.pp_print_substring as a whole. Consequently, out_width can be used to
compute an approximative width for unicode substrings., the out_flush function flushes the pretty-printer output device., out_newline is called to open a new line when the pretty-printer splits
the line., the out_spaces function outputs spaces when a break hint leads to spaces
instead of a line split. It is called with the number of spaces to output., the out_indent function performs new line indentation when the
pretty-printer splits the line. It is called with the indentation value of
the new line.
By default: fields out_string and out_flush are output device specific;
(e.g. output_string and flush for a
out_channel device, or Buffer.add_substring and
ignore for a Buffer.t output device),, field out_width is the number of unicode scalar values
(see Format.utf_8_scalar_width) in the substring., field out_newline is equivalent to out_string "\n" 0 1;, fields out_spaces and out_indent are equivalent to
out_string (String.make n ' ') 0 n.
|
| formatter_stag_functions [Format] |
The semantic tag handling functions specific to a formatter:
mark versions are the 'tag-marking' functions that associate a string
marker to a tag in order for the pretty-printing engine to write
those markers as 0 length tokens in the output device of the formatter.
|
| formatting_gen [CamlinternalFormatBasics] | |
| formatting_lit [CamlinternalFormatBasics] | |
| fortran_layout [Bigarray] |
To facilitate interoperability with existing C and Fortran code,
this library supports two different memory layouts for Bigarrays,
one compatible with the C conventions,
the other compatible with the Fortran conventions.
|
| fpclass [Stdlib] |
The five classes of floating-point numbers, as determined by
the
classify_float function.
|
| fpclass [Float] |
The five classes of floating-point numbers, as determined by
the
Float.classify_float function.
|
G | |
| geometry [Format] | |
| getaddrinfo_option [UnixLabels] |
Options to
UnixLabels.getaddrinfo.
|
| getaddrinfo_option [Unix] |
Options to
Unix.getaddrinfo.
|
| getnameinfo_option [UnixLabels] |
Options to
UnixLabels.getnameinfo.
|
| getnameinfo_option [Unix] |
Options to
Unix.getnameinfo.
|
| group_entry [UnixLabels] |
Structure of entries in the
groups database.
|
| group_entry [Unix] |
Structure of entries in the
groups database.
|
H | |
| handler [Effect.Shallow] | ('a,'b) handler is a handler record with three fields -- retc
is the value handler, exnc handles exceptions, and effc handles the
effects performed by the computation enclosed by the handler.
|
| handler [Effect.Deep] | ('a,'b) handler is a handler record with three fields -- retc
is the value handler, exnc handles exceptions, and effc handles the
effects performed by the computation enclosed by the handler.
|
| heter_list [CamlinternalFormat] | |
| host_entry [UnixLabels] |
Structure of entries in the
hosts database.
|
| host_entry [Unix] |
Structure of entries in the
hosts database.
|
I | |
| id [Domain] |
Domains have unique integer identifiers
|
| ignored [CamlinternalFormatBasics] | |
| impl [CamlinternalOO] | |
| in_channel [Stdlib] |
The type of input channel.
|
| in_channel [Scanf.Scanning] |
The notion of input channel for the
Scanf module:
those channels provide all the machinery necessary to read from any source
of characters, including a in_channel value.
|
| inet_addr [UnixLabels] |
The abstract type of Internet addresses.
|
| inet_addr [Unix] |
The abstract type of Internet addresses.
|
| init_table [CamlinternalOO] | |
| int16_signed_elt [Bigarray] | |
| int16_unsigned_elt [Bigarray] | |
| int32_elt [Bigarray] | |
| int64_elt [Bigarray] | |
| int8_signed_elt [Bigarray] | |
| int8_unsigned_elt [Bigarray] | |
| int_conv [CamlinternalFormatBasics] | |
| int_elt [Bigarray] | |
| interval_timer [UnixLabels] |
The three kinds of interval timers.
|
| interval_timer [Unix] |
The three kinds of interval timers.
|
| interval_timer_status [UnixLabels] |
The type describing the status of an interval timer
|
| interval_timer_status [Unix] |
The type describing the status of an interval timer
|
K | |
| key [MoreLabels.Map.S] |
The type of the map keys.
|
| key [MoreLabels.Hashtbl.SeededS] | |
| key [MoreLabels.Hashtbl.S] | |
| key [Map.S] |
The type of the map keys.
|
| key [Hashtbl.SeededS] | |
| key [Hashtbl.S] | |
| key [Ephemeron.SeededS] | |
| key [Ephemeron.S] | |
| key [Domain.DLS] |
Type of a DLS key
|
| key [Arg] | |
| kind [Bigarray] |
To each element kind is associated an OCaml type, which is
the type of OCaml values that can be stored in the Bigarray
or read back from it.
|
L | |
| label [CamlinternalOO] | |
| layout [Bigarray] | |
| lexbuf [Lexing] |
The type of lexer buffers.
|
| lifecycle [Runtime_events] |
Lifecycle events for Runtime_events and domains.
|
| linking_error [Dynlink] | |
| location [Printexc] |
The type of location information found in backtraces.
|
| lock_command [UnixLabels] |
Commands for
UnixLabels.lockf.
|
| lock_command [Unix] |
Commands for
Unix.lockf.
|
M | |
| meth [CamlinternalOO] | |
| msg_flag [UnixLabels] | |
| msg_flag [Unix] | |
| mutable_char_set [CamlinternalFormat] | |
N | |
| name_info [UnixLabels] |
Host and service information returned by
UnixLabels.getnameinfo.
|
| name_info [Unix] |
Host and service information returned by
Unix.getnameinfo.
|
| nativeint_elt [Bigarray] | |
| neutral_concat [CamlinternalFormatBasics] | |
| node [Seq] |
A node is either
Nil, which means that the sequence is empty,
or Cons (x, xs), which means that x is the first element
of the sequence and that xs is the remainder of the sequence.
|
O | |
| obj [CamlinternalOO] | |
| obj_t [Obj.Ephemeron] |
alias for
Obj.t
|
| ocaml_release_info [Sys] | |
| open_flag [UnixLabels] |
The flags to
UnixLabels.openfile.
|
| open_flag [Unix] |
The flags to
Unix.openfile.
|
| open_flag [Stdlib] |
Opening modes for
open_out_gen and
open_in_gen.
|
| open_flag [Out_channel] |
Opening modes for
Out_channel.open_gen.
|
| open_flag [In_channel] |
Opening modes for
In_channel.open_gen.
|
| out_channel [Stdlib] |
The type of output channel.
|
P | |
| pad_option [CamlinternalFormatBasics] | |
| padding [CamlinternalFormatBasics] | |
| padty [CamlinternalFormatBasics] | |
| param_format_ebb [CamlinternalFormat] | |
| params [CamlinternalOO] | |
| passwd_entry [UnixLabels] |
Structure of entries in the
passwd database.
|
| passwd_entry [Unix] |
Structure of entries in the
passwd database.
|
| position [Lexing] |
A value of type
position describes a point in a source file.
|
| prec_option [CamlinternalFormatBasics] | |
| precision [CamlinternalFormatBasics] | |
| process_status [UnixLabels] |
The termination status of a process.
|
| process_status [Unix] |
The termination status of a process.
|
| process_times [UnixLabels] |
The execution times (CPU times) of a process.
|
| process_times [Unix] |
The execution times (CPU times) of a process.
|
| protocol_entry [UnixLabels] |
Structure of entries in the
protocols database.
|
| protocol_entry [Unix] |
Structure of entries in the
protocols database.
|
R | |
| raw_backtrace [Printexc] |
The type
raw_backtrace stores a backtrace in a low-level format,
which can be converted to usable form using raw_backtrace_entries
and backtrace_slots_of_raw_entry below.
|
| raw_backtrace_entry [Printexc] |
A
raw_backtrace_entry is an element of a raw_backtrace.
|
| raw_backtrace_slot [Printexc] |
This type is used to iterate over the slots of a
raw_backtrace.
|
| raw_data [Obj] | |
| ref [Stdlib] |
The type of references (mutable indirection cells) containing
a value of type
'a.
|
| regexp [Str] |
The type of compiled regular expressions.
|
| repr [Sys.Immediate64.Make] | |
| result [Stdlib] | |
| runtime_counter [Runtime_events] |
The type for counter events emitted by the runtime.
|
| runtime_phase [Runtime_events] |
The type for span events emitted by the runtime.
|
S | |
| scanbuf [Scanf.Scanning] |
The type of scanning buffers.
|
| scanner [Scanf] |
The type of formatted input scanners:
('a, 'b, 'c, 'd) scanner
is the type of a formatted input function that reads from some
formatted input channel according to some format string; more
precisely, if scan is some formatted input function, then scan applies f to all the arguments specified by format
string fmt, when scan has read those arguments from the
Scanf.Scanning.in_channel formatted input channel ic.
|
| scanner_opt [Scanf] | |
| seek_command [UnixLabels] |
Positioning modes for
UnixLabels.lseek.
|
| seek_command [Unix] |
Positioning modes for
Unix.lseek.
|
| service_entry [UnixLabels] |
Structure of entries in the
services database.
|
| service_entry [Unix] |
Structure of entries in the
services database.
|
| setattr_when [UnixLabels] | |
| setattr_when [Unix] | |
| shape [CamlinternalMod] | |
| shutdown_command [UnixLabels] |
The type of commands for
shutdown.
|
| shutdown_command [Unix] |
The type of commands for
shutdown.
|
| signal [Sys] |
The type for signal numbers.
|
| signal_behavior [Sys] |
What to do when receiving a signal:
Signal_default: take the default behavior
(usually: abort the program), Signal_ignore: ignore the signal, Signal_handle f: call function f, giving it the signal
number as an argument.
|
| sigprocmask_command [UnixLabels] | |
| sigprocmask_command [Unix] | |
| sockaddr [UnixLabels] |
The type of socket addresses.
|
| sockaddr [Unix] |
The type of socket addresses.
|
| socket_bool_option [UnixLabels] |
The socket options that can be consulted with
UnixLabels.getsockopt
and modified with UnixLabels.setsockopt.
|
| socket_bool_option [Unix] |
The socket options that can be consulted with
Unix.getsockopt
and modified with Unix.setsockopt.
|
| socket_domain [UnixLabels] |
The type of socket domains.
|
| socket_domain [Unix] |
The type of socket domains.
|
| socket_float_option [UnixLabels] |
The socket options that can be consulted with
UnixLabels.getsockopt_float
and modified with UnixLabels.setsockopt_float.
|
| socket_float_option [Unix] |
The socket options that can be consulted with
Unix.getsockopt_float
and modified with Unix.setsockopt_float.
|
| socket_int_option [UnixLabels] |
The socket options that can be consulted with
UnixLabels.getsockopt_int
and modified with UnixLabels.setsockopt_int.
|
| socket_int_option [Unix] |
The socket options that can be consulted with
Unix.getsockopt_int
and modified with Unix.setsockopt_int.
|
| socket_optint_option [UnixLabels] |
The socket options that can be consulted with
UnixLabels.getsockopt_optint
and modified with UnixLabels.setsockopt_optint.
|
| socket_optint_option [Unix] |
The socket options that can be consulted with
Unix.getsockopt_optint
and modified with Unix.setsockopt_optint.
|
| socket_type [UnixLabels] |
The type of socket kinds, specifying the semantics of
communications.
|
| socket_type [Unix] |
The type of socket kinds, specifying the semantics of
communications.
|
| span [Runtime_events.Type] | |
| spec [Arg] |
The concrete type describing the behavior associated
with a keyword.
|
| split_result [Str] | |
| stag [Format] |
Semantic tags (or simply tags) are user's defined annotations
to associate user's specific operations to printed entities.
|
| stat [Gc] |
The memory management counters are returned in a
stat record.
|
| statistics [MoreLabels.Hashtbl] | |
| statistics [Hashtbl] | |
| stats [CamlinternalOO] | |
| stats [UnixLabels.LargeFile] | |
| stats [UnixLabels] |
The information returned by the
UnixLabels.stat calls.
|
| stats [Unix.LargeFile] | |
| stats [Unix] |
The information returned by the
Unix.stat calls.
|
| suspended_collection_work [Gc] | |
| symbolic_output_buffer [Format] |
The output buffer of a symbolic pretty-printer.
|
| symbolic_output_item [Format] |
Items produced by symbolic pretty-printers
|
T | |
| t [CamlinternalOO] | |
| t [CamlinternalLazy] | |
| t [Thread] |
The type of thread handles.
|
| t [Weak.S] |
The type of tables that contain elements of type
data.
|
| t [Weak] |
The type of arrays of weak pointers (weak arrays).
|
| t [Unit] |
The unit type.
|
| t [Uchar] |
The type for Unicode characters.
|
| t [Type.Id] |
The type for identifiers for type
'a.
|
| t [Sys.Immediate64.Immediate] | |
| t [Sys.Immediate64.Non_immediate] | |
| t [Sys.Immediate64.Make] | |
| t [String] |
The type for strings.
|
| t [StringLabels] |
The type for strings.
|
| t [Stack] |
The type of stacks containing elements of type
'a.
|
| t [Set.OrderedType] |
The type of the set elements.
|
| t [Set.S] |
The type of sets.
|
| t [Seq] |
A sequence
xs of type 'a t is a delayed list of elements of
type 'a.
|
| t [Semaphore.Binary] |
The type of binary semaphores.
|
| t [Semaphore.Counting] |
The type of counting semaphores.
|
| t [Runtime_events.Callbacks] |
Type of callbacks.
|
| t [Runtime_events.User] |
The type for a user event.
|
| t [Runtime_events.Type] |
The type for a user event content type.
|
| t [Runtime_events.Timestamp] |
Type for the int64 timestamp to allow for future changes.
|
| t [Result] |
The type for result values.
|
| t [Random.State] |
The type of PRNG states.
|
| t [Queue] |
The type of queues containing elements of type
'a.
|
| t [Printexc.Slot] | |
| t [Printexc] |
The type of exception values.
|
| t [Pqueue.OrderedPolyType] |
The polymorphic type of elements.
|
| t [Pqueue.OrderedType] |
The type of elements.
|
| t [Pqueue.MaxPoly] | |
| t [Pqueue.MinPoly] | |
| t [Pqueue.Max] | |
| t [Pqueue.Min] |
The type of priority queues.
|
| t [Pair] |
The type for pairs.
|
| t [Out_channel] |
The type of output channel.
|
| t [Option] |
The type for option values.
|
| t [Obj.Ephemeron] |
an ephemeron cf
Obj.Ephemeron
|
| t [Obj.Extension_constructor] | |
| t [Obj] | |
| t [Nativeint] |
An alias for the type of native integers.
|
| t [Mutex] |
The type of mutexes.
|
| t [MoreLabels.Set.OrderedType] |
The type of the set elements.
|
| t [MoreLabels.Set.S] |
The type of sets.
|
| t [MoreLabels.Map.OrderedType] |
The type of the map keys.
|
| t [MoreLabels.Map.S] |
The type of maps from type
key to type 'a.
|
| t [MoreLabels.Hashtbl.SeededHashedType] |
The type of the hashtable keys.
|
| t [MoreLabels.Hashtbl.HashedType] |
The type of the hashtable keys.
|
| t [MoreLabels.Hashtbl.SeededS] | |
| t [MoreLabels.Hashtbl.S] | |
| t [MoreLabels.Hashtbl] |
The type of hash tables from type
'a to type 'b.
|
| t [Map.OrderedType] |
The type of the map keys.
|
| t [Map.S] |
The type of maps from type
key to type 'a.
|
| t [ListLabels] |
An alias for the type of lists.
|
| t [List] |
An alias for the type of lists.
|
| t [Lazy] |
A value of type
'a Lazy.t is a deferred computation, called a suspension,
that has a result of type 'a.
|
| t [Int64] |
An alias for the type of 64-bit integers.
|
| t [Int32] |
An alias for the type of 32-bit integers.
|
| t [Int] |
The type for integer values.
|
| t [In_channel] |
The type of input channel.
|
| t [Iarray] |
An alias for the type of immutable arrays.
|
| t [Hashtbl.SeededHashedType] |
The type of the hashtable keys.
|
| t [Hashtbl.HashedType] |
The type of the hashtable keys.
|
| t [Hashtbl.SeededS] | |
| t [Hashtbl.S] | |
| t [Hashtbl] |
The type of hash tables from type
'a to type 'b.
|
| t [Gc.Memprof] |
the type of a profile
|
| t [Float.ArrayLabels] |
The type of float arrays with packed representation.
|
| t [Float.Array] |
The type of float arrays with packed representation.
|
| t [Float] |
An alias for the type of floating-point numbers.
|
| t [Ephemeron.Kn.Bucket] |
A bucket is a mutable "list" of ephemerons.
|
| t [Ephemeron.Kn] |
an ephemeron with an arbitrary number of keys
of the same type
|
| t [Ephemeron.K2.Bucket] |
A bucket is a mutable "list" of ephemerons.
|
| t [Ephemeron.K2] |
an ephemeron with two keys
|
| t [Ephemeron.K1.Bucket] |
A bucket is a mutable "list" of ephemerons.
|
| t [Ephemeron.SeededS] | |
| t [Ephemeron.S] | |
| t [Ephemeron.K1] |
an ephemeron with one key
|
| t [Either] |
A value of
('a, 'b) Either.t contains
either a value of 'a or a value of 'b
|
| t [Effect] |
The type of effects.
|
| t [Dynarray] |
A dynamic array containing values of type
'a.
|
| t [Domain] |
A domain of type
'a t runs independently, eventually producing a
result of type 'a, or an exception
|
| t [Digest.S] |
The type of digests.
|
| t [Digest] |
The type of digests: 16-byte strings.
|
| t [Condition] |
The type of condition variables.
|
| t [Complex] |
The type of complex numbers.
|
| t [Char] |
An alias for the type of characters.
|
| t [BytesLabels] |
An alias for the type of byte sequences.
|
| t [Bytes] |
An alias for the type of byte sequences.
|
| t [Buffer] |
The abstract type of buffers.
|
| t [Bool] |
The type of booleans (truth values).
|
| t [Bigarray.Array3] |
The type of three-dimensional Bigarrays whose elements have
OCaml type
'a, representation kind 'b, and memory layout 'c.
|
| t [Bigarray.Array2] |
The type of two-dimensional Bigarrays whose elements have
OCaml type
'a, representation kind 'b, and memory layout 'c.
|
| t [Bigarray.Array1] |
The type of one-dimensional Bigarrays whose elements have
OCaml type
'a, representation kind 'b, and memory layout 'c.
|
| t [Bigarray.Array0] |
The type of zero-dimensional Bigarrays whose elements have
OCaml type
'a, representation kind 'b, and memory layout 'c.
|
| t [Bigarray.Genarray] |
The type
Genarray.t is the type of Bigarrays with variable
numbers of dimensions.
|
| t [Atomic.Loc] |
This module exposes a dedicated type
'a Atomic.Loc.t for
atomic locations (storing a value of type 'a) inside objects
that may not be atomic references.
|
| t [Atomic] |
An atomic (mutable) reference to a value of type
'a.
|
| t [ArrayLabels] |
An alias for the type of arrays.
|
| t [Array] |
An alias for the type of arrays.
|
| table [CamlinternalOO] | |
| tables [CamlinternalOO] | |
| tag [CamlinternalOO] | |
| tag [Runtime_events.User] |
The type for a user event tag.
|
| tag [Format] | |
| terminal_io [UnixLabels] | |
| terminal_io [Unix] | |
| tm [UnixLabels] |
The type representing wallclock time and calendar date.
|
| tm [Unix] |
The type representing wallclock time and calendar date.
|
| tracker [Gc.Memprof] |
A
('minor, 'major) tracker describes how memprof should track
sampled blocks over their lifetime, keeping a user-defined piece
of metadata for each of them: 'minor is the type of metadata
to keep for minor blocks, and 'major the type of metadata
for major blocks.
|
U | |
| usage_msg [Arg] | |
| utf_decode [Uchar] |
The type for UTF decode results.
|
W | |
| wait_flag [UnixLabels] |
Flags for
UnixLabels.waitpid.
|
| wait_flag [Unix] |
Flags for
Unix.waitpid.
|