Module CString

module type S = module type of Stdlib.String

Module type S is the one from OCaml Stdlib.

We include the standard library

include S
type t = string
val make : int -> char -> string
val init : int -> (int -> char) -> string
val empty : string
val of_bytes : bytes -> string
val to_bytes : string -> bytes
val length : string -> int
val get : string -> int -> char
val concat : string -> string list -> string
val cat : string -> string -> string
val equal : t -> t -> bool
val compare : t -> t -> int
val starts_with : prefix:string -> string -> bool
val ends_with : suffix:string -> string -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val contains : string -> char -> bool
val sub : string -> int -> int -> string
val split_on_char : char -> string -> string list
val map : (char -> char) -> string -> string
val mapi : (int -> char -> char) -> string -> string
val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a
val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'a
val for_all : (char -> bool) -> string -> bool
val exists : (char -> bool) -> string -> bool
val trim : string -> string
val escaped : string -> string
val uppercase_ascii : string -> string
val lowercase_ascii : string -> string
val capitalize_ascii : string -> string
val uncapitalize_ascii : string -> string
val iter : (char -> unit) -> string -> unit
val iteri : (int -> char -> unit) -> string -> unit
val index_from : string -> int -> char -> int
val index_from_opt : string -> int -> char -> int option
val rindex_from : string -> int -> char -> int
val rindex_from_opt : string -> int -> char -> int option
val index : string -> char -> int
val index_opt : string -> char -> int option
val rindex : string -> char -> int
val rindex_opt : string -> char -> int option
val to_seq : t -> char Stdlib.Seq.t
val to_seqi : t -> (int * char) Stdlib.Seq.t
val of_seq : char Stdlib.Seq.t -> t
val get_utf_8_uchar : t -> int -> Stdlib.Uchar.utf_decode
val is_valid_utf_8 : t -> bool
val get_utf_16be_uchar : t -> int -> Stdlib.Uchar.utf_decode
val is_valid_utf_16be : t -> bool
val get_utf_16le_uchar : t -> int -> Stdlib.Uchar.utf_decode
val is_valid_utf_16le : t -> bool
val create : int -> bytes
val set : bytes -> int -> char -> unit
val blit : string -> int -> bytes -> int -> int -> unit
val copy : string -> string
val fill : bytes -> int -> int -> char -> unit
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
val get_uint8 : string -> int -> int
val get_int8 : string -> int -> int
val get_uint16_ne : string -> int -> int
val get_uint16_be : string -> int -> int
val get_uint16_le : string -> int -> int
val get_int16_ne : string -> int -> int
val get_int16_be : string -> int -> int
val get_int16_le : string -> int -> int
val get_int32_ne : string -> int -> int32
val get_int32_be : string -> int -> int32
val get_int32_le : string -> int -> int32
val get_int64_ne : string -> int -> int64
val get_int64_be : string -> int -> int64
val get_int64_le : string -> int -> int64
val unsafe_get : string -> int -> char
val unsafe_set : bytes -> int -> char -> unit
val unsafe_blit : string -> int -> bytes -> int -> int -> unit
val unsafe_fill : bytes -> int -> int -> char -> unit

Equality on strings

val hash : string -> int

Hashing on strings. Should be compatible with generic one.

val is_empty : string -> bool

Test whether a string is empty.

val explode : string -> string list

explode "x1...xn" returns ["x1"; ...; "xn"]

val implode : string list -> string

implode [s1; ...; sn] returns s1 ^ ... ^ sn

val drop_simple_quotes : string -> string

Remove the eventual first surrounding simple quotes of a string.

val quote_coq_string : string -> string

Quote a string according to Rocq conventions (i.e. doubling double quotes and surrounding by double quotes)

val unquote_coq_string : string -> string option

Unquote a quoted string according to Rocq conventions (i.e. removing surrounding double quotes and undoubling double quotes); returns None if not a quoted string

val html_escape : string -> string

replace HTML reserved characters with escape sequences, e.g. `&` -> "&"

val string_index_from : string -> int -> string -> int

As index_from, but takes a string instead of a char as pattern argument

val string_contains : where:string -> what:string -> bool

As contains, but takes a string instead of a char as pattern argument

val plural : int -> string -> string

plural n s adds a optional 's' to the s when 2 <= n.

val lplural : _ list -> string -> string

lplural l s is plural (List.length l) s.

val conjugate_verb_to_be : int -> string

conjugate_verb_to_be returns "is" when n=1 and "are" otherwise

val ordinal : int -> string

Generate the ordinal number in English.

val is_sub : string -> string -> int -> bool

is_sub p s off tests whether s contains p at offset off.

val is_prefix : string -> string -> bool

is_prefix p s tests whether p is a prefix of s.

val is_suffix : string -> string -> bool

is_suffix suf s tests whether suf is a suffix of s.

val edit_distance : ?limit:int -> string -> string -> int

edit_distance s0 s1 is the number of single character edits (understood as insertion, deletion, substitution, transposition) that are needed to change s0 into s1.

If limit is provided the function returns with limit as soon as it was determined that s0 and s1 have distance of at least limit. This is faster if you have a fixed limit, for example for spellchecking.

copied from ocaml 5.4

Generic operations

*

module Set : CSet.ExtS with type elt = t

Finite sets on string

module Map : CMap.ExtS with type key = t and module Set := Set

Finite maps on string

module Pred : Predicate.S with type elt = t
module List : CList.MonoS with type elt = t

Association lists with string as keys

val hcons : string Hashcons.f

Hashconsing on string