module UCS4:`sig`

..`end`

type`t =`

`(int32, Bigarray.int32_elt, Bigarray.c_layout) Bigarray.Array1.t`

UCS4 encoded string. The type is the bigarray of 32-bit integers.
Bigarray.cma or Bigarray.cmxa must be linked when this module is used.

`exception Malformed_code`

`val validate : ``t -> unit`

`validate s`

If `s`

is valid UCS4 then successes otherwise raises `Malformed_code`

.
Other functions assume strings are valid UCS4, so it is prudent
to test their validity for strings from untrusted origins.All functions below assume strings are valid UCS4. If not, the result is unspecified.

`val get : ``t -> int -> CamomileLibrary.Type.UChar.t`

`get s n`

returns `n`

-th Unicode character of `s`

.`val init : ``int -> (int -> CamomileLibrary.Type.UChar.t) -> t`

`init len f`

returns a new string which contains `len`

Unicode characters.
The i-th Unicode character is initialised by `f i`

`val length : ``t -> int`

`length s`

returns the number of Unicode characters contained in `s`

type`index =`

`int`

Positions in the string represented by the number of characters
from the head.
The location of the first character is

`0`

`val nth : ``t -> int -> index`

`nth s n`

returns the position of the `n`

-th Unicode character.
The call requires O(n)-time`val first : ``t -> index`

`first s`

: The position of the head of the last Unicode character.`val last : ``t -> index`

`last s`

: The position of the head of the last Unicode character.`val look : ``t ->`

index -> CamomileLibrary.Type.UChar.t

`look s i`

returns the Unicode character of the location `i`

in the string `s`

.`val out_of_range : ``t -> index -> bool`

`out_of_range s i`

tests whether `i`

points the valid position of `s`

.`val compare_index : ``t ->`

index -> index -> int

`compare_aux s i1 i2`

returns
If `i1`

is the position located before `i2`

, a value < 0,
If `i1`

and `i2`

points the same location, 0,
If `i1`

is the position located after `i2`

, a value > 0.`val next : ``t ->`

index -> index

`next s i`

returns the position of the head of the Unicode character
located immediately after `i`

.
If `i`

is a valid position, the function always success.
If `i`

is a valid position and there is no Unicode character after `i`

,
the position outside `s`

is returned.
If `i`

is not a valid position, the behaviour is undefined.`val prev : ``t ->`

index -> index

`prev s i`

returns the position of the head of the Unicode character
located immediately before `i`

.
If `i`

is a valid position, the function always success.
If `i`

is a valid position and there is no Unicode character before `i`

,
the position outside `s`

is returned.
If `i`

is not a valid position, the behaviour is undefined.`val move : ``t ->`

index -> int -> index

`move s i n`

:
If n >= 0, returns `n`

-th Unicode character after `i`

.
If n < 0, returns `-n`

-th Unicode character before `i`

.
If there is no such character, the result is unspecified.`val iter : ``(CamomileLibrary.Type.UChar.t -> unit) -> t -> unit`

`iter f s`

:
Apply `f`

to all Unicode characters in `s`

.
The order of application is same to the order
in the Unicode characters in `s`

.`val compare : ``t -> t -> int`

Code point comparison

module Buf:`sig`

..`end`

Buffer module for UCS4