Stdlib.StringLabels(3) OCaml library Stdlib.StringLabels(3)

# [NAME](#NAME)

Stdlib.StringLabels - no description

# [Module](#Module)

Module Stdlib.StringLabels

# [Documentation](#Documentation)

Module **StringLabels**  
: **(module Stdlib\_\_StringLabels)**

## [Strings](#Strings)

*type t* = **string**

The type for strings.

*val make* : **int -> char -> string**

**make n c** is a string of length **n** with each index holding the character **c** .

**Raises Invalid\_argument** if **n < 0** or **n >** **Sys.max\_string\_length** .

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

**init n ~f** is a string of length **n** with index **i** holding the character **f i** (called in increasing index order).

**Since** 4.02.0

**Raises Invalid\_argument** if **n < 0** or **n >** **Sys.max\_string\_length** .

*val empty* : **string**

The empty string.

**Since** 4.13.0

*val of\_bytes* : **bytes -> string**

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

**Since** 4.13.0

*val to\_bytes* : **string -> bytes**

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

**Since** 4.13.0

*val length* : **string -> int**

**length s** is the length (number of bytes/characters) of **s** .

*val get* : **string -> int -> char**

**get s i** is the character at index **i** in **s** . This is the same as writing **s.\[i]** .

**Raises Invalid\_argument** if **i** not an index of **s** .

## [Concatenating](#Concatenating)

Note. The **(^)** binary operator concatenates two strings.

*val concat* : **sep:string -> string list -> string**

**concat ~sep ss** concatenates the list of strings **ss** , inserting the separator string **sep** between each.

**Raises Invalid\_argument** if the result is longer than **Sys.max\_string\_length** bytes.

*val cat* : **string -> string -> string**

**cat s1 s2** concatenates s1 and s2 ( **s1 ^ s2** ).

**Since** 4.13.0

**Raises Invalid\_argument** if the result is longer than **Sys.max\_string\_length** bytes.

## [Predicates and comparisons](#Predicates_and_comparisons)

*val equal* : **t -> t -> bool**

**equal s0 s1** is **true** if and only if **s0** and **s1** are character-wise equal.

**Since** 4.05.0

*val compare* : **t -> t -> int**

**compare s0 s1** sorts **s0** and **s1** in lexicographical order. **compare** behaves like **compare** on strings but may be more efficient.

*val starts\_with* : **prefix:string -> string -> bool**

**starts\_with** **~prefix s** is **true** if and only if **s** starts with **prefix** .

**Since** 4.13.0

*val ends\_with* : **suffix:string -> string -> bool**

**ends\_with** **~suffix s** is **true** if and only if **s** ends with **suffix** .

**Since** 4.13.0

*val contains\_from* : **string -> int -> char -> bool**

**contains\_from s start c** is **true** if and only if **c** appears in **s** after position **start** .

**Raises Invalid\_argument** if **start** is not a valid position in **s** .

*val rcontains\_from* : **string -> int -> char -> bool**

**rcontains\_from s stop c** is **true** if and only if **c** appears in **s** before position **stop+1** .

**Raises Invalid\_argument** if **stop < 0** or **stop+1** is not a valid position in **s** .

*val contains* : **string -> char -> bool**

**contains s c** is **String.contains\_from** **s 0 c** .

## [Extracting substrings](#Extracting_substrings)

*val sub* : **string -> pos:int -> len:int -> string**

**sub s ~pos ~len** is a string of length **len** , containing the substring of **s** that starts at position **pos** and has length **len** .

**Raises Invalid\_argument** if **pos** and **len** do not designate a valid substring of **s** .

*val split\_on\_char* : **sep:char -> string -> string list**

**split\_on\_char ~sep s** is the list of all (possibly empty) substrings of **s** that are delimited by the character **sep** .

The function's result is specified by the following invariants:

-The list is not empty.

-Concatenating its elements using **sep** as a separator returns a string equal to the input ( **concat (make 1 sep)**  
(split\_on\_char sep s) = s ).

-No string in the result contains the **sep** character.

**Since** 4.05.0

## [Transforming](#Transforming)

*val map* : **f:(char -> char) -> string -> string**

**map f s** is the string resulting from applying **f** to all the characters of **s** in increasing order.

**Since** 4.00.0

*val mapi* : **f:(int -> char -> char) -> string -> string**

**mapi ~f s** is like **StringLabels.map** but the index of the character is also passed to **f** .

**Since** 4.02.0

*val fold\_left* : **f:('a -> char -> 'a) -> init:'a -> string -> 'a**

**fold\_left f x s** computes **f (... (f (f x s.\[0]) s.\[1]) ...) s.\[n-1]** , where **n** is the length of the string **s** .

**Since** 4.13.0

*val fold\_right* : **f:(char -> 'a -> 'a) -> string -> init:'a -> 'a**

**fold\_right f s x** computes **f s.\[0] (f s.\[1] ( ... (f s.\[n-1] x) ...))** , where **n** is the length of the string **s** .

**Since** 4.13.0

*val for\_all* : **f:(char -> bool) -> string -> bool**

**for\_all p s** checks if all characters in **s** satisfy the predicate **p** .

**Since** 4.13.0

*val exists* : **f:(char -> bool) -> string -> bool**

**exists p s** checks if at least one character of **s** satisfies the predicate **p** .

**Since** 4.13.0

*val trim* : **string -> string**

**trim s** is **s** without leading and trailing whitespace. Whitespace characters are: **' '** , **'\\x0C'** (form feed), **'\\n'** , **'\\r'** , and **'\\t'** .

**Since** 4.00.0

*val escaped* : **string -> string**

**escaped s** is **s** with special characters represented by escape sequences, following the lexical conventions of OCaml.

All characters outside the US-ASCII printable range \[0x20;0x7E] are escaped, as well as backslash (0x2F) and double-quote (0x22).

The function **Scanf.unescaped** is a left inverse of **escaped** , i.e. **Scanf.unescaped (escaped s) = s** for any string **s** (unless **escaped s** fails).

**Raises Invalid\_argument** if the result is longer than **Sys.max\_string\_length** bytes.

*val uppercase\_ascii* : **string -> string**

**uppercase\_ascii s** is **s** with all lowercase letters translated to uppercase, using the US-ASCII character set.

**Since** 4.05.0

*val lowercase\_ascii* : **string -> string**

**lowercase\_ascii s** is **s** with all uppercase letters translated to lowercase, using the US-ASCII character set.

**Since** 4.05.0

*val capitalize\_ascii* : **string -> string**

**capitalize\_ascii s** is **s** with the first character set to uppercase, using the US-ASCII character set.

**Since** 4.05.0

*val uncapitalize\_ascii* : **string -> string**

**uncapitalize\_ascii s** is **s** with the first character set to lowercase, using the US-ASCII character set.

**Since** 4.05.0

## [Traversing](#Traversing)

*val iter* : **f:(char -> unit) -> string -> unit**

**iter ~f s** applies function **f** in turn to all the characters of **s** . It is equivalent to **f s.\[0]; f s.\[1]; ...; f s.\[length s - 1]; ()** .

*val iteri* : **f:(int -> char -> unit) -> string -> unit**

**iteri** is like **StringLabels.iter** , but the function is also given the corresponding character index.

**Since** 4.00.0

## [Searching](#Searching)

*val index\_from* : **string -> int -> char -> int**

**index\_from s i c** is the index of the first occurrence of **c** in **s** after position **i** .

**Raises Not\_found** if **c** does not occur in **s** after position **i** .

**Raises Invalid\_argument** if **i** is not a valid position in **s** .

*val index\_from\_opt* : **string -> int -> char -> int option**

**index\_from\_opt s i c** is the index of the first occurrence of **c** in **s** after position **i** (if any).

**Since** 4.05

