Rope-based persistent sequence type
npm install rope-sequenceThis 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.
RopeSequencestatic from(?union<[T], 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
Append an array or other rope to this one, returning a new rope.
prepend(union<[T], 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.