---
name: "StdLabels.String"
section: "3o"
platform: "linux"
package: "ocaml"
version: "5.5.0-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/StdLabels.String"
---

# StdLabels.String(3o)

no description

## NAME

StdLabels.String - no description

## Module

Module   StdLabels.String

## Documentation

Module **String**\
  :  **(module StringLabels)**

### 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

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

*val empty* :  **string**

The empty string.

**Since** 4.13

*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** .

*val of\_char* :  **char -\> string**

**of\_char c** is  **c** as a string.

**Since** 5.5

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

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

**Since** 4.13

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

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

**Since** 4.13

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

Same as  **Bytes.blit\_string** which should be preferred.

### 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

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

### 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

*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 is\_empty* :  **string -\> bool**

**is\_empty s** is  **true** if and only if  **s** is an empty string.

**Since** 5.5

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

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

**Since** 4.13

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

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

**Since** 4.13

*val includes* :  **affix:string -\> string -\> bool**

**includes ~affix s** is  **true** if and only if  **affix** occurs in  **s** .

Note. To test the same  **affix** string multiple times, partially applying the  **~affix** argument and using the resulting function repeatedly is more efficient.

**Since** 5.5

*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

*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** .

### Splitting strings

### Splitting with magnitudes

*val take\_first* :  **int -\> string -\> string**

**take\_first n s** are the first  **n** bytes of  **s** . This is  **s** if **n \>= length s** and  **""** if  **n \<= 0** .

**Since** 5.5

*val take\_last* :  **int -\> string -\> string**

**take\_last n s** are the last  **n** bytes of  **s** .  This is  **s** if **n \>= length s** and  **""** if  **n \<= 0** .

**Since** 5.5

*val drop\_first* :  **int -\> string -\> string**

**drop\_first n s** is  **s** without the first  **n** bytes of  **s** . This is  **""** if  **n \>= length s** and  **s** if  **n \<= 0** .

**Since** 5.5

*val drop\_last* :  **int -\> string -\> string**

**drop\_last n s** is  **s** without the last  **n** bytes of  **s** . This is  **""** if  **n \>= length s** and  **s** if  **n \<= 0** .

**Since** 5.5

*val cut\_first* :  **int -\> string -\> string \* string**

**cut\_first n v** is  **(take\_first n v, drop\_first n v)** .

**Since** 5.5

*val cut\_last* :  **int -\> string -\> string \* string**

**cut\_last n v** is  **(drop\_last n v, take\_last n v)** .

**Since** 5.5

### Splitting with predicates

*val take\_first\_while* :  **(char -\> bool) -\> string -\> string**

**take\_first\_while p s** is the first consecutive bytes of  **s** satisfying the predicate  **p** .

**Since** 5.5

*val take\_last\_while* :  **(char -\> bool) -\> string -\> string**

**take\_last\_while p s** is the last consecutive bytes of  **s** satisfying the predicate  **p** .

**Since** 5.5

*val drop\_first\_while* :  **(char -\> bool) -\> string -\> string**

**drop\_first\_while p s** is  **s** without the first consecutive bytes of  **s** satisfying the predicate  **p** .

**Since** 5.5

*val drop\_last\_while* :  **(char -\> bool) -\> string -\> string**

**drop\_last\_while p s** is  **s** without the last consecutive bytes of  **s** satisfying the predicate  **p** .

**Since** 5.5

*val cut\_first\_while* :  **(char -\> bool) -\> string -\> string \* string**

**cut\_first\_while p s** is **(take\_first\_while p s, drop\_first\_while p s)** .

**Since** 5.5

*val cut\_last\_while* :  **(char -\> bool) -\> string -\> string \* string**

**cut\_last\_while p s** is **(drop\_last\_while p s, take\_last\_while p s)** .

**Since** 5.5

### Splitting with separators

Note. To split the same  **sep** string multiple times, partially applying the  **~sep** argument of these functions and using the resulting function repeatedly is more efficient.

*val split\_first* :  **sep:string -\> string -\> (string \* string) option**

**split\_first ~sep s** is the pair  **Some (left, right)** made of the two (possibly empty) substrings of  **s** that are delimited by the first match of the separator  **sep** in  **s** or  **None** if  **sep** can't be found. Search for  **sep** starts at position  **0** and uses **StringLabels.find\_first** .

