• en

Module Zed_rope

type t
Type of unicode ropes.
type rope = t
Alias.
exception Out_of_bounds
Exception raised when trying to access a character which is outside the bounds of a rope.
val empty : t
The empty rope.
val make : int -> CamomileLibrary.UChar.t -> t
make length char creates a rope of length length containing only char.
val init : int -> int -> CamomileLibrary.UChar.t -> t
init n f returns the contenation of singleton (f 0), singleton (f 1), ..., singleton (f (n - 1)).
val rev_init : int -> int -> CamomileLibrary.UChar.t -> t
rev_init n f returns the contenation of singleton (f (n - 1)), ..., singleton (f 1), singleton (f 0).
val singleton : CamomileLibrary.UChar.t -> t
singleton ch creates a rope of length 1 containing only ch.
val length : t -> int
Returns the length of the given rope.
val is_empty : t -> bool
is_empty rope returns whether str is the empty rope or not.
val compare : t -> t -> int
Compares two ropes (in code point order).
val equal : t -> t -> bool
equal r1 r2 retuns true iff r1 is equal to r2.
val of_string : string -> t
of_string str creates a rope from a string. The string must be UTF-8 encoded and is validated. Note that str must not be modified after this operation, if you intend to do so you must copy it before passing it to of_string.
val to_string : t -> string
to_string rope flatten a rope into a string encoded in UTF-8.
val get : t -> int -> CamomileLibrary.UChar.t
get str rope returns the character at index idx in rope.
val append : t -> t -> t
Concatenates the two given ropes.
val concat : t -> t list -> t
concat sep l concatenates all strings of l separating them by sep.
val sub : t -> int -> int -> t
sub rope ofs len Returns the sub-rope of rope starting at ofs and of length len.
val break : t -> int -> (t * t)
break rope pos returns the sub-ropes before and after pos in rope. It is more efficient than creating two sub-ropes with sub.
val before : t -> int -> t
before rope pos returns the sub-rope before pos in rope.
val after : t -> int -> t
after rope pos returns the sub-string after pos in rope.
val insert : t -> int -> t -> t
insert rope pos sub inserts sub in rope at position pos.
val remove : t -> int -> int -> t
remove rope pos len removes the len characters at position pos in rope
val replace : t -> int -> int -> t -> t
replace rope pos len repl replaces the len characters at position pos in rope by repl.
val lchop : t -> t
lchop rope returns rope without is first character. Returns empty if rope is empty.
val rchop : t -> t
rchop rope returns rope without is last character. Returns empty if rope is empty.
val iter : CamomileLibrary.UChar.t -> unit -> t -> unit
iter f rope applies f on all characters of rope starting from the left.
val rev_iter : CamomileLibrary.UChar.t -> unit -> t -> unit
rev_iter f rope applies f an all characters of rope starting from the right.
val fold : CamomileLibrary.UChar.t -> 'a -> 'a -> t -> 'a -> 'a
fold f rope acc applies f on all characters of rope starting from the left, accumulating a value.
val rev_fold : CamomileLibrary.UChar.t -> 'a -> 'a -> t -> 'a -> 'a
rev_fold f rope acc applies f on all characters of rope starting from the right, accumulating a value.
val map : CamomileLibrary.UChar.t -> CamomileLibrary.UChar.t -> t -> t
map f rope maps all characters of rope with f.
val rev_map : CamomileLibrary.UChar.t -> CamomileLibrary.UChar.t -> t -> t
rev_map f str maps all characters of rope with f in reverse order.
val iter_leaf : Zed_utf8.t -> unit -> t -> unit
iter_leaf f rope applies f on all leaves of rope starting from the left.
val rev_iter_leaf : Zed_utf8.t -> unit -> t -> unit
iter_leaf f rope applies f on all leaves of rope starting from the right.
val fold_leaf : Zed_utf8.t -> 'a -> 'a -> t -> 'a -> 'a
fold f rope acc applies f on all leaves of rope starting from the left, accumulating a value.
val rev_fold_leaf : Zed_utf8.t -> 'a -> 'a -> t -> 'a -> 'a
rev_fold f rope acc applies f on all leaves of rope starting from the right, accumulating a value.
module Zip : sig
type t
Type of zippers. A zipper allow to naviguate in a rope in a convenient and efficient manner. Note that a zipper points to a position between two characters, not to a character, so in a rope of length len there is len + 1 positions.
val make_f : rope -> int -> t
make_f rope pos creates a new zipper pointing to positon pos of rope.
val make_b : rope -> int -> t
make_f rope pos creates a new zipper pointing to positon length rope - pos of rope.
val offset : t -> int
Returns the position of the zipper in the rope.
val next : t -> (CamomileLibrary.UChar.t * t)
next zipper returns the code point at the right of the zipper and a zipper to the next position. It raises Out_of_bounds if the zipper points to the end of the rope.
val prev : t -> (CamomileLibrary.UChar.t * t)
prev zipper returns the code point at the left of the zipper and a zipper to the previous position. It raises Out_of_bounds if the zipper points to the beginning of the rope.
val move : int -> t -> t
move n zip moves the zipper by n characters. If n is negative it is moved to the left and if it is positive it is moved to the right. It raises Out_of_bounds if the result is outside the bounds of the rope.
val at_bos : t -> bool
at_bos zipper returns true iff zipper points to the beginning of the rope.
val at_eos : t -> bool
at_eos zipper returns true iff zipper points to the end of the rope.
val find_f : CamomileLibrary.UChar.t -> bool -> t -> t
find_f f zip search forward for a character to satisfy f. It returns a zipper pointing to the left of the first character to satisfy f, or a zipper pointing to the end of the rope if no such character exists.
val find_b : CamomileLibrary.UChar.t -> bool -> t -> t
find_b f zip search backward for a character to satisfy f. It returns a zipper pointing to the right of the first character to satisfy f, or a zipper pointing to the beginning of the rope if no such character exists.
val sub : t -> int -> rope
sub zipper len returns the sub-rope of length len pointed by zipper.
val slice : t -> t -> rope
slice zipper1 zipper2 returns the rope between zipper1 and zipper2. If zipper1 > zipper2 then this is the same as slice zipper2 zipper1.
The result is unspecified if the two zippers do not points to the same rope.
end
module Buffer : sig
type t
Type of rope buffers.
val create : unit -> t
Create a new empty buffer.
val add : t -> CamomileLibrary.UChar.t -> unit
add buffer x add x at the end of buffer.
val contents : t -> rope
contents buffer returns the contents of buffer as a rope.
val reset : t -> unit
reset buffer resets buffer to its initial state.
end
module Text : sig
Camomile compatible interface
type t = rope
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 = Zip.t
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.
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
Character buffers. Similar to Buffer.
type buf
val create : int -> buf
create n creates the buffer. n is used to determine the initial size of the buffer. The meaning of n differs from modules to modules.
val contents : buf -> t
val clear : buf -> unit
val reset : buf -> unit
val add_char : buf -> CamomileLibrary.UChar.t -> unit
val add_string : buf -> t -> unit
val add_buffer : buf -> buf -> unit
end
end