Library
Module
Module type
Parameter
Class
Class type
type 'a printer = Format.formatter -> 'a -> unit
A "bigstring" here is simply a bigarray of chars. It can be used instead of regular strings when IO involve calling C (or another language), when very large strings are required, or for memory-mapping.
type t =
(char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
val create : int -> t
Create a new bigstring of the given size. Content is arbitrary.
val make : int -> char -> t
Create a new bigstring of the given size filled with c
.
val empty : t
Empty string
val init : int -> (int -> char) -> t
Initialize with the given function (called at every index). init n f
is the string f 0, f 1, ..., f (n-1)
.
val fill : t -> char -> unit
Fill the string with the given byte.
val fill_slice : t -> char -> int -> int -> unit
fill_slice s c i len
is the same as fill (sub s i len) c
, it fills the slice from i
to i+len-1
of s
with the char c
val size : t -> int
Number of bytes
val get : t -> int -> char
Obtain the byte at the given index.
val unsafe_get : t -> int -> char
Same as get
, but without bound check. Can fail arbitrarily (including segfault) if used improperly.
val set : t -> int -> char -> unit
Change the byte at the given index.
val unsafe_set : t -> int -> char -> unit
Same as set
, but without bound check. Can fail arbitrarily (including segfault) if used improperly.
Blit a slice of the bigstring into another. blit s1 i1 s2 i2 len
means that elements from s1
whose indices range from i1
to i1+len-1
are copied into the slots of s2
whose indices range from i2
to i2+len-1
. This is similar to String.blit
or Bytes.blit
or Array.blit
.
sub s i len
takes a slice of length len
from the string s
, starting at offset i
. The slice shares the same memory as s
, meaning that modifications of the slice will modify s
as well. Slicing is cheap since it does not involve copying the whole range.
val fold : ('a -> char -> 'a) -> 'a -> t -> 'a
Fold on every char in increasing order
val foldi : ('a -> int -> char -> 'a) -> 'a -> t -> 'a
Fold on every char in increasing order
val iter : (char -> unit) -> t -> unit
Iterate on every char in increasing order
val iteri : (int -> char -> unit) -> t -> unit
Iterate on every char in increasing order
val to_string : t -> string
val of_string : string -> t
val of_string_slice : string -> int -> int -> t
val sub_string : t -> int -> int -> string
val blit_of_string : string -> int -> t -> int -> int -> unit
concat set l
concatenates the list l
, inserting sep
between each pair of string.
Copy of the string with all characters in lowercase (see Char.lowercase
)
Copy of the string with all characters in uppercase (see Char.uppercase
)
trim s
returns a slice of s
without the leading and trailing whitespaces, where whitespaces are defined identically to String.trim
. note that it does not copy the substring, but returns a slice!
val index : t -> c:char -> int
index s ~c
returns the index of the first occurrence of character c
in string s
.
val rindex : t -> c:char -> int
rindex s ~c
returns the index of the last occurrence of character c
in string s
.
val index_pred : f:(char -> bool) -> t -> int
index_pred ~f s
returns the index of the first char in s
that satisfies s
.
val rindex_pred : f:(char -> bool) -> t -> int
rindex_pred ~f s
returns the index of the last char in s
that satisfies s
.
val contains : t -> c:char -> bool
String.contains s c
tests if character c
appears in the string s
.
val for_all : f:(char -> bool) -> t -> bool
True for all chars?
val exists : f:(char -> bool) -> t -> bool
True for some char?