Immutable collections based on the SDK collections. Each SDK collection class is split into a new immutable collection class and a corresponding mutable builder class.

RxDart is an implementation of the popular ReactiveX api for asynchronous programming, leveraging the native Dart Streams api.

Functional Programming in Dart. Purify your Dart code using efficient immutable data structures, monads, lenses and other FP tools.

Give your types superpowers and spice up your generics. Make types great again.

Yet another variation of the good old Maybe monad with eager execution written in Dart.

Functional programming in Dart and Flutter. All the main functional programming types and patterns fully documented, tested, and with examples.

Reactive Extensions Library for Dart providing an API for asynchronous programming with observable streams.

Immutable lists, sets, maps, and multimaps, which are as fast as their native mutable counterparts. Extension methods and comparators for native Dart collections.

Annotations and helpers for lenses for code generated with the `function_data_generator` package.

Result for dart. It is an implementation based on Kotlin Result and Swift Result.

Multiple results for dart. Inspired by dartz's Either and Kotlin's sealed classes

Simple union types using extension types. Types: the union of `int` and `String` is `Union2<int, String>`. Values: `42.u21` is `42` with type `Union2<int, Never>`.

Build composable, reusable and type-safe lenses for Dart.

Either monad for Dart language and Flutter framework. Type-safe error handling, railway oriented programming. Supports Monad comprehensions, async map, async flatMap.

The power of lazy-evaluated enumerables in your hands! (A port of functional LINQ from the .NET library.)

Cached lazy variables that can be marked for re-initialization and memoized single and double argument functions.

Supercharged brings all the comfort features from languages like Kotlin to all Dart developers.

Forus Labs' standard library extension. Utilities for date-times, timezones, collections, monads & more.

Definitions of Rust-like types, Option and Result, to promote safer programming.

A Generic Double Linked List data structure. Allows constant time inserting at elements at both ends, before and after any element and constant time element deletion.

Class definitions for pseudo-lists that simplify working with structures commonly encountered in combinatorics such as permutations, combinations and subsets.

This project is a port of kotlin-stdlib for Dart/Flutter projects. It includes collections (KtList, KtMap, KtSet) with 150+ methods as well as other useful packages.

Result Type for Dart.

Kotlin-inspired scope functions implemented in Dart with the goal of executing a block of code within the context of an object

The Results Dart package provides a simple and type-safe way to handle results in your Dart and Flutter applications. It allows you to represent the outcome of an operation as either an error or a success and provides convenient methods for working with these results.

Functional batteries for Dart. Implementation of Either, Optional etc.

Supercharge Dart & Flutter with C++ STL architecture. Unlock zero-cost primitives, associative collections, memory views, and C++23 ranges.

A package inspired by functional programming, designed to enhance the structure, safety, and debuggability of mission-critical code.

Annotations for the df_safer_dart_lints package.

A Dart implementation of the Result Monad which allows for more expressive result generation and processing without using exceptions.

Dart implementation of Conflict-free Replicated Data Types (CRDTs).

A set of useful extension methods for Dart collections, designed for the purpose of making it easier to write functional-programming-styled, concise Dart code.

Functional programming essentials for Dart. Tail call optimization, partial application, memoization, and more.

Useful extensions on Result class of async package.

The simple library for Error Handling with functionnal programming concept

Result class that stops errors from throwing by returning either a value or an error

Idiomatic error handling capabilities to make your code safer, more maintainable, and errors easier to debug. Dart implementation of Rust's Result monad type and "anyhow" crate.

Provides matchers to help unit-testing your apps when using functional programming types defined in the dartz package.

A command pattern implementation for Dart and Flutter using result_dart package.

Dart implementation of Conflict-free Replicated Data Types (CRDTs) using Sqlite

An explicit acyclic step dependency framework with concurrent evaluation and dependency injection.

Parser combinator library for Dart with left recursion, stack-safe trampolining, typed errors, lazy error construction, and sealed ADT design.

A core Dart utility package providing extensions, validation utilities, and functional programming constructs for consistent development.

Railway-Oriented Programming for Dart. Build composable service objects that return Result values — never throw — using Success, Failure, and andThen.

