include Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
This function only needs implementation if t
exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t
afterwards.
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
include Ppx_sexp_conv_lib.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
include Core_kernel.Comparable.S with type t := t
include Base.Comparable.S with type t := t
compare t1 t2
returns 0 if t1
is equal to t2
, a negative integer if t1
is less than t2
, and a positive integer if t1
is greater than t2
.
ascending
is identical to compare
. descending x y = ascending y x
. These are intended to be mnemonic when used like List.sort ~compare:ascending
and List.sort
~cmp:descending
, since they cause the list to be sorted in ascending or descending order, respectively.
clamp_exn t ~min ~max
returns t'
, the closest value to t
such that between t' ~low:min ~high:max
is true.
Raises if not (min <= max)
.
val clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Base.Comparator.S with type t := t
val comparator : (t, comparator_witness) Base.Comparator.comparator
val validate_lbound : min:t Base.Maybe_bound.t -> t Base.Validate.check
val validate_ubound : max:t Base.Maybe_bound.t -> t Base.Validate.check
val validate_bound : min:t Base.Maybe_bound.t -> max:t Base.Maybe_bound.t -> t Base.Validate.check
module Replace_polymorphic_compare : sig ... end
module Map : Core_kernel.Map.S with type Key.t = t with type Key.comparator_witness = comparator_witness
module Set : Core_kernel.Set.S with type Elt.t = t with type Elt.comparator_witness = comparator_witness
include Core_kernel.Hashable.S with type t := t
include Core_kernel.Hashable.Common with type t := t
val compare : t -> t -> Base.Int.t
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
val hashable : t Core_kernel.Hashtbl.Hashable.t
module Table : Core_kernel.Hashtbl.S with type key = t
module Hash_set : Core_kernel.Hash_set.S with type elt = t
module Hash_queue : Core_kernel.Hash_queue.S with type key = t
val of_system_int : int -> t
of_system_int
and to_system_int
return and take respectively a signal number corresponding to those in the system's /usr/include/bits/signum.h (or equivalent). It is not guaranteed that these numbers are portable across any given pair of systems -- although some are defined as standard by POSIX.
val to_system_int : t -> int
val of_caml_int : int -> t
of_caml_int
constructs a Signal.t
given an OCaml internal signal number. This is only for the use of the Core_unix
module.
val to_caml_int : t -> int
val to_string : t -> string
to_string t
returns a human-readable name: "sigabrt", "sigalrm", ...
type sys_behavior = [
| `Continue | Continue the process if it is currently stopped |
| `Dump_core | Terminate the process and dump core |
| `Ignore | Ignore the signal |
| `Stop | Stop the process |
| `Terminate | Terminate the process |
]
The default behaviour of the system if these signals trickle to the top level of a program. See include/linux/kernel.h in the Linux kernel source tree (not the file /usr/include/linux/kernel.h).
val sexp_of_sys_behavior : sys_behavior -> Ppx_sexp_conv_lib.Sexp.t
val sys_behavior_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> sys_behavior
val __sys_behavior_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> sys_behavior
val default_sys_behavior : t -> sys_behavior
Queries the default system behavior for a signal.
val handle_default : t -> unit
handle_default t
is set t `Default
.
val ignore : t -> unit
ignore t
is set t `Ignore
.
val sexp_of_pid_spec : pid_spec -> Ppx_sexp_conv_lib.Sexp.t
send signal pid_spec
sends signal
to the processes specified by pid_spec
.
send_i
is like send
, except that it silently returns if the specified processes don't exist.
send_exn
is like send
, except that it raises if the specified processes don't exist.
All of send
, send_i
, and send_exn
raise if you don't have permission to send the signal to the specified processes or if signal
is unknown.
val can_send_to : Core_kernel.Pid.t -> bool
can_send_to pid
returns true if pid
is running and the current process has permission to send it signals.
val sigprocmask : sigprocmask_command -> t list -> t list
sigprocmask cmd sigs
changes the set of blocked signals.
- If
cmd
is`Set
, blocked signals are set to those in the listsigs
. - If
cmd
is`Block
, the signals insigs
are added to the set of blocked signals. - If
cmd
is`Unblock
, the signals insigs
are removed from the set of blocked signals.
sigprocmask
returns the set of previously blocked signals.
val sigpending : unit -> t list
sigpending ()
returns the set of blocked signals that are currently pending.
val sigsuspend : t list -> unit
sigsuspend sigs
atomically sets the blocked signals to sigs
and waits for * a non-ignored, non-blocked signal to be delivered. On return, the blocked * signals are reset to their initial value.
val abrt : t
Dump_core
Abnormal termination
val alrm : t
Terminate
Timeout
val bus : t
Dump_core
Bus error
val chld : t
Ignore
Child process terminated
val cont : t
Continue
Continue
val fpe : t
Dump_core
Arithmetic exception
val hup : t
Terminate
Hangup on controlling terminal
val ill : t
Dump_core
Invalid hardware instruction
val int : t
Terminate
Interactive interrupt (ctrl-C)
val kill : t
Terminate
Termination (cannot be ignored)
val pipe : t
Terminate
Broken pipe
val poll : t
Terminate
Pollable event
val prof : t
Terminate
Profiling interrupt
val quit : t
Dump_core
Interactive termination
val segv : t
Dump_core
Invalid memory reference
val sys : t
Dump_core
Bad argument to routine
val stop : t
Stop
Stop
val term : t
Terminate
Termination
val trap : t
Dump_core
Trace/breakpoint trap
val tstp : t
Stop
Interactive stop
val ttin : t
Stop
Terminal read from background process
val ttou : t
Stop
Terminal write from background process
val urg : t
Ignore
Urgent condition on socket
val usr1 : t
Terminate
Application-defined signal 1
val usr2 : t
Terminate
Application-defined signal 2
val vtalrm : t
Terminate
Timeout in virtual time
val xcpu : t
Dump_core
Timeout in cpu time
val xfsz : t
Dump_core
File size limit exceeded
val zero : t
Ignore
No-op; can be used to test whether the target process exists and the current process has permission to signal it
module Expert : sig ... end
The Expert
module contains functions that novice users should avoid, due to their complexity.
module Stable : sig ... end