rope-sequence

This module implements a single data type, RopeSequence, which is a
persistent sequence type implemented as a loosely-balanced
rope.
It supports appending, prepending, and slicing without doing a full
copy. Random access is somewhat more expensive than in an array
(logarithmic, with some overhead), but should still be relatively
fast.

Licensed under the MIT license.

class RopeSequence

static from(?union<[T], RopeSequence>) → RopeSequence

Create a rope representing the given array, or return the rope itself
if a rope was given.

static empty: RopeSequence

The empty rope.

length: number

The length of the rope.

append(union<[T], RopeSequence>) → RopeSequence

Append an array or other rope to this one, returning a new rope.

prepend(union<[T], RopeSequence>) → RopeSequence

Prepend an array or other rope to this one, returning a new rope.

slice(from: ?number = 0, to: ?number = this.length) → RopeSequence

Create a rope repesenting a sub-sequence of this rope.

get(index: number) → T

Retrieve the element at the given position from this rope.

forEach(f: fn(element: T, index: number) → ?bool, from: ?number, to: ?number)

Call the given function for each element between the given indices.
This tends to be more efficient than looping over the indices and
calling get, because it doesn't have to descend the tree for every
element.

to may be less then from, in which case the iteration will happen
in reverse (starting at index from - 1, down to index to.

The iteration function may return false to abort iteration early.

map(f: fn(element: T, index: number) → U, from: ?number, to: ?number) → [U]

Map the given functions over the elements of the rope, producing a
flat array.

flatten() → [T]

Return the content of this rope as an array.