Skip to content
CAI
Software that uses CAICheck a score

louthy/language-ext

43.0

Weak · 23 October 2026

169.6k

lines of production code

C#

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

LanguageExt is a functional programming library for .NET that provides a comprehensive suite of immutable data structures, monadic types, and concurrency primitives. It enables developers to write pure, composable code through features like the IO and Eff effect systems, Software Transactional Memory, and a rich set of monad transformers for state, error handling, and streaming. The system also includes utilities for parsing, reactive extensions, and type-safe physical units, all designed to integrate seamlessly with modern C\# and F\# ecosystems.

How it got here

2014–2021 — Core library expansion and concurrency primitives

81 changes.

This period focused on significantly expanding the LanguageExt core library with new data structures, parser combinators, and functional utilities. It introduced a comprehensive Software Transactional Memory (STM) system and lock-free concurrency primitives like Atoms and VectorClocks. The work also established robust testing coverage and added interoperability features for F\# and Blazor.

2022–2024 — Effects subsystem and monadic expansion

60 changes.

This period focused on establishing a comprehensive Effects subsystem, introducing the Eff and IO monads with robust concurrency, resource management, and scheduling capabilities. It simultaneously expanded the library's core by adding numerous monad transformers (Reader, State, Writer, RWST, Free, Trampoline) and new collection types like Iterator and TrackingHashMap to support advanced functional programming patterns.

2025 — Streaming library and monadic operator expansion

67 changes.

This period focused on introducing the LanguageExt.Streaming library, which provides a comprehensive, channel-based model for asynchronous data pipelines with configurable buffering and transducer support. Concurrently, the core library expanded its functional capabilities by adding new monads like These and ChronicleT, while significantly enhancing existing types with extensive operator overloads and higher-kinded type class derivations.

Features

Add bigint wrapper around System.Numerics.BigInteger

A new \bigint\ readonly struct has been added to the \LanguageExt\ namespace, providing a convenient wrapper around \System.Numerics.BigInteger\. This type implements \IComparable\, \IComparable\<bigint\>\, \IEquatable\<bigint\>\, and \Monoid\<bigint\>\, and includes constructors for various numeric types (int, long, decimal, double, float, byte arrays) as well as static properties for \Zero\, \One\, and \MinusOne\. This allows users to work with arbitrarily large integers using LanguageExt's functional patterns.

LanguageExt.Core/DataTypes/BigInt · high confidence

Added Either Prelude constructors and applicative operators

The library now exposes dedicated Prelude methods for constructing and operating on the Either monad. Users can create Either instances using the new \Right\ and \Left\ static methods, which also provide implicit casting to \Pure\ and \Fail\ types respectively. Additionally, functional operators including \map\, \action\, and \apply\ are now available in the Prelude, enabling standard functor and applicative patterns on Either values.

LanguageExt.Core/Monads/Alternative Monads/Either/Prelude · high confidence

Added HashMapPatch type to expose map change details

A new \HashMapPatch\ class has been introduced in the \LanguageExt\ namespace to represent changes to a Hash-Map. This type provides \From\ and \To\ properties to access the previous and current map states, as well as a \Changes\ property that exposes the specific key-value modifications. It is designed to support change events on \AtomHashMap\ types and the \Changes\ property of \TrackingHashMap\, allowing users to inspect detailed diffs of map updates.

LanguageExt.Core/DataTypes/MapPatch · high confidence

Added Ord instances for primitive types, collections, and LanguageExt data structures

This change introduces a comprehensive set of ordering (Ord) class instances for the LanguageExt library, enabling consistent comparison and sorting capabilities across a wide range of types. The diff adds new files in the Ord directory implementing equality and ordering for primitive types (int, long, short, float, double, decimal, bool, char, Guid, DateTime, bigint), standard .NET collections (arrays, IEnumerable, HashSet), and LanguageExt's own functional data structures (Lst, Seq, Set, Map, Que, Stck, Option, Either). It also includes specific instances for string comparison (including ordinal ignore-case) and a generic OrdDefault that delegates to .NET's Comparer, providing a unified way to order values throughout the library.

LanguageExt.Core/Class Instances/Ord · high confidence

Added Prelude helpers for Pure and Fail monads

The Prelude now includes static factory methods Pure and Fail, allowing users to easily construct pure and failure monad instances that integrate with bind operators for Option, Eff, Either, Fin, IO, and Validation. Additionally, a Lower extractor is provided to simplify value extraction from these monadic types.

LanguageExt.Core/Monads · high confidence

Added Pretty/Doc system for structured text layout

A new Pretty/Doc system has been added to LanguageExt.Core, providing a Haskell-inspired framework for building and laying out structured text documents. This includes core document types (Doc, DocAnn) with operations for concatenation, nesting, alignment, and conditional line breaks (Group, FlatAlt, HardLine, SoftLine), as well as a layout engine (Layout) that respects configurable page widths and ribbon fractions to produce formatted output.

LanguageExt.Core/Pretty · high confidence

Added VersionHashMap with vector-clock conflict resolution

A new thread-safe, mutable VersionHashMap collection has been introduced to support distributed data structures. It attaches vector clocks to values to track causality across multiple actors, enabling automatic conflict resolution when concurrent updates collide. The API provides atomic swap and update operations, allows for soft-deletion of items (which can be cleaned up later), and exposes keys and values for iteration.

LanguageExt.Core/Concurrency/VersionHashMap · high confidence

