Algorithms and Data structures

Jump consistent hash implementation in Elixir

Generic Zipper Implementation for Erlang

A fast consistent hash ring implementation in Elixir.

Raft library

Computational parallel flows for Elixir

Parallel stream operations for Elixir

Erlang/Elixir library for partitioned or sharded ETS tables.

General purpose circular buffer.

A high-performance graph datastructure library for Elixir projects

A fast consistent hash ring implementation in Elixir

Unified access to tabular data

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

Erlang Trie Implementation

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.

Implementations of δ-CRDTs

A faster Map, augmented with a MerkleTree

Priority Search Queue

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

Consistent Hash Ring

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

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

Elixir implementation of bidirectional map and multimap

Jump Consistent Hash NIF library for Erlang/Elixir.

Fast bounded deque using two rotating lists.

A splay-tree implementation

SortedSet is a fast and efficient Rust backed sorted set.

A library for cosine similarity & simhash calculation

A simple, dependency free boolean satisfiability solver.

Algebra utilities for Elixir

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

Ordered map for Elixir lang

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

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.

Bloomex is a pure Elixir implementation of Scalable Bloom Filters.

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.

Erlang Priority Queue Implementation

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

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

A double-ended queue data structure

Huet's zippers in Elixir

Elixir library computing simple combination and permutation on Enumerables.

Tries in Gleam

Immutable arrays for Gleam

riak CTDT datatypes

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

Library for dealing with data structures

Storing a set of closed intervals

Erlang lazy list library

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

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

A Jump Consistent Hash library

Double-ended queue with limited length

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).

An Elixir implementation of the Google diff_match_patch library.

Monads, Functors and Do-Notation for Erlang

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

An OTP application

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

Trie based router.

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

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

ExShards – Elixir Wrapper for cabol/shards

Extensions to Elixir data structures

Non-empty lists in Gleam

LexoRank on Elixir. An implementation of a list ordering system.

Bags (or multisets) in Gleam

Helper functions for working with weighted random values.

Fast-and-loose PRNG experiments

Easily sort by multiple fields in a readable manner

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

Conflict-free Replicated Data Types

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

A fleet of Raft consensus groups

Merkle Trees for data replication purposes

A hash tree or Merkle tree is a tree in which every non-leaf node is labelled with the hash of the labels or values (in case of leaves) of its child nodes. Hash trees are useful because they allow efficient and secure verification of the contents of large data structures.

Dependency graphs for optimal function call ordering

An ETS-based implementation of the token bucket algorithm

Monadic types collection. Option (Maybe) - some(val)/none(). Result - ok(val)/error(err).