package core_kernel

  1. Overview
  2. Docs
package core_kernel
Legend:
Library
Module
Module type
Parameter
Class
Class type

This module extends Base.Bytes.

type t = Base.Bytes.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (Base.Int.t -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val typerep_of_t : t Typerep_lib.Std.Typerep.t
val typename_of_t : t Typerep_lib.Std.Typename.t
include module type of struct include Base.Bytes end with type t := t
include sig ... end
val t_of_sexp : Base.Sexp.t -> t
val sexp_of_t : t -> Base.Sexp.t

Common Interfaces

include Base.Blit.S with type t := t
val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
val blito : src:t -> ?src_pos:int -> ?src_len:int -> dst:t -> ?dst_pos:int -> unit -> unit
val unsafe_blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
val sub : t -> pos:int -> len:int -> t
val subo : ?pos:int -> ?len:int -> t -> t
include Base.Comparable.S with type t := t
include Base.Comparisons.S with type t := t
include Base.Comparisons.Infix with type t := t
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int

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.

val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int

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.

val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool

between t ~low ~high means low <= t <= high

val clamp_exn : t -> min:t -> max:t -> t

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
type comparator_witness = Base.Bytes.comparator_witness
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
include Base.Stringable.S with type t := t
val of_string : string -> t
val to_string : t -> string

Note that pp allocates in order to preserve the state of the byte sequence it was initially called with.

include Base.Pretty_printer.S with type t := t
val pp : Base.Formatter.t -> t -> unit
module To_string = Base.Bytes.To_string
module From_string = Base.Bytes.From_string
val create : int -> t

create len returns a newly-allocated and uninitialized byte sequence of length len. No guarantees are made about the contents of the return value.

val make : int -> char -> t

make len c returns a newly-allocated byte sequence of length len filled with the byte c.

val copy : t -> t

copy t returns a newly-allocated byte sequence that contains the same bytes as t.

val init : int -> f:(int -> char) -> t

init len ~f returns a newly-allocated byte sequence of length len with index i in the sequence being initialized with the result of f i.

val of_char_list : char list -> t

of_char_list l returns a newly-alloated byte sequence where each byte in the sequence corresponds to the byte in l at the same index.

val length : t -> int

length t returns the number of bytes in t.

val get : t -> int -> char

get t i returns the ith byte of t.

val unsafe_get : t -> int -> char
val set : t -> int -> char -> unit

set t i c sets the ith byte of t to c.

val unsafe_set : t -> int -> char -> unit
val fill : t -> pos:int -> len:int -> char -> unit

fill t ~pos ~len c modifies t in place, replacing all the bytes from pos to pos + len with c.

val tr : target:char -> replacement:char -> t -> unit

tr ~target ~replacement t modifies t in place, replacing every instance of target in s with replacement.

val to_list : t -> char list

to_list t returns the bytes in t as a list of chars.

val contains : ?pos:int -> ?len:int -> t -> char -> bool

contains ?pos ?len t c returns true iff c appears in t between pos and pos + len.

val max_length : int

Maximum length of a byte sequence, which is architecture-dependent. Attempting to create a Bytes larger than this will raise an exception.

Unsafe conversions (for advanced users)

This section describes unsafe, low-level conversion functions between bytes and string. They might not copy the internal data; used improperly, they can break the immutability invariant on strings provided by the -safe-string option. They are available for expert library authors, but for most purposes you should use the always-correct Bytes.to_string and Bytes.of_string instead.

val unsafe_to_string : no_mutation_while_string_reachable:t -> string

Unsafely convert a byte sequence into a string.

To reason about the use of unsafe_to_string, it is convenient to consider an "ownership" discipline. A piece of code that manipulates some data "owns" it; there are several disjoint ownership modes, including:

  • Unique ownership: the data may be accessed and mutated
  • Shared ownership: the data has several owners, that may only access it, not mutate it.

Unique ownership is linear: passing the data to another piece of code means giving up ownership (we cannot access the data again). A unique owner may decide to make the data shared (giving up mutation rights on it), but shared data may not become uniquely-owned again. unsafe_to_string s can only be used when the caller owns the byte sequence s -- either uniquely or as shared immutable data. The caller gives up ownership of s, and gains (the same mode of) ownership of the returned string. There are two valid use-cases that respect this ownership discipline:

  1. The first is creating a string by initializing and mutating a byte sequence that is never changed after initialization is performed.

    let string_init len f : string =
  let s = Bytes.create len in
  for i = 0 to len - 1 do Bytes.set s i (f i) done;
  Bytes.unsafe_to_string ~no_mutation_while_string_reachable:s

    This function is safe because the byte sequence s will never be accessed or mutated after unsafe_to_string is called. The string_init code gives up ownership of s, and returns the ownership of the resulting string to its caller.

    Note that it would be unsafe if s was passed as an additional parameter to the function f as it could escape this way and be mutated in the future -- string_init would give up ownership of s to pass it to f, and could not call unsafe_to_string safely.

    We have provided the String.init, String.map and String.mapi functions to cover most cases of building new strings. You should prefer those over to_string or unsafe_to_string whenever applicable.

  2. The second is temporarily giving ownership of a byte sequence to a function that expects a uniquely owned string and returns ownership back, so that we can mutate the sequence again after the call ended.

    let bytes_length (s : bytes) =
  String.length
    (Bytes.unsafe_to_string ~no_mutation_while_string_reachable:s)

    In this use-case, we do not promise that s will never be mutated after the call to bytes_length s. The String.length function temporarily borrows unique ownership of the byte sequence (and sees it as a string), but returns this ownership back to the caller, which may assume that s is still a valid byte sequence after the call. Note that this is only correct because we know that String.length does not capture its argument -- it could escape by a side-channel such as a memoization combinator. The caller may not mutate s while the string is borrowed (it has temporarily given up ownership). This affects concurrent programs, but also higher-order functions: if String.length returned a closure to be called later, s should not be mutated until this closure is fully applied and returns ownership.

val unsafe_of_string_promise_no_mutation : string -> t

Unsafely convert a shared string to a byte sequence that should not be mutated.

The same ownership discipline that makes unsafe_to_string correct applies to unsafe_of_string_promise_no_mutation, however unique ownership of string values is extremely difficult to reason about correctly in practice. As such, one should always assume strings are shared, never uniquely owned (For example, string literals are implicitly shared by the compiler, so you never uniquely own them)

The only case we have reasonable confidence is safe is if the produced bytes is shared -- used as an immutable byte sequence. This is possibly useful for incremental migration of low-level programs that manipulate immutable sequences of bytes (for example Marshal.from_bytes) and previously used the string type for this purpose.

include Hexdump.S with type t := t
module Hexdump : sig ... end
include Quickcheckable.S with type t := t
val shrinker : t Quickcheck.Shrinker.t

Like gen, but generate bytes with the given distribution of characters.

Like gen', but generate bytes with the given length.

module Stable : sig ... end

Note that bytes is already stable by itself, since as a primitive type it is an integral part of the sexp / bin_io protocol. Bytes.Stable exists only to provide interface uniformity with other stable types.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct