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.

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

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

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

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

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

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

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

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.

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.

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.

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

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

Annotations for the df_safer_dart_lints package.

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

Result Type for Dart.

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

Useful extensions on Result class of async package.

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.

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

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

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.

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

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

The simple library for Error Handling with functionnal programming concept

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

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

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.

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

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

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

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

Parser combinators for Dart with left recursion, stack-safe trampolining, typed errors, and lossless green/red syntax trees with resilient parsing and incremental reparse.

Flutter Result is a lightweight and easy-to-use package that provides a custom Result type for handling the outcome of a method call in Flutter.

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

A collection of functions and monads for functional programming in dart.

Generic immutable undo/redo ring for Dart. Type-safe CommandHistory<S> with Command<S> — maxSize cap, undo/redo labels, value equality, no Flutter dependency.

A lightweight Dart utility package offering common abstractions and missing features to write safer, more expressive code.

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

A lightweight, zero-dependency functional error handling package for Dart 3. Built with sealed classes and pattern matching.

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

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

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

A lightweight, idiomatic Dart result type. Built on Dart 3 with zero dependencies. Features Trace<T,E>, Ok, Err, split, map, mapError and bind.

Multi type supported platform selector to write functional programming.

A library implementing functional zippers following Huet's paper.

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

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

Extension methods for Strings and lists, inspired by Haskell

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

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

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

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 result monad with two subtypes representing a success or a failure

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

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

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

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

A performant and flexible reactive programming framework for Dart

The generator for algebraic data types.

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

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

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

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

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

A Flutter package for simplified error handling and result type management using functional programming patterns.

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

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

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

Dart macros for algebraic types

Convenience facade re-exporting gmana_functional, gmana_predicates, gmana_validation, gmana_utils, and gmana_extensions.

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

A Dart package providing an immutable data structure for managing unique ID pairs by type, with features for filtering, serialization, and validation.

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

Functional result and option monads supporting the AppleTheia Flutter DDD toolkit.

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

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

A simple Dart package that provides immutable equatable's with the option to store the hashes.

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

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

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

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

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

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

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

A trie data structure Dart implementation — useful for autocomplete.

A lightweight Result type for modeling success/failure in Flutter and Dart using sealed classes.

This package is a simple approach to return multiple values, inspired on dartz package.

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

Annotations and helper stuff for algebraic data types that allows you to create immutable data classes and discriminated unions, that compare as value types.

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.

A dart implementation of Rusts Result type to make errors visible and make error handling easy

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

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

A small utility for representing values with two possible outcomes, commonly failure or success.

Encapsulate a value as a success or an error as a failure using Result, execute a function using runCatching that returns a Result, and transform the Stream value into a Result.

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

Sealed Unions for Dart

Provide methods to handle Result mapping and chaining with asynchronous operations.

nullx_either is a collection of elegant extensions for handling null types on dartz either types.