module BatUTF8:`sig`

..`end`

UTF-8 encoded Unicode strings. The type is normal string.

type`t =`

`string`

UTF-8 encoded Unicode strings. The type is normal string.

`exception Malformed_code`

`val validate : ``t -> unit`

`validate s`

successes if s is valid UTF-8, otherwise raises Malformed_code.
Other functions assume strings are valid UTF-8, so it is prudent
to test their validity for strings from untrusted origins.

`val get : ``t -> int -> BatUChar.t`

`get s n`

returns `n`

-th Unicode character of `s`

.
The call requires O(n)-time.

`val init : ``int -> (int -> BatUChar.t) -> t`

`init len f`

returns a new string which contains `len`

Unicode characters.
The i-th Unicode character is initialized 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 bytes 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`

The position of the head of the first Unicode character.

`val last : ``t -> index`

The position of the head of the last Unicode character.

`val look : ``t -> index -> BatUChar.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`

is a position inside of `s`

.

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

`compare_index s i1 i2`

returns
a value < 0 if `i1`

is the position located before `i2`

,
0 if `i1`

and `i2`

points the same location,
a value > 0 if `i1`

is the position located after `i2`

.

`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 inside of `s`

, the function always successes.
If `i`

is inside of `s`

and there is no Unicode character after `i`

,
the position outside `s`

is returned.
If `i`

is not inside of `s`

, the behaviour is unspecified.

`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 inside of `s`

, the function always successes.
If `i`

is inside of `s`

and there is no Unicode character before `i`

,
the position outside `s`

is returned.
If `i`

is not inside of `s`

, the behaviour is unspecified.

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

`move s i n`

returns `n`

-th Unicode character after `i`

if n >= 0,
`n`

-th Unicode character before `i`

if n < 0.
If there is no such character, the result is unspecified.

`val iter : ``(BatUChar.t -> unit) -> t -> unit`

`iter f s`

applies `f`

to all Unicode characters in `s`

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

.

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

Code point comparison by the lexicographic order.
`compare s1 s2`

returns
a positive integer if `s1`

> `s2`

,
0 if `s1`

= `s2`

,
a negative integer if `s1`

< `s2`

.

module Buf:`sig`

..`end`

`with type buf = Buffer.t`

Buffer module for UTF-8 strings