String (catala.Catala

include module type of Stdlib.String

type t = string

val make : int -> char -> string

val init : int -> (int -> char) -> string

val empty : string

val length : string -> int

val get : string -> int -> char

val of_bytes : bytes -> string

val to_bytes : string -> bytes

val blit : string -> int -> bytes -> int -> int -> unit

val concat : string -> string list -> string

val cat : string -> string -> string

val equal : t -> t -> bool

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 : ('acc -> char -> 'acc) -> 'acc -> string -> 'acc

val fold_right : (char -> 'acc -> 'acc) -> string -> 'acc -> 'acc

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 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 seeded_hash : int -> t -> int

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_blit : string -> int -> bytes -> int -> int -> unit

module Set : Stdlib.Set.S with type elt = string

module Map : Map.S with type key = string

Helper functions used for string manipulation.

val compare : string -> string -> int

String comparison with natural ordering of numbers within strings

val hash : string -> Hash.t

val to_ascii : string -> string

Removes all non-ASCII diacritics from a string by converting them to their base letter in the Latin alphabet. Anything that is not convertible is replaced by "?"

val to_id : string -> string

Like to_ascii, but in addition replaces any non-alphanumeric character by _

val utf8_seq : string -> Stdlib.Uchar.t Stdlib.Seq.t

val map_utf8 : (Stdlib.Uchar.t -> Stdlib.Uchar.t) -> string -> string

val is_uppercase_ascii : char -> bool

is_uppercase c returns if c is in the set 'A'...'Z'.

val begins_with_uppercase : string -> bool

begins_with_uppercase s returns if the first letter of s is uppercase. Handles utf8. false if s is empty.

val to_snake_case : string -> string

Converts CamlCase into snake_case after removing Remove all diacritics on Latin letters.

val to_camel_case : ?capitalize:bool -> string -> string

Converts snake_case into CamlCase after removing Remove all diacritics on Latin letters.

If capitalize is false, the first letter is lowercase. Defaults to true.

val remove_prefix : prefix:string -> string -> string

remove_prefix ~prefix str returns

if str starts with prefix, a string s such that prefix ^ s = str
otherwise, str unchanged

val trim_end : string -> string

Like Stdlib.String.trim, but only trims at the end of the string

val format : Stdlib.Format.formatter -> string -> unit

val width : string -> int

Returns the width of a given string in screen columns (assuming a monospace font). Useful for alignment. This takes unicode (except composite chars) and tabs into account, but not escape sequences.

val cut_at_width : string -> int -> string

Returns a string prefix of s that can fit into width screen columns. Same limitations as width.

val quote : string -> string

quote s returns the string s prefixed and suffixed by '"'. The special characters '\\', '"', '\t', '\n', '\r', '\b' and '\f' ('\x0c') present in s are also escaped using '\\'. This is expected to be compatible with JSON escaping. No utf-8 escaping takes place.

val re_split_delim : ?pos:int -> ?len:int -> Re.re -> t -> t list

split_delim re s splits s into chunks separated by re. It yields the chunks themselves, not the separator. Occurences of the separator at the beginning or the end of the string will produce empty chunks.

Note: from Re, but not available before 1.12 -- remove once we update the dependency