module type Type =`sig`

..`end`

`type `

t

The type of string.

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

`get t i`

: `i`

-th character of the storage.`val init : ``int ->`

(int -> CamomileLibrary.UChar.t) -> t

`init len f`

creates a new storage.
the returned storage has length `len`

, its nth-element is `f n`

.
`f`

is called with integers `0 ... len - 1`

, only once for each integer.
The call is in the increasing order f 0, f 1, f 2, ...`val length : ``t -> int`

The number of Unicode characters in the storage

`type `

index

locations in storages.

`val look : ``t ->`

index -> CamomileLibrary.UChar.t

`look t i`

: The character in the location `i`

of `t`

.`val nth : ``t ->`

int -> index

`nth t n`

: the location of the `n`

-th character in `t`

.`next x i, prev x i`

:
The operation is valid if `i`

points the valid element, i.e. the
returned value may point the location beyond valid elements by one.
If `i`

does not point a valid element, the results are unspecified.`val next : ``t ->`

index ->

index

`val prev : ``t ->`

index ->

index

`val out_of_range : ``t ->`

index -> bool

`val iter : ``(CamomileLibrary.UChar.t -> unit) ->`

t -> unit

`val compare : ``t ->`

t -> int

`val first : ``t ->`

index

The location of the first character in the storage.

`val last : ``t ->`

index

The location of the last character in the storage.

`val move : ``t ->`

index ->

int -> index

`move t i n`

:
if `n`

>= 0, then returns `n`

-th character after `i`

and
otherwise returns -`n`

-th character before `i`

.
If there is no such character, or `i`

does not point
a valid character, the result is unspecified.`val compare_index : ``t ->`

index ->

index -> int

`compare_index t i j`

returns
a positive integer if `i`

is the location placed after `j`

in `t`

,
0 if `i`

and `j`

point the same location, and
a negative integer if `i`

is the location placed before `j`

in `t`

.module Buf:`sig`

..`end`

Character buffers.