Open-source alternatives to Immutable Js

Lodash is a JavaScript utility library and data manipulation toolkit. It provides a collection of modular functions for transforming, filtering, and validating arrays, objects, strings, and numbers. The project functions as a functional programming toolkit, offering capabilities for function composition, currying, and lazy evaluation. It includes mechanisms for execution control, such as debouncing and throttling, to manage the timing and frequency of function invocations. The library covers a broad surface of data operations, including deep cloning and merging of complex nested structures,

go-datastructures is a collection of thread-safe and lock-free data structures designed for high-performance concurrent applications in Go. It provides a modular library of specialized algorithmic toolsets, including a lock-free collection library and an immutable data structure library. The project distinguishes itself through a suite of persistent AVL trees and hash array mapped tries that use branch-copying to preserve previous versions. It also implements non-blocking hash maps, queues, and tries that enable linearizable snapshots and concurrent updates without the use of mutual exclusion

language-ext is a functional programming framework for C# that provides a suite of immutable data structures and monadic types. It enables the implementation of pure functional programming patterns, utilizing containers to manage side effects, optional values, and error handling. The library is distinguished by its advanced concurrency and state management tools, including a software transactional memory system and lock-free atomic references. It also provides specialized utilities for distributed systems, such as vector clocks for causality tracking and deterministic data conflict resolution

Immer is an immutable state management library for JavaScript that enables the creation of new versions of state trees. It functions as a state container that uses a proxy-based handler to ensure data immutability. The library utilizes a copy-on-write mechanism and a draft-based mutation model. This allows users to write mutating code on a temporary proxy, which the system then uses to produce a new immutable result while keeping the original state unchanged. The project covers immutable state management and complex object cloning to facilitate predictable state transitions. These capabiliti

ClojureScript's persistent data structures and supporting API from the comfort of vanilla JavaScript

Postmodern immutable and persistent data structures for C++ — value semantics at scale

Lazy.js is a JavaScript library that implements a lazy evaluation model for processing collections and data streams. It defers all computation until iteration begins, building chains of transformations that execute only when values are consumed, avoiding intermediate arrays and buffering. The library wraps data sources into a uniform sequence interface, enabling operations like map and filter to be chained together without materializing intermediate results. The library extends lazy processing beyond simple collections to handle asynchronous data sources, DOM events, strings, and Node.js stre

AlgoXY is a functional programming educational book and technical publication produced as a LaTeX digital book. It serves as a programming education resource and library focused on functional algorithms and data structures. The project provides a collection of persistent data structures, such as trees and heaps, designed for immutable state management. It includes a series of implementation exercises and verified answers to teach core computer science concepts through the practical application of functional logic. The content covers the design of persistent data structures and the implementa

Functional-Light-JS is a JavaScript functional programming library designed to implement functional patterns within JavaScript applications. It serves as a toolkit for declarative data processing, immutable data management, and the construction of complex logic through higher-order functions. The library focuses on a pragmatic implementation of functional programming, providing utilities for curried argument application and function composition. It emphasizes the use of pure functions to calculate state updates and manage application data without side effects. The project covers broad capabi

Radash is a TypeScript functional utility library designed for data transformation, validation, and workflow management. It provides a collection of typed helper functions to manipulate arrays, objects, and strings. The project features an asynchronous workflow toolkit for managing promises, retries, and concurrency limits, alongside a suite of boolean validators for verifying primitive types, objects, and promises. It also implements functional programming patterns such as function composition, partial application, and error-first response patterns. The library covers a broad surface of cap

attrs is a Python library that automatically generates initialization, representation, equality, hashing, and ordering methods from declarative class attribute definitions. At its core, it provides a class decorator metaprogramming framework that intercepts class creation to rewrite the class body, producing dunder methods without manual boilerplate. The library includes a comprehensive attribute validation toolkit with built-in validators for type checks, range constraints, regex matching, length limits, and logical composition of validation rules. The library distinguishes itself through it

Draft-js is a framework for building customizable rich text editors within React applications. It functions as a content editable framework that separates the underlying data model from the visual rendering layer, acting as a rich text content engine to manage complex text data and formatting. The project utilizes an immutable state management system to ensure consistent updates and predictable undo history. It manages editor state through persistent data structures, providing an immutable data state manager to prevent accidental mutation. The framework includes capabilities for high perform

