Std.Bytes
Extension of the standard bytes module.
We enhanced OCaml standard Bytes
module with the expected set of functions. Bytes
are not Regular
, as Regular
interface itself refers to bytes. However it includes a pretty big subset of regular (excluding Data
module, but bytes indeed do not need any specific support for the serialization).
include Core_kernel.Bin_prot.Binable.S with type t := t
include Ppx_sexp_conv_lib.Sexpable.S with type t := t
include Core_kernel.Container.S0 with type t := t with type elt := char
val mem : t -> char -> bool
val is_empty : t -> bool
val iter : t -> f:(char -> unit) -> unit
val fold : t -> init:'accum -> f:('accum -> char -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> char -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
t ->
init:'accum ->
f:
('accum ->
char ->
('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
finish:('accum -> 'final) ->
'final
val exists : t -> f:(char -> bool) -> bool
val for_all : t -> f:(char -> bool) -> bool
val count : t -> f:(char -> bool) -> int
val sum :
(module Base__.Container_intf.Summable with type t = 'sum) ->
t ->
f:(char -> 'sum) ->
'sum
val find : t -> f:(char -> bool) -> char option
val find_map : t -> f:(char -> 'a option) -> 'a option
val to_list : t -> char list
val to_array : t -> char array
val min_elt : t -> compare:(char -> char -> int) -> char option
val max_elt : t -> compare:(char -> char -> int) -> char option
include Core_kernel.Identifiable.S 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
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
val t_of_sexp : Sexplib0__.Sexp.t -> t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val pp : Base__.Formatter.t -> t -> unit
module Replace_polymorphic_compare : sig ... end
val comparator : (t, comparator_witness) Core_kernel__.Comparator.comparator
module Map : sig ... end
module Set : sig ... end
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t ->
Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core_kernel__.Hashtbl.Hashable.t
module Table : sig ... end
module Hash_set : sig ... end
module Hash_queue : sig ... end
module To_string : sig ... end
val create : int -> t
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 -> t
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) -> t
init n ~f
returns a fresh byte sequence of length n
, with character i
initialized to the result of f i
(in increasing index order). Raise Invalid_argument
if n < 0
or n >
Sys
.max_string_length.
val empty : t
empty
a byte sequence of size 0.
val length : t -> int
length t
returns the length (number of bytes) of t
.
val get : t -> int -> char
get s n
returns the byte at index n
in s
. Raise Invalid_argument
if n
not a valid index in s
.
val set : t -> 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 of_string : string -> t
of_string s
returns a new byte sequence that contains the same bytes as the given string.
val to_string : t -> string
to_string t
returns a new string that contains the same bytes as the given byte sequence.
extend s left right
returns a new byte sequence that contains the bytes of s
, with left
uninitialized bytes prepended and right
uninitialized bytes appended to it. If left
or right
is negative, then bytes are removed (instead of appended) from the corresponding side of s
. Raise Invalid_argument
if the result length is negative or longer than Sys
.max_string_length bytes.
val fill : t -> int -> 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
.
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. Raise Invalid_argument
if the result is longer than Sys
.max_string_length bytes.
cat s1 s2
concatenates s1
and s2
and returns the result as new byte sequence. Raise Invalid_argument
if the result is longer than Sys
.max_string_length bytes.
val iteri : t -> f:(int -> char -> unit) -> unit
iteri t ~f
same as iter
, but the function is applied to the index of the byte as first argument and the byte itself as second argument.
map s ~f
applies function f
in turn to all the bytes of s
(in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.
mapi s ~f
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.
trim t
returns a copy of t
, without leading and trailing whitespace. The bytes regarded as whitespace are the ASCII characters ' '
, '\012'
, '\n'
, '\r'
, and '\t'
.
escaped t
returns a copy of t
, with special characters represented by escape sequences, following the lexical conventions of OCaml. Raise Invalid_argument
if the result is longer than Sys
.max_string_length bytes.
val index : t -> 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 : t -> 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 : t -> int -> char -> int
index_from s i c
returns the index of the first occurrence of byte c
in s
after position i
. index s c
is equivalent to 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 : t -> 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 (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 : t -> char -> bool
contains s c
tests if byte c
appears in s
.
val contains_from : t -> 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 : t -> 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
.
uppercase t
returns a copy of t
, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
lowercase t
returns a copy of t
, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
module Unsafe : sig ... end