If  **sep** is  **""** , this is  **Some ("", s)** .

The invariant  **concat sep \[left; right\] = s** holds.

**Since** 5.5

*val split\_last* :  **sep:string -\> string -\> (string \* string) option**

**split\_last ~sep s** is the pair  **Some (left, right)** made of the two (possibly empty) substrings of  **s** that are delimited by the last match of the separator  **sep** in  **s** or  **None** if  **sep** can't be found. Search for  **sep** starts at position  **length s** and uses **StringLabels.find\_last** .

If  **sep** is  **""** , this is  **Some (s, "")** .

The invariant  **concat sep \[left; right\] = s** holds.

**Since** 5.5

*val split\_all* :  **sep:string -\> ?drop:(string -\> bool) -\> string -\> string list**

**split\_all ~sep s** is the list of all substrings of  **s** that are delimited by non-overlapping matches of the separator  **sep** or the list  **\[s\]** if  **sep** can't be found. Search for  **sep** starts at position  **0** in increasing indexing order and uses  **StringLabels.find\_all** .

Substrings  **sub** for which  **drop sub** is  **true** are not included in the result.  **drop** defaults to  **Fun.const false** .

If  **sep** is  **""** , this is  **\[""; c0; ...; cn; ""\]** with  **ci** the string  **of\_char s.\[i\]** .

The invariant  **concat sep (split\_all ~sep s) = s** holds.

**Since** 5.5

*val rsplit\_all* :  **sep:string -\> ?drop:(string -\> bool) -\> string -\> string list**

**rsplit\_all ~sep s** is the list of all substrings of  **s** that are delimited by non-overlapping matches of the separator  **sep** or **\[s\]** if  **sep** can't be found. Search for  **sep** starts at position **length s** in decreasing indexing order and uses  **StringLabels.rfind\_all** .

Substrings  **sub** for which  **drop sub** is  **true** are not included in the result.  **drop** defaults to  **Fun.const false** .

If  **sep** is  **""** , this is  **\[""; c0; ...; cn; ""\]** with  **ci** the string  **of\_char s.\[i\]** .

The invariant  **concat sep (rsplit\_all ~sep s) = s** holds.

**Since** 5.5

*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** . If  **s** is empty, the result is the singleton list  **\[""\]** .

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

### 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

*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

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

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

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

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

*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

*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

*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

*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 (0x5C) 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

*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

*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

*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

### 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

### Finding indices

*val find\_first\_index* :  **(char -\> bool) -\> ?start:int -\> string -\> int option**

**find\_first\_index p ~start s** is the index of the first character of  **s** that satisfies predicate  **p** at or after the index or position  **start** (defaults to  **0** ).

If  **start** is  **length s** , the result is always  **None** .

**Since** 5.5

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

*val find\_last\_index* :  **(char -\> bool) -\> ?start:int -\> string -\> int option**

**find\_last\_index p ~start s** is the index of the last character of **s** that satisfies predicate  **p** at or before the index or position  **start** (defaults to  **length s** ).

**Since** 5.5

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

*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

### Finding substrings

Note. To find the same  **sub** string multiple times, partially applying the  **~sub** argument of these functions and using the resulting function repeatedly is more efficient

*val find\_first* :  **sub:string -\> ?start:int -\> string -\> int option**

**find\_first ~sub ~start s** is the starting position of the first occurrence of  **sub** in  **s** at or after the index or position  **start** (defaults to  **0** ).

If  **sub** is  **""** the result is  **Some start** . The result of the function is always a valid index of  **s** except when  **sub** is **""** and  **start** is  **length s** .

**Since** 5.5

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

*val find\_last* :  **sub:string -\> ?start:int -\> string -\> int option**

**find\_last ~sub ~start s** is the starting position of the last occurrence of  **sub** in  **s** at or before the index or position **start** (defaults to  **String.length s** ).

If  **sub** is  **""** the result is  **Some start** . The result of the function is always a valid index of  **s** except when  **sub** is **""** and  **start** is  **length s** .

**Since** 5.5

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

*val find\_all* :  **sub:string -\> f:(int -\> 'acc -\> 'acc) -\> ?start:int -\> string -\> 'acc -\> 'acc**

