# Module BytesLabels

    module BytesLabels: sig .. end

Byte sequence operations.
Since 4.02.0

    val length : bytes -> int

Return the length (number of bytes) of the argument.

    val get : bytes -> int -> char

`get s n` returns the byte at index `n` in argument `s`.

Raise `Invalid_argument` if `n` not a valid index in `s`.

    val set : bytes -> int -> char -> unit

`set s n c` modifies `s` in place, replacing the byte at index `n` with `c`.

Raise `Invalid_argument` if `n` is not a valid index in `s`.

    val create : int -> bytes

`create n` returns a new byte sequence of length `n`. The sequence is uninitialized and contains arbitrary bytes.

Raise `Invalid_argument` if `n < 0` or `n >` `Sys.max_string_length`.

    val make : int -> char -> bytes

`make n c` returns a new byte sequence of length `n`, filled with the byte `c`.

Raise `Invalid_argument` if `n < 0` or `n >` `Sys.max_string_length`.

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

`init n f` returns a fresh byte sequence of length `n`, with character `i` initialized to the result of `f i`.

Raise `Invalid_argument` if `n < 0` or `n >` `Sys.max_string_length`.

    val empty : bytes

A byte sequence of size 0.

    val copy : bytes -> bytes

Return a new byte sequence that contains the same bytes as the argument.

    val of_string : string -> bytes

Return a new byte sequence that contains the same bytes as the given string.

    val to_string : bytes -> string

Return a new string that contains the same bytes as the given byte sequence.

    val sub : bytes -> pos:int -> len:int -> bytes

`sub s start len` returns a new byte sequence of length `len`, containing the subsequence of `s` that starts at position `start` and has length `len`.

Raise `Invalid_argument` if `start` and `len` do not designate a valid range of `s`.

    val sub_string : bytes -> int -> int -> string

Same as `sub` but return a string instead of a byte sequence.

    val fill : bytes -> pos:int -> len:int -> char -> unit

`fill s start len c` modifies `s` in place, replacing `len` characters with `c`, starting at `start`.

Raise `Invalid_argument` if `start` and `len` do not designate a valid range of `s`.

    val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit

`blit src srcoff dst dstoff len` copies `len` bytes from sequence `src`, starting at index `srcoff`, to sequence `dst`, starting at index `dstoff`. It works correctly even if `src` and `dst` are the same byte sequence, and the source and destination intervals overlap.

Raise `Invalid_argument` if `srcoff` and `len` do not designate a valid range of `src`, or if `dstoff` and `len` do not designate a valid range of `dst`.

    val concat : sep:bytes -> bytes list -> bytes

`concat sep sl` concatenates the list of byte sequences `sl`, inserting the separator byte sequence `sep` between each, and returns the result as a new byte sequence.

    val iter : f:(char -> unit) -> bytes -> unit

`iter f s` applies function `f` in turn to all the bytes of `s`. It is equivalent to `f (get s 0); f (get s 1); ...; f (get s (length s - 1)); ()`.

    val iteri : f:(int -> char -> unit) -> bytes -> unit

Same as `Bytes.iter`, but the function is applied to the index of the byte as first argument and the byte itself as second argument.

    val map : f:(char -> char) -> bytes -> bytes

`map f s` applies function `f` in turn to all the bytes of `s` and stores the resulting bytes in a new sequence that is returned as the result.

    val mapi : f:(int -> char -> char) -> bytes -> bytes

`mapi f s` calls `f` with each character of `s` and its index (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.

    val trim : bytes -> bytes

Return a copy of the argument, without leading and trailing whitespace. The bytes regarded as whitespace are the ASCII characters `' '`, `'\012'`, `'\n'`, `'\r'`, and `'\t'`.

    val escaped : bytes -> bytes

Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml.

    val index : bytes -> char -> int

`index s c` returns the index of the first occurrence of byte `c` in `s`.

Raise `Not_found` if `c` does not occur in `s`.

    val rindex : bytes -> char -> int

`rindex s c` returns the index of the last occurrence of byte `c` in `s`.

Raise `Not_found` if `c` does not occur in `s`.

    val index_from : bytes -> int -> char -> int

`index_from s i c` returns the index of the first occurrence of byte `c` in `s` after position `i`. `Bytes.index s c` is equivalent to `Bytes.index_from s 0 c`.

Raise `Invalid_argument` if `i` is not a valid position in `s`. Raise `Not_found` if `c` does not occur in `s` after position `i`.

    val rindex_from : bytes -> int -> char -> int

`rindex_from s i c` returns the index of the last occurrence of byte `c` in `s` before position `i+1`. `rindex s c` is equivalent to `rindex_from s (Bytes.length s - 1) c`.

Raise `Invalid_argument` if `i+1` is not a valid position in `s`. Raise `Not_found` if `c` does not occur in `s` before position `i+1`.

    val contains : bytes -> char -> bool

`contains s c` tests if byte `c` appears in `s`.

    val contains_from : bytes -> int -> char -> bool

`contains_from s start c` tests if byte `c` appears in `s` after position `start`. `contains s c` is equivalent to `contains_from s 0 c`.

Raise `Invalid_argument` if `start` is not a valid position in `s`.

    val rcontains_from : bytes -> int -> char -> bool

`rcontains_from s stop c` tests if byte `c` appears in `s` before position `stop+1`.

Raise `Invalid_argument` if `stop < 0` or `stop+1` is not a valid position in `s`.

    val uppercase : bytes -> bytes

Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.

    val lowercase : bytes -> bytes

Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.

    val capitalize : bytes -> bytes

Return a copy of the argument, with the first byte set to uppercase.

    val uncapitalize : bytes -> bytes

Return a copy of the argument, with the first byte set to lowercase.

    type t = bytes

An alias for the type of byte sequences.

    val compare : t -> t -> int

The comparison function for byte sequences, with the same specification as `compare`. Along with the type `t`, this function `compare` allows the module `Bytes` to be passed as argument to the functors `Set.Make` and `Map.Make`.