**Raises Invalid\_argument** if **i** is not a valid position in **s** .

*val rindex\_from* : **string -> int -> char -> int**

**rindex\_from s i c** is the index of the last occurrence of **c** in **s** before position **i+1** .

**Raises Not\_found** if **c** does not occur in **s** before position **i+1** .

**Raises Invalid\_argument** if **i+1** is not a valid position in **s** .

*val rindex\_from\_opt* : **string -> int -> char -> int option**

**rindex\_from\_opt s i c** is the index of the last occurrence of **c** in **s** before position **i+1** (if any).

**Since** 4.05

**Raises Invalid\_argument** if **i+1** is not a valid position in **s** .

*val index* : **string -> char -> int**

**index s c** is **String.index\_from** **s 0 c** .

*val index\_opt* : **string -> char -> int option**

**index\_opt s c** is **String.index\_from\_opt** **s 0 c** .

**Since** 4.05

*val rindex* : **string -> char -> int**

**rindex s c** is **String.rindex\_from** **s (length s - 1) c** .

*val rindex\_opt* : **string -> char -> int option**

**rindex\_opt s c** is **String.rindex\_from\_opt** **s (length s - 1) c** .

**Since** 4.05

## [Strings and Sequences](#Strings_and_Sequences)

*val to\_seq* : **t -> char Seq.t**

**to\_seq s** is a sequence made of the string's characters in increasing order. In **"unsafe-string"** mode, modifications of the string during iteration will be reflected in the sequence.

**Since** 4.07

*val to\_seqi* : **t -> (int * char) Seq.t**

**to\_seqi s** is like **StringLabels.to\_seq** but also tuples the corresponding index.

**Since** 4.07

*val of\_seq* : **char Seq.t -> t**

**of\_seq s** is a string made of the sequence's characters.

**Since** 4.07

## [UTF decoding and validations](#UTF_decoding_and_validations)

## [UTF-8](#UTF-8)

*val get\_utf\_8\_uchar* : **t -> int -> Uchar.utf\_decode**

**get\_utf\_8\_uchar b i** decodes an UTF-8 character at index **i** in **b** .

*val is\_valid\_utf\_8* : **t -> bool**

**is\_valid\_utf\_8 b** is **true** if and only if **b** contains valid UTF-8 data.

## [UTF-16BE](#UTF-16BE)

*val get\_utf\_16be\_uchar* : **t -> int -> Uchar.utf\_decode**

**get\_utf\_16be\_uchar b i** decodes an UTF-16BE character at index **i** in **b** .

*val is\_valid\_utf\_16be* : **t -> bool**

**is\_valid\_utf\_16be b** is **true** if and only if **b** contains valid UTF-16BE data.

## [UTF-16LE](#UTF-16LE)

*val get\_utf\_16le\_uchar* : **t -> int -> Uchar.utf\_decode**

**get\_utf\_16le\_uchar b i** decodes an UTF-16LE character at index **i** in **b** .

*val is\_valid\_utf\_16le* : **t -> bool**

**is\_valid\_utf\_16le b** is **true** if and only if **b** contains valid UTF-16LE data.

## [Deprecated functions](#Deprecated_functions)

*val create* : **int -> bytes**

**Deprecated.** This is a deprecated alias of **Bytes.create** / **BytesLabels.create** .

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

**Raises Invalid\_argument** if **n < 0** or **n >** **Sys.max\_string\_length** .

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

**Deprecated.** This is a deprecated alias of **Bytes.set** / **BytesLabels.set** .

**set s n c** modifies byte sequence **s** in place, replacing the byte at index **n** with **c** . You can also write **s.\[n] <- c** instead of **set s n c** .

**Raises Invalid\_argument** if **n** is not a valid index in **s** .

*val blit* : **src:string -> src\_pos:int -> dst:bytes -> dst\_pos:int -> len:int -> unit**

