Algorithms and Data structures

Jump consistent hash implementation in Elixir

A fast consistent hash ring implementation in Elixir.

Raft library

Computational parallel flows for Elixir

Generic Zipper Implementation for Erlang

General purpose circular buffer.

Erlang/Elixir library for partitioned or sharded ETS tables.

Parallel stream operations for Elixir

A high-performance graph datastructure library for Elixir projects

A fast consistent hash ring implementation in Elixir

Erlang Trie Implementation

Unified access to tabular data

A bitwise radix tree for prefix based matching on bitstring keys of any length.

Murmur is a pure Elixir implementation of the non-cryptographic hash Murmur3. It aims to implement the x86_32bit, x86_128bit and x64_128bit variants.

A faster Map, augmented with a MerkleTree

Implementations of δ-CRDTs

Fast bounded deque using two rotating lists.

Library for boolean satisfiability solving and expression manipulation.

Elixir implementation of bidirectional map and multimap

Simple Elixir queue, with a constant-time `size/1` and a maximum capacity.

Jump Consistent Hash NIF library for Erlang/Elixir.

Consistent Hash Ring

A `:queue` wrapper with improvements in API and addition of Protocol implementations

SortedSet is a fast and efficient Rust backed sorted set.

Algebra utilities for Elixir

Implementation of the Ramer–Douglas–Peucker algorithm for reducing the number of points used to represent a curve.

Priority Search Queue

Small composable Heap implementation. Heaps sort elements at insert time.

Ordered map for Elixir lang

A splay-tree implementation

A simple, dependency free boolean satisfiability solver.

A circular buffer backed by a queue, map, or ETS

Elixir library computing simple combination and permutation on Enumerables.

A library for cosine similarity & simhash calculation

Erlang Priority Queue Implementation

Permutation is a package and protocol for calculating the possible permutations or combinations of an Enumerable.

Non-empty lists in Gleam

Elixir/Erlang interface to MiniZinc (https://www.minizinc.org/).

Immutable arrays for Gleam

An OTP application

Well-structured Arrays with fast random-element-access for Elixir, offering a common interface with multiple implementations (MapArray, Erlang :array, etc.) with varying performance guarantees that can be switched in your configuration.

Dependency graphs for optimal function call ordering

A high-performance, concurrent, and mutable Cuckoo Filter for Erlang and Elixir

A double-ended queue data structure

Storing a set of closed intervals

Merkle Trees for data replication purposes

Bags (or multisets) in Gleam

sets-like wrapper based on maps

NaryTree implements the data structure for n-ary tree (also called rose tree), where each node in the tree can have zero or more children. NaryTree provides methods for traversal and manipulation of the tree structure and node contents.

Double-ended queue with limited length

A Jump Consistent Hash library

Use `:atomics` as a bit array or as an array of N-bit counters.

Helper functions for working with weighted random values.

Erlang lazy list library

Fast-and-loose PRNG experiments

Probabilistic data structures powered by atomics. Bloom filter, Counting bloom filter, Linear counter (cardinality)

A pure Gleam package to compute the edit distance of two strings

Constraint Programming Solver

Tries in Gleam

Real-valued intervals with support for the `Enumerable` protocol.

Library for dealing with data structures

riak CTDT datatypes

Extensions to Elixir data structures

A fast, safe, batteries-included array for Gleam!

RingBuffer - size limited queue, like a ring or cyclic buffer. With non blocking and non locking writers.

An Elixir implementation of the Google diff_match_patch library.

Trie based router.

GlobalConst converts large Key-Value entities to a module to make fast accessing by thousands of processes.

Bloomex is a pure Elixir implementation of Scalable Bloom Filters.

Sorts a list of maps per a list of sort specs.

Pure Elixir AVL tree implementation

GenStagA data type and related functions to support an unrooted (multiple starting nodes) polytree (a tree-like graph with edges).

ExShards – Elixir Wrapper for cabol/shards

Traverse is a toolset to walk arbitrary Elixir Datastructures in a functional way.

A fleet of Raft consensus groups

Easily sort by multiple fields in a readable manner