**find\_all ~sub f ~start s acc** , starting with  **acc** , folds  **f** by increasing index order over all non-overlapping starting positions of  **sub** in  **s** at or after the index or position  **start** (defaults to  **0** ). The result is  **acc** if  **sub** could not be found in  **s** .

If  **sub** is  **""** ,  **f** gets invoked on all positions of  **s** at or after **start** .

**Since** 5.5

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

*val rfind\_all* :  **sub:string -\> f:(int -\> 'acc -\> 'acc) -\> ?start:int -\> string -\> 'acc -\> 'acc**

**rfind\_all ~sub f ~start s acc** , starting with  **acc** , folds  **f** by decreasing index order over all non-overlapping starting positions of  **sub** in  **s** at or before the index or position **start** (defaults to  **String.length s** ). The result is  **acc** if **sub** could not be found in  **s** .

If  **sub** is  **""** ,  **f** gets invoked on all positions of  **s** at or before  **start** .

**Since** 5.5

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

### Replacing substrings

Note. To replace the same  **sub** string multiple times, partially applying the  **~sub** argument of these functions and using the resulting function repeatedly is more efficient.

*val replace\_first* :  **sub:string -\> by:string -\> ?start:int -\> string -\> string**

**replace\_first ~sub ~by ~start s** replaces by  **by** the first occurrence of  **sub** in  **s** at or after the index or position **start** (defaults to  **0** ).

If  **sub** is  **""** , this inserts  **by** at position  **start** .

**Since** 5.5

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

*val replace\_last* :  **sub:string -\> by:string -\> ?start:int -\> string -\> string**

**replace\_last ~sub ~by ~start s** replaces by  **by** the last occurrence of  **sub** in  **s** at or after the index or position **start** (defaults to  **String.length s** ).

If  **sub** is  **""** , this inserts  **by** at position  **start** .

**Since** 5.5

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

*val replace\_all* :  **sub:string -\> by:string -\> ?start:int -\> string -\> string**

**replace\_all ~sub ~by ~start s** replaces by  **by** all non-overlapping occurrences of  **sub** in  **s** at or after the index or position  **start** (defaults to  **0** ). Occurrences are found in increasing indexing order.

If  **sub** is  **""** , this inserts  **by** on all positions from  **start** on.

**Since** 5.5

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

### 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.

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

*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

*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.

### Spellchecking

*val edit\_distance* :  **?limit:int -\> t -\> t -\> 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.

The function assumes the strings are UTF-8 encoded and uses  **Uchar.t** for the notion of character. Decoding errors are replaced by **Uchar.rep** . Normalizing the strings to NFC gives better results.

Note. This implements the simpler Optimal String Alignment (OSA) distance, not the Damerau-Levenshtein distance. With this function **"ca"** and  **"abc"** have a distance of 3 not 2.

**Since** 5.4

*val spellcheck* :  **?max\_dist:(string -\> int) -\>** **((string -\> unit) -\> unit) -\> string -\> string list**

**spellcheck iter\_dict s** are the strings enumerated by the iterator  **iter\_dict** whose  **StringLabels.edit\_distance** to  **s** is the smallest and at most  **max\_dist s** . If multiple corrections are returned their order is as found in  **iter\_dict** . The default **max\_dist s** is:

\- **0** if  **s** has 0 to 2 Unicode characters.

\- **1** if  **s** has 3 to 4 Unicode characters.

\- **2** otherwise.

If your dictionary is a list  **l** , a suitable  **iter\_dict** is given by  **(fun yield -\> List.iter yield l)** .

All strings are assumed to be UTF-8 encoded, decoding errors are replaced by  **Uchar.rep** characters.

**Since** 5.4

### 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

*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

*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

*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

*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

*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

*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

*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

*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

*val hash* :  **t -\> int**

An unseeded hash function for strings, with the same output value as **Hashtbl.hash** . This function allows this module to be passed as argument to the functor  **Hashtbl.Make** .

**Since** 5.0

*val seeded\_hash* :  **int -\> t -\> int**

A seeded hash function for strings, with the same output value as **Hashtbl.seeded\_hash** . This function allows this module to be passed as argument to the functor  **Hashtbl.MakeSeeded** .

**Since** 5.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

*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

*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

*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

*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