Development: Algorithms & data structures
A list that might have at most one selected item
An array-based gap buffer implementation
Operational Replicated Data Types for crafting replicated data types
Port of the community parser combinator to elm 0.19
A composable way of joining dictionaries
Library providing functional tools to manipulate complex records
simple method for time-throttling action / message propogation
First in, first out (FIFO) queue
An array that has at least one element.
tuple-like datastructure allowing more than 3 elements.
Accessors, a library implementing lenses for Elm.
A key-value container similar to Dict but stores different types of values.
An implementation of the Murmur3 hash function for Elm
A data structure for working with a non-empty progression of values
A CRDT for sequential data based on LSEQ
Implements HashCash to prevent spammers abusing a resource.
Calculate and Validate number sequences according to the Modulus 10 algorithm
Verify and calculate check digits according to the algorithm Modulus 11
flatMap over various Elm types and parameter counts
Hierarchical statecharts for Elm
Strongly typed fixed level trees with a zipper.
Floyd Cycle detection Algorithm
Implementation of the Johnson Trotter permutation algorithm
Imperative syntax functions for porting imperative code into Elm
Keep track of lots of different data by ids
Collection types of a fixed length
Types and helpers for your types with ids
A type to arrange things in order
Variations of standard collections that always have at least 1 item
A non-empty list type
A non-empty list type
Fast graph search algorithms for problem-solving, with visualizations.
The integers, ℤ = { ..., -2, -1, 0, 1, 2, ... }
The natural numbers, ℕ = { 0, 1, 2, ... }
Dicts with any type as a key and Sets with any type as a member
Dict that works with any key types by converting keys to String
Optimized dictionary specialization for Integers. Mirrors the dictionary API.
Split lists into chunks
Trie data structure.
The bit is a basic unit of information in information theory, computing.
Boolean data type has two possible truth values to represent logic.
Algorithms for edit distance calculation
Common operations on association lists
Set implemented using association-list-based Dict
Accessors, a library implementing lenses for Elm.
A special Dict data structure that derives keys from values.
QuadTree implementation in Elm
Turn elm objects into comparable hash values
Non-empty lists for Elm.
A list that caches its size.
a priority queue for Elm.
A list with a maximum capacity
A deque (double-ended queue)
Efficient 64-bit (unsigned) integer
Threading state through computation
Calculate contour level lines for a two-dimensional scalar field
Strict multiway trees aka rosetrees and a Zipper to go with them
A small library for special triple support
Elm Bloom filter implementation using Murmur3
Extend Return with Monocle's Lenses for fun in the update function
A set of unique values. The values can be any type (not just comparables).
The most comprehensive debouncer for Elm
Add elements to a Radix tree.
A StorageKey represents a value that is either New or Existing.
Quantify List, Set, Dict or a single value according to a predicate
The most simple debouncer for Elm.
Elm library for arbitrary precision arithmetic
Provides intersections of multiple dictionaries
Throttling and debouncing for messages and values.
A collection of helpers for the Tuple type.
Optics for Elm with single composition operator
A non-empty list data structure.
Generic indexed triangular mesh data structure
Work with binary data.
lookup values by many keys
lookup value-pairs from the left or the right
A type representing a bounded number
This library helps with keeping history of states of your variables.
An Elm package for data structure permutations
A module for consistent hashing
Ordered Dict and Set for Elm
A bidirectional Dict data structure
A graph data structure with a nice API
Specialized List mapN fns giving all combinations of items instead of zipping
Transform recursive data structures from the bottom up
Yet another debouncer for Elm.
A diff implementation for Elm
Generates a new key between two keys
Functions for List grouping
A bag, also known as a multiset.
Repeatedly apply a function to a value.
DEPRECATED An equal package
Values that can be one of two types or both at once
2D Arrays implemented in Elm
Support for Pointfree style in Elm with a subset of Ramda functions.
tools for working with the lambda calculus
Search and sort a list of data using a DSL for conjunction and negation
Representation of and computation spreadsheets in Elm.
Build rose trees from a string
Transform hierarchical list to a rose tree
Operations on rose trees to go with zwilias/elm-rosetree
Haskell's 'Either' type
The A* pathfinding algorithm.
A collection of functions missing from the core.
Queue with O(1) enqueueing and dequeueing even in the worst case.
Enables floating point arithmetics with 32 exponent bits.
A disjoint set implementation with path compression
Convenience functions not included in mgold/elm-nonempty-list
Efficient 64-bit (unsigned) integer
DList is a representation of lists with an efficient append operation
2-dimensional Grid in elm
Partition problem (number partitioning) solvers
Red Black self-balancing binary search trees
A circular buffer (infinite cyclic list)
lookup for multiple arbitrary keys. safe. log n
navigate rosetrees and forests
@deprecated ( x, y ): create, transform, read
Implementation of a CRDT algorithm for distributed graphs
Implementation of a CRDT algorithm for replicated trees
Simple tree with path access, and updates and fold an map functions
navigate rosetrees and forests
Ordered List that allows moving an item around within the list
Pack rectangles closely together. Useful for texture atlases and sprite sheets.
A safe 54-bit signed integer
64-bit unsigned integer with division
Use Dict that is guaranteed to be nonempty
A library for writing custom comparison functions
Dictionary supporting opaque Elm types as keys.
Utilities for working with Bezier curves
head and tail without the Maybe
A package which implements a Stack
Elegant recursion in Elm without blowing the stack
Create nanoids in Elm
Drop-in, faster, replacement for Dict from elm/core
Codegen dictionaries and sets with arbitrary key types.
A data structure that supports efficient concatenation.
Implementation of the Salsa20 encryption and random number generation for Elm
A library for encapsulating keyed lists in Elm
Fork of terezka/intervals@2.0.1 to fix dependencies.
Refinement types in elm
Implementations of some common CRDTs in Elm.
Hashing-based container datastructures
Tools for composing comparison functions
A type keeping track of changes to a value since it was last saved.
Helpers to convert common types into a `String`.
A list that might have at most one selected item
A simple implementation of a stack data structure in Elm
Fixed point decimal data type
Indexed mesh data structure with arbitrary face sizes
Two implementations of a bag using a dict and an association list
A simple yet fast text index
Elm Dict and Set with custom keys based on AVL trees
Elm Queue
The Union Find data structure
Throttling and debouncing for messages and values.
Dict and Set for TSFoster/elm-uuid.
Two-dimensional matrix with indexMap, backed by fast Array from the Elm core.
Read configuration from an implicit environment
Dictionary with custom keys implemented using association lists
Intervals for Elm. Handles ∩, -, ∪ with any combo of open / closed bounds.
Down-sampling data with the Largest-Triangle-Three-Buckets algorithm.
Compute HMAC with SHA-1 hash function
A simple sparse vector implementation
Elm implementation of Trie data structure
A double-ended queue for Elm
Model and operate on a range of values
An experimental indexed store un pure Elm.
Bin Packing of Rectangles
Create spaced repetition software using several different popular algorithms.
Provides functions for unpacking lists items as arguments.
Convenience functions for working with pzp1997/assoc-list Dict
Implementation of L-Systems in Elm
List with a selected element that makes impossible state impossible.
A datastructure that allows you to reset its value to an original value.
Elm Bloom filter implementation using Murmur3
AI Search for Elm
An efficient gap buffer implementation for Elm base around slicing Array.
A one-to-many data structure implementation for Elm.
Lazy lists for Elm.
Dict that works with any key types by converting keys to String
A generator library for simulating laziness.
Either for representing a structure with two types
A library for navigating and updating immutable trees.
A basic DPLL SAT solver
2D Array library for Elm
A key-value container similar to Dict but stores different types of values.
Set from any type using a Dict under the hood
Helpers for comparing non-comparable values
Heap structure for elmlang
Computes MD5 hash of non-string data
Generate SHA1 digests of strings or arbitrary data
Elm dictionary with custom key types.
Lazy rose tree (multiway tree) with zipper.
Functions for working (a, List a) and NonEmpty List Zipper
Simple FIFO (first in, first out) Queue implementation in Elm
Fork of coreygirard/..., without hard dependency on test
Generate list range based on increment and decrease functions
Implements Buchheim, Junger and Leipert's tree layout algorithm
A zipper for List
A data structure for one-to-one mapping between values.
A dictionary mapping unique keys to values preserving insert order.
Product Type that allows you to hold and use two values in one type.
Ordered Dict and Set for Elm
Data stream buffer inspired by Apache Kafka
Pivot: a list with a cursor pointing at the center, like a zipper.
Quadtree space partitioning for collision detection.
Data structure implemented by simple list
A list zipper that can focus on the holes between items
Reorder entries while maintaining a key/value correspondence.
Strict multiway trees aka rosetrees and a Zipper to go with them
Would you like to use Elm for real-world projects?
📢 My book
Practical Elm
skips the basics and gets straight into the nuts-and-bolts of building non-trivial apps.
🛠 Things like building out the UI, communicating with servers, parsing JSON, structuring the application as it grows, testing, and so on.