Flix is a statically typed multi-paradigm programming language that combines functional, imperative, and logic programming paradigms within a single unified environment. It utilizes a constraint-driven execution environment to derive results by satisfying logical predicates rather than following linear sequential instructions. The language features a unification-based logic engine designed to solve complex computational problems through term unification and backtracking. This is supported by a core library of persistent immutable data structures that ensure side-effect free state management a

This is a JavaScript immutable data library used to create objects and arrays that prevent direct mutation. It serves as an immutable state manager and object wrapper designed to ensure data consistency by blocking modifications while remaining compatible with standard JavaScript syntax. The library functions as a converter that transforms standard mutable data into frozen structures and can convert them back for local modifications. This allows for a workflow where data is switched between immutable and mutable versions to perform bulk edits before locking the state again. The project provi

Underscore is a JavaScript utility library providing a suite of functional programming and data manipulation helpers. It serves as a framework for transforming data collections, composing functions, managing objects, and performing precise data type validation without modifying core language prototypes. The project includes a functional programming toolkit designed to control function execution timing and behavior through techniques such as debouncing, throttling, and partial application. It also provides a dedicated object manipulation utility for cloning, merging, picking, and omitting prop

Coconut is a functional programming language that compiles to Python. It functions as a source-to-source compiler, translating high-level functional syntax into compatible Python code to maintain runtime compatibility. The language introduces a logic system for pattern matching and destructuring complex data structures. It provides a mechanism for tail call optimization to prevent stack overflow errors during deep recursive function calls and employs a lazy evaluation engine to defer computations until results are explicitly required. The project includes support for algebraic data types, pi

Immer is an immutable state management library used to create new versions of data structures. It allows the production of new state by mutating a temporary draft instead of using manual object spreading. The project implements structural sharing to reuse unchanged parts of a data tree between versions, which reduces memory consumption. It also functions as a JSON patch generator to calculate and output the differences between two state versions. To ensure data integrity, the library includes a state mutation protector that freezes data structures to detect and prevent accidental modificatio

Toolz is a Python library that implements functional programming utilities for iterable transformation, dictionary manipulation, function composition, and lazy evaluation. It provides a set of pure functions designed to work with Python's built-in data structures, enabling concise and composable data processing workflows. What distinguishes toolz is its support for curried partial application, allowing functions to be incrementally applied and reused. It includes dictionary-centric operations that handle nested structures, and offers iterable chain transformers that combine mapping, filtering

Persistent/Immutable/Functional data structures for Python

RxJS is a library for reactive programming that provides a framework for composing asynchronous and event-based programs. It utilizes observable sequences to model data flows, allowing developers to manage complex sequences of events through a declarative programming interface. The library implements the observer pattern to facilitate decoupled communication between data producers and subscribers. By employing a lazy execution model, streams remain dormant until a consumer explicitly subscribes, at which point data production is triggered. This approach enables the construction of predictable

A complete, fully tested and documented data structure library written in pure JavaScript.

Fast & memory efficient hashtable based on robin hood hashing for C++11/14/17/20

ConcurrentQueue is a header-only C++ template library that provides a lock-free data structure for multi-producer multi-consumer thread communication. It functions as a synchronization primitive designed to coordinate data flow between concurrent execution units using atomic operations rather than traditional mutex locking. The library distinguishes itself through a design that minimizes contention and synchronization overhead. It utilizes sub-queue token mapping to distribute workloads across partitioned internal queues and supports bulk operations to transfer multiple data elements in singl

Sugar is a JavaScript utility library designed to extend native objects and prototypes with additional methods for data manipulation and transformation. It functions as a toolkit for object utilities, date manipulation, string inflection, and the polyfilling of missing or broken standard language features. The library provides the ability to map utility methods directly onto built-in prototypes or wrap values in temporary objects to enable method chaining without modifying global prototypes. It also includes a polyfill system to ensure consistent behavior across different execution environmen

C++ small containers

A family of header-only, very fast and memory-friendly hashmap and btree containers.