Open_flags.t
represents the flags associated with a file descriptor in the open-file-descriptor table. It deals with the same thing as OCaml's open_flag
type; however, it uses Core's Flags
approach and the underlying integer bitmask representation, and so interoperates more smoothly with C.
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
include Flags.S with type t := 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 Typerep_lib.Typerepable.S with type t := t
val typerep_of_t : t Typerep_lib.Std_internal.Typerep.t
val typename_of_t : t Typerep_lib.Typename.t
consistent with subset
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
val of_int : int -> t
val to_int_exn : t -> int
val empty : t
set difference. Although we use operators +
and -
, they do not satisfy the usual arithmetic equations, e.g. x - y = x + (empty - y)
does not hold.
val is_empty : t -> bool
module Unstable : sig ... end
val rdonly : t
access mode.
These three flags are not individual bits like flags usually are. The access mode is represented by the lower two bits of the Open_flags.t
. A particular Open_flags.t
should include exactly one access mode. Combining different Open_flags.t
's using flags operations (e.g +
) is only sensible if they have the same access mode.
val wronly : t
val rdwr : t
val creat : t
creation
val excl : t
val noctty : t
val trunc : t
val append : t
val nonblock : t
val dsync : t
val sync : t
val rsync : t
val can_read : t -> bool
can_read t
iff t
has rdonly
or rdwr
val can_write : t -> bool
can_read t
iff t
has wronly
or rdwr