A pure Dart implementation of Rust patterns. Types include Result, Option, Cell, Slice, Array, Iterator, Channels, Mutex, Path, etc.

A lightweight Dart library for Rust-like Option/Result types. Supports exhaustive pattern matching and provides helpers for None()/Err() propagation

Packrat parser combinators that support static typing, generics, file spans, memoization, and more.

A lightweight Result type for Dart with functional helpers, async support, and zero dependencies.

Functional programming (FP) kernel. Provides common FP datatypes like Option, Either, State, Validated, as well as collection hierarchy inspired by the Scala programming language.

A functional programming library for Dart and Flutter providing type-safe error handling with Either type, functional composition, and async support.

The Result that allows to specify a list of expected errors.

A pure Dart implementation of Rust patterns. Types include Result, Option, Cell, Slice, Array, Iterator, etc. Facilitates functional programming and error handling.

A bedrock package providing the blueprints and abstract definitions necessary to build a scalable and maintainable Dart/Flutter application.

Functional effect system with IO monad, safe concurrent state (Ref), and resource management and pure synchronziation primitive (Deferred).

Some / Maybe / Option / Result / Nullable, like Haskel Maybe, Can avoid semantic confusion caused by returning null when returning a value

A pure-Dart use case result wrapper that funnels thrown errors into typed success/failure values. Zero dependencies.

A library implementing functional zippers following Huet's paper.

HTTP-client agnostic error handling for Dart/Flutter — Either pattern, typed Failures, and a pluggable mapper chain.

A simple, fluent discriminated union of an error or a result. Inspired by ErrorOr for .net by Amantiband

A lightweight toolkit for functional-style types like Either, built for clarity and real-world use.

A performant and flexible reactive programming framework for Dart

Extension methods for Strings and lists, inspired by Haskell

Return a result ErrorOr with either a value T or an error Object.

Implementation of the Result object which allows to handle errors easily using sealed classes.

Result and Option for Dart, with addition of FutureResult and do-notation. Inspired by fp_dart, dartz, and neverthrow for TypeScript.

A Dart package for working with algebraic data types (ADTs) representing "any-of" values with multiple options.

Multi type supported platform selector to write functional programming.

Typesafe error-handling for dart . An implementation of rust's `Result` type in dart.

Rust-style Result type for type-safe error handling with pattern matching

Carefully crafted monads, such as Result and Option for exhaustive pattern matching in Dart.

Functional Dart provides tools for writing functional code in Dart, emphasizing immutability, function composition, type safety, and avoiding the `dynamic` type.

A versatile Dart algorithms library providing implementations of various algorithms..

Commonly used standalone data structures, types and extensions that simplify application logic development.

The Result<T> type implemented in Ok<T> and Err<T> types with unwrap methods.

Trve immutable wrapper classes for the Dart collections List, Set and Map.

A Dart library for Rust-like Option/Result types, providing a structured approach to error handling.

Code generator for functional enum that makes the use of enums much better.

A result monad with two subtypes representing a success or a failure

a lightweight dart micro-package to help you handle functions results

A simple posibility to return a Result with eiter success or failure.

This package brings a Kotlin-like Result<T> to Dart, using extension types for zero-cost wrapping.

A Dart implementation similar to Kotlin scope functions, enable you for powerful chained programming style.

A trie data structure Dart implementation — useful for autocomplete.

Helper classes that returns a Result or Errors objects to reduce amount of exception throwing.

Computable reals, or constructive real numbers in Dart. Approximates real numbers to arbitrary precision.

Efficient, immutable and stack safe implementation of a Trie data structure in dart: autocomplete, text search, spell checking, strings and prefixes.

Provides a Result type (Result<T>) for robust error handling, encapsulating either a success value or an error. Includes helpers for safe execution and chaining.

Sealed Unions for Dart

A minimal, lawful Dart functional toolkit for composing synchronous and asynchronous workflows using continuation-passing style (CPS).

An asynchronous Responsibility Chain design pattern implementation with functional and object-oriented approaches to implementing handlers of responsibility.

A persistent treap for Dart. A heap balanced randomized binary tree with efficient value semantics.