# Module type CamomileLibrary.Type.UnicodeString.Type

    module type Type = sig .. end

    type t

The type of string.

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

`get t i` : `i`-th character of the storage.

    val init : int ->
           (int -> CamomileLibrary.Type.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.Type.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.Type.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.