Stdlib.Uchar(3) OCaml library Stdlib.Uchar(3)

# [NAME](#NAME)

Stdlib.Uchar - no description

# [Module](#Module)

Module Stdlib.Uchar

# [Documentation](#Documentation)

Module **Uchar**  
: **(module Stdlib\_\_Uchar)**

*type t*

The type for Unicode characters.

A value of this type represents a Unicode scalar value which is an integer in the ranges **0x0000** ... **0xD7FF** or **0xE000** ... **0x10FFFF** .

*val min* : **t**

**min** is U+0000.

*val max* : **t**

**max** is U+10FFFF.

*val bom* : **t**

**bom** is U+FEFF, the byte order mark (BOM) character.

**Since** 4.06

*val rep* : **t**

**rep** is U+FFFD, the replacement character.

**Since** 4.06

*val succ* : **t -> t**

**succ u** is the scalar value after **u** in the set of Unicode scalar values.

**Raises Invalid\_argument** if **u** is **Uchar.max** .

*val pred* : **t -> t**

**pred u** is the scalar value before **u** in the set of Unicode scalar values.

**Raises Invalid\_argument** if **u** is **Uchar.min** .

*val is\_valid* : **int -> bool**

**is\_valid n** is **true** if and only if **n** is a Unicode scalar value (i.e. in the ranges **0x0000** ... **0xD7FF** or **0xE000** ... **0x10FFFF** ).

*val of\_int* : **int -> t**

**of\_int i** is **i** as a Unicode character.

**Raises Invalid\_argument** if **i** does not satisfy **Uchar.is\_valid** .

*val to\_int* : **t -> int**

**to\_int u** is **u** as an integer.

*val is\_char* : **t -> bool**

**is\_char u** is **true** if and only if **u** is a latin1 OCaml character.

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

**of\_char c** is **c** as a Unicode character.

*val to\_char* : **t -> char**

**to\_char u** is **u** as an OCaml latin1 character.

**Raises Invalid\_argument** if **u** does not satisfy **Uchar.is\_char** .

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

**equal u u'** is **u = u'** .

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

**compare u u'** is **Stdlib.compare u u'** .

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

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

**Since** 5.3

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

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

**Before5.3** The hashing algorithm was different. Use **Hashtbl.rebuild** for stored tables which used this hashing function

## [UTF codecs tools](#UTF_codecs_tools)

*type utf\_decode*

The type for UTF decode results. Values of this type represent the result of a Unicode Transformation Format decoding attempt.

*val utf\_decode\_is\_valid* : **utf\_decode -> bool**

**utf\_decode\_is\_valid d** is **true** if and only if **d** holds a valid decode.

*val utf\_decode\_uchar* : **utf\_decode -> t**

**utf\_decode\_uchar d** is the Unicode character decoded by **d** if **utf\_decode\_is\_valid d** is **true** and **Uchar.rep** otherwise.

*val utf\_decode\_length* : **utf\_decode -> int**

**utf\_decode\_length d** is the number of elements from the source that were consumed by the decode **d** . This is always strictly positive and smaller or equal to **4** . The kind of source elements depends on the actual decoder; for the decoders of the standard library this function always returns a length in bytes.

*val utf\_decode* : **int -> t -> utf\_decode**

**utf\_decode n u** is a valid UTF decode for **u** that consumed **n** elements from the source for decoding. **n** must be positive and smaller or equal to **4** (this is not checked by the module).

*val utf\_decode\_invalid* : **int -> utf\_decode**

**utf\_decode\_invalid n** is an invalid UTF decode that consumed **n** elements from the source to error. **n** must be positive and smaller or equal to **4** (this is not checked by the module). The resulting decode has **Uchar.rep** as the decoded Unicode character.

*val utf\_8\_decode\_length\_of\_byte* : **char -> int**

**utf\_8\_decode\_length\_of\_byte byte** is the number of bytes, from 1 to **Uchar.max\_utf\_8\_decode\_length** , that a valid UTF-8 decode starting with byte **byte** would consume or **0** if **byte** cannot start a valid decode.

**Since** 5.4

*val max\_utf\_8\_decode\_length* : **int**

**max\_utf\_8\_decode\_length** is **4** , the maximal number of bytes a valid or invalid UTF-8 decode can consume.

**Since** 5.4

*val utf\_8\_byte\_length* : **t -> int**

**utf\_8\_byte\_length u** is the number of bytes needed to encode **u** in UTF-8.

*val utf\_16\_byte\_length* : **t -> int**

**utf\_16\_byte\_length u** is the number of bytes needed to encode **u** in UTF-16.

2026-10-23 OCamldoc

---

Document: Stdlib.Uchar(3o) from ocaml 5.5.2-r0 (Chainguard OS)
Source: https://github.com/ocaml/ocaml