**blit ~src ~src\_pos ~dst ~dst\_pos ~len** copies **len** bytes from the string **src** , starting at index **src\_pos** , to byte sequence **dst** , starting at character number **dst\_pos** .

**Raises Invalid\_argument** if **src\_pos** and **len** do not designate a valid range of **src** , or if **dst\_pos** and **len** do not designate a valid range of **dst** .

*val copy* : **string -> string**

**Deprecated.** Because strings are immutable, it doesn't make much sense to make identical copies of them.

Return a copy of the given string.

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

**Deprecated.** This is a deprecated alias of **Bytes.fill** / **BytesLabels.fill** .

**fill s ~pos ~len c** modifies byte sequence **s** in place, replacing **len** bytes by **c** , starting at **pos** .

**Raises Invalid\_argument** if **pos** and **len** do not designate a valid substring of **s** .

*val uppercase* : **string -> string**

**Deprecated.** Functions operating on Latin-1 character set are deprecated.

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* : **string -> string**

**Deprecated.** Functions operating on Latin-1 character set are deprecated.

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* : **string -> string**

**Deprecated.** Functions operating on Latin-1 character set are deprecated.

Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..

*val uncapitalize* : **string -> string**

**Deprecated.** Functions operating on Latin-1 character set are deprecated.

Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.

## [Binary decoding of integers](#Binary_decoding_of_integers)

The functions in this section binary decode integers from strings.

All following functions raise **Invalid\_argument** if the characters needed at index **i** to decode the integer are not available.

Little-endian (resp. big-endian) encoding means that least (resp. most) significant bytes are stored first. Big-endian is also known as network byte order. Native-endian encoding is either little-endian or big-endian depending on **Sys.big\_endian** .

32-bit and 64-bit integers are represented by the **int32** and **int64** types, which can be interpreted either as signed or unsigned numbers.

8-bit and 16-bit integers are represented by the **int** type, which has more bits than the binary encoding. These extra bits are sign-extended (or zero-extended) for functions which decode 8-bit or 16-bit integers and represented them with **int** values.

*val get\_uint8* : **string -> int -> int**

**get\_uint8 b i** is **b** 's unsigned 8-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int8* : **string -> int -> int**

**get\_int8 b i** is **b** 's signed 8-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_uint16\_ne* : **string -> int -> int**

**get\_uint16\_ne b i** is **b** 's native-endian unsigned 16-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_uint16\_be* : **string -> int -> int**

**get\_uint16\_be b i** is **b** 's big-endian unsigned 16-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_uint16\_le* : **string -> int -> int**

**get\_uint16\_le b i** is **b** 's little-endian unsigned 16-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int16\_ne* : **string -> int -> int**

**get\_int16\_ne b i** is **b** 's native-endian signed 16-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int16\_be* : **string -> int -> int**

**get\_int16\_be b i** is **b** 's big-endian signed 16-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int16\_le* : **string -> int -> int**

**get\_int16\_le b i** is **b** 's little-endian signed 16-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int32\_ne* : **string -> int -> int32**

**get\_int32\_ne b i** is **b** 's native-endian 32-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int32\_be* : **string -> int -> int32**

**get\_int32\_be b i** is **b** 's big-endian 32-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int32\_le* : **string -> int -> int32**

**get\_int32\_le b i** is **b** 's little-endian 32-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int64\_ne* : **string -> int -> int64**

**get\_int64\_ne b i** is **b** 's native-endian 64-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int64\_be* : **string -> int -> int64**

**get\_int64\_be b i** is **b** 's big-endian 64-bit integer starting at character index **i** .

**Since** 4.13.0

*val get\_int64\_le* : **string -> int -> int64**

**get\_int64\_le b i** is **b** 's little-endian 64-bit integer starting at character index **i** .

**Since** 4.13.0

2026-10-27 OCamldoc

---

Document: Stdlib.StringLabels(3o) from ocaml-4 4.14.4-r4 (Chainguard OS)
Source: https://github.com/ocaml/ocaml