lib-rrbit v2.0.12-beta

lib-rrbit

is a set core operations and helpers for use on Vectors(i.e Arrays) implementing a Relaxed-Radix-Balance technique from the 2015 paper

this library adopts a Bring-Your-Own base factory(class) to easily allow seamless integrations across multiple environments.

If your looking for a immutable collection implementation, considering looking at our sister project instead: rrbit-js

About

lib-rrbit aims to ease your transition to immutable collections, by letting you decide the API for you needs, while handling all the bit-fiddling and dark magic of persistence algorithms behind the scenes. A typical well rounded List class can be quickly put together in less than 300 LOC, while adding around 10k(unminified) to your project.

Want your List's to return Optionals or Maybes instead of nulls? try it!

Need a List API that mimic's your your platform's (e.g. Java's ArrayList or Elm's Array), knock it out in an afternoon!

This project hope to bring more options to JS that help make it easy to focus on business logic and worry less about shared mutable state

Advantages

Every data structure has advantages and disadvantages depending on the use case. RRB data structures offer several unique advantages:

• immutable every operations returns a new Vector
• structural sharing Vectors safely share internal data, minimizing memory usage. Great for historical use cases(e.g. undo/redo stacks)
• efficient prepend AND appends Vectors apply changes to an internal local cache or "focus" before merging them into the trie. instead of using a "tail" or "head", we use a movable "focus"

Great for queues

• fast splitting slicing operations only require a trimming of indexes, no array copy required!
• fast concat appending operations can often be completed with only and index update, requiring extremely little to no array copying

Operations

rrbit only provides a few operations to perform on Vectors efficiently. All other collection operations can be build from these:

1. append - adds a single element
2. update - updates a single
3. take - keep first n elements, deleting everything after
4. drop - delete first n elements, keeping the rest
5. nth - get the element at given position
6. appendAll - join two RRB Vectors together efficiently

Performance

RRB Vectors are able to keep up with or outperform their mutable Array counterparts on almost all operations save append. With a suitable Builder class or helper to convert from your favorite collection type, even this limitation can be mitigated

comparisons with other frameworks