Added \`fun\` helper for Func type inference

The \Prelude\ class now includes a \fun\ helper method with overloads for \Func\ types with up to 10 arguments. This allows users to assign lambda expressions to variables without explicitly specifying the generic type parameters, letting the compiler infer the types automatically (e.g., \var add = fun((int x, int y) =\> x + y);\).

LanguageExt.Core/Prelude/Lambda function inference · high confidence

Added extension methods for Iterator and IteratorAsync

New extension methods have been added to the Iterator and IteratorAsync types to improve interoperability with standard .NET collections. Users can now convert any IEnumerable into an Iterator using the new GetIterator method, and similarly convert IAsyncEnumerable into an IteratorAsync using GetIteratorAsync. Additionally, a downcast operator (As) is now available for both types to facilitate casting from the generic K interface.

LanguageExt.Core/Immutable Collections/Iterator/Extensions, LanguageExt.Core/Immutable Collections/IteratorAsync/Extensions · high confidence

Added hash-code calculation functions for collections

The Prelude now includes a set of \hash\ overloads for various collection types (such as \Arr\, \HashMap\, \HashSet\, \Lst\, \Map\, \Que\, \Seq\, \Set\, and \Stck\) and \IEnumerable\. These functions provide a consistent way to calculate hash codes for collections, leveraging the underlying \GetHashCode\ method or specific hashable instances, which is useful for scenarios like using collections as keys in hash-based structures or for debugging.

LanguageExt.Core/Prelude/Hash code functions · high confidence

Added initial Continuation Monad Transformer (ContT)

Added the \ContT\ monad transformer to the \LanguageExt.ContT\ namespace, providing \Pure\, \Map\, \Bind\, and \Run\ operations for handling continuations over any applicative type constructor \M\. This introduces a new capability for composing continuation-based logic, though the implementation is currently marked as work-in-progress and not yet ready for production use.

LanguageExt.Core/Monads/ContT · high confidence

Adds applicative and functor operators to Validation and ValidationT monads

This change introduces new prelude functions and extension methods for the \Validation\ and \ValidationT\ monads, enabling applicative-style composition. Users can now use \map\, \apply\, and \action\ operators to transform and combine validation results while accumulating errors (via the \Semigroup\/\Monoid\ constraint on the error type \F\). For \ValidationT\, additional extensions provide \Map\, \Apply\, \Action\, \SelectMany\, and conversion helpers like \ToOption\ and \ToEither\, allowing these monad transformers to integrate more seamlessly with other functional patterns.

LanguageExt.Core/Monads/Alternative Monads/Validation/Prelude, LanguageExt.Core/Monads/Alternative Monads/ValidationT/Extensions, LanguageExt.Core/Monads/Alternative Monads/ValidationT/Prelude · high confidence

Async iterator implementation and Identity extension methods

This change introduces the internal implementation for \IteratorAsync\, a thread-safe, immutable async sequence type, including concrete cases for \Cons\ (head/tail), \Nil\ (empty), and lazy evaluation, along with a \Split\ method to break linked-list chains for garbage collection. It also adds \As()\ and \Run()\ extension methods to the \Identity\ monad to facilitate conversion and value extraction.

LanguageExt.Core/Immutable Collections/IteratorAsync/DSL, LanguageExt.Core/Monads/Identity/Extensions · high confidence

Async iterator trait implementation with memoization support

The IteratorAsync type now implements core Monad, Functor, and Applicative traits, enabling functional composition of asynchronous iterators. This includes standard Bind and Map operations, as well as specialized Apply methods that support both standard iterators and memoized iterators, allowing for efficient reuse of computed values during asynchronous enumeration.

LanguageExt.Core/Immutable Collections/IteratorAsync/Trait · high confidence

AtomHashMap now exposes change events for state modifications

The AtomHashMap concurrency primitive now notifies subscribers when its underlying data is modified. A new \Change\ event (typed as \AtomHashMapChangeEvent\) is exposed on the class, firing with a \HashMapPatch\ that details the additions, removals, and updates resulting from atomic operations like \Swap\ and \SwapKey\. This allows consumers to react to state changes in real-time without polling, supporting lock-free, event-driven architectures.

LanguageExt.Core/Concurrency/AtomHashMap · high confidence

BiMap now supports bulk operations and range-based updates

The BiMap collection now includes methods for adding, updating, or removing multiple items at once via \AddRange\, \TryAddRange\, and \AddOrUpdateRange\. These methods accept tuples, \Tuple\<A, B\>\, or \KeyValuePair\<A, B\>\ inputs, allowing users to efficiently modify both the forward and reverse mappings in a single atomic operation without manual iteration.

LanguageExt.Core/Immutable Collections/BiMap · high confidence

ChronicleT operator overloads for functional composition

The ChronicleT monad transformer now supports a comprehensive set of operator overloads to enable more idiatic functional composition. Users can now use \\*\ for functor mapping and applicative application, \\>\>\ for monadic binding and sequencing, \\|\ for choice and error handling, \+\ for semigroup combining, and \\>\>\>\ for applicative sequencing. These operators are implemented across dedicated extension files (Functor, Applicative, Monad, Choice, SemigroupK, etc.) and allow chaining operations directly on \K\<ChronicleT\<Ch, M\>, A\>\ instances without explicit method calls.

LanguageExt.Core/Monads/Alternative Monads/ChronicleT/Operators · high confidence

Comprehensive functional extensions for C\# ValueTuples

This update adds a complete set of functional programming extensions to C\# ValueTuples (1 through 7 elements), bringing them to feature parity with the library's reference Tuple types. Users can now use Prelude functions and extension methods for mapping, iterating, and folding over tuple elements, including specific operations like \biMap\/\triMap\ for transforming multiple items, \sum\/\product\ for numeric tuples, and \head\/\tail\ for structural manipulation. Additionally, two-element tuples now support \Traverse\ and \Sequence\ operations, allowing users to transform and aggregate collections of tuples wrapped in monads like \Arr\ and \Either\.

LanguageExt.Core/DataTypes/ValueTuple · high confidence

Expanded equality comparison support for collections, primitives, and string variants

The library now provides comprehensive equality (Eq) and hash-code implementations for a wide range of types, enabling consistent structural comparison across the codebase. This includes support for primitive types (int, long, short, float, double, decimal, bool, char, Guid, DateTime, bigint), LanguageExt collection types (Seq, Lst, Arr, Array, Set, HashSet, Map, Que, Stck, Iterable, Enumerable), and functional types (Option, Either, Identity, Edit, Patch, Compositions, Record). Additionally, string equality has been extended with multiple comparison modes, including invariant culture, current culture, ordinal, and their case-insensitive variants, allowing users to choose the appropriate comparison semantics for their needs.

LanguageExt.Core/Class Instances/Eq · high confidence

Fin monad gains operator overloads for functional composition

The Fin monad now supports a comprehensive set of operator overloads (such as \\*\, \+\, \\|\, \\>\>\, and \\>\>\>\) across its \K\<Fin, A\>\ wrapper and direct \Fin\<A\>\ types. These additions enable more idiatic functional programming patterns, including functor mapping, applicative application, monadic binding, semigroup combining, and choice/fallback operations, allowing users to write more concise and readable code when working with finite computations.

LanguageExt.Core/Monads/Alternative Monads/Fin/Operators · high confidence

FinT monad operator overloads and extension methods

This change introduces a comprehensive set of operator overloads and extension methods for the FinT monad within the LanguageExt library. It adds support for standard functional programming operators, including functor mapping (\), applicative application (\), monadic binding (\>\>), sequencing (\>\>\>), choice (\|), and semigroup combining (+). Additionally, it provides utility extensions for partitioning FinT sequences into success and failure collections, binding with Guard conditions, and executing finally blocks, thereby enabling more idiomatic and concise usage of the FinT monad in C\# code.

LanguageExt.Core/Monads/Alternative Monads/FinT/Operators · high confidence

FinT monad trait implementation added

The \FinT\ monad trait implementation (\FinT.TraitImpl.cs\) has been added to the \LanguageExt.Core\ library. This file provides the concrete implementations for the \FinT\ monad transformer, enabling it to function as a Monad, Applicative, Functor, MonoidK, Alternative, and Choice. It also includes natural transformations to convert \FinT\ into \EitherT\, \OptionT\, and \TryT\, as well as support for \MonadIO\ lifting and fallible error handling.

LanguageExt.Core/Monads/Alternative Monads/FinT/Trait · high confidence

Hashable class instances for LanguageExt types and primitives

The Hashable class instances directory now contains implementations for hashing LanguageExt collection types (such as Arr, Lst, Seq, Map, Set, Que, Stck, HashSet, and Enumerable), functional types (Option, Either, Identity, Edit, Patch), and primitive types (int, long, short, float, double, decimal, bool, char, string, DateTime, Guid, bigint, Exception, Task, TypeInfo, and records). String hashing includes variants for invariant culture, ordinal, and current culture comparisons, with case-insensitive options. These instances enable consistent hash code generation for LanguageExt types, supporting their use in hash-based collections and operations.

LanguageExt.Core/Class Instances/Hashable · high confidence

IdentityT monad transformer adds IO support and sequencing operators

The IdentityT monad transformer now implements MonadIO and MonadUnliftIO, allowing users to lift IO actions directly into the transformer stack and unlift the context for nested IO operations. Additionally, the type introduces a right-sequencing operator (\>\>) for composing actions while discarding intermediate results, and provides extension methods to easily unwrap the underlying monad value.

LanguageExt.Core/Monads/IdentityT · high confidence

Immutable Collections module introduces Cons overloads and Sort extensions

The new LanguageExt.Core/Immutable Collections module adds a suite of high-performance immutable collection utilities. It introduces multiple overloads for the \Cons\ extension method, allowing users to prepend elements to \Seq\, \Iterable\, \Iterator\, \IteratorAsync\, and \Lst\ types, including support for async tails and function-based tail generation. Additionally, it provides \Sort\ extension methods for \IEnumerable\, \Seq\, \Lst\, \Arr\, and arrays, leveraging the \Ord\ trait for type-safe ordering.

LanguageExt.Core/Immutable Collections · high confidence

Immutable Queue collection added

An immutable queue data structure (\Que\<A\>\) is now available, providing FIFO semantics with efficient enqueue and dequeue operations. The implementation uses two internal stacks to ensure amortized O(1) performance for core operations. The collection supports standard functional operations such as mapping, filtering, folding, and pattern matching via the \Case\ property, and includes both instance methods and static module functions for convenient usage.

LanguageExt.Core/Immutable Collections/Queue · high confidence

Immutable Set now supports Functor, Applicative, and Monad operations

The \Set\ collection now implements the \Monad\, \Functor\, \Applicative\, and \Traversable\ traits, enabling functional programming patterns such as \Map\, \Apply\, and \Bind\ directly on sets. This allows you to transform set contents, combine multiple sets using applicative styles, and chain monadic operations seamlessly. The implementation leverages an AVL tree structure for efficient self-balancing and includes optimized traversal methods for these new capabilities.

LanguageExt.Core/Immutable Collections/Set · high confidence

Immutable TrackingHashMap with change tracking and snapshot support

The \TrackingHashMap\ immutable collection now exposes a \Changes\ property that records morphisms (additions, updates, removals) between states, allowing users to inspect what has changed since the last \Snapshot()\ call. The collection also implements \Monoid\ for combining maps and provides LINQ-style extension methods (such as \ToTrackingHashMap\, \Find\, and \AddOrUpdate\) to facilitate creation and manipulation of nested or multi-key structures.

LanguageExt.Core/Immutable Collections/TrackingHashMap · high confidence

Implement Alternative Monad traits for Try, OptionT, and TryT

The \Try\, \OptionT\, and \TryT\ monads now implement the \Alternative\ trait, enabling users to use the \Choose\ operator for fallback logic (selecting the first successful result) and the \Empty\ operator to create empty instances. This change also adds trait implementations for \Fallible\ (standardizing error handling and catching) and \MonadIO\ (allowing direct lifting of IO operations), while ensuring tail-recursive recursion is supported via the \Recur\ method.

LanguageExt.Core/Monads/Alternative Monads/OptionT/Trait, LanguageExt.Core/Monads/Alternative Monads/Try/Trait, LanguageExt.Core/Monads/Alternative Monads/TryT/Trait · high confidence

Implementation of Reader Monad traits

The Reader monad now implements the core functional programming traits (Monad, Functor, Applicative, and Readable). This enables users to utilize standard operations such as binding, mapping, pure value creation, and environment access (Ask/Asks/Local) directly on the Reader type, providing a consistent API for handling read-only environment contexts.

LanguageExt.Core/Monads/State and Environment Monads/Reader/Reader/Trait · high confidence

Initial implementation of ChronicleT trait interfaces

This change introduces the core trait implementations for the \ChronicleT\ monad transformer, adding \ChronicleT.TraitImpl.cs\ and \ChronicleT.TraitImpl.2.cs\. These files provide the concrete logic for \Monad\, \MonadIO\, \Fallible\, \Choice\, and \Chronicaler\ interfaces, enabling users to lift effects, handle errors via the \Fallible\ pattern, perform choice operations, and manage accumulated state (chronicles) through the \Chronicaler\ interface.

LanguageExt.Core/Monads/Alternative Monads/ChronicleT/Trait · high confidence

Initial implementation of Fin monad traits

The Fin monad now implements core functional programming traits including Monad, MonoidK, Fallible, Traversable, Alternative, and Natural transformations to Either, Option, Try, Eff, and IO. This enables users to treat Fin as a standard composable monad with support for binding, mapping, applicative operations, and conversion to other effect types.

LanguageExt.Core/Monads/Alternative Monads/Fin/Trait · high confidence

Initial implementation of the LanguageExt.Megaparsec parser combinator library

This change introduces the LanguageExt.Megaparsec library, providing a comprehensive set of parser combinators for building parsers in C\#. It includes core primitives for token matching (single, satisfy, tokens, takeWhile), text parsing utilities (string, ch, newline, character classes like upperChar/digitChar), and state management (getInput, setOffset, getSourcePos). The library also features robust error handling with detailed error types (ParseError, ErrorItem, ErrorFancy), hint systems for better error messages, and advanced control flow combinators such as try, lookAhead, notFollowedBy, withRecovery, and region.

LanguageExt.Megaparsec · high confidence

Initial repository setup with project structure and documentation

The repository is initialized with the core C\# solution file (language-ext.sln) defining the main projects (LanguageExt.Core, LanguageExt.Streaming, LanguageExt.Sys, etc.) and sample applications. It includes a comprehensive README detailing the library's functional programming features, immutable collections, and streaming capabilities, alongside a Performance.md document benchmarking these collections against .NET's ImmutableCollections. Standard open-source governance files (LICENSE, CODE\_OF\_CONDUCT, CONTRIBUTING) and developer tooling (an .editorconfig for C\# style guidelines, build/clean scripts) are also added to establish the project's baseline.

(repo-wide) · high confidence

Introduce Iterator\<A\> as a thread-safe, immutable sequence wrapper

Added a new \Iterator\<A\>\ type in \LanguageExt.Core\ that wraps .NET's \IEnumerator\ to provide a thread-safe, immutable, and lazily-evaluated sequence abstraction. This new collection type supports functional operations such as \Map\, \Bind\ (monadic bind), \SelectMany\, and \Apply\, and allows pattern matching via \Head\, \Tail\, and \IsEmpty\ properties. It includes factory methods like \from\, \singleton\, \Cons\, and \Nil\ for construction, and implements \IEnumerable\<A\>\, \IEquatable\<Iterator\<A\>\>\, and \IDisposable\ to integrate with existing LINQ and disposal patterns while preventing race conditions inherent in standard enumerators.

LanguageExt.Core/Immutable Collections/Iterator · high confidence

Introduce LanguageExt.Rx reactive extensions for functional types

This release adds the new LanguageExt.Rx package, providing Reactive Extensions (Rx) integration for the language-ext library. It introduces extension methods to convert functional types such as Option, Either, Validation, and Eff into IObservable streams, enabling seamless integration with reactive programming patterns. Additionally, it adds change-observation capabilities for state-managing monads, allowing developers to subscribe to updates from Atom, Ref, and AtomHashMap instances via OnChange and Latest operators.

LanguageExt.Rx · high confidence

Introduce Reader monad transformer

Adds the \Reader\<Env, A\>\ monad transformer to LanguageExt, enabling functions to access a static environment implicitly. This change introduces the core \Reader\ record type along with its module (providing \pure\, \ask\, \asks\, \asksM\, and \local\ functions) and extension methods (including \Run\ and \Flatten\), allowing users to compose computations that depend on a shared context without passing it explicitly through every function argument.

LanguageExt.Core/Monads/State and Environment Monads/Reader/Reader · high confidence

Introduce SinkT DSL with composable sink primitives

The SinkT module now provides a comprehensive DSL for constructing and combining sinks, including \SinkChoose\ for routing values based on Either results, \SinkCombine\ for splitting streams into multiple sinks, and \SinkContraMap\/\SinkContraMapT\ for transforming input types. New sink variants like \SinkEmpty\ and \SinkVoid\ allow for no-op or error-raising sinks, while \SinkWriter\ enables direct integration with System.Threading.Channels. The core SinkT type now implements CoFunctor, Divisible, and Decidable type classes, enabling advanced composition patterns such as dividing inputs across multiple sinks or discarding values entirely.

LanguageExt.Streaming/SinkT · high confidence

Introduce SourceT as a new monadic stream abstraction

A new \SourceT\<M, A\>\ type has been added to the LanguageExt Streaming library, providing a monadic stream abstraction that supports lifting values from \IEnumerable\, \System.Threading.Channels\, and existing \Source\ types. This new abstraction includes methods for folding, mapping, filtering, and combining streams, and is designed to work with the \MonadIO\ constraint to support asynchronous and effectful operations.

LanguageExt.Streaming/SourceT · high confidence

Introduce VersionVector for conflict-free versioned state

Added \VersionVector\ and \Version\ types to \LanguageExt.Core.Concurrency.VersionVector\ to manage versioned state with automatic conflict resolution. The \VersionVector\ record stores a value, timestamp, and vector clock, supporting operations to register writes and resolve concurrent updates by merging values and taking the maximum of vector clocks. The \Version\ record provides a simplified, less generic interface for working with individual versioned entries, handling states such as never existed, deleted, or having a value, and includes helper methods to map between the simplified view and the underlying vector clock logic.

LanguageExt.Core/Concurrency/VersionVector · high confidence

Introduce configurable buffering strategies for Conduit streams

The LanguageExt.Streaming library now includes a new \Buffer\<A\>\ abstraction that allows users to configure how values are stored within \Conduit\ and \ConduitT\ components. This change adds specific buffer implementations—\Unbounded\, \Single\, \New\, \Bounded\, and \Latest\—enabling control over backpressure and memory usage in open-stream pipelines. Users can now choose between storing all messages, limiting capacity, or keeping only the most recent value, which directly impacts how \Conduit\ handles data flow between its input and output transducers.

LanguageExt.Streaming · high confidence

Introduce the \`These\` alternative monad

Adds the \These\<A, B\>\ type, an alternative monad that represents a value being in one of three states: \This\ (containing an A), \That\ (containing a B), or \Both\ (containing both). This new capability allows users to model scenarios where two distinct outcomes or errors can occur simultaneously or exclusively, providing standard monadic operations like \Match\, \Map\, \BiMap\, and \Merge\ to handle each case.

LanguageExt.Core/Monads/Alternative Monads/These · high confidence

Introduces AtomQue for lock-free concurrent queues

Adds a new \AtomQue\<A\>\ type in the \LanguageExt\ namespace, providing a thread-safe, lock-free queue implementation that wraps the internal \Que\ structure. This new collection type supports atomic enqueue and dequeue operations, exposes \Dequeued\ and \Enqueued\ events for observing state changes, and implements the \Foldable\ trait to allow functional iteration patterns. An extension method \As\ is also provided to convert the trait key \K\<AtomQue, A\>\ into the concrete \AtomQue\<A\>\ type.

LanguageExt.Core/Concurrency/AtomQue · high confidence

Introduces Compositions data structure for efficient monoid delta composition

Adds a new \Compositions\<A\>\ type (a right-biased composition tree) that allows computing the combined state of a list of monoid elements in logarithmic time. This is particularly useful for scenarios like collaborative editors or version control systems where deltas need to be composed efficiently. The implementation includes optimized operations for \cons\, \take\, \skip\, \splitAt\, and \composed\, leveraging a tree structure to minimize the number of element combinations required.

LanguageExt.Core/DataTypes/Compositions · high confidence

Introduces IteratorAsync for thread-safe, lazy async enumeration

Adds a new \IteratorAsync\<A\>\ type that wraps .NET's \IAsyncEnumerator\ to provide a thread-safe, immutable, and lazily-evaluated async sequence. This allows users to consume asynchronous streams with functional operations like \Map\, \Bind\, and \SelectMany\ without the race conditions or mutability issues inherent in the standard BCL interfaces. The change includes the core implementation, module helper methods (such as \from\, \singleton\, and \Cons\), and documentation explaining the design.

LanguageExt.Core/Immutable Collections/IteratorAsync · high confidence

Introduces the Free monad for effectful computations

Adds a new Free monad implementation to the LanguageExt library, allowing any functor to be lifted into a monad for composing effectful operations. This includes the core \Free\<F, A\>\ type with \Pure\ and \Bind\ cases, standard monadic operators (map, bind, apply, action), and extension methods for functional programming patterns like currying and sequencing. Users can now model complex workflows as data structures and interpret them later, supporting tail-recursive execution and natural transformations.

LanguageExt.Core/Monads/Free · high confidence

Introduces the State monad with functional operators and trait implementations

Adds the \State\<S, A\>\ monad to LanguageExt, providing core state management operations (\Get\, \Put\, \Modify\, \Gets\) and a static module for convenient access. The implementation includes full \Monad\, \Functor\, and \Applicative\ trait support, along with a suite of extension operators for mapping (\\\), applying (\\\), sequencing (\\>\>\>\), and binding (\\>\>\), enabling functional composition of stateful computations.

LanguageExt.Core/Monads/State and Environment Monads/State/State · high confidence

Introduction of Atom for lock-free concurrent state management

The LanguageExt library now includes the \Atom\ type in the \LanguageExt.Core.Concurrency\ namespace, providing a way to manage shared, synchronous, independent state without using locks. Atoms use compare-and-swap (CAS) loops to atomically update immutable values, ensuring thread safety. The implementation includes \Atom\<A\>\ for simple state and \Atom\<M, A\>\ for state with metadata, both supporting validators to ensure state invariants. Key methods include \Swap\ for immediate updates, \SwapMaybe\ for conditional updates returning \Option\<A\>\, and \SwapIO\ variants for integration with the IO monad. A \Change\ event is raised on successful updates, allowing observers to react to state changes.

LanguageExt.Core/Concurrency/Atom · high confidence

Introduction of AtomSeq for lock-free concurrent sequences

A new \AtomSeq\<A\>\ class has been added to the \LanguageExt.Core.Concurrency\ namespace, providing a thread-safe, lock-free sequence implementation. It wraps the existing \Seq\ type and uses atomic compare-and-swap operations to ensure that all modifications (such as \Add\ and \Swap\) are performed atomically without resorting to traditional locking mechanisms. The class implements \IEnumerable\<A\>\ and provides methods for atomic state transitions, enabling safe concurrent access to sequence data.

LanguageExt.Core/Concurrency/AtomSeq · high confidence

Introduction of Effects subsystem with MinRT and Prelude utilities

A new Effects subsystem has been added to the core library, introducing a minimal runtime struct (MinRT) and a comprehensive set of Prelude extension methods for managing IO-based side-effects. This includes utilities for tail-call optimization, synchronization context posting, and thread-pool queuing, alongside advanced concurrency controls such as uninterruptible blocks, local cancellation environments, and fork/await operations with optional timeouts. The addition also provides robust operators for awaiting multiple operations concurrently, including 'awaitAll' for collecting all results and 'awaitAny' for returning on the first success while cancelling remaining tasks.

LanguageExt.Core/Effects · high confidence

Introduction of FinT monad transformer

The \FinT\ monad transformer has been added to the library, allowing the \Fin\ result type (carrying either a success value or an error) to be layered over any underlying monad \M\. This new component provides standard monadic operations including \Match\ for pattern matching on success/failure states, \Map\ and \MapFail\ for transforming values and errors, and \Bind\ for chaining computations. It also includes utility methods like \IfFail\ and \IfSucc\ for conditional execution, and \lift\/\liftIO\ functions to lift pure values, failures, and IO operations into the transformer context.

LanguageExt.Core/Monads/Alternative Monads/FinT · high confidence

Introduction of LanguageExt.Prelude static utility functions

The LanguageExt library now exposes a \Prelude\ static class containing core functional programming utilities, allowing users to import them via \using static LanguageExt.Prelude;\. This addition provides static alternatives to fluent methods for common operations, including identity and constant functions, exception raising helpers (\failwith\, \raiseapp\, \raise\), predicate negation (\not\), and null/default checks (\isDefault\, \notDefault\, \isnull\).

LanguageExt.Core/Prelude · high confidence

Introduction of Lens and Prism optics for immutable data access and updates

This change introduces the core Lens and Prism types to the library, enabling users to access and update nested values within immutable structures without mutation. The Lens implementation provides a \readonly struct\ with \Get\ and \SetF\ functions, along with static helper methods in \Lens.cs\ for composing lenses over tuples (renamed from 'pair' and 'triple'), conditionals, and enumerables. The \Prelude.Lens.cs\ file adds sequential composition operators for chaining up to ten lenses. Additionally, the Prism type is introduced to handle optional values, allowing lenses to be converted into prisms via implicit conversions or explicit \ToPrism\ methods, which is particularly useful for manipulating \Option\<A\>\ fields. These components are defined in \LanguageExt.Core/Lens\ and \LanguageExt.Core/Prism\.

LanguageExt.Core/Lens · high confidence

Introduction of Live IO Runtime with System.Diagnostics.Activity support

A new live runtime implementation has been added to the LanguageExt.Sys library, providing a concrete execution environment for Eff effects. This runtime integrates support for System.Diagnostics.Activity, allowing users to manage distributed tracing contexts within their applications. It also exposes standard I/O capabilities including console, file, text reading, time, environment variables, directory, and encoding operations, all accessible through a unified interface that supports local context modification for activity environments.

LanguageExt.Sys/Live · high confidence

Introduction of Ratio\<A\> readonly struct

A new \Ratio\<A\>\ readonly struct has been added to the \LanguageExt\ namespace, providing a simple container for a numerator and denominator of generic type \A\. This type is intended for use in the definition of \Fractional\ and exposes its fields as public readonly members initialized via a constructor.

LanguageExt.Core/DataTypes/Ratio · high confidence

Introduction of Software Transactional Memory (STM) with Ref and Isolation levels

This change introduces a new Software Transactional Memory (STM) system to the library, providing \Ref\<A\>\ for safe, transactional mutable state and an \Isolation\ enum supporting \Snapshot\ and \Serialisable\ transaction isolation levels. The \Ref\ class allows values to be read and written only within transactions, supports change events via \AtomChangedEvent\, and includes atomic operations like \Swap\ and \Commute\ (which returns a \CommuteRef\ proxy for commutative updates). The core \STM\ engine uses Multi-Version Concurrency Control (MVCC) to manage state, automatically retrying transactions on conflict and notifying listeners of committed changes.

LanguageExt.Core/Concurrency/STM · high confidence

Introduction of StringM domain type with configurable string comparison traits

Added the StringM type and its associated trait interfaces (OrdString, HashableString, EqString) and concrete implementations (StringOrdinalM, StringCultureM, StringInvariantM, etc.) to the LanguageExt.Core library. This introduces a new domain type wrapper around strings that supports various string comparison modes (ordinal, culture-sensitive, invariant, case-sensitive, case-insensitive) via static traits, allowing users to enforce specific comparison semantics at the type level for equality, ordering, and hashing operations.

LanguageExt.Core/DataTypes/StringM · high confidence

Introduction of TrieMap internal implementation for HashMap

The internal TrieMap class, which implements the CHAMP trie hash map data structure, has been added to the LanguageExt library. This component serves as the underlying engine for the public HashMap collection, providing core functionality for immutable key-value storage including operations like Add, TryAdd, and AddOrUpdate. This change represents a structural addition to the immutable collections subsystem rather than a modification of existing public API behavior.

LanguageExt.Core/Immutable Collections/TrieMap · high confidence

Introduction of TrieSet as the internal implementation for HashSet

The TrieSet class has been added to the LanguageExt.Core library to serve as the underlying data structure for HashSet. This implementation utilizes a CHAMP (Compressed Hash Array Map Trie) algorithm to provide immutable set operations, including Add, TryAdd, AddOrUpdate, and their range-based counterparts. By exposing this internal component, the library ensures efficient, allocation-aware set management for users relying on LanguageExt.HashSet.

LanguageExt.Core/Immutable Collections/TrieSet · high confidence

Introduction of core functional primitives and error-handling infrastructure

This release adds foundational components to the LanguageExt.Core library, including a new \CatchM\ record struct and extension methods to support the \@catch\ syntax for error handling, and a \Guard\ struct to enable contextual validation within LINQ-style queries. It also introduces a comprehensive set of Lambda Calculus combinators (such as I, K, S, Y) in both dynamic and typed variants, a \Number\<A\>\ trait implementation for modern .NET numeric types, and a \Void\ type to represent uninhabited types in the pipes system. Additionally, it provides a new README file to guide users through the library's structure, including the Prelude, Traits, and Monads.

LanguageExt.Core · high confidence

Introduction of non-empty lazy sequence type IterableNE

A new immutable, non-empty lazy sequence type, IterableNE, has been added to the LanguageExt core library. This type guarantees at least one element (Head) and provides efficient, lazy evaluation for sequences, addressing performance issues with standard LINQ operators like Skip and Count. The implementation includes a dedicated module with factory methods (create, createRange, generate, repeat) and core operations (Map, Bind, Iter) that support both synchronous and asynchronous data sources via IO wrappers.

LanguageExt.Core/Immutable Collections/IterableNE · high confidence

Introduction of the 'Eff no runtime' Eff monad implementation

A new implementation of the Eff monad has been added in the 'Eff no runtime' directory, providing a version that operates without an explicit runtime instance. This new structure introduces \Eff.Module.cs\ with static factory methods like \Success\, \Fail\, and various \lift\ overloads for pure values, IO, and async tasks, alongside \Eff.Monad.cs\ which implements core monadic interfaces such as \MonadUnliftIO\, \Alternative\, and \Fallible\. The core \Eff.cs\ file defines the \Eff\<A\>\ record type, enabling users to encapsulate side effects and handle errors through a unified API that supports mapping, lifting, and composition without requiring a runtime context.

LanguageExt.Core/Effects/Eff/Eff no runtime · high confidence

Introduction of the Iterable abstraction for unified synchronous and asynchronous sequence handling

The library introduces a new \Iterable\<A\>\ type that unifies synchronous \IEnumerable\<A\>\ and asynchronous \IAsyncEnumerable\<A\>\ sequences under a single interface. This change provides a consistent set of functional operations—including \Map\, \Filter\, \FoldWhileIO\, \FoldUntilIO\, \Reverse\, \Concat\, \Zip\, and \Choose\—that work seamlessly across both sync and async data sources. By supporting lazy evaluation and cancellation tokens, \Iterable\ allows users to compose complex data pipelines without needing to manage the underlying execution model, effectively replacing or supplementing previous collection abstractions with a more versatile, effect-based sequence type.

LanguageExt.Core/Immutable Collections/Iterable · high confidence

Introduction of the LanguageExt.Parsec combinator library

This release introduces the LanguageExt.Parsec library, providing a full suite of parser combinators for building custom parsers. The library includes a generic token parser system (GenTokenParser) that allows users to define language-specific lexing rules for identifiers, operators, and literals, along with pre-configured definitions for Haskell and Java styles. It supports expression parsing with operator precedence and associativity, handles whitespace and comments, and offers both standard and IO-based parser variants (Parser\<T\> and Parser\<I,O\>) to accommodate different input types.

LanguageExt.Parsec · high confidence

Introduction of the Loop type for tail-recursive patterns

A new \Loop\<A\>\ record struct has been added to the LanguageExt core library to support tail-recursive loop implementations. This type wraps a bound value and provides a \Map\ method for transformation, a \ToNext\ method to convert into a \Next\ value for control flow, and extension operators (\\>\>\) that allow for value extraction and function composition, enabling users to lift loop stages into other monads more easily.

LanguageExt.Core/DataTypes/Loop · high confidence

Introduction of the Range\<A\> type with construction, iteration, and extension methods

A new Range\<A\> record type has been added to the library, allowing users to create and iterate over sequences of values defined by a start, end, and step. The type provides factory methods in the Range module to construct ranges from a minimum/maximum pair or from a start point and count, supporting both forward and backward iteration. It implements Foldable to enable standard folding operations and includes extension methods to check if a value falls within the range or if two ranges overlap. The type also exposes a Case property to support C\# pattern matching.

LanguageExt.Core/DataTypes/Range · high confidence

Introduction of the Sink abstraction for streaming data consumption

The Pipes library has been renamed to Streaming, and this change introduces the new \Sink\ type within the \LanguageExt.Streaming\ namespace. \Sink\ serves as the entry point for consuming streams, allowing users to post values to a channel, complete the stream, or handle errors. It supports combining multiple sinks, mapping incoming values via contravariant functors (including transducers), and converting to \ConsumerT\ or \Consumer\ components for integration with the broader streaming pipeline.

LanguageExt.Streaming/Sink · high confidence

Introduction of the Trampoline monad for stack-safe recursion

A new Trampoline monad has been added to the LanguageExt library, enabling stack-safe execution of recursive operations. This implementation allows users to defer computation steps, preventing stack overflow errors in deep recursive calls by running them iteratively. The feature includes standard monadic operations such as Pure, Bind, Map, and LINQ-style Select/SelectMany, providing a robust tool for handling potentially infinite or deeply nested recursive logic without exhausting the call stack.

LanguageExt.Core/Monads/Trampoline · high confidence

Introduction of the immutable Stck\<T\> stack collection

The library now includes a new immutable stack type, Stck\<T\>, located in LanguageExt.Core/Immutable Collections/Stack. This addition provides a functional, persistent stack data structure with standard operations such as push, pop, peek, and traversal, along with LINQ-style extension methods like Map, Filter, and Fold. The implementation supports collection initializers, nullable reference types, and efficient iteration, offering users a new tool for stack-based algorithms within the LanguageExt ecosystem.

LanguageExt.Core/Immutable Collections/Stack · high confidence

New Alternative and Applicative trait implementations with law verification

The \LanguageExt.Core/Traits\ area now includes new \Alternative\ and \Applicative\ trait definitions, along with their corresponding law verification modules (\Alternative.Laws.cs\, \Applicative.Laws.cs\). This introduces a monoid on applicative functors, enabling users to perform choice propagation (e.g., returning the first successful applicative functor via \OneOf\ or \choice\) and providing default implementations for operations like \some\, \many\, and \endBy\. The \Applicative\ trait adds support for lifting pure values and applying lifted functions, with extension methods for arithmetic operations and tuple-based application. The included law modules allow developers to assert and validate that their custom implementations adhere to the mathematical laws of these traits.

LanguageExt.Core/Traits · high confidence

New Arr extension methods and Iterator DSL implementation

This change introduces new extension methods for the immutable \Arr\ collection, including \Map\, \Action\, \Apply\, \Flatten\, \Filter\, \Where\, \Select\, \Bind\, and \SelectMany\, alongside corresponding Prelude functions. It also adds a new internal DSL for the \Iterator\ type, implementing concrete cases such as \Cons\, \ConsFirst\, \ConsValue\, \ConsValueEnum\, \ConsValueLazy\, and \Nil\ to support lazy, thread-safe sequence iteration with features like cloning and splitting.

LanguageExt.Core/Immutable Collections/Arr/Extensions, LanguageExt.Core/Immutable Collections/Arr/Prelude, LanguageExt.Core/Immutable Collections/Iterator/DSL · high confidence

New Ask type and extensions for Reader monads

Added a new \Ask\<Env, A\>\ record struct and corresponding \AskExtensions\ to the \LanguageExt\ namespace. This convenience type, created by the Prelude \ask\ function, simplifies usage in \ReaderT\ and \Reader\ monads by reducing generic parameter complexity. It provides methods to convert to \Reader\, \ReaderT\, and \RWST\ types, and includes monadic bind (\SelectMany\) operations for seamless integration with LINQ-style queries and other monadic contexts.

LanguageExt.Core/Monads/State and Environment Monads/Reader · high confidence

New Async module and LINQ extensions for IAsyncEnumerable

This change introduces a new \LanguageExt.Async\ module to help transition from standard \Task\/\async\/\await\ patterns by providing \Async.await\ for yielding threads while waiting on tasks and \Async.fork\ for parallel execution via the IO monad. Additionally, it adds \LanguageExt.Async.Linq\ extensions for \IAsyncEnumerable\, enabling functional composition with \Select\, \SelectMany\, \Where\, \Skip\, and \Take\ on asynchronous streams.

LanguageExt.Core/Concurrency/Async · high confidence

New Blazor sample application demonstrating Effects and Atom usage

A new Blazor Server sample project has been added to the Samples directory, providing a complete reference implementation for using LanguageExt's Eff and Atom types within a Blazor environment. The sample includes a Weather page that fetches forecasts using a typed Eff runtime with Time and Random traits, and a Counter page that manages state via LanguageExt Atoms. It also introduces a base Page component that intercepts Blazor lifecycle methods (OnInitialized, OnAfterRender, etc.) to execute them as Eff computations, along with the necessary runtime wiring in Program.cs.

Samples · high confidence

New Change event types for collection modifications

Added a new set of types in the \LanguageExt.Core/DataTypes/Change\ namespace to represent changes to values in key-value collections. This includes the abstract \Change\<A\>\ base class implementing \Monoid\, along with specific variants: \NoChange\<A\>\ for unchanged states, \EntryAdded\<A\>\ for new entries, \EntryRemoved\<A\>\ for deleted entries, and \EntryMapped\<A, B\>\ for updated entries (mapping from an old value to a new one). These types provide properties like \HasNoChange\, \HasChanged\, \HasRemoved\, \HasMapped\, and \HasAdded\ to inspect the nature of the change, and support pattern matching via deconstruction. This infrastructure supports change-event tracking for collection types like \AtomHashMap\ and \Ref\.

LanguageExt.Core/DataTypes/Change · high confidence

New ChronicleT and Either extension methods

This change introduces a new set of extension methods for the ChronicleT and Either monads. For ChronicleT, it adds operators for downcasting, running the chronicle to yield its inner monad, monadic join (Flatten), bifunctor mapping (BiMap), filtering (Where/Filter), and monadic bind (SelectMany). It also adds support for natural transformations from Guard to ChronicleT. For Either, it adds applicative action and apply operations, functor map operations, filtering, monadic join, and conversion methods to Validation and Eff monads. Additionally, it adds natural transformation and monadic binding support from Guard to Either.

LanguageExt.Core/Monads/Alternative Monads/ChronicleT/Extensions, LanguageExt.Core/Monads/Alternative Monads/ChronicleT/Prelude, LanguageExt.Core/Monads/Alternative Monads/Either/Extensions · high confidence

New ChronicleT monad transformer for hybrid error/writer semantics

The \ChronicleT\ monad transformer has been added to LanguageExt, providing a hybrid error/writer capability that allows computations to accumulate non-fatal outputs while supporting fatal aborts. This new type introduces specific behaviors for users: \dictate\ records output values, \confess\ terminates with a final error/output, and \memento\ captures records only if a fatal error occurs. Additionally, \absolve\ discards accumulated records on success, \condemn\ converts non-fatal errors into fatal ones, and \censor\ modifies the accumulated output. The implementation includes full monad transformer support via \lift\ and \liftIO\, enabling seamless integration with existing monadic workflows.

LanguageExt.Core/Monads/Alternative Monads/ChronicleT · high confidence

New IO Prelude API for concurrency, transactions, and functional composition

This change introduces a new set of IO Prelude functions in the LanguageExt library, providing users with enhanced capabilities for concurrent programming and state management. Specifically, it adds \refIO\, \atomicIO\, \snapshotIO\, and \serialIO\ to support Software Transactional Memory (STM) for safe, atomic updates to shared mutable state within IO computations. It also introduces concurrency primitives like \awaitAll\ and \awaitAny\ to manage multiple parallel IO operations, and functional composition helpers such as \map\, \apply\, and \action\ for working with IO as a functor and applicative. Additionally, \uninterruptible\ allows wrapping IO operations to ignore cancellation requests, and \yieldFor\ enables controlled thread yielding.

LanguageExt.Core/Effects/IO/Prelude · high confidence

New IO-based thread synchronization primitives

Added \Signal\ and \CountdownSignal\ classes within the \LanguageExt\ namespace, providing monadic wrappers around .NET's \EventWaitHandle\ and \CountdownEvent\. These new types allow users to perform cross-thread synchronization (such as waiting for signals or counting down to zero) directly within their \IO\ effects, ensuring proper resource management via the \use\ operator and avoiding impure side effects by offering both safe \K\<M, ...\>\ methods and unsafe direct accessors.

LanguageExt.Core/Concurrency/Signals · high confidence

New LanguageExt.FSharp interop library for C\#-F\# type conversion

The new LanguageExt.FSharp package provides bidirectional conversion methods between LanguageExt types (Option, Either, Map, List) and their F\# counterparts (FSharpOption, FSharpResult, FSharpMap, FSharpList). This enables seamless interoperability between C\# and F\# projects using the language-ext functional programming framework, allowing developers to pass data between the two languages without manual mapping.

LanguageExt.FSharp · high confidence

New LanguageExt.XUnitExt package for type-aware assertions

A new \LanguageExt.XUnitExt\ library has been added, providing XUnit extension methods for language-ext types. This includes \AssertSucc\/\AssertFail\ for \Eff\ and \IO\ effects, \AssertLeft\/\AssertRight\ for \Either\, \AssertSome\/\AssertNone\ for \Option\, \AssertSucc\/\AssertFail\ for \Fin\, and a \Throws\ helper for \Error\ exceptions, enabling more concise and readable tests for these specific types.

LanguageExt.XUnitExt · high confidence

New Lift monad transformer for unified monadic composition

A new \Lift\ monad transformer has been introduced to simplify composing functions with other monadic types, such as \IO\, \Eff\, and LINQ expressions. This change adds \Lift.cs\, \Lift.Prelude.cs\, and \Lift.Extensions.cs\, providing \lift\ and \liftIO\ methods to wrap synchronous and asynchronous actions into the \Lift\ type. Users can now easily convert lifted functions into \IO\ or \Eff\ contexts via \ToIO()\ and \ToEff()\ methods, enabling more consistent and readable monadic pipelines without manually handling transformer stacks.

LanguageExt.Core/Monads/Lifting · high confidence

New Next data type for tail-recursive control flow

Added the \Next\<A, B\>\ struct and its companion \Next\ module to support tail-recursive patterns. This lightweight, allocation-free type allows recursive functions to explicitly signal whether they should continue looping (\Loop\) or terminate with a result (\Done\). It integrates with the existing \Monad\ trait via the \Tail\ function and provides pattern-matching support (\IsLoop\, \IsDone\, \Match\) as well as implicit conversions from \Either\<A, B\>\ and explicit casts to extract the loop or done values.

LanguageExt.Core/DataTypes/Next · high confidence

New Parsec parser combinators and language definition support

The Parsec library now includes a comprehensive suite of new parser modules: Char.cs provides character-level parsers (e.g., \ch\, \satisfy\, \oneOf\, \LF\, \CRLF\); Prim.cs introduces core combinators like \parse\, \either\, \choice\, and \lazyp\; Token.cs and Token2.cs offer \makeTokenParser\ for building lexical analyzers from \GenLanguageDef\ definitions, handling whitespace, comments, and literals; Expr.cs adds \buildExpressionParser\ for constructing expression parsers with operator precedence and associativity; and Indent.cs provides indentation-sensitive parsing (\indented\, \indented1\, etc.). These changes enable users to define custom programming languages or complex text formats with greater ease and structure.

LanguageExt.Parsec/Parsers · high confidence

New Patch and SpanArray data types for document diffing and manipulation

Added the \Patch\ data type, which represents a collection of edits (Insert, Delete, Replace) applied to a document (an \IEnumerable\<A\>\). Patches form a monoid with support for composition, inversion, and validation via \applicable\ and \composable\ checks. The implementation includes \Edit\ classes for individual operations, \PatchParams\ for configuring diffing behavior, and internal helpers for computing least changes. Additionally, a new \SpanArray\ type was introduced to provide a mutable, sliceable array structure optimized for performance in diffing algorithms.

LanguageExt.Core/DataTypes/Patch · high confidence

New Prelude utilities for currying, partial application, and random generation

The LanguageExt Prelude now includes new static methods for functional programming patterns and utility generation. Users can now curry functions up to ten arguments using \curry\, partially apply arguments from the left or right using \par\ and \lpar\, and uncurry curried functions back to multi-argument forms using \uncurry\ and \Uncurry\. Additionally, argument order can be reversed for both curried and standard functions using \flip\ and \Flip\. New random number utilities provide a thread-safe, cryptographically strong \random\ method for generating integers and a \randomBase64\ method for generating Base64-encoded random strings. Finally, a \delay\ method allows scheduling actions to execute after a specified time span or at a specific DateTime.

(repo-wide) · high confidence

New Pure, Fail, and Lower monadic types with cross-monad binding

The LanguageExt library introduces three new core data types: \Pure\<A\>\ for representing pure success values, \Fail\<E\>\ for representing error values, and \Lower\ as a marker type. These types provide a unified way to lift values into other monads (such as \Validation\, \Option\, \Either\, \IO\, \Eff\, \Fin\, \Try\, \Reader\, \State\, and \K\) without requiring explicit generic arguments. Users can now use the \\>\>\ operator for value extraction and function composition, and access conversion methods like \ToValidation\, \ToOption\, \ToEither\, \ToIO\, and \ToEff\ to seamlessly integrate these new types with existing monadic workflows.

LanguageExt.Core/DataTypes/Fail, LanguageExt.Core/DataTypes/Lower, LanguageExt.Core/DataTypes/Pure · high confidence

New RWST monad transformer with full operator and LINQ support

The RWST (Reader/Writer/State/Transformer) monad transformer is now available, allowing computations to access an environment, produce output, maintain state, and lift effects from an underlying monad. This release adds the core RWST type along with a comprehensive set of extension methods and operators, including LINQ-style SelectMany, monadic bind (\>\>), applicative apply (\), functor map (\), choice (\|), and semigroup combine (+). It also provides standard Reader (ask, asks, local), Writer (tell, write, pass, listen, censor), and State (get, gets, put, modify) behaviors, as well as trait implementations for Monad, Functor, Applicative, Readable, Writable, Stateful, and MonadIO.

LanguageExt.Core/Monads/State and Environment Monads/RWS · high confidence

New Record type system with structural equality and ordering

This change introduces a new \Record\<RECORDTYPE\>\ base class and supporting infrastructure in \LanguageExt.Core/DataTypes/Record\. Deriving from this class provides structural equality (\IEquatable\), structural ordering (\IComparable\), structural hashing, and default \ToString()\ and serialization behavior. The system uses attributes like \EqAttribute\, \OrdAttribute\, and \HashableAttribute\ to configure field-level behavior, and \IgnoreBaseAttribute\ to exclude base type fields from structural operations. The implementation relies on static IL-generated functions for performance, as seen in \RecordType.cs\.

LanguageExt.Core/DataTypes/Record · high confidence

New Schedule system for retry and repeat delays

The \LanguageExt.Core/Effects/Schedule\ area now introduces a dedicated \Schedule\ type and supporting \Duration\ struct to manage retry and repeat timing. This new API allows users to define complex delay strategies—such as linear or exponential backoff, fixed intervals, and time-series sequences—and compose them using operators like union (\\|\) and intersection (\&\). It also provides transformers to limit execution counts (\recurs\), enforce no delay on the first attempt (\NoDelayOnFirst\), or repeat schedules indefinitely (\RepeatForever\), replacing previous ad-hoc delay mechanisms with a composable, type-safe DSL.

LanguageExt.Core/Effects/Schedule · high confidence

New Sink DSL implementations for routing, mapping, and channel writing

This change introduces a new set of Sink DSL components in the LanguageExt.Streaming library, enabling more flexible data processing pipelines. Users can now route values based on Either results using SinkChoose, combine outputs into tuples via SinkCombine, and transform inputs using SinkContraMap and SinkContraMapT (which supports Transducers). Additionally, SinkEmpty and SinkVoid provide no-op sinks for discarding data, while SinkWriter allows direct integration with .NET System.Threading.Channels for asynchronous writing.

LanguageExt.Streaming/Sink/DSL · high confidence

New Source API for creating and combining value streams

The \LanguageExt.Streaming/Source\ module now provides a dedicated \Source\<A\>\ type for handling streams of values. Users can create sources from various inputs including \IEnumerable\, \IAsyncEnumerable\, \IObservable\, and \System.Threading.Channels.Channel\ using the new \lift\ methods, as well as creating empty, singleton, or infinite sources. The API supports combining multiple sources via \merge\ and \zip\ (up to four streams), and offers standard stream operations like \Map\, \Bind\, \Where\, \Skip\, \Take\, and \Fold\ for processing the data.

LanguageExt.Streaming/Source · high confidence

New Source extension methods for iteration, collection, and type conversion

Added new extension methods to the Source API to facilitate consuming and converting stream data. Users can now force stream evaluation for side effects using \Iter\, retrieve the final element with \Last\, or gather all items into a sequence via \Collect\. Additionally, convenience methods \AsSource\ allow converting standard .NET types—such as \IEnumerable\<T\>\, \IAsyncEnumerable\<T\>\, \IObservable\<T\>\, and \Channel\<T\>\—into LanguageExt Sources, and a generic \As\ method enables downcasting from the \K\<Source, A\>\ trait.

LanguageExt.Streaming/Source/Extensions · high confidence

New SourceT DSL operators and trait implementations

The SourceT streaming library now exposes a comprehensive set of new DSL operators and internal implementations, significantly expanding its functional capabilities. Users can now combine multiple streams using Zip (2-4 sources), Choose, and Combine operators, and apply transformations via Map, Filter, and Transducers. New folding capabilities include FoldWhile, FoldUntil, and support for lifting Foldable types into sources. Stream control is enhanced with Take, TakeFor (duration-based), and Forever operators. The library also adds support for converting IObservable sequences and IAsyncEnumerable/IEnumerable items into SourceT streams, and introduces MultiListenerSourceT for broadcasting a single source to multiple concurrent consumers. These changes are underpinned by new trait implementations for SourceT, including MonadUnliftIO and MonoidK.

LanguageExt.Streaming/SourceT/DSL · high confidence

New SourceT extension methods for timing, merging, zipping, and reduction

This change introduces a suite of new extension methods for the \SourceT\ stream type. Users can now control stream timing with \Delay\ and \TakeFor\, combine streams using \Choose\ (merge) and \Zip\ (pair items), and perform reductions such as \Collect\, \CollectWhile\, \CollectUntil\, \FirstOrNone\, and \LastOrNone\. Additionally, conversion helpers like \AsSourceT\ and \AsSourceM\ allow lifting various sources (channels, enumerables, observables) into \SourceT\.

LanguageExt.Streaming/SourceT/Extensions · high confidence

New SysIO traits for structured system access

The \LanguageExt.Sys/Traits\ directory now introduces a comprehensive set of new interfaces—\ActivitySourceIO\, \ConsoleIO\, \DirectoryIO\, \EncodingIO\, \EnvironmentIO\, \FileIO\, \TextReadIO\, and \TimeIO\—along with a composite \HasSys\ trait. These additions provide a functional, IO-wrapped abstraction over common .NET Base Class Library operations, allowing users to perform file system, console, environment, time, and diagnostic activities in a purely functional manner.

LanguageExt.Sys/Traits · high confidence

New Task extension methods and Prelude functions for LINQ-style and monadic operations

The \LanguageExt.Core/Concurrency/Task\ area now exposes a comprehensive set of extension methods and Prelude functions for \System.Threading.Tasks.Task\<T\>\, enabling LINQ-style querying and monadic composition directly on standard .NET Tasks. Users can now flatten nested tasks (\Flatten\), perform monadic binds (\Bind\/\SelectMany\), filter (\Where\/\Filter\), and fold (\Fold\) task results. Additionally, new Prelude functions like \choice\ (returning the first successful task from a sequence) and \apply\ (applicative composition) are available, along with utility methods such as \CompletedSuccessfully\, \AsFailedTask\, and \Count\ to inspect task states without throwing exceptions.

LanguageExt.Core/Concurrency/Task · high confidence

New Tell record for Writer monad convenience

A new \Tell\<W\>\ record type has been added to the Writer monad implementation to provide a convenient way to emit log values. This type, created by the Prelude \put\ function, simplifies usage in \WriterT\ and \State\ based monads by avoiding excessive generic parameters. It includes methods to convert to \WriterT\ or \Writer\ instances and supports monadic binding (\SelectMany\) for chaining operations within \Writer\, \WriterT\, and \RWST\ contexts.

LanguageExt.Core/Monads/State and Environment Monads/Writer · high confidence

New Units of Measure library for type-safe physical quantities

This change introduces a new \Units of Measure\ namespace in LanguageExt.Core, providing strongly-typed structs for physical quantities including Length, Area, Mass, Time, TimeSq, Velocity, VelocitySq, Accel, and Temperature. These types replace raw numeric values with domain-specific wrappers that handle unit conversions automatically (e.g., Metres, Kilometres, Miles for Length; Celsius, Fahrenheit, Kelvin for Temperature) and support standard arithmetic operators, comparisons, and conversions. The library includes extension methods for convenient creation (e.g., \1.Metres()\, \10.Kilograms()\) and a \Module.cs\ with static constants for common units. This enables compile-time safety for physical calculations, preventing errors like mixing incompatible units.

LanguageExt.Core/Units of Measure · high confidence

New Validation extension methods for applicative, functor, and guard operations

This change introduces a new set of extension methods for the \Validation\ monad in \LanguageExt.Core\, enabling more functional programming patterns. Users can now apply functions within the validation context using \Apply\ and \Action\ (which combine errors via a \Semigroup\ when both sides fail), map values with \Map\, and filter results with \Filter\/\Where\. Additionally, \Guard\ types can be converted to \Validation\ via \ToValidation\, and sequences of validations can be filtered into successes or failures using \Successes\ and \Fails\. These additions enhance the library's support for composing validation logic while accumulating error information.

LanguageExt.Core/Monads/Alternative Monads/Validation/Extensions · high confidence

New ValueTask extension methods and Prelude functions

The library now provides a comprehensive set of LINQ-style and functional programming extensions for \ValueTask\<T\>\. Users can now use methods such as \Select\, \Where\, \SelectMany\, \Flatten\, \Fold\, \Iter\, \Exists\, and \ForAll\ directly on \ValueTask\ instances, enabling seamless integration with existing functional patterns. Additionally, the \Prelude\ now includes corresponding global functions like \map\, \bind\, \choice\, and \apply\ for \ValueTask\, allowing for more concise and idiomatic asynchronous code without needing to call extension methods explicitly.

LanguageExt.Core/Concurrency/ValueTask · high confidence

New VectorClock concurrency primitive

Added a new VectorClock type in LanguageExt.Core/Concurrency to support distributed systems logic. This includes a generic record for managing versioned entries, a static utility class for operations like combining, finding the maximum, and determining causal relationships (Causes, CausedBy, Concurrent) between clocks, and a Relation enum to represent these outcomes. The implementation supports both simple comparable keys with long values and more complex generic keys/values using Ord and Num traits.

LanguageExt.Core/Concurrency/VectorClock · high confidence

New applicative and monadic operations for Option, Try, and These types

This change introduces a comprehensive set of new extension methods and prelude functions for the Option, OptionT, Try, TryT, and These monads, enabling more functional programming patterns. Specifically, it adds \Map\, \Apply\, and \Action\ methods to support applicative functor operations, allowing functions wrapped in these types to be applied to values also wrapped in them. It also includes monadic operations like \Bind\, \Flatten\, and \SelectMany\ for chaining computations, as well as utility methods such as \ToValidation\, \Somes\, \Add\, \Subtract\, \Product\, \Divide\, and \Match\ variants for Option and These. The \Option\ type now supports conversion to \Nullable\ and \Validation\, and \Try\ types can be run to produce \Fin\ results. These additions enhance the library's support for functional composition and error handling across its core monadic types.

(repo-wide) · high confidence

New concurrency primitives: STM, Atoms, and Conflict Resolution

This update introduces a new Software Transactional Memory (STM) system for managing shared mutable state via \Ref\ types, supporting snapshot and serializable isolation levels to ensure atomic, consistent, and isolated transactions. It also adds lock-free atomic operations through \Atom\, \AtomHashMap\, and \AtomSeq\ for safe concurrent access to collections without explicit locking. Additionally, a conflict resolution framework is provided with the \Conflict\<V\>\ interface and built-in \LastWriteWins\ and \FirstWriteWins\ resolvers, enabling deterministic handling of concurrent updates in versioned data structures.

LanguageExt.Core/Concurrency · high confidence

New convenience types for State monad operations

Added \Put\, \Modify\, and \Gets\ record structs to simplify state manipulation in \State\, \StateT\, and \RWST\ monads. These types provide explicit conversion methods (\ToStateful\, \ToStateT\, \ToState\) and LINQ-compatible \SelectMany\ overloads, reducing the need for verbose generic parameters when chaining stateful operations.

LanguageExt.Core/Monads/State and Environment Monads/State · high confidence

New extension methods for functions, observables, and LINQ queries

This release adds several new extension methods to the LanguageExt library. Function composition is now supported via \Compose\ and \BackCompose\ extension methods, along with a \Flip\ method to reverse argument order. For reactive programming, \IObservable\ types can now be extended with \PostSubscribe\ to execute actions after subscription and \ToAsyncEnumerable\ to convert observables into async enumerables. LINQ \IQueryable\ support is expanded with a comprehensive set of query operators including \HeadOrNone\, \HeadOrLeft\, \Tail\, \Map\, \Filter\, \Choose\, \Collect\, \Fold\, \Reduce\, \Zip\, and \Freeze\. Additionally, \IDictionary\ and \IReadOnlyDictionary\ types gain \TryGetValue\ extension methods that return \Option\ values, and \ObjectExt\ provides a null-check method that avoids boxing value types.

LanguageExt.Core/Extensions · high confidence

New extension methods for non-empty immutable collections

Added new extension methods to the \IterableNE\ (non-empty iterable) type, including \Map\ and \Apply\ for functor and applicative operations, \Action\ for sequencing effects, \AsIterableNE\ for converting standard collections (like \IEnumerable\, \Seq\, \Arr\, \Lst\) into non-empty collections, and \Flatten\ for monadic join. These additions enhance the functional programming capabilities of non-empty collections by providing standard higher-kinded type operations.

LanguageExt.Core/Immutable Collections/IterableNE/Extensions · high confidence

New extension methods for the Fin monad

Added a set of extension methods to the \Fin\ monad in the \LanguageExt\ library. These additions include applicative operations (\Action\, \Apply\), functor mapping (\Map\), monadic flattening (\Flatten\), arithmetic operations (\Plus\, \Subtract\, \Product\, \Divide\), and utility methods for partitioning and extracting results (\Partition\, \Fails\, \Succs\). Additionally, natural transformations and binding support were added to convert from \Guard\<Error, Unit\>\ to \Fin\.

LanguageExt.Core/Monads/Alternative Monads/Fin/Extensions · high confidence

New extension methods for the IO monad and kinded IO

This change introduces a new set of extension methods in the \LanguageExt.Core/Effects/IO/Extensions\ directory to enhance the \IO\ effect type. It adds applicative-style operations (\Map\, \Apply\, \Action\) for \IO\ and its kinded wrapper \K\<IO, A\>\, allowing for more functional composition patterns. It also provides convenience methods to convert between kinded and concrete \IO\ types (\As\), run effects synchronously or asynchronously (\Run\, \RunAsync\, \RunSafe\, \RunSafeAsync\), and flatten nested structures (\Flatten\). Additionally, it extends \SelectMany\ support to work with various transformer types (OptionT, TryT, EitherT, etc.) when starting from a \K\<IO, A\>\ context, and adds a \Guard\ extension to conditionally execute \IO\ actions based on a guard flag.

LanguageExt.Core/Effects/IO/Extensions · high confidence

New generic ParserIO system with expression and indentation support

The Parsec library introduces a new \ParserIO\ subsystem that generalizes parsing from character streams to generic token streams (\Parser\<I, O\>\). This location provides the core building blocks for this system, including \ExprIO\ for building expression parsers with operator tables (handling precedence and associativity), \IndentIO\ for parsing indentation-sensitive structures, and \ItemIO\/\PrimIO\ for primitive token matching and combinator logic. Users can now define parsers for arbitrary token types rather than just characters, enabling more flexible and efficient parsing implementations.

LanguageExt.Parsec/ParserIOs · high confidence

New higher-kinded type class derivings for functional abstractions

The \LanguageExt.Core/Deriving\ directory now includes a comprehensive set of new interfaces that allow users to automatically derive functional programming abstractions for wrapper types. These new files provide derived implementations for core type classes including \Functor\, \Applicative\, \Monad\, \MonadIO\, and \MonadUnliftIO\, as well as algebraic structures like \Foldable\, \Traversable\, \Alternative\, \Choice\, \MonoidK\, and \SemigroupK\. Additionally, support for effectful and stateful patterns is added via \Fallible\, \Final\, \Stateful\, \Readable\, and \Writable\. This enables users to compose complex monadic stacks and handle effects like IO, resource management (bracketing), and state transitions with less boilerplate.

LanguageExt.Core/Deriving · high confidence

New in-memory system abstractions for testing

The LanguageExt.Sys package now includes in-memory implementations of system services to facilitate unit testing. Specifically, MemoryConsole provides an emulated console with support for pre-building keyboard buffers (WriteKey, WriteKeyChar, WriteKeyString) and committing them, along with color management including a new reset color function. MemorySystemEnvironment offers a mutable, injectable representation of System.Environment, allowing tests to initialize from the real environment and then tweak specific values (such as environment variables, command-line arguments, and OS details) using a With() method.

LanguageExt.Sys · high confidence

New live implementations for system I/O traits

This location introduces concrete, live implementations for the LanguageExt Sys trait interface, wrapping standard .NET I/O operations in the IO monad. The new files provide \ActivitySourceIO\ for distributed tracing, \ConsoleIO\ for terminal interaction, \DirectoryIO\ and \FileIO\ for file-system operations (including async file reads/writes), \EncodingIO\ for text encoding, \EnvironmentIO\ for process and system environment data, \TextReadIO\ for stream reading, and \TimeIO\ for date/time and delays. These components allow users to perform side-effecting system operations in a pure, composable manner.

LanguageExt.Sys/Live/Implementations · high confidence

New memoization types and extension methods for lazy caching

This change introduces the \Memo\<A\>\ and \Memo\<F, A\>\ types, which provide thread-safe, lazy value acquisition with caching. Users can now wrap functions or enumerables to cache their results, ensuring that expensive computations or side effects are performed at most once. The \Memo\<A\>\ class supports cloning and resetting cached values, while the \Memo\<F, A\>\ class adds support for natural transformations between higher-kinded structures. Extension methods are provided for \Func\<T, R\>\ (with both safe and unsafe caching variants) and \IEnumerable\<T\>\, allowing easy integration into existing codebases.

LanguageExt.Core/Memo · high confidence

New monadic conditional operators: guard, guardnot, when, unless, and iff

The Prelude now includes a suite of monadic conditional helpers to enable cleaner control flow in applicative and monadic expressions. \guard\ and \guardnot\ allow you to short-circuit computation and return an alternative value (such as an error) if a condition is not met, supporting types like \Either\, \Validation\, and \Aff\. \when\ and \unless\ provide conditional execution of side effects or other monadic computations based on a boolean flag, while \iff\ offers a ternary-style conditional that works with monadic predicates and supports mixing pure and IO computations. These additions simplify complex monadic pipelines by replacing manual pattern matching with declarative conditional logic.

LanguageExt.Core/Monads/Monadic conditionals · high confidence

New monoid instances for arithmetic, boolean, error, and unit types

The library now provides dedicated monoid implementations for common data types, allowing users to combine values using standard monoidal operations. Addition and Product monoids are available for numeric types, supporting sum and product aggregations respectively. Boolean monoids (All and Any) enable logical conjunction and disjunction folding. Additionally, monoids for Error (combining errors) and Unit (ignoring values) are introduced, expanding the compositional capabilities of the library's type classes.

LanguageExt.Core/Class Instances/Monoid · high confidence

New operator overloads for EitherT monad transformer

This change introduces a comprehensive set of new operator overloads for the \EitherT\ monad transformer, enabling more idiomatic functional syntax. Users can now use \\*\ for functor mapping and applicative application, \\>\>\ for monadic binding and sequencing, \\|\ for choice (alternative) and finalization, and \+\ for combining effects (SemigroupK) or downcasting. These operators are implemented across new extension files in the \EitherT/Operators\ directory, covering Functor, Applicative, Monad, Choice, Fallible, and Final capabilities.

LanguageExt.Core/Monads/Alternative Monads/EitherT/Operators · high confidence

New operator overloads for Option, These, and TryT monads

This change introduces a comprehensive set of new operator overloads for the Option, These, and TryT monads, enabling more idiomatic functional syntax. Users can now use the \\*\ operator for functor mapping and applicative application (supporting curried functions up to 10 arguments), the \\>\>\ operator for monadic binding and sequencing, the \\|\ operator for choice and fallback logic, and the \+\ operator for downcasting and combining These values. These operators are implemented as extension methods on the \K\<Monad, A\>\ type, allowing seamless integration with existing LanguageExt code.

LanguageExt.Core/Effects/IO/Operators, LanguageExt.Core/Monads/Alternative Monads/Option/Operators, LanguageExt.Core/Monads/Alternative Monads/These/Operators, LanguageExt.Core/Monads/Alternative Monads/TryT/Operators · high confidence

New operator overloads for SourceT streams

This change introduces a comprehensive set of operator overloads for the \SourceT\ stream type, enabling more idiomatic functional composition. Users can now use \\*\ for functor mapping and applicative application, \\>\>\ for monadic binding and sequencing, \\|\ for choice/alternative operations, \+\ for semigroup combining, and \&\ for zipping streams together. These operators are defined across multiple extension files (Functor, Applicative, Monad, Choice, Combine, Zip) and require specific trait constraints (e.g., \MonadIO\, \Alternative\, \Fallible\) on the underlying monad \M\.

LanguageExt.Streaming/Source/Operators, LanguageExt.Streaming/SourceT/Operators · high confidence

New operator overloads for the Try monad

This change introduces a new set of operator overloads for the \Try\ monad within the \LanguageExt\ library, located in the \Try.Operators\ namespace. Users can now use standard C\# operators to compose \Try\ computations more concisely: the \\*\ operator is overloaded for functor mapping and applicative application (supporting functions of up to 11 arguments), the \\>\>\ operator enables monadic binding and sequential composition, the \\|\ operator provides choice/fallback logic (alternative monad behavior) and finally-block execution, and the \+\ operator allows downcasting from the \K\<Try, A\>\ trait to \Try\<A\>\. These additions enhance the library's support for functional programming patterns by allowing more idiomatic expression of error-handling workflows.

LanguageExt.Core/Monads/Alternative Monads/Either/Operators, LanguageExt.Core/Monads/Alternative Monads/Try/Operators, LanguageExt.Core/Monads/State and Environment Monads/Reader/Reader/Operators · high confidence

New streaming consumer and effect abstractions in LanguageExt.Streaming

The Pipes library now exposes first-class \Event\ types for bridging .NET delegates to the streaming model, alongside new \Consumer\, \ConsumerT\, \Effect\, and \EffectT\ monad transformers. These additions provide structured ways to consume upstream data streams and execute side-effecting operations, with \Consumer\ and \Effect\ offering specialized versions for the \Eff\ runtime and \ConsumerT\/\EffectT\ supporting generic monad transformers.

LanguageExt.Streaming/Pipes · high confidence

New trait implementations for Either monad

Added new trait implementation files for the \Either\ monad, introducing support for \Coproduct\, \Bimonad\, \Monad\, \Applicative\, \Traversable\, \Foldable\, \Choice\, \Fallible\, and \Natural\ transformations. This enables users to utilize these functional programming abstractions with \Either\<L, R\>\, including specific behaviors for recursion (\Recur\), folding (\FoldWhile\, \FoldBackWhile\), and choice operations.

LanguageExt.Core/Monads/Alternative Monads/Either/Trait · high confidence

New utility classes for async enumeration, hashing, and reflection

The LanguageExt.Core/Utility directory now includes several new helper classes to support core library functionality. AsyncEnumerableEx provides a Merge method to combine multiple async-enumerable sequences into one. Fnv introduces a Fowler–Noll–Vo 32-bit hash function for improved hashing performance and consistency. CollectionFormat adds ToShortString and ToFullString helpers to control how collection items are displayed, preventing excessive output in logs. IL and Reflect provide optimized, platform-aware code generation and reflection utilities, including fallbacks to Expression trees when IL emission is unavailable. SysInfo exposes system details like processor count and default async sequence parallelism. Other new utilities include Box for efficient value boxing, Pool for thread-safe object pooling, and WaitAsync for simplified async waiting on WaitHandles.

LanguageExt.Core/Utility · high confidence

Operator overloads added for Eff and Eff\<RT\>

This change introduces a comprehensive set of operator overloads for the Eff effect system, available in both the no-runtime (\Eff\<A\>\) and runtime (\Eff\<RT, A\>\) variants. Users can now use standard C\# operators to compose effects more concisely: \\*\ for functor mapping and applicative application, \\>\>\ for monadic binding and sequential composition, \\>\>\>\ for applicative sequencing, \\|\ for choice (alternative) and error handling (catch/fallible), and \+\ for downcasting from the generic \K\<Eff, A\>\ wrapper to the concrete \Eff\<A\>\ type. These operators are implemented across dedicated extension files (Functor, Applicative, Monad, Choice, Fallible, Final) to support curried functions and various effect combinations.

LanguageExt.Core/Effects/Eff/Eff no runtime/Operators, LanguageExt.Core/Effects/Eff/Eff with runtime/Operators · high confidence

Operator overloads added for Validation and ValidationT monads

New operator overloads have been added to the \Validation\ and \ValidationT\ monads in the LanguageExt library, enabling more idiomatic functional composition. These include applicative sequence (\\>\>\>\) and apply (\\\) operators, functor mapping (\\\), monadic bind (\\>\>\), choice (\\|\), and semigroup combination (\+\ and \&\) operators. This allows users to write validation logic using familiar infix syntax rather than method calls.

LanguageExt.Core/Monads/Alternative Monads/Validation/Operators, LanguageExt.Core/Monads/Alternative Monads/ValidationT/Operators · high confidence

OptionT operator overloads added for functional composition

The OptionT monad now supports a comprehensive set of operator overloads for functional composition, including functor mapping (\), applicative application (\), monadic binding (\>\>), and choice/alternative operations (\|). This allows users to write more concise and idiomatic code when combining OptionT values, such as chaining transformations or handling fallbacks, without explicitly calling Map, Apply, or Bind methods.

LanguageExt.Core/Monads/Alternative Monads/OptionT/Operators · high confidence

ReaderT monad transformer gains comprehensive operator overloads and trait support

The ReaderT monad transformer now exposes a full suite of functional programming operators, allowing users to write more idiomatic and concise code. This includes standard monadic bind (\>\>), sequential composition, and SelectMany for LINQ-style queries, as well as Functor map (\) and Applicative apply (\) operators that support curried functions of varying arities. Additionally, choice (\|) and semigroup combine (+) operators are available for monads implementing the respective traits, alongside error-handling operators for fallible computations and finally blocks. The transformer also implements MonadUnliftIO, enabling safe lifting of IO effects within the reader context.

LanguageExt.Core/Monads/State and Environment Monads/Reader/ReaderT · high confidence

Source trait implements Monad, MonoidK, and Alternative interfaces

The Source type now explicitly implements the Monad, MonoidK, and Alternative traits, enabling users to leverage standard functional programming patterns such as monadic binding, mapping, pure value creation, and applicative application. This implementation also includes support for recursion via the Monad's Rec method and provides choice/combine operations through the Alternative and MonoidK interfaces, allowing for more expressive stream composition and error handling.

LanguageExt.Streaming/Source/Trait · high confidence

These monad gains Foldable and Traversable implementations

The \These\<A\>\ type now implements the \Foldable\ and \Traversable\ traits, enabling users to fold, traverse, and map over \These\ values using standard functional patterns. This adds support for recursive folding operations (\FoldWhile\, \FoldBackWhile\) and applicative traversal, allowing \These\ to be used in contexts requiring generic collection-like behavior.

LanguageExt.Core/Monads/Alternative Monads/These/Trait · high confidence

Validation monad trait implementations added

The \Validation\ monad now exposes explicit trait implementations for core functional programming interfaces, including \Monad\, \Applicative\, \Alternative\, \Foldable\, \Traversable\, and \Bimonad\. This enables users to leverage standard functional patterns such as recursive folding (\Foldable\), traversal over effects (\Traversable\), and bifunctor operations (\Bimonad\) directly on \Validation\ types, providing a more composable and idiomatic API for handling validation logic.

LanguageExt.Core/Monads/Alternative Monads/Validation/Trait · high confidence

ValidationT now implements core functional traits including Monad, Alternative, and Bimonad

The \ValidationT\ monad transformer now exposes a comprehensive set of trait implementations, enabling it to function as a Monad, Applicative, Functor, Alternative, Bimonad, MonadIO, and Fallible type. This change adds support for standard functional operations such as \Bind\, \Map\, \Pure\, \Apply\, \Empty\, \Combine\, and \Choose\, as well as specific behaviors like \BiMap\ and \BindFirst\/\BindSecond\ for the Bimonad instance. Users can now leverage these traits for more expressive composition, error handling, and monadic lifting within the \ValidationT\ context.

LanguageExt.Core/Monads/Alternative Monads/ValidationT/Trait · high confidence

Writer monad implementation with standard operators

The Writer monad is now available in LanguageExt, providing a way to perform computations that produce a result alongside an accumulative output (such as logs or audit trails) using a Monoid. This release adds the core \Writer\<W, A\>\ type along with its Monad, Functor, and Applicative trait implementations. Users can now utilize standard functional operators including \pure\, \tell\, \write\, \listen\, \listens\, and \censor\, as well as sequence and apply operators (\\>\>\>\, \\*\) and monadic bind (\\>\>\) to compose writer-based workflows.

LanguageExt.Core/Monads/State and Environment Monads/Writer/Writer · high confidence

WriterT monad transformer gains comprehensive operator support and trait implementations

The WriterT monad transformer now exposes a full suite of functional programming operators and trait implementations, enabling more idiomatic usage. Users can now utilize standard operators for Functor mapping (\), Applicative application (\), Monad binding (\>\>), and sequential sequencing (\>\>). Additionally, Choice (\|) and SemigroupK (+) operators are available for handling alternative outcomes and combining effects, while Fallible and Final operators support error catching and cleanup logic. The underlying trait implementation ensures these operators correctly propagate the writer's output state through the inner monad.

LanguageExt.Core/Monads/State and Environment Monads/Writer/WriterT · high confidence

Behavioural changes

Activity tracing now supports generic monads via Eff and Aff

The \Activity\ class in \LanguageExt.Sys.Diag\ has been refactored to support generic monads (\M\) instead of being tied exclusively to the \Eff\ monad. This change introduces a new \Activity.Eff.cs\ file for \Eff\-specific usage while updating the core \Activity.cs\ to work with any \MonadIO\<M\>\ implementation, allowing distributed tracing spans to be created and managed within broader effect systems beyond just \Eff\.

LanguageExt.Sys/Sys/Diag · high confidence

Added downcast operators for core monadic types

New operator overloads (+ and \>\>) have been added to the Arr, IterableNE, Iterator, IteratorAsync, and Identity types, allowing users to explicitly downcast from their respective K\<...\> trait wrappers to the concrete monadic types (e.g., K\<Arr, A\> to Arr\<A\>). This change simplifies type coercion in code that works with these trait-based abstractions, making it easier to transition from generic trait contexts to specific implementations without manual casting.

(repo-wide) · high confidence

Arr immutable collection refactored with span-based slicing and Monoid support

The Arr immutable array implementation has been refactored to improve performance and API consistency. It now implements the Monoid interface, enabling standard monoidal operations. The internal structure supports zero-copy slicing via new AsSpan and Splice methods that utilize ReadOnlySpan, significantly reducing allocation overhead for sub-segments. Additionally, the collection builder pattern is explicitly defined, and the module exposes functional helpers like empty, create, singleton, add, remove, and flatten.

LanguageExt.Core/Immutable Collections/Arr · high confidence

Arr trait implements tail-recursive fold operations

The Arr collection type now provides tail-recursive implementations for its fold operations (FoldStep and FoldStepBack). This change prevents stack overflow errors when processing large arrays, ensuring that folding operations remain stable and safe regardless of the collection size.

LanguageExt.Core/Immutable Collections/Arr/Trait · high confidence

Conduit implementation refactored to use Transducers

The internal Conduit implementation in LanguageExt.Streaming has been refactored to utilize Transducers for its sink and source operations. This change replaces previous Reader-based source types with MultiListener implementations, allowing the Source to support multiple concurrent Reduce operations. Users interacting with the Conduit internals will see a shift in how data flows through the internal queue, with transformations now handled via transducer pipelines rather than the prior mechanism.

LanguageExt.Streaming/Conduit/Internal · medium confidence

Conduit now uses System.Threading.Channels and exposes Functor/Cofunctor traits

The Conduit implementation has been refactored to use System.Threading.Channels for its internal buffering, replacing the previous ChannelWriter-based approach. This change introduces configurable buffer strategies (unbounded, bounded, single, latest, newest) and exposes the Conduit as both a Functor and Cofunctor, allowing users to map values on the source side and comap values on the sink side. The API now includes explicit methods for filtering, skipping, taking, and folding while flowing through the conduit, and provides conversion methods to integrate with the existing Producer/Consumer pipe components.

LanguageExt.Streaming/Conduit · high confidence

ConduitT refactored to use Transducers and MultiListener

The internal implementation of ConduitT has been rewritten to utilize Transducers for data transformation and MultiListener for source handling, replacing the previous Reader-based source types. This change introduces a new ConduitT.ABC.cs file that defines the conduit's core behavior, including sink posting, completion, and reduction logic via a Channel. Users will see this as an internal architectural shift that likely improves performance and composability of streaming pipelines, while maintaining the same public API surface for operations like Map, Filter, Take, and FoldWhile.

LanguageExt.Streaming/ConduitT/Internal · high confidence

Deprecation of FinSucc and FinFail constructors

The FinSucc and FinFail helper methods in the Prelude are now obsolete. Users should migrate to the Fin.Succ and Fin.Fail case constructors, or use Prelude.Pure and Prelude.Fail, to align with the updated Fin type structure.

LanguageExt.Core/Obsolete and Deprecated · high confidence

Eff monad refactored to use transformers

The Eff monad implementation has been rewritten to utilize monad transformers, changing its internal structure to wrap a ReaderT over IO. This refactor introduces new static factory methods (Success, Fail, unit) and a comprehensive set of lift operators that allow direct integration of pure values, errors, IO actions, and async tasks into the Eff context. It also adds runtime helper methods such as runtime, getState, and localCancel to manage the runtime environment and cancellation contexts more effectively.

LanguageExt.Core/Effects/Eff/Eff with runtime · high confidence

Either monad refactored to use nested case types

The \Either\<L, R\>\ monad implementation has been restructured so that its \Left\ and \Right\ states are now defined as nested sealed records within the main \Either\ type, rather than as separate top-level types. This change introduces new files for the \Left\ and \Right\ case implementations and a module for construction helpers, while preserving the existing public API for matching, mapping, and binding. Users will see no functional change in how they interact with \Either\, but the internal type hierarchy has shifted to a nested structure.

LanguageExt.Core/Monads/Alternative Monads/Either · high confidence

EitherT monad transformer restructured with new lift and IO capabilities

The EitherT monad transformer has been refactored to support a more modular architecture, introducing a dedicated module file for static helper methods. This change adds new \lift\ overloads that allow values, monads, and \Either\ results to be lifted into the transformer more flexibly, and introduces \liftIO\ methods to handle \IO\ effects when the underlying monad implements \MonadIO\. The core \EitherT\ record now exposes \IsRight\ and \IsLeft\ as lazy monadic properties and provides updated \Match\, \Map\, and \MapLeft\ signatures, ensuring consistent behavior for error handling and value transformation within the monadic context.

LanguageExt.Core/Monads/Alternative Monads/EitherT · high confidence

EitherT now implements Choice and tail-recursive Bind

The EitherT monad transformer now supports the Choice interface, allowing users to select the first successful result between two EitherT computations without requiring a SemigroupK constraint. Additionally, the Bind operation has been updated to support tail recursion, enabling more efficient handling of deeply nested or iterative asynchronous workflows.

LanguageExt.Core/Monads/Alternative Monads/EitherT/Trait · high confidence

Fin monad restructured to use nested case types

The Fin monad has been refactored to use nested case types (Fin\<A\>.Succ and Fin\<A\>.Fail) within the main Fin\<A\> class, replacing the previous separate Fin and Fin\<A\> types. This change introduces a new internal structure with dedicated Succ and Fail classes that implement Match, Map, Bind, and other monadic operations, while maintaining the same functional behavior as Either\<Error, A\>. The module now provides static factory methods Fin.Succ and Fin.Fail for construction, and the type supports implicit conversions from values, errors, Either, Pure, and Fail types.

LanguageExt.Core/Monads/Alternative Monads/Fin · high confidence

HashMap refactored to use Eq traits and standardised Functor/Map operations

The HashMap implementation has been restructured to support explicit equality traits (HashMapEq) alongside the default equality path, allowing users to provide custom equality logic for keys. Additionally, the Map and Functor operations have been standardised across the library, ensuring consistent functional mapping behavior for both the default and trait-based HashMap variants.

LanguageExt.Core/Immutable Collections/HashMap · high confidence

IO monad refactored with new environment, resource management, and concurrency primitives

The IO monad implementation has been significantly restructured to improve robustness and concurrency support. A new EnvIO class now manages the execution environment, including explicit support for timeouts, synchronization context posting, and local cancellation scopes. Resource management has been consolidated into the IO monad via a new Resources class, replacing the previous ResourceT transformer and ensuring automatic disposal of IDisposable and IAsyncDisposable objects. Additionally, new concurrency primitives have been added, including ForkIO for forking operations with cancel/await capabilities, uninterruptible blocks, and improved timeout handling.

LanguageExt.Core/Effects/IO · high confidence

Identity monad implementation with traversal support

The Identity monad now includes explicit Traverse and TraverseM methods, allowing users to traverse and map over Identity values using Applicative and Monad traits respectively. The record also implements IComparable and provides standard monadic operations like Map, Bind, and SelectMany.

LanguageExt.Core/Monads/Identity · high confidence

Identity monad implements recursive fold and tail-recursive bind

The Identity monad now supports tail-recursive operations and recursive folding. Users can leverage the new \Recur\ method for efficient, stack-safe recursion within the Identity context, and the \Foldable\ trait has been updated with \FoldWhile\, \FoldBackWhile\, and \FoldStep\ methods to enable recursive folding patterns.

LanguageExt.Core/Monads/Identity/Trait · high confidence

Immutable HashSet refactored to use Traits and Monoid derivation

The LanguageExt HashSet implementation has been restructured to derive from the Monoid interface and utilize the new Traits system (replacing the previous TypeClasses). This change introduces static trait interfaces for Monad, MonoidK, Alternative, and Traversable behaviors, enabling more consistent functional programming patterns. Users will see new extension methods for Functor map and Applicative apply operations, as well as improved performance for back-folding operations. The core HashSet struct now implements IAdditionOperators and ISubtractionOperators, allowing for standard C\# operator syntax for set union and difference, while maintaining backward compatibility with existing functional module methods.

LanguageExt.Core/Immutable Collections/HashSet · high confidence

Immutable List (Lst) refactored to use Traits and Monoid

The immutable list implementation has been restructured to derive from the Monoid trait and utilize the new Traits system (replacing the previous TypeClasses). This change introduces standard functional operations such as Functor map, Applicative apply, and monadic bind directly on the list type, while also adding tail-recursion protection to improve performance and prevent stack overflows on large collections.

LanguageExt.Core/Immutable Collections/List · high confidence

Introduction of ConduitT streaming component with transducer support

The Pipes library has been renamed to Streaming, introducing the new ConduitT component which replaces the previous implementation. ConduitT provides a channel-based streaming model with configurable buffering strategies (unbounded, bounded, single, latest, newest) and supports transducer-based transformations for both input (Sink) and output (Source) sides. The component implements Functor and Cofunctor traits, allowing values to be mapped or comapped before and after the internal queue, and includes conversion methods to integrate with the existing Producer and Consumer pipe components.

LanguageExt.Streaming/ConduitT · high confidence

IterableNE now supports tail-recursive folding operations

The \IterableNE\ collection type now implements tail-recursive folding via \FoldStep\ and \FoldStepBack\. This change prevents stack overflow errors when processing large non-empty collections, as the fold operations are now executed iteratively rather than recursively. Note that backward folding (\FoldBackWhile\) remains unsupported and will throw a \NotSupportedException\.

LanguageExt.Core/Immutable Collections/IterableNE/Trait · high confidence

Iterator trait implementation adds recursion and memoization support

The Iterator type now implements core functional traits (Monad, Traversable, Foldable, etc.) with specific support for recursive operations and memoization. This includes new overloads for Applicative.Apply and Alternative.Choose that accept Memo\<Iterator, A\> arguments, enabling optimized repeated access to iterator state. Additionally, Foldable methods like FoldStep and FoldStepBack are implemented using recursive helper functions to support tail-recursive folding, improving performance and stack safety for large iterators.

LanguageExt.Core/Immutable Collections/Iterator/Trait · high confidence

Major refactor of the Error type system with centralized error codes

The core error handling mechanism has been restructured to use a new abstract \Error\ record type that distinguishes between exceptional, expected, and multiple errors, replacing previous implicit string conversions that could cause null reference exceptions. Error codes are now centralized in the \ErrorCodes\ static class, and the \Errors\ static class provides predefined instances (such as \Cancelled\, \TimedOut\, and \ValidationFailed\) for consistent error matching. A new \ErrorException\ hierarchy bridges the \Error\ type with standard .NET exceptions, allowing seamless conversion between the two while preserving error fidelity. This change improves error safety, serialization support, and pattern-matching capabilities across the library.

LanguageExt.Core/Common · high confidence

Map enumerator performance and API standardization

The Map collection now uses optimized, stack-based enumerators (MapKeyEnumerator, MapEnumerator, MapValueEnumerator) that avoid allocations by pooling internal stacks, improving iteration performance. Additionally, Map now implements standard Functor and Foldable traits, providing consistent Map extension methods and prelude functions for mapping and folding operations across the library.

LanguageExt.Core/Immutable Collections/Map · high confidence

New exception types for Option, Either, and Result validation errors

The library now exposes specific exception classes to signal validation failures in functional types. Users catching errors from Option, Either, or Result operations can now distinguish between \OptionIsNoneException\ (when an Option is empty), \EitherIsNotRightException\ or \EitherIsNotLeftException\ (when an Either is in the unexpected state), and \ValueIsNoneException\/\ValueIsNullException\/\ResultIsNullException\ for general value checks. A new \SomeNotInitialisedException\ is also available for cases where a Some value is accessed before initialization.

LanguageExt.Core/Exceptions · high confidence

New trait-based class instances for primitive types

The Class Instances directory now includes new implementations for core types (bigint, bool, char, decimal, double, float, int, long, short, string) that implement the new Traits interfaces (such as Num, Floating, Ord, Bool). This refactors the library's ad-hoc polymorphism system, allowing generic numeric and logical operations on these primitives without boxing, and adds support for tuple booleans.

LanguageExt.Core/Class Instances · high confidence

Option monad implements core functional traits and recursion support

The Option monad now explicitly implements a comprehensive set of functional programming traits, including Monad, Functor, Applicative, Alternative, Traversable, and Natural transformations to various collection types (Array, List, Seq, Iterable) and effect types (Eff, OptionT\<IO\>). This change introduces native support for tail-recursive operations via the Recur method and provides specific folding behaviors (FoldWhile, FoldBackWhile, FoldStep) that allow users to process Option values with stateful predicates and accumulation logic. Additionally, the Choice trait is implemented to enable preferential selection between two Option values.

LanguageExt.Core/Monads/Alternative Monads/Option/Trait · high confidence

Option monad refactored to use external constructor functions and readonly struct

The Option monad has been migrated to use external constructor functions (Option.Some and Option.None) instead of direct instantiation, and the Option\<A\> type is now a readonly struct. This change improves API consistency and aligns with the new SuccessI/FailI conventions, while also fixing the Option\<T\>.Case property functionality that was broken in previous versions.

LanguageExt.Core/Monads/Alternative Monads/Option · high confidence

Refactored IO monad execution into a structured DSL

The IO monad's internal execution engine has been replaced with a new DSL located in the \LanguageExt.DSL\ namespace. This change introduces a suite of new record types—including \IOAction\, \IOActions\, \IOApply\, \IOBind\, \IOCatch\, \IOEmpty\, \IOFail\, \IOFinal\, \IOFold\, and \IOLocal\—to represent specific computational patterns. For users, this provides a more explicit and optimized execution model for IO operations, supporting advanced features such as async/await integration via \ValueTask\, structured error handling with \IOCatch\, and local environment scoping with \IOLocal\.

LanguageExt.Core/Effects/IO/DSL · high confidence

Refactored Maybe MonadIO and MonadUnliftIO interfaces

The \MonadIO\ and \MonadUnliftIO\ interfaces for the \Maybe\ type have been refactored to use a generic \Supertype\/\Subtype\ pattern. This change allows the derived implementations to correctly lift IO operations and extract/map inner IO monads through the type hierarchy, ensuring that \LiftIO\, \ToIO\, and \MapIO\ behave correctly when \Maybe\ is used as part of a larger monad stack.

LanguageExt.Core/Deriving/Maybe · high confidence

Refactored Transducer DSL with new Reduced types and IO-based execution

The transducer implementation in LanguageExt.Streaming/Transducers has been restructured to use a new \Reduced\<A\>\ record struct and associated \ReducedM\ types to explicitly manage stream termination states (Continue vs Done). This change introduces a suite of new DSL transducer implementations (such as \FoldWhileTransducer\, \FoldUntilTransducer\, \FilterTransducer\, and \ComposeTransducer\) that execute via \IO\-wrapped reducers (\ReducerIO\), replacing previous patterns. The update also adds \TransduceFrom\ and \TransduceTo\ trait implementations to support monadic binding and cofunctor composition within the transducer pipeline, fundamentally changing how transducers are composed and executed.

LanguageExt.Streaming/Transducers · high confidence

Seq collection rewritten with optimized internal representation and new streaming capabilities

The \Seq\ immutable collection has been completely refactored to use a new internal architecture (\ISeqInternal\) with specialized implementations for empty (\SeqEmptyInternal\), strict (\SeqStrict\), lazy (\SeqLazy\), and concatenated (\SeqConcat\) sequences. This change introduces a new \Enum\ helper class to cache and share enumeration results, improving performance for indexed access and iteration. Additionally, a new \SeqLoan\ type has been added to allow efficient, zero-allocation reading of data from \ArrayPool\ buffers for streaming scenarios, which automatically converts to a standard \Seq\ upon transformation. The public API surface remains consistent, but the underlying behavior for operations like \Add\, \Cons\, and indexing is now backed by these optimized internal structures.

LanguageExt.Core/Immutable Collections/Seq · high confidence

Standardized Eff Functor and Applicative operations with new execution extensions

The Eff effect system now exposes standardized Functor and Applicative extension methods, including Map, Apply, and Action, allowing for consistent functional composition of effects. Additionally, new extension methods have been added to simplify effect execution, providing both safe (returning Fin) and unsafe (throwing) variants for synchronous and asynchronous runs, as well as specific support for binding and transforming Guard values within the Eff context.

LanguageExt.Core/Effects/Eff/Eff with runtime/Extensions · high confidence

Standardized Eff Prelude with Functor and Applicative operators

The Eff effect system now exposes standardized functional programming operators in the Prelude, including \map\ for Functor transformations and \apply\ for Applicative composition. This change introduces consistent method signatures (e.g., \map\<A, B\>\ and \apply\<A, B\>\) that allow users to compose Eff computations using familiar functional patterns, alongside existing helpers like \timeout\, \liftEff\, and \flatten\.

LanguageExt.Core/Effects/Eff/Eff no runtime/Prelude · high confidence

Standardized Eff applicative/functor operations and added Guard support

The Eff effect system now exposes standardized Map and Apply extension methods for both Eff and K\<Eff, A\> types, aligning with Functor and Applicative traits. New RunAsync and RunUnsafeAsync variants allow asynchronous execution of effects, while Guard types can now be naturally transformed into Eff effects, enabling conditional effect execution based on guard flags.

LanguageExt.Core/Effects/Eff/Eff no runtime/Extensions · high confidence

Standardized Eff monad Prelude with Applicative and Functor operations

The Eff monad's Prelude has been refactored to standardize its interface, introducing consistent \map\, \apply\, and \action\ operations via the \K\<Eff\<RT\>, A\>\ type. This change aligns the Eff monad with standard functional programming patterns by implementing proper Functor and Applicative abstractions, allowing users to map over and combine effects more uniformly. The update also includes runtime helper methods like \runtime\, \getState\, and \localEff\ to manage environment context and state within the effect system.

LanguageExt.Core/Effects/Eff/Eff with runtime/Prelude · high confidence

StateT monad transformer refactored with new operator overloads and trait implementations

The StateT monad transformer has been restructured to provide a comprehensive set of operator overloads and trait implementations. Users can now utilize standard operators for Functor mapping (\), Applicative application (\), Monad binding (\>\>), and sequencing (\>\>\>) on StateT computations. Additionally, new operators support Choice (\|), SemigroupK combination (+), and Fallible error handling (\|), allowing for more expressive stateful logic. The core StateT type now implements the MonadT and Stateful traits, ensuring consistent behavior with the library's monadic abstractions, while extension methods provide convenient access to state operations like Get, Put, Modify, and Lift.

LanguageExt.Core/Monads/State and Environment Monads/State/StateT · high confidence

Sys library refactored to support generic monads alongside Eff

The LanguageExt.Sys library has been refactored to support generic monads in addition to the existing Eff effect system. New static classes (e.g., Console, Environment, Time, Encoding) are now available with two type parameters (M, RT), allowing system IO operations to be executed within any monad that implements the MonadIO trait, rather than being restricted to Eff. This change provides greater flexibility for users who need to integrate system interactions into different monadic contexts while maintaining the existing Eff-based API.

LanguageExt.Sys/Sys · high confidence

Sys.IO refactored to use generic MonadIO and ProducerT

The LanguageExt.Sys.IO module has been refactored to support generic monads via the MonadIO trait, replacing the previous Eff-specific implementations. This change introduces new generic classes (Directory\<M, RT\>, File\<M, RT\>, TextRead\<M, RT\>) and updates streaming APIs to use ProducerT instead of Producer, enabling more flexible effect handling and improved type safety for file and directory operations.

LanguageExt.Sys/Sys/IO · high confidence

Try monad refactored to use external constructor functions and Fin type

The Try monad implementation has been refactored to use external static constructor functions (Succ, Fail, lift) in Try.Module.cs instead of internal constructors, and now wraps its internal state in the Fin type. This change standardizes the Applicative and Functor patterns for Try, TryT, Option, and OptionT, and ensures that BindFail correctly binds on failure. Users should now use the static factory methods to create Try instances.

LanguageExt.Core/Monads/Alternative Monads/Try · high confidence

TryT monad transformer refactored to use external constructor functions

The TryT monad transformer now uses dedicated static factory methods (Succ, Fail, lift, liftIO) in TryT.Module.cs for construction and lifting, replacing previous internal or direct constructor patterns. This change standardizes how TryT instances are created and how inner monads (including IO) are lifted into the transformer, ensuring consistent behavior for success and failure cases while maintaining the existing match, map, and bind semantics.

LanguageExt.Core/Monads/Alternative Monads/OptionT, LanguageExt.Core/Monads/Alternative Monads/TryT · high confidence

Unified resource management with \`use\` and \`MonadUnliftIO\` support

The \Prelude.Resources\ module now provides a consolidated set of \use\ methods for managing resources within the IO monad. These methods support automatic disposal for \IDisposable\ and \IAsyncDisposable\ types, as well as manual release via \bracketIO\ or \@using\ blocks. A key behavioral change is the introduction of generic overloads that work with \MonadUnliftIO\<M\>\, allowing resource management to be lifted into any monad that implements this trait, rather than being limited to the concrete \IO\ type.

LanguageExt.Core/Prelude/Resources · high confidence

Unit type gains comparison, monoid, and tuple interoperability

The Unit type now implements IComparable and Monoid, enabling direct comparison (always equal) and chaining via the addition operator. It also supports implicit conversion to and from ValueTuple, as well as from Seq, Lst, and Iterable of Unit, allowing seamless interoperability with standard C\# tuples and collection types. Additionally, Prelude methods for constructing Unit and ignoring values have been added.

LanguageExt.Core/DataTypes/Unit · high confidence

Validation monad refactored to use sealed sub-records for Fail and Success states

The Validation monad implementation has been restructured to use a sealed \Fail\ record and a sealed \Success\ record as concrete sub-types of the abstract \Validation\<F, A\>\ base. This change introduces specific behaviors for each state, such as \FailSpan()\ returning a span of the failure value in the \Fail\ state and an empty span in \Success\, and updates the \Match\, \Map\, \Bind\, and \BiMap\ methods to correctly handle the new record structure. The \Validation\ module now provides factory methods like \Empty\, \Success\, and \Fail\ that construct these new record types, ensuring that failure values are properly encapsulated and that the monad's applicative and monadic operations respect the new internal representation.

LanguageExt.Core/Monads/Alternative Monads/Validation · high confidence

ValidationT monad transformer refactored with new SuccessI/FailI conventions

The ValidationT monad transformer has been rewritten to unify its case-type pattern and improve API consistency. This change introduces new external constructor functions (SuccessI, FailI) and updates the lift API, meaning users interacting with ValidationT will see changes in how success and failure states are constructed and lifted into the transformer context.

LanguageExt.Core/Monads/Alternative Monads/ValidationT · high confidence

Value parsing methods now support any Alternative type

The Prelude's value parsing methods (such as parseInt, parseLong, parseFloat, etc.) have been extended to accept a generic type parameter constrained by the Alternative trait. This allows users to parse strings into types other than the standard Option, such as Either or other custom Alternative implementations, by providing the specific Alternative type as a generic argument. The methods return the result wrapped in the specified Alternative type, enabling more flexible error handling and type composition in parsing logic.

LanguageExt.Core/Prelude/Value parsing · high confidence

Test coverage

Added comprehensive unit tests for IO operations; Added comprehensive unit tests for Seq types and operations; Added in-memory system IO implementations for testing; Added test runtime for LanguageExt.Sys; Added tests for F\# interop conversions; Added tests for HashSet traverse/sequence operations; Added tests for Iterator basic behavior, thread safety, and edge cases; Added tests for Lst transformer cross-product behavior; Added tests for SeqT collection traverse behavior; Added trait law and default-implementation tests; Added unit tests for Arr transformer SequenceM across collection types; Added unit tests for EitherT Traverse behavior; Added unit tests for EitherT collection traversal; Added unit tests for IEnumerable traverse on Arr and HashSet collections; Added unit tests for Identity monad traverse operations; Added unit tests for Option transformer traverse operations; Added unit tests for Prelude default value checks; Added unit tests for Prelude parsing methods; Added unit tests for Schedule and Duration functionality; Added unit tests for SetT Traverse transformers; Added unit tests for core library components; Added unit tests for null-check functions; Added unit tests for streaming Source and SourceT operations; Added unit tests for synchronous IEnumerable traverse operations; Added unit tests for synchronous Lst traversal transformers; Added unit tests for synchronous SeqT traverse transformers; New benchmark suite for LanguageExt collections.

Dependencies

Added LanguageExt.Core 3.1.9-beta NuSpec for GitHub 'Used By' support

A NuSpec file for LanguageExt.Core version 3.1.9-beta has been added to the pjv directory. This change enables the 'Used By' feature on GitHub by providing the necessary package metadata, including dependencies for .NET Framework 4.5 and .NET Standard 2.0, and referencing the compiled DLLs and XML documentation files.

pjv · high confidence

LanguageExt projects migrate to .NET 10

The LanguageExt library and its associated samples, benchmarks, and test projects have been updated to target .NET 10 (net10.0). This migration updates the target framework for core packages (LanguageExt.Core, LanguageExt.FSharp, LanguageExt.Parsec, LanguageExt.Rx, LanguageExt.Streaming, LanguageExt.Sys) and all sample applications (such as BlazorApp, CardGame, and TestBed) to ensure compatibility with the latest .NET runtime.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 44 → 43 (-1.1)

Lenses

  • Code Health 61 → 54 (-7.8)
  • Architecture 95 → 95 (-0.0)
  • Maturity 53 → 58 (+4.4)
  • Readiness 28 → 26 (-2.0)
  • Security 55 → 55 (+0.0)
  • Performance 72 → 72 (+0.0)

Resolved (8)

  • Inconsistent naming for the failure collection: 'fails' (lowercase, plural noun) vs 'Fails' (uppercase, singular noun in a tuple). While one is a method name and the other a tuple element, the semantic concept of 'failures' is represented inconsistently.
  • Inconsistent naming of the collection type in the Seq module: 'SeqLoan' is used in one method signature while 'Seq' is used in another. These appear to refer to the same underlying sequence concept but are named differently, causing confusion.
  • Inconsistent naming of the collection type: 'SeqLoan' vs 'Seq'. 'SeqLoan' is likely a typo or a specific variant, but 'Seq' is the standard name. This creates confusion.
  • Inconsistent naming of the failure collection: 'fails' vs 'Fails'. 'fails' is a method name, 'Fails' is a tuple element. The semantic concept is the same, but the casing and plurality are inconsistent.
  • Inconsistent naming of the list type: 'LstInternal' vs 'ListItem'. 'LstInternal' is an internal implementation, while 'ListItem' is a node. If 'ListItem' is used to represent the list itself in some contexts, it is confusing.
  • Inconsistent naming of the list type: 'LstInternal' vs 'ListItem'. 'LstInternal' suggests an internal implementation detail, while 'ListItem' suggests a node in a linked list. If they represent the same logical list structure, the naming is confusing.
  • Thin analysable surface across projects
  • redundant comment (LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.Eq.cs)

New (5)

  • EmptyCatchBlock (LanguageExt.Core/Effects/IO/IO.cs)
  • EmptyCatchBlock (LanguageExt.Core/Effects/IO/IO.cs)
  • Orphaned file (LanguageExt.Core/Effects/Schedule/Duration.cs)
  • Orphaned file (LanguageExt.Core/Prism/Prelude_Prism.cs)
  • Orphaned file (LanguageExt.Streaming/Transducers/ReducedM.cs)

API surface

  • Unchanged — 4 HTTP endpoints

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 0 removed · edges 6 added · 6 removed

Added dependency edges (6)

  • LanguageExt.Megaparsec → LanguageExt.Core
  • LanguageExt.Streaming → LanguageExt.Core
  • LanguageExt.Sys → LanguageExt.Core
  • LanguageExt.Sys → LanguageExt.Streaming
  • Samples → LanguageExt.Core
  • Samples → LanguageExt.Streaming

Removed dependency edges (was a dependency, now gone) (6)

  • LanguageExt.Megaparsec → LanguageExt.Core (coupling)
  • LanguageExt.Streaming → LanguageExt.Core (coupling)
  • LanguageExt.Sys → LanguageExt.Core (coupling)
  • LanguageExt.Sys → LanguageExt.Streaming (coupling)
  • Samples → LanguageExt.Core (coupling)
  • Samples → LanguageExt.Streaming (coupling)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

louthy/language-ext was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 23 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 54d27a2d76cf3f14b964ce1ab421ae80a080bb7a — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.6+preprod-d36780c2d857.