louthy/language-ext

LanguageExt is a C\# library that provides a comprehensive suite of functional programming abstractions, including monads, monad transformers, and immutable data structures. It enables developers to write composable, side-effect-free code by offering types for error handling (Either, Validation), state management (State, Reader, Writer), and concurrency (STM, Atoms). The system also includes a robust concurrency framework with Software Transactional Memory and lock-free collections, alongside utility types for optics, memoization, and scheduling.

79 changes.

This period focused on expanding the library's functional programming capabilities with new concurrency primitives like STM and VectorClocks, alongside a comprehensive suite of immutable collections and monadic conditionals. The work also introduced interop layers for F\#, a parser framework, and enhanced the core library with extensive unit test coverage and system IO abstractions.

59 changes.

This period focused on expanding the library's functional programming capabilities by introducing a comprehensive suite of monads, including IO, Eff, Free, and various transformers like ReaderT, StateT, and WriterT. The work also involved refactoring existing types such as Option, Either, and Validation to support new traits and external constructor patterns, while adding concurrency primitives and lazy sequence abstractions.

71 changes.

This period focused on introducing a comprehensive streaming library with Source, Sink, and Conduit abstractions for functional data processing. It also significantly expanded functional programming support across the codebase by adding operator overloads and trait implementations for numerous monads, including Option, Either, Try, and Validation.

A new Blazor sample project has been added to the Samples directory, providing a complete example of integrating the library with a Blazor Server application. The sample includes a base Page component that wraps standard Blazor lifecycle methods (OnInitialized, OnAfterRender, etc.) in the Eff monad, allowing side effects like random number generation and time access to be handled cleanly within the application's runtime. It also demonstrates a Weather page that fetches and displays data using the library's functional effects, showcasing how to manage state and side effects in a Blazor context.

Samples · high confidence

The library introduces the ContT type, a continuation monad transformer that allows adding continuation handling to any type constructor. This new component provides monadic bind and map operations, enabling users to compose asynchronous or complex control-flow logic within the LanguageExt monadic framework.

LanguageExt.Core/Monads/ContT · high confidence

New operators are added for the \Fin\ monad, including functor mapping (\\*\), monadic bind (\\>\>\), applicative sequencing (\\>\>\>\), choice (\\|\), semigroup combining (\+\), and downcasting (\+\/\\>\>\), enabling functional composition and error handling patterns for \Fin\.

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

Introduces new \Lens\ and \Prism\ types in the \LanguageExt\ library to support functional, immutable data access and updates. The \Lens\ struct provides bidirectional transformations for direct field access, while the \Prism\ struct handles optional or conditional access via \Option\<B\>\. The update includes operator overloading for composing lenses, convenience methods for extracting tuple elements (fst, snd, thrd), and sequential composition for both lenses and prisms up to ten levels deep. A README file is also added to explain the concepts.

LanguageExt.Core/Lens · high confidence

The LanguageExt library introduces a new \Loop\<A\>\ record struct designed to represent values in tail-recursive loops, allowing other types to convert from it and provide binding extensions. This change adds the core \Loop\ struct along with a \Prelude\ factory method and extension operators for value extraction and function composition, enabling users to lift values into other monads without specifying extra generic arguments.

LanguageExt.Core/DataTypes/Loop · high confidence

The library introduces new \Pure\<A\>\ and \Fail\<E\>\ value types, each providing standard monadic operators (map, bind, select many) and conversion methods to other types such as \Either\, \Option\, \IO\, \Fin\, \Try\, and \Validation\. \Pure\ represents a successful value and includes a \ToIO()\ method, while \Fail\ represents an error state and includes a \ToValidation()\ method. These additions enable more direct manipulation of pure and failure states within the monadic framework.

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

A new \Ratio\<A\>\ struct has been added to the \LanguageExt\ namespace. This readonly struct holds a numerator and denominator, providing a way to represent fractional values in non-reduced form, which is used in the definition of \Fractional\.

LanguageExt.Core/DataTypes/Ratio · high confidence

The LanguageExt.Rx package now provides extension methods to convert \Atom\, \Ref\, and \AtomHashMap\ instances into observable streams. Users can subscribe to changes on these stateful types using the new \OnChange\ and \Latest\ methods, which emit the current value and subsequent updates. Additionally, \Eff\, \Option\, \Either\, and \Validation\ types can be converted into observables via \ToObservable\ and \MatchObservable\ methods, enabling reactive programming patterns with the library's functional types.

LanguageExt.Rx · high confidence

New extension methods are added to the Source type to support converting various input types (Channel, IEnumerable, IAsyncEnumerable, and IObservable) into a Source, as well as forcing iteration over a Source to collect results or trigger side effects. This introduces the \AsSource\ overloads for different input types and the \Iter\, \Last\, and \Collect\ methods to execute stream processing.

LanguageExt.Streaming/Source/Extensions · high confidence

The LanguageExt library introduces a new \StringM\ type, a wrapper around the standard string type that implements domain type and ordering traits. This addition provides specialized string wrappers for different comparison behaviors, including ordinal, case-insensitive, culture-aware, and invariant string handling. These new types enable consistent string comparison and hashing across the library's functional programming abstractions.

LanguageExt.Core/DataTypes/StringM · high confidence

The LanguageExt library introduces a new \Tell\ record type to support the \Writer\ and \RWST\ monads. This type provides convenience methods to convert to \WriterT\, \Writer\, and \RWST\ contexts, enabling users to perform write-only logging or state accumulation within these monadic workflows.

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

A new \VersionHashMap\ collection has been added to the \LanguageExt.Core\ library. This mutable, thread-safe data structure maintains versioned values using vector clocks to track causality across multiple actors (e.g., network nodes or users). It supports atomic, transactional updates and includes built-in conflict resolution logic that merges or resolves competing versions. The API provides methods for swapping keys, updating versions, and cleaning up deleted or old entries.

LanguageExt.Core/Concurrency/VersionHashMap · high confidence

A new \bigint\ readonly struct is introduced as a convenience wrapper around \System.Numerics.BigInteger\. It provides constructors for common numeric types (int, long, decimal, etc.), static constants for Zero/One/MinusOne, and utility properties like IsEven and IsZero, enabling users to work with large integers in a functional-style API.

LanguageExt.Core/DataTypes/BigInt · high confidence

New extension methods are added for Arr, IterableNE, Iterator, IteratorAsync, and Identity types, each providing a '+' operator and a '\>\>' operator to perform downcasting from their respective K-wrapped types to their concrete types.

(repo-wide) · high confidence

New extension methods are added to the LanguageExt library to improve interoperability with standard .NET collections. For synchronous iteration, the \IteratorExtensions\ class provides an \As\ method to cast a constrained \K\<Iterator, A\>\ to an \Iterator\<A\>\, and a \GetIterator\ method to convert any \IEnumerable\<A\>\ into an \Iterator\<A\>\. Similarly, for asynchronous iteration, \IteratorAsyncExtensions\ introduces an \As\ method to cast \K\<IteratorAsync, A\>\ to \IteratorAsync\<A\>\, and a \GetIteratorAsync\ method to convert \IAsyncEnumerable\<A\>\ into an \IteratorAsync\<A\>\.

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

New operator overloads are added to the \Option\, \These\, and \TryT\ monads, enabling functional-style composition. \Option\ and \TryT\ gain applicative (\\\, \\>\>\>\) and monadic (\\>\>\) operators, along with choice (\\|\) and fallible/catch operators. \These\ gains functor (\\\) and semigroup (\+\) operators. These changes allow users to compose computations using symbolic operators rather than method calls.

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

The LanguageExt library introduces new functional programming capabilities for several monad types. For \Option\, \OptionT\, \Try\, and \TryT\, extension methods and prelude functions are added to support functor \map\, applicative \apply\, and \action\ operations. For the \These\ monad, new extension methods and prelude functions are added to support \map\, \apply\, \combine\, and \partition\ operations. These additions enable more expressive functional programming patterns, such as applying functions within applicative contexts and combining values from multiple monadic structures.

(repo-wide) · high confidence

The Prelude now provides generic parsing methods (e.g., \parseInt\<M\>\, \parseLong\<M\>\) that accept any type \M\ implementing the \Alternative\ trait. This allows users to parse string values into specific types wrapped in their chosen \Alternative\ container (such as \Option\ or \Either\), enabling more flexible error handling and type-safe conversions across the library.

LanguageExt.Core/Prelude/Value parsing · high confidence

Introduces a new immutable \Que\<T\>\ collection type, providing queue semantics (FIFO) with efficient head/tail operations, including \Enqueue\, \Dequeue\, \Peek\, and functional combinators like \map\, \filter\, and \fold\.

LanguageExt.Core/Immutable Collections/Queue · high confidence

Introduced \MemorySystemEnvironment\ and \MemoryConsole\ classes that provide in-memory implementations of the system environment and console, enabling unit tests to simulate user input and environment variables without relying on the actual operating system or physical console.

LanguageExt.Sys · high confidence

Introduced new live implementations for system IO operations, including file, directory, console, environment, time, and text reading. These components provide a functional, effect-based interface to standard system services, enabling side-effecting operations to be handled within the IO monad.

LanguageExt.Sys/Live/Implementations · high confidence

The LanguageExt library introduces new monadic conditional operators to the \Prelude\ class. \guard\ and \guardnot\ allow short-circuiting applicative expressions based on a boolean flag, supporting both generic applicatives and specific \IO\/\Error\ variants. \when\ and \unless\ provide conditional execution of monadic computations, with overloads for \Monad\, \MonadIO\, and \Pure\ types. Additionally, \iff\ enables if-then-else logic within monadic contexts, supporting mixed \IO\ and pure branches. These additions enable more declarative, composable control flow in functional code.

LanguageExt.Core/Monads/Monadic conditionals · high confidence

New monoid implementations have been added for several types, enabling users to combine values using specific aggregation rules: addition for numeric types, multiplication for numeric types, logical AND/OR for booleans, error concatenation, and unit handling. These instances allow for more expressive functional programming patterns when working with these core types.

LanguageExt.Core/Class Instances/Monoid · high confidence

The \EitherT\ monad transformer now supports a comprehensive set of operator overloads and extension methods, enabling more idiomatic functional programming syntax. This includes the \\>\>\ operator for sequential monadic binding, the \\*\ operator for applicative application and functor mapping, the \\|\ operator for choice and fallback logic, and the \+\ operator for combining results. These additions allow developers to compose \EitherT\ computations using standard C\# operators, improving readability and conciseness.

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

The \OptionT\ monad now supports a comprehensive set of operator overloads, including functor mapping (\\*\), monadic binding (\\>\>\), applicative sequencing (\\>\>\>\), choice (\\|\), and semigroup combining (\+\). These additions enable more idiomatic and concise usage of \OptionT\ in expressions, supporting multi-argument function application, sequential action composition, and error/alternative handling directly through operators.

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

The Reader monad now implements the Monad, Readable, Functor, and Applicative traits, providing standard functional programming operations such as Bind, Map, Pure, and Apply, as well as environment access methods like Ask, Asks, and Local.

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

The ValidationT monad transformer now implements a comprehensive set of functional programming traits, including Monad, Applicative, Functor, Alternative, MonoidK, SemigroupK, Choice, and Fallible. This enables ValidationT to be used as a composable, effectful computation that accumulates or short-circuits errors according to the underlying monad M, while supporting alternative choice and error handling patterns.

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

The library now includes a comprehensive set of strongly-typed units of measure for physics calculations, including Length, Area, Mass, Time, Temperature, Velocity, Acceleration, and their squared variants. Each type handles unit conversions automatically, allowing users to perform arithmetic operations (addition, subtraction, multiplication, division) between compatible units while maintaining type safety. The module provides extension methods to create these types from primitive numeric types and accessors to extract values in various units (e.g., Metres, Kilometres, Miles for Length; Grams, Kilograms, Tonnes for Mass).

LanguageExt.Core/Units of Measure · high confidence

Introduced new Activity classes in the LanguageExt.Sys.Diag namespace to support distributed tracing. The implementation provides span creation and activity management for both the Eff effect system and a generic M monad interface, allowing developers to trace operations with tags, baggage, and parent context.

LanguageExt.Sys/Sys/Diag · high confidence

The \LanguageExt.Core/Class Instances/Hashable\ directory now includes new \Hashable\ implementations for a wide range of types, including primitives (bool, char, decimal, double, float, int, long, short), collections (Arr, Array, Enumerable, HashSet, Lst, Map, Seq, Set, Stck, Que), and LanguageExt-specific types (Either, Edit, Identity, Option, Patch, Record, Task, Tuple, TypeInfo). This enables consistent hashing behavior across the library's data structures.

LanguageExt.Core/Class Instances/Hashable · high confidence

The \IterableNE\ type now implements the \Foldable\ and \Monad\ traits, enabling functional programming operations such as \FoldWhile\, \FoldBackWhile\, and monadic recursion support. This allows users to perform fold and map operations on non-empty iterables, with specific support for converting to \Arr\, \Lst\, \Seq\, \Set\, and \HashSet\ types.

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

The LanguageExt library now includes a new \LanguageExt.Pretty\ namespace featuring a \Doc\ and \DocAnn\ system for building and laying out formatted text documents. This addition provides functions for constructing documents with features like line breaks, indentation, grouping, and alignment, allowing users to generate structured text output with configurable page widths and ribbon fractions.

LanguageExt.Core/Pretty · high confidence

The internal TrieSet class has been added to support the CHAMP trie hash map data structure, which is used internally by LanguageExt.HashSet. This new implementation provides methods for adding, removing, and updating items in an immutable set, including range operations and conditional adds.

LanguageExt.Core/Immutable Collections/TrieSet · high confidence

A new \Next\<A, B\>\ struct and its associated module have been added to the \LanguageExt\ library. This lightweight, allocation-free data type is designed to support tail-recursive monad operations, allowing functions to indicate whether they should continue a loop or return a final value. It provides pattern matching, mapping, and conversion to \Either\ types to facilitate recursive algorithm implementations.

LanguageExt.Core/DataTypes/Next · high confidence

A new \fun\ helper function has been added to the \Prelude\ class to assist with lambda type inference. This allows users to write expressions like \var add = fun((int x, int y) =\> x + y);\ instead of explicitly declaring the \Func\ type, enabling the compiler to infer the types of the lambda parameters and return value.

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

A new benchmarking project has been introduced to measure the performance of collection operations. The suite includes benchmarks for adding, checking existence, iterating, and removing items from maps (HashMap, Map, ImmutableDictionary, ImmutableSortedDictionary, Sasa Trie) and sets (HashSet, Set, ImmutableHashSet, ImmutableSortedSet, Sasa Trie). It also covers list iteration and addition for Lst and Seq. The benchmarks are parameterized by type (int, string) and use a shared ValuesGenerator for test data.

LanguageExt.Benchmarks · high confidence

The library now provides class instances for \bool\, \char\, \decimal\, \double\, \float\, \int\, \long\, \short\, \string\, and \bigint\. These instances implement traits such as \Num\, \Floating\, \Ord\, and \Bool\, enabling functional programming patterns like ad-hoc polymorphism for these standard types.

LanguageExt.Core/Class Instances · high confidence

The State and Environment monads now include new \Put\, \Modify\, and \Gets\ record structs that provide convenient conversion methods to \Stateful\, \StateT\, and \State\ types, as well as LINQ-style \SelectMany\ bindings for \RWST\.

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

The Prelude now provides a \hash\ function that calculates hash codes for various collection types, including \Arr\, \HashMap\, \HashSet\, \Lst\, \Map\, \Que\, \Seq\, \Set\, and \Stck\. This allows users to easily compute hash codes for these collections, which is useful for hashing in dictionaries or other hash-based data structures.

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

The \LanguageExt\ library now provides convenience methods for the \Either\ monad. The \Prelude\ class includes \Right\ and \Left\ constructors that return \Either\<L, R\>\ instances, as well as \Pure\ and \Fail\ wrappers. Additionally, functional programming operations such as \map\, \action\, and \apply\ are exposed as static methods on \Prelude\, enabling more concise usage of the \Either\ type in functional pipelines.

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

The LanguageExt library now includes an immutable \Stck\<T\>\ collection type, providing a functional stack data structure. This addition brings stack-specific functional operations such as \map\, \filter\, \fold\, \foldBack\, \choose\, \collect\, and \rev\ (reverse), along with standard stack operations like \push\, \pop\, \peek\, and \clear\. The implementation supports LINQ-style projection and filtering, allowing users to transform and query stack data immutably.

LanguageExt.Core/Immutable Collections/Stack · high confidence

Implemented \Ord\ (ordering) and \Eq\ (equality) class instances for a wide range of types, including primitives (int, long, float, double, bool, char, decimal, Guid, DateTime, Exception), collections (List, Array, Set, Map, Queue, Stack, Sequence, Enumerable, Iterable), and custom types (Option, Either, Record). This enables consistent comparison, sorting, and hashing behavior across the library.

LanguageExt.Core/Class Instances/Ord · high confidence

The codebase now includes the concrete trait implementations for the \EitherT\ monad transformer. This adds support for monadic operations (Bind, Map, Apply, Pure), recursion (Recur), and choice (Choose) for \EitherT\. It also introduces \Fallible\ support for error handling and \Natural\ transformation to \OptionT\. These changes enable \EitherT\ to function as a full-featured monad transformer within the LanguageExt library.

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

Introduced new trait implementations for the \OptionT\, \Try\, and \TryT\ monads. These changes add support for alternative monad operations, including \Bind\, \Recur\ (tail recursion), \Map\, \Pure\, \Apply\, \Empty\, \Choose\ (choice/alternative), and \Catch\ (error handling) for these types. This enables functional programming patterns like error handling and monadic composition for these specific types within the LanguageExt library.

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

The Validation monad now implements a comprehensive set of functional programming traits, including Monad, MonoidK, Alternative, Traversable, and Foldable. This adds support for recursive operations, applicative composition, choice/empty semantics, and traversal capabilities, enabling more expressive and composable error-handling logic in user code.

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

Introduces the \Alternative\ trait, which provides support for failure and choice propagation in applicative functors, including methods like \choice\, \some\, \many\, and \endBy\ for parsing and sequencing operations. Additionally, new law test files (\Alternative.Laws.cs\, \Applicative.Laws.cs\) are added to validate that \Alternative\ and \Applicative\ implementations adhere to their respective mathematical laws.

LanguageExt.Core/Traits · high confidence

The \FinT\ monad now supports a comprehensive set of operators and extension methods, enabling functional programming patterns such as functor mapping, monadic binding, applicative sequencing, and choice/catch handling. Users can now use operators like \\*\ for applicative application, \\>\>\ for sequencing, \\|\ for choice and error handling, and \+\ for combining results. Additionally, utility methods for partitioning, flattening, and guarding are available on \FinT\ instances.

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

The Maybe monad now supports lifting and unlifting IO operations. A new \MonadIO\ interface allows IO operations to be lifted into the Maybe monad, while a new \MonadUnliftIO\ interface enables extracting or mapping the inner IO monad within the Maybe structure. This provides a more consistent and powerful way to handle side effects within the Maybe monad.

LanguageExt.Core/Deriving/Maybe · high confidence

The LanguageExt library introduces new functional programming capabilities for C\# Task types. New extension methods and Prelude functions are added to support monadic operations such as \Select\, \SelectMany\, \Where\, \Bind\, \Fold\, \Iter\, \Exists\, \ForAll\, and \Filter\ on \Task\ objects. Additionally, utility functions like \Flatten\ for nested tasks, \Count\, and \choice\ for executing multiple tasks and returning the first success are now available, enabling more declarative and composable asynchronous code.

LanguageExt.Core/Concurrency/Task, LanguageExt.Core/Concurrency/ValueTask · high confidence

The Writer monad is introduced, providing a new way to handle side effects that produce a log or output alongside a value. This update adds the core \Writer\<W, A\>\ type, along with extensions for monadic bind (\\>\>\), functor mapping (\\\), and applicative operators (\\>\>\>\, \\\). It also includes helper functions like \tell\, \write\, \pass\, \listen\, \listens\, and \censor\ in the \Prelude\ and module classes, enabling users to compose computations that accumulate output using a \Monoid\-constrained type \W\.

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

New extension methods are added to the \Validation\ monad to support functional programming patterns. This includes \Apply\ and \Action\ for applicative-style composition, \Map\ for functor mapping, and \Bind\/\SelectMany\ for monadic binding. Additionally, a \Guard\ extension allows converting a guard condition into a \Validation\ result, and utility methods like \Successes\ and \Fails\ allow filtering collections of validations.

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

New methods are introduced to support functional programming patterns for the \Validation\ and \ValidationT\ monads. For \Validation\, the \Prelude\ now includes \action\ and \apply\ for applicative-style sequencing and mapping, as well as \Success\ and \Fail\ constructors. For \ValidationT\, extension methods are added to the \Prelude\ and \ValidationTExtensions\ classes, providing \map\, \action\, and \apply\ operations, along with monadic bind (\SelectMany\) and guard integration (\ToValidationT\). These changes enable users to compose \Validation\ and \ValidationT\ values using standard applicative and functor idioms.

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

The LanguageExt.Core/Utility directory now includes several new utility classes to support asynchronous programming and concurrency. AsyncEnumerableEx provides an async Merge operator for combining multiple IAsyncEnumerable sequences. TaskExt introduces a WhenAny implementation for awaiting the completion of any task in a collection. WaitAsync adds helpers for waiting on WaitHandles asynchronously. SysInfo exposes system processor count and a default parallelism setting. Additional utilities include Box for efficient value-type boxing, Pool for thread-safe object pooling, Fnv for fast hashing, and Reflect for reflection-based type inspection. These additions provide foundational building blocks for async workflows and concurrent state management within the library.

LanguageExt.Core/Utility · high confidence

The file IteratorAsync.TraitImpl.cs is added, implementing the Monad, Functor, and Applicative type classes for the IteratorAsync type. This introduces support for asynchronous iteration, including a new Apply method that handles function application over async iterables, enabling users to perform asynchronous operations within the iterator pipeline.

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

The \ReaderT\ monad transformer now supports a full suite of functional programming operators, including Functor mapping (\\\), Applicative application (\\\), Monad binding (\\>\>\), and Choice (\\|\) operators. These additions enable more concise and expressive code when composing \ReaderT\-wrapped effects, allowing developers to use standard infix syntax for sequencing, mapping, and handling alternative paths in their monadic pipelines.

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

The State monad now supports a full suite of functional programming operators. Users can now use the \\*\ operator for Applicative application and Functor mapping, the \\>\>\ operator for sequential composition and monadic binding, and the \+\ operator for downcasting. Additionally, extension methods like \Run\, \Flatten\, and \As\ are provided to simplify running stateful computations and flattening nested states.

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

The LanguageExt.Core library now provides \Eq\ (equality) and \Hashable\ (hash code) class instances for a broad set of types, including primitives (int, long, short, bool, char, float, double, decimal, Guid, DateTime, Exception, TypeInfo), collections (Array, List, IEnumerable, Set, HashSet, Map, Seq, Lst, Que, Stck), custom types (Option, Either, Edit, Patch, Identity, Compositions, Task), and tuples. This enables consistent equality testing and hashing across the library's data structures.

LanguageExt.Core/Class Instances/Eq · high confidence

New extension methods are added to the \IterableNE\ type, introducing functional programming capabilities including \Map\ for functor mapping, \Apply\ for applicative operations, and \Action\ for sequencing. Additionally, conversion helpers (\AsIterableNE\) are provided to create non-empty collections from standard sequences, arrays, and lists, alongside a \Flatten\ method for monadic joins.

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

New extension methods are added to the \Reader\ monad, enabling functional programming patterns such as functor mapping, applicative sequencing, and monadic binding using operators like \\*\ and \\>\>\. This allows developers to compose and transform values within the \Reader\ context using a more concise, operator-based syntax.

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

The LanguageExt library introduces a new set of operators for the \Either\ type, enabling functional programming patterns. This includes functor mapping (\\\), monadic binding and sequencing (\\>\>\), applicative composition (\\\), and choice/fallback (\\|\) operators. These additions allow developers to compose \Either\ computations using standard infix syntax for cleaner, more expressive code.

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

The \Eff\ type now supports a comprehensive set of functional programming operators, including functor mapping (\\\), monadic binding and sequencing (\\>\>\), applicative sequencing and apply (\\>\>\>\, \\\), choice (\\|\), fallible handling, and \finally\ blocks. These operators are implemented for both the base \Eff\ type and the runtime-parameterized \Eff\<RT\>\ type, enabling more concise and expressive effectful computations.

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

The \Arr\ type now supports functional programming patterns including \Map\, \Select\, \Bind\, \SelectMany\, \Action\, and \Apply\ operations, enabling users to transform, filter, and combine arrays using standard functor, applicative, and monadic interfaces.

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

The LanguageExt library adds new functional programming utilities to the \Prelude\ class, including \curry\ and \uncurry\ methods for transforming between curried and uncurried functions, \par\ for partial application, and \flip\ for reversing function argument order. Additionally, a thread-safe cryptographically strong random number generator is introduced, providing \random\ and \randomBase64\ methods for generating random integers and Base64-encoded strings.

(repo-wide) · high confidence

The LanguageExt library introduces a new set of operator overloads for the \Try\ monad, enabling more idiomatic functional programming syntax. This includes the \\>\>\ operator for sequential composition and monadic bind, the \\*\ operator for functor mapping and applicative application, the \\|\ operator for choice and error handling, and a \+\ operator for downcasting. These operators allow developers to compose \Try\ actions and functions using standard C\# operators, supporting up to 11-argument curried functions.

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

New operator overloads have been added to the \Validation\ and \ValidationT\ types, enabling functional programming patterns such as applicative sequencing (\\>\>\>\), apply (\\\), functor mapping (\\\), monadic binding (\\>\>\), choice (\\|\), and semigroup combining (\&\, \+\). These operators allow users to compose validation computations more concisely, supporting multi-argument function application and sequential execution while preserving error accumulation.

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

The \Either\ type now implements a comprehensive set of functional programming traits, including \Monad\, \Applicative\, \Functor\, \Traversable\, \Foldable\, \Choice\, and \Fallible\. This provides users with standard functional abstractions for working with \Either\<L, R\>\ values, enabling more idiomatic and composable code using these interfaces.

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

The Arr (array) collection now implements a full suite of functional programming traits including Monad, Traversable, Alternative, MonoidK, and various Foldable operations. This enables more expressive, composable code using standard functional patterns like bind, map, and fold operations on arrays.

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

The library introduces a new asynchronous iterator DSL for the \IteratorAsync\ type, implementing a linked-list style sequence with \Cons\ (head and tail) and \Nil\ (empty) cases. This includes internal implementations for handling async enumerables, values, and lazy evaluation, enabling users to process asynchronous sequences with head/tail deconstruction and safe memory management. Additionally, extension methods are added to the \Identity\ monad, allowing conversion to the underlying value or the identity wrapper itself.

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

The \AtomHashMap\ type now exposes a \Change\ event that fires whenever an operation successfully modifies the underlying data. Subscribers can listen to this event to receive \HashMapPatch\ objects describing the modifications, enabling reactive updates or synchronization without polling.

LanguageExt.Core/Concurrency/AtomHashMap · high confidence

The BiMap collection now exposes methods to add or update multiple items at once via AddRange, TryAddRange, and AddOrUpdateRange over tuples, Tuples, and KeyValuePairs. It also provides TryAdd and Add for single-item additions. These additions are atomic and preserve the bidirectional lookup, ensuring both the primary and reverse maps are updated consistently.

LanguageExt.Core/Immutable Collections/BiMap · high confidence

The \ChronicleT\ monad now supports functional composition and sequencing via the \\\ and \\>\>\ operators. The \\\ operator enables applicative-style application and functor mapping for up to 11-argument functions, while the \\>\>\ operator provides monadic binding and sequential composition, allowing users to chain and combine \ChronicleT\ actions more concisely.

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

The library now provides extensive functional programming capabilities for C\# ValueTuples of sizes 1 through 7. This includes extension methods and Prelude functions for mapping, folding, iterating, and traversing tuples, as well as utility methods like head, tail, and contains. The implementation leverages the library's type-class system (Traits) to provide generic, composable operations on tuples, enabling users to treat tuples as first-class functional data structures with support for monadic operations like Traverse and Sequence.

LanguageExt.Core/DataTypes/ValueTuple · high confidence

The EitherT monad transformer now includes new extension methods for lifting values and monadic computations into the transformer context. Specifically, it adds liftIO overloads to handle IO\<Either\<L, A\>\> and K\<IO, A\> effects, as well as lift overloads for Pure and Fail wrappers. Additionally, the module exposes MapLeft and Select operations, allowing users to transform the right-hand side of the EitherT result or map the left-hand side error type directly.

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

The Parsec library introduces a comprehensive set of new parser combinators and utilities. Character parsing is enhanced with new primitives like \LF\, \oneOf\, \noneOf\, and \satisfy\, alongside the deprecation of the \newline\ parser in favor of explicit \LF\ and \CRLF\ handling. Expression parsing is supported via the new \Expr.buildExpressionParser\ for building operator tables with associativity and precedence. Indentation-sensitive parsing is introduced through the \Indent\ module. Additionally, the \Prim\ module exposes \getPos\ and \getIndex\ for tracking parser position, while the \Token\ and \Token2\ modules provide robust lexical analysis including support for comments, escape codes, and number parsing.

LanguageExt.Parsec/Parsers · high confidence

The LanguageExt.Prelude static class has been expanded with several new utility functions, including identity, constant, failwith, raise, and exceptionIs, as well as not and isDefault helpers. These additions provide more functional programming primitives and error-handling utilities directly in the prelude namespace.

LanguageExt.Core/Prelude · high confidence

The SourceT DSL now includes a comprehensive set of new source types and operators, including support for IObservable, async/sync iterators, and multi-listener channels. This adds capabilities for combining, zipping, and transforming streams, as well as new folding and filtering operators. The implementation introduces MultiListenerSourceT to handle multiple concurrent consumers, enabling more robust stream processing patterns.

LanguageExt.Streaming/SourceT/DSL · high confidence

The \LanguageExt.Core/Deriving\ namespace now includes new derived implementations for a broader set of functional programming type classes, including \MonadIO\, \MonadUnliftIO\, \Decidable\, \Divisible\, \Readable\, \Stateful\, and \Writable\. These additions provide automatic derivation for higher-kinded types, enabling more expressive and composable abstractions for effects, state, and resource management.

LanguageExt.Core/Deriving · high confidence

The immutable HashSet collection now implements functional programming traits including Monad, Traversable, Alternative, and MonoidK, and exposes corresponding extension methods for Map, Apply, and Action operations. This enables developers to use functional composition, monadic binding, and applicative style operations directly on HashSet instances, aligning the collection with the library's broader functional abstractions.

LanguageExt.Core/Immutable Collections/HashSet · high confidence

The immutable Set collection now implements functional programming interfaces including Monad, Applicative, and Traversable. This enables functional composition patterns such as mapping, applying functions, and traversing sets using the library's functional abstractions. The Set type now supports higher-order functions and monadic operations, allowing developers to compose set transformations in a functional style.

LanguageExt.Core/Immutable Collections/Set · high confidence

The Source type now implements the Monad, MonoidK, and Alternative typeclasses, providing essential functional programming capabilities such as binding, mapping, applying, and combining streams. This enables more expressive and composable stream processing using standard functional patterns.

LanguageExt.Streaming/Source/Trait · high confidence

Added the \Atom\ class in \LanguageExt.Core/Concurrency/Atom\, providing a way to manage shared, synchronous, independent state without locks. Users can now create atomic references to immutable data structures and update them atomically using the \Swap\ and \SwapIO\ methods, which handle concurrency via spin loops. The implementation includes a \Change\ event to notify listeners of state updates and supports optional validators to ensure state validity during transitions.

LanguageExt.Core/Concurrency/Atom · high confidence

Added the new \AtomSeq\<A\>\ class in \LanguageExt.Core/Concurrency/AtomSeq/AtomSeq.cs\. This provides a thread-safe, lock-free sequence type that allows multiple threads to perform atomic updates (via \Swap\ and \Add\ methods) without using traditional locking mechanisms, improving concurrency performance.

LanguageExt.Core/Concurrency/AtomSeq · high confidence

Added the \ChronicleT\ monad transformer, which enables accumulating side-effects or logs alongside standard monadic computations. This new type implements \MonadT\, \MonadIO\, \Fallible\, \Choice\, and \Chronicaler\ interfaces, allowing users to build computations that produce both a result and a chronological record of events or errors. The implementation supports tail recursion and memoization, providing a robust foundation for logging, auditing, or debugging workflows within the LanguageExt library.

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

Added the ChronicleT monad transformer, which combines accumulating outputs with the ability to abort computation via a final output. This new type provides methods such as dictate, confess, memento, absolve, condemn, and censor, enabling users to manage both non-fatal errors (accumulated) and fatal errors (aborts) in a single structure.

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

Added a new \Compositions\<A\>\ data type and supporting modules (\Compositions.Module\, \Compositions.Extensions\, \FoldCompositions\) that maintain a right-biased composition tree. This allows computing the composition of the first or last \k\ elements in logarithmic time, which is useful for scenarios like wiki version control or collaborative editing where deltas need to be composed efficiently.

LanguageExt.Core/DataTypes/Compositions · high confidence

The library now provides a \Conduit\ type that represents a channel with an internal queue, exposing both a \Sink\ (input) and a \Source\ (output). Users can create conduits with configurable buffering strategies (unbounded, bounded, single, latest, newest, or new) and manipulate values using functor (\Map\) and cofunctor (\Comap\) operations, as well as transducers. This adds a new way to process streams in the LanguageExt library.

LanguageExt.Streaming/Conduit · high confidence

The ConduitT class is introduced, providing a channel-based conduit with a Sink and Source that support functional transformations via Functor and Cofunctor traits. Users can now map values on the Source side and Comap values on the Sink side, enabling composable data processing pipelines with configurable buffering strategies.

LanguageExt.Streaming/ConduitT · medium confidence

A new \Fin\ monad implementation has been added to the library, providing a functional data type that supports tail recursion via a \Recur\ method. The implementation includes standard monadic operations (\Bind\, \Map\, \Pure\, \Apply\), as well as \Foldable\ and \Traversable\ support. Additionally, the \Fin\ type now implements natural transformations to \Either\, \Option\, \Try\, and \IO\, allowing for easy conversion between these effect types.

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

Added a new \HashMapPatch\ class that represents the difference between two states of a \HashMap\. This class exposes \From\ and \To\ properties to access the previous and current map states, as well as a \Changes\ property that details the specific key-value modifications. This change primarily supports the \Change\ events on \AtomHashMap\ types and the \Changes\ property of \TrackingHashMap\, enabling users to track and react to map modifications.

LanguageExt.Core/DataTypes/MapPatch · high confidence

The IdentityT monad transformer is now available, providing a generic wrapper for monadic computations that supports lifting IO actions via the MonadUnliftIO interface. The implementation includes extension methods for conversion and a module for pure and lift operations, enabling users to sequence and map over identity-wrapped values while preserving the underlying monad's behavior.

LanguageExt.Core/Monads/IdentityT · high confidence

Added support for manipulating patches (diffs) on a collection of elements. This introduces the \Patch\<EqA, A\>\ struct and \Edit\ types (Insert, Delete, Replace) to represent and compose document edits. The implementation includes logic to normalize, merge, and invert patches, as well as helper types like \SpanArray\ for efficient array slicing and \PatchParams\ for customizing patch behavior.

LanguageExt.Core/DataTypes/Patch · high confidence

The \Reader\ monad is now available, allowing code to access a static environment value throughout a computation. This includes the \Reader\ class and its extensions, providing methods like \ask\ and \asks\ to retrieve the environment, \local\ to temporarily modify it, and \run\ to execute the computation with a specific environment. This enables functional programming patterns where environment data is threaded through without explicit parameter passing.

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

The library now provides a new \Sink\ type that allows users to consume streaming data. This abstraction supports functional composition via contravariant functors (Comap), combining multiple sinks (Divide/Route), and converting to existing Consumer types. Users can create sinks from channels or combine them to process data streams.

LanguageExt.Streaming/Sink · high confidence

The LanguageExt.Streaming library now exposes the Source and SourceT types, providing a functional stream abstraction. Users can create empty, singleton, or infinite sources, and lift data from Channels, IEnumerables, IAsyncEnumerables, and IObservables into the stream. The Source type includes operators for mapping, binding, filtering, combining, choosing, zipping, skipping, taking, and folding, enabling functional composition of data pipelines.

LanguageExt.Streaming/Source · high confidence

The \SourceT\ type is introduced as a new stream abstraction, providing methods to lift values, foldables, and \System.Threading.Channels.Channel\ instances into streams. It supports transformation via transducers, monadic binding, and reduction, enabling users to construct and process infinite or finite streams with consistent behavior.

LanguageExt.Streaming/SourceT · medium confidence

Added a new \TrackingHashMap\ immutable collection that automatically tracks changes (additions, updates, removals) since the last snapshot. Users can access a \Changes\ property to see a map of all modifications, and can call \Snapshot()\ to reset the change log, enabling easy detection of state differences over time.

LanguageExt.Core/Immutable Collections/TrackingHashMap · high confidence

Added a new Trampoline monad implementation in LanguageExt.Core/Monads/Trampoline/Trampoline.cs. This provides a way to handle deep or infinite recursive computations without risking stack overflow, using a trampoline pattern that executes steps iteratively. The implementation includes Pure, More, Bind, Map, and Select methods, along with internal step types (PureStep, MoreStep, BindStep) that manage the recursive execution loop.

LanguageExt.Core/Monads/Trampoline · high confidence

Added a new VectorClock implementation in the LanguageExt.Core library, providing a data structure for tracking causal ordering in distributed systems. The change introduces a Relation enum (Causes, CausedBy, Concurrent) and static methods to compare, merge, and compute differences between vector clocks, enabling users to determine the causal relationship between events across different processes.

LanguageExt.Core/Concurrency/VectorClock · high confidence

The library now provides \IteratorAsync\<A\>\, a functional wrapper around \IAsyncEnumerable\<A\>\ that offers an immutable, thread-safe way to consume asynchronous sequences. This new type supports standard functional operations such as \Map\, \Bind\ (monadic bind), \SelectMany\, \Apply\, and \Concat\, allowing users to compose async streams without the mutation and race-condition risks associated with raw enumerators. The change includes the core implementation in \IteratorAsync.cs\ and its module in \IteratorAsync.Module.cs\, along with a \README\ explaining the design.

LanguageExt.Core/Immutable Collections/IteratorAsync · high confidence

The LanguageExt library now includes a new suite of high-performance immutable collections, including \Seq\, \Lst\, \HashMap\, \HashSet\, \Map\, and \Arr\, along with corresponding factory methods in the \Prelude\ (such as \Seq\, \List\, \Map\, \Set\, and \Cons\ overloads). These types are designed for superior performance, with \Seq\ offering array-backed speed and \Lst\ supporting efficient middle-insertions via an AVL tree structure. The \README\ documentation clarifies usage recommendations, such as preferring \Seq\ for general list operations and \HashMap\ for unsorted dictionary operations.

LanguageExt.Core/Immutable Collections · medium confidence

Added the foundational types and combinators for the Megaparsec integration, including \ErrorItem\ and \ErrorFancy\ for detailed error reporting, \Hints\ for expected items, and \ModuleT\ with primitives like \single\, \satisfy\, \try\, \lookAhead\, and \token\ to support parser construction.

LanguageExt.Megaparsec · high confidence

Added a new \Iterator\<A\>\ type in \LanguageExt.Core/Immutable Collections/Iterator\ that wraps \IEnumerator\ to provide a thread-safe, immutable sequence interface. The implementation includes a module with factory methods (\from\, \singleton\, \Cons\, \Nil\) and core types (\ConsFirst\, \ConsValue\, \Nil\) that enable functional-style enumeration without the race conditions or mutability issues of standard .NET enumerators. This allows users to work with lazy, reusable sequences that support pattern matching and functional operations like \Map\ and \Bind\.

LanguageExt.Core/Immutable Collections/Iterator · high confidence

Added new \Transducer\ and \TransducerM\ types along with a comprehensive set of DSL components for data transformation pipelines. This includes core types like \Reduced\ and \ReducedM\ to manage reduction states, as well as specific transducer implementations for mapping, filtering, folding, and composing data streams. The update also introduces extension methods and trait implementations for \TransduceFrom\ and \TransduceTo\, enabling a fluent, composable approach to building streaming data processors.

LanguageExt.Streaming/Transducers · high confidence

Added the \IterableNE\ type, a non-empty lazy sequence structure that guarantees at least one head element, along with a companion module providing factory methods (\create\, \createRange\, \generate\, \repeat\) and operations (\head\, \flatten\, \map\, \bind\). This new immutable collection type supports both synchronous and asynchronous iteration, offering a safe alternative to standard enumerables by preventing empty sequences.

LanguageExt.Core/Immutable Collections/IterableNE · high confidence

The LanguageExt.Streaming library is introduced, providing compositional streaming capabilities for .NET. This includes a new \Buffer\<A\>\ abstract record with static factories for unbounded, single, newest, latest, and bounded buffer strategies, alongside the \Buffer.cs\ implementation file. The release also adds comprehensive documentation in \README.md\ and \README.nuget.md\, detailing the closed-stream (Pipes) and open-stream (Source, Sink, Conduit) APIs, including their monad-transformer variants and conversion methods.

LanguageExt.Streaming · high confidence

The \These\ monad has been added to the \LanguageExt\ library, providing a new way to handle scenarios where a value can be in one of three states: \This\ (containing a single value of type A), \That\ (containing a single value of type B), or \Both\ (containing both). This new type includes a module with constructors (\This\, \That\, \Both\) and helper functions like \merge\ and \partition\ to work with sequences of \These\ values. The implementation uses abstract record types with sealed inner records for each case, enabling pattern matching and bi-functor operations.

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

The \LanguageExt\ library introduces a new \Iterable\ type that provides a unified, lazy, and composable interface for working with sequences of data. This new abstraction supports both synchronous (\IEnumerable\) and asynchronous (\IAsyncEnumerable\) iteration, allowing users to build complex data pipelines using functional combinators like \Map\, \Filter\, \Fold\, and \Zip\. The implementation includes specialized internal classes for different data sources (strict, singleton, nil, and async) and exposes extension methods for common functional operations, enabling seamless integration with existing \IO\ and \K\-based effects.

LanguageExt.Core/Immutable Collections/Iterable · high confidence

Added a new \VersionVector\ and \Version\ API for managing versioned state with vector-clock based conflict resolution. This enables tracking concurrent writes from multiple actors, automatically handling causal ordering and merging concurrent updates via a configurable conflict resolution strategy.

LanguageExt.Core/Concurrency/VersionVector · high confidence

Added a new \Eff\ monad implementation that operates without a runtime context. This change introduces new files (\Eff.Module.cs\, \Eff.Monad.cs\, \Eff.cs\) that define the \Eff\ type and its associated traits (\MonadUnliftIO\, \Alternative\, \MonoidK\, etc.), providing a way to encapsulate side effects and exception capture in a runtime-agnostic manner.

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

The FinT monad transformer is added to the LanguageExt library, providing a way to carry either an Error or a result value within a monadic context. This change introduces the FinT type along with its module containing lift operations for pure values, failures, and IO monads, as well as match and map operations for handling success and failure states.

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

The \OptionT\ monad transformer now exposes static factory methods (\Some\, \None\, \lift\, \liftIO\) in its module file, providing a consistent external API for constructing and lifting values into the transformer. The core \OptionT\ class implements the \Match\, \Map\, and \Bind\ operations, enabling users to compose optional effects within a monadic context.

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

Adds a new Software Transactional Memory (STM) system to the concurrency library, enabling safe, lock-free updates to shared mutable state within transactional boundaries. This includes the \Ref\<A\>\ class for creating transactional references, the \CommuteRef\<A\>\ proxy for commutative updates, and the \Isolation\ enum to configure snapshot or serializable isolation levels. The \STM\ static class provides the core transaction execution logic, supporting nested transactions and conflict resolution via automatic retry.

LanguageExt.Core/Concurrency/STM · high confidence

The \ValidationT\ monad transformer is introduced, providing a new way to handle validation scenarios within a monadic context. The change adds a module file (\ValidationT.Module.cs\) and the main implementation (\ValidationT.cs\), featuring new static methods for creating success and failure states (\Success\, \Fail\, \lift\, \liftIO\), as well as \match\ and \BiBind\ operations for pattern matching. This allows users to compose validation logic with other monads, supporting both synchronous and asynchronous (IO) lifting, and provides a consistent API for handling success and failure cases in a monadic stack.

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

The Parsec library now supports a generalized parser architecture, introducing \GenLanguageDef\ and \GenTokenParser\ to define language-specific lexical rules (identifiers, operators, comments) and build token parsers. This enables users to create custom parsers for different programming languages by configuring language definitions and using combinators like \makeTokenParser\. The update also adds support for parsing indentation, process configuration variables, and improves error handling and type resolution for let expressions and operators.

LanguageExt.Parsec · high confidence

A new \Memo\ type and associated extension methods have been added to the \LanguageExt.Core\ library. This feature allows functions and enumerables to be wrapped in a cache, ensuring that expensive computations or side-effects are performed at most once. The implementation is thread-safe and includes utilities for transforming higher-kinded structures, resetting cached values, and safe memory management for function memoization.

LanguageExt.Core/Memo · high confidence

The LanguageExt.Streaming/Pipes area adds new types to support functional streaming and event handling. The \Event\<A\>\ class allows subscribing to a delegate and forwarding values to subscribers via channels. New \Consumer\ and \ConsumerT\ monad transformers provide a functional way to consume streams, supporting operations like \awaiting\, \pure\, \error\, \empty\, \lift\, \liftIO\, and \repeat\. Additionally, \Effect\ and \EffectT\ types are introduced to handle side-effecting computations within the streaming pipeline, offering similar functional composition capabilities. These additions enable users to build complex data processing pipelines using a functional, composable approach.

LanguageExt.Streaming/Pipes · high confidence

Adds the trait implementation for the FinT monad, providing support for tail recursion, alternative/choice operations, and natural transformations to EitherT, OptionT, and TryT.

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

The Free monad implementation is added to the LanguageExt library, providing a new \Free\<F, A\>\ type that turns any functor \F\ into a monad. This includes the core \Free\ record types (\Pure\, \Bind\) and a module with \pure\, \lift\, and \bind\ functions. Extension methods and operators are introduced for mapping (\Map\), applying (\Apply\), and sequencing (\\>\>\) values within the free monad, supporting up to 11-ary functions via curried applicative operators. The implementation also includes a trait implementation for \Monad\<Free\<F\>\>\ and \Applicative\<Free\<F\>\>\.

LanguageExt.Core/Monads/Free · high confidence

A new \Ask\ record struct is added to the \LanguageExt\ namespace, providing a convenience type for accessing the environment in \Reader\ and \ReaderT\ monads. This type includes methods to convert to \Reader\, \ReaderT\, and \RWST\ types, as well as monadic bind operations (\SelectMany\) that facilitate chaining computations that require access to the environment. This change supports the broader refactor of monad transformers and the introduction of LINQ support for \RWST\.

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

The IO monad has been refactored to include a new \EnvIO\ environment type that manages cancellation tokens, synchronization contexts, and resource tracking. This change introduces \EnvIO\ for managing the IO execution context, \ForkIO\ for asynchronous forking and awaiting of IO operations, and \Resources\ for automatic resource disposal. The \IO\ class now implements \MonadUnliftIO\ and \Alternative\, providing new capabilities such as \uninterruptible\ blocks, \local\ cancellation scopes, \ForkIO\ for concurrent execution, and \BracketIO\ for resource-safe operations. The \EnvIO\ class handles the environment state, including \SynchronizationContext\ and \CancellationToken\ management, while \Resources\ tracks and disposes of \IDisposable\ and \IAsyncDisposable\ objects automatically. This refactor supports more robust error handling, cancellation, and resource management within the IO monad.

LanguageExt.Core/Effects/IO · high confidence

A new Live runtime implementation has been added to the LanguageExt.Sys library, providing a concrete execution environment for system-level side effects. This runtime supports a range of IO capabilities including ActivitySource, Console, File, TextReader, Time, Environment, Directory, and Encoding operations, enabling users to perform system interactions within the Eff monad.

LanguageExt.Sys/Live · high confidence

Added a new \Change\<A\>\ type hierarchy in the \LanguageExt.Core/DataTypes/Change\ namespace, introducing classes for \EntryAdded\, \EntryRemoved\, \EntryMapped\, and \NoChange\ states. This structure allows users to explicitly represent and pattern-match on collection modifications, supporting features like change tracking for \AtomHashMap\ and \Ref\.

LanguageExt.Core/DataTypes/Change · high confidence

The Eff monad now exposes a set of prelude helpers to simplify working with effects. You can create success or failure effects via SuccessEff and FailEff, and access the runtime environment with the new runtime() helper. Lifting functions into the Eff monad is now supported for Func, Fin, and Task-based operations, and the monad can be flattened with flatten(). Mapping and bi-mapping over success and failure states is available via map, mapFail, and bimap. Additionally, the Prelude provides Functor and Applicative operations (map, apply, action) for the Eff type, enabling standard functional programming patterns.

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

The LanguageExt library introduces a comprehensive set of extension methods for the \Fin\ monad, enabling functional programming patterns such as applicative actions, functor mapping, and monadic binding. These additions include \Action\ and \Apply\ for applicative-style composition, \Map\ for functor operations, and \Bind\/\SelectMany\ for monadic chaining. The \FinExtensions\ class also provides arithmetic operations (Plus, Subtract, Product, Divide) and utility methods like \ToFin\ for transforming \Either\ types, as well as partitioning helpers (\Partition\, \Fails\, \Succs\) for working with sequences of \Fin\ values.

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

The \LanguageExt.Core/Effects\ area introduces a new \MinRT\ struct for running non-runtime based IO monads, alongside a comprehensive set of new IO effect combinators in \Prelude.cs\. Users gain access to \uninterruptible\ for blocking cancellation tokens, \localIO\ for local cancellation environments, and enhanced \fork\/\awaitIO\/\awaitAny\ operations with timeout support. These changes improve control over asynchronous IO execution, resource management, and error handling within the effects system.

LanguageExt.Core/Effects · high confidence

The LanguageExt library adds new extension methods to the \IO\ type, introducing functional programming operators such as \Map\, \Apply\, and \Action\ for mapping and applying functions within the IO effect. Additionally, the \IO\ type now supports monadic binding via \Bind\ and \SelectMany\ (query comprehension) across various monad transformers, and provides new methods for running IO effects (\Run\, \RunAsync\, \RunSafe\) and guarding execution based on a \Guard\ condition.

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

The LanguageExt library introduces a comprehensive set of operator overloads for the \K\<IO, A\>\ type, enabling more idiomatic functional programming styles. This includes functor mapping (\\*\), monadic binding (\\>\>\), applicative sequencing (\\>\>\>\), choice (\\|\), and finalization (\\|\), allowing developers to compose \IO\ actions using standard mathematical and logical symbols.

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

Added new concurrency primitives—Signal, CountdownSignal, and their module constructors—that wrap .NET's EventWaitHandle and CountdownEvent within the IO monad. These allow users to perform thread synchronization (auto-reset, manual-reset, and countdown events) in a pure, effect-managed way, with automatic resource cleanup via the IO system.

LanguageExt.Core/Concurrency/Signals · high confidence

The LanguageExt.Parsec library introduces a new ParserIOs module that provides a generic, token-based parsing system, moving away from the previous character-specific implementation. This includes new static classes for expression parsing (ExprIO), indentation handling (IndentIO), common item parsers (ItemIO), and primitive combinators (PrimIO). The changes enable parsing arbitrary token streams rather than just characters, allowing for more flexible and efficient parsing of structured input.

LanguageExt.Parsec/ParserIOs · high confidence

The RWST (Reader/Writer/State) monad transformer is introduced, providing a combined environment, output, and stateful computation model. This change adds the core \RWST\ record type and its trait implementations for \Monad\, \Functor\, \Applicative\, \Readable\, \Writable\, and \Stateful\ behaviors. Additionally, a comprehensive set of extension methods and operators are added to \RWSTExtensions\, including functor mapping, monadic bind (\\>\>\), applicative sequencing (\\>\>\>\), choice (\\|\), and semigroup combination (\+\), enabling functional composition and error handling within the transformer.

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

The Range type is introduced as a new data type representing a sequence of values from a start to an end, supporting forward and backward iteration with a configurable step. The implementation includes extension methods to check if a value is within a range (InRange) and to detect if two ranges overlap (Overlaps). Additionally, the Range class implements Foldable, providing fold and fold-while operations for functional processing of the range's elements.

LanguageExt.Core/DataTypes/Range · high confidence

The \LanguageExt.Core/Effects/Schedule\ namespace now includes a new \Schedule\ type and supporting types (\Duration\, \ScheduleTransformer\) that allow users to define and compose sequences of delays for \repeat\ and \retry\ operations. This change introduces a DSL for building schedules (e.g., \linear\, \exponential\, \fixedInterval\) and combining them (union, intersect, interleave), enabling more flexible and predictable retry logic in the library.

LanguageExt.Core/Effects/Schedule · high confidence

The library introduces a new \SinkT\<M, A\>\ abstraction for managing output streams and channels. This includes a \Channel\-backed sink implementation (\SinkTWriter\) and a suite of DSL components for combining, mapping, and routing data flows (\SinkChoose\, \SinkCombine\, \SinkContraMap\, \SinkEmpty\, \SinkVoid\). Users can now create sinks from \System.Threading.Channels\ and compose them using functional patterns like \Divide\ and \Route\.

LanguageExt.Streaming/SinkT · high confidence

Added a comprehensive set of operators for the Source type, enabling functional programming patterns such as functor mapping, monadic binding, applicative sequencing, and zipping. Users can now use operators like \* for mapping and applying functions, \>\> for sequencing actions, + for combining sources, \| for choice, and & for zipping streams, supporting up to 11 arguments in curried forms.

LanguageExt.Streaming/Source/Operators · high confidence

The \SourceT\ API is expanded with new combinators: \Delay\ to pause value yielding, \TakeFor\ to limit streams by duration, \Choose\ to merge or choose between sources, \Zip\ to pair up to four streams, and reduction methods like \First\, \Last\, and \Collect\ to aggregate stream values into single results.

LanguageExt.Streaming/SourceT/Extensions · high confidence

The SourceT type now supports a comprehensive set of functional programming operators, including applicative sequencing (\>\>\>) and apply (\), functor mapping (\), monadic binding (\>\>), choice (\|), semigroup combining (+), and zipping (&). These additions enable more idiomatic and concise stream processing, allowing developers to compose, map, bind, and merge streams using standard operators.

LanguageExt.Streaming/SourceT/Operators · high confidence

The LanguageExt.Sys library introduces a new set of traits in the \LanguageExt.Sys.Traits\ namespace to encapsulate common .NET Base Class Library (BCL) I/O operations. New interfaces include \ActivitySourceIO\ for distributed tracing, \ConsoleIO\ for terminal interaction, \DirectoryIO\ and \FileIO\ for file system manipulation, \EncodingIO\ for character encoding, \EnvironmentIO\ for system environment variables, \TextReadIO\ for text stream handling, and \TimeIO\ for time-related operations. These traits are aggregated into a composite \HasSys\<M\>\ interface, providing a unified, monadic interface for system-level side effects.

LanguageExt.Sys/Traits · high confidence

Added a new \LanguageExt.XUnitExt\ library providing XUnit assertion helpers for language-ext types. This includes \AssertFail\/\AssertSucc\ for \Eff\, \Fin\, and \IO\ monads; \AssertLeft\/\AssertRight\ for \Either\; \AssertNone\/\AssertSome\ for \Option\; and \Throws\ for \Error\-based exceptions. These extensions allow developers to write more readable and idiomatic unit tests for functional programming constructs.

LanguageExt.XUnitExt · high confidence

A new \Lift\ record type has been introduced to provide a unified way to lift synchronous and asynchronous functions into monadic contexts. This includes extension methods in \Lift.Extensions.cs\ to convert lifted values to \IO\ or \Eff\ types, and prelude methods in \Lift.Prelude.cs\ that enable lifting actions and functions into various transformer stacks (such as \OptionT\<IO, A\>\ and \EitherT\<L, IO, A\>\).

LanguageExt.Core/Monads/Lifting · high confidence

Added the \LanguageExt.Async\ module with \Async.await\ and \Async.fork\ to simplify asynchronous programming by providing synchronous-style awaiting and parallel forking. Additionally, new extension methods for \IAsyncEnumerable\ were introduced, including \MapAsync\, \ApplyAsync\, \BindAsync\, \FilterAsync\, and LINQ-style query operators (\Select\, \SelectMany\, \Where\, \Skip\, \Take\) to support functional-style asynchronous enumeration.

LanguageExt.Core/Concurrency/Async · high confidence

Added new concurrency primitives for the IO effect, including Software Transactional Memory (STM) support via \Ref\ and \sync\/\serial\/\snapshot\ transactional operations. Introduced parallel execution helpers \awaitAll\ and \awaitAny\ to run multiple IO computations concurrently, along with \ForkIO\ for forking and awaiting tasks. Also added \uninterruptible\ to block cancellation tokens and \yieldFor\ to pause execution.

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

The library introduces a Software Transactional Memory (STM) system for safe, lock-free shared mutable state. Users can now create \Ref\ references and execute code within \sync\ or \serial\ transactions, which provide snapshot or serializable isolation levels. Additionally, the update adds \Atom\ types for lock-free atomic operations on single values, and a \Conflict\ interface with \LastWriteWins\ and \FirstWriteWins\ resolvers for handling concurrent state changes.

LanguageExt.Core/Concurrency · medium confidence

Added new extension methods for the ChronicleT and Either monads. ChronicleT gains utility functions including downcast operators (As, As2), a Run method to yield the inner monad, monadic join (Flatten), functor/bifunctor mapping (BiMap), filtering (Where, Filter), monadic bind (SelectMany), and prelude helpers (dictate, confess, memento, absolve, condemn, censor). Either gains applicative action and apply operations, functor mapping, monadic join, filtering, and conversion helpers to Eff and Validation types.

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

Added new extension methods to the library: function composition (Compose, BackCompose, Flip) and operators (\>\>, \<\<) in FuncExtensions; observable integration with PostSubscribe and ToAsyncEnumerable in ObservableExt; and a comprehensive set of LINQ query operators (HeadOrNone, HeadOrLeft, Tail, Map, Filter, Fold, etc.) in Query. Also added unsafe value access for Option and Either types, and a TryGetValue extension for dictionaries.

LanguageExt.Core/Extensions · high confidence

The library introduces new functional programming primitives, including a \CatchM\ record and extension methods for error catching, alongside a \Combinators\ class providing lambda calculus combinators (e.g., I, K, S, Y) for both dynamic and typed contexts. Additionally, a \Guard\ struct is added to support LINQ-style guards for error-producing monads, and a \Number\ class implements the \Num\<A\>\ trait for \INumber\<A\>\ types. The \Void\ type is also introduced to represent uninhabited types in the functional effects system.

LanguageExt.Core · high confidence

The LanguageExt.FSharp package introduces a new \Prelude.cs\ file that provides extension methods to convert between LanguageExt types (Option, Either, Lst, Map) and their F\# counterparts (FSharpOption, FSharpResult, FSharpList, FSharpMap). This enables developers to easily bridge C\# and F\# codebases by converting data structures directly, such as turning an F\# Option into a LanguageExt Option or vice versa, facilitating smoother integration between the two languages.

LanguageExt.FSharp · high confidence

The \Prelude.Resources\ file introduces a new \use\ API for the \IO\ monad, allowing users to acquire and automatically release resources (including \IDisposable\ and \IAsyncDisposable\ types) within the IO environment. This change consolidates resource handling by merging \ResourceT\ functionality into the \IO\ monad, providing a unified way to manage resource lifecycles using \bracketIO\ or the \@using\ syntax.

LanguageExt.Core/Prelude/Resources · high confidence

Added new sink implementations to the DSL layer, including SinkChoose for routing Either types, SinkCombine for splitting values into left/right sinks, SinkContraMap and SinkContraMapT for function and transducer-based mapping, SinkEmpty and SinkVoid as no-op sinks, and SinkWriter for writing to channels.

LanguageExt.Streaming/Sink/DSL · high confidence

Added a new \AtomQue\<A\>\ type in \LanguageExt.Core/Concurrency/AtomQue\ that provides a lock-free, atomic queue implementation for concurrent scenarios. The type supports standard queue operations (enqueue, dequeue, peek, clear) and exposes \Dequeued\ and \Enqueued\ events to notify subscribers of state changes. It also implements the \Foldable\ trait, enabling functional-style folding and iteration over the queue's contents.

LanguageExt.Core/Concurrency/AtomQue · high confidence

The Option type now implements a comprehensive set of functional programming traits, including Monad, Applicative, Traversable, Alternative, and Natural transformations to various collection types (Arr, Lst, Seq, Iterable, Eff, OptionT\<IO\>, Fin). This provides a unified, consistent API for working with optional values, supporting operations like bind, map, pure, apply, traverse, and choice. The implementation also includes fold operations and recursion support, enabling more expressive and composable code when handling potentially absent values.

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

The repository now includes a \.editorconfig\ file to enforce C\# coding styles and formatting rules, alongside standard repository metadata files (\CODE\_OF\_CONDUCT.md\, \CONTRIBUTING.md\, \LICENSE.md\) and a \language-ext.sln\ solution file that organizes the core library, extensions, and sample projects.

(repo-wide) · high confidence

The \WriterT\ monad transformer now includes a full suite of operators, including Functor, Applicative, Monad, SemigroupK, Choice, and Fallible handling. This enables users to compose \WriterT\ computations using standard operators like \\*\ for applicative application, \\>\>\ for sequencing, \\|\ for choice and error handling, and \+\ for combining outputs. The implementation also adds extension methods for \Run\, \Flatten\, and \SelectMany\, providing a complete API for working with the writer monad in a functional style.

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

The \Prelude\ class now includes \Pure\ and \Fail\ monads, providing dedicated types for constructing pure and failure values respectively. These monads are designed to work with \Option\, \Eff\, \Either\, \Fin\, \IO\, and \Validation\ to simplify the construction of lifted values and errors.

LanguageExt.Core/Monads · medium confidence

The These monad now includes explicit trait implementations for traversal and folding operations. Specifically, the file introduces Map, FoldWhile, FoldBackWhile, and Traverse methods that handle the This, That, and Both states of the These type. Additionally, it implements the Foldable interface with FoldStep and FoldBackStep methods, enabling recursive folding capabilities for this monad.

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

The FinSucc and FinFail constructors are now obsolete and will be removed in a future release. Users should migrate to the new Fin.Succ and Fin.Fail syntax, or use Prelude.Pure and Prelude.Fail instead. Additionally, the Change class provides guidance for other deprecated collection initializers and conversion methods.

LanguageExt.Core/Obsolete and Deprecated · high confidence

The Identity monad now implements the Foldable and Traversable interfaces, enabling collection-style operations like folding and traversing. A new tail-recursive Bind implementation supports recursion without stack overflow risks, and Foldable methods (FoldWhile, FoldBackWhile, FoldStep) allow stateful iteration over Identity values.

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

The Identity monad is now implemented with a dedicated module and record class, providing core functional programming capabilities such as map, bind, and traverse operations. This includes the addition of TraverseM and Traverse methods for applicative and monadic traversal, as well as standard LINQ-style Select and SelectMany operators, enabling users to work with the Identity type as a simple wrapper for values without additional behavior.

LanguageExt.Core/Monads/Identity · medium confidence

The \HashMap\ implementation has been refactored to support a generic \EqK\ trait, allowing users to provide custom equality comparers for keys. This change introduces new overloads and extension methods that accept an \EqK\ type parameter, enabling more flexible and performant key comparisons. The core struct now implements \K\<HashMapEq\<EqK, K\>, V\>\ and relies on \TrieMap\<EqK, K, V\>\, while the module and extension files have been updated to expose these new generic signatures alongside the existing default-equality versions.

LanguageExt.Core/Immutable Collections/HashMap · high confidence

The \Arr\ type and its associated module have been refactored, introducing a new \Arr.Module.cs\ file that provides functional-style static methods for array creation (e.g., \empty\, \create\, \singleton\), modification (\add\, \remove\), and transformation (\rev\, \flatten\). The core \Arr.cs\ struct now implements \Monoid\<Arr\<A\>\>\ and exposes span-based slicing (\AsSpan\, \Splice\) for zero-copy access, while also fixing a \NullReferenceException\ in \GetHashCode\ for default instances.

LanguageExt.Core/Immutable Collections/Arr · medium confidence

The internal implementation of the immutable list (Lst) has been refactored to implement functional programming traits (Monad, Applicative, Traversable, Foldable, etc.) via the LanguageExt.Traits system. This change introduces new extension methods for mapping and applying functions over lists, and standardizes the list's behavior to align with other functional collection types in the library.

LanguageExt.Core/Immutable Collections/List · medium confidence

Added new \Eff.Prelude.cs\ and \Eff.Prelude.mapapply.cs\ files that provide a consistent set of \map\, \apply\, and \action\ extension methods for the \Eff\ monad. These additions standardise the API for mapping over success states and applying functions within the effect system, alongside helper methods for lifting synchronous and asynchronous effects into the \IO\ monad.

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

The Iterator type in LanguageExt now implements a comprehensive set of functional programming interfaces, including Monad, MonoidK, Alternative, Traversable, and Natural transformations to Seq, Arr, Lst, Set, Iterable, and HashSet. This enables using Iterator with higher-order functions like map, bind, and traverse, and allows seamless conversion between Iterator and other collection types.

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

The \Error\ type has been refactored into a new hierarchy of abstract records and classes to improve error handling and serialization. The core \Error\ type is now an abstract record in \LanguageExt.Common\, with a parallel \ErrorException\ class for interop with standard .NET exceptions. Error codes are centralized in a new \ErrorCodes\ class, and a static \Errors\ helper class provides pre-defined error instances (e.g., \Errors.TimedOut\, \Errors.ValidationFailed\). This change improves how errors are created, matched, and serialized, and removes implicit conversions from strings to prevent null reference exceptions.

LanguageExt.Core/Common · high confidence

The LanguageExt library adds new extension methods to the Eff monad, introducing Functor and Applicative standardisation with Map and Apply operations that unwrap, transform, and re-wrap values. The update also introduces RunAsync and RunUnsafeAsync variants for asynchronous execution, alongside Bind and SelectMany support for Guard types, enabling more robust and idiomatic functional programming patterns for effectful computations.

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

The library now introduces specific exception classes to handle common state errors: SomeNotInitialisedException, ValueIsNoneException, ValueIsNullException, ResultIsNullException, OptionIsNoneException, EitherIsNotRightException, and EitherIsNotLeftException. These provide more precise error reporting when accessing values from Option, Either, and Result types that are in an invalid or empty state.

LanguageExt.Core/Exceptions · medium confidence

The \Option\ monad has been refactored to use external constructor functions (\Some\ and \None\) rather than internal constructors, changing how instances are created. The \None\ value is now a \readonly\ field, and the \Case\ property functionality has been fixed to ensure compatibility with version 5. Additionally, the \Option\ type now implements the \Monoid\ interface, and \IEnumerable\ has been removed from \Option\, \Either\, \Fin\, and \Validation\ types.

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

The \Eff\ monad has been refactored to use transformers, moving from a direct implementation to a \ReaderT\<RT, IO, A\>\ based structure. This change introduces new \Eff.Module.cs\ and \Eff.cs\ files that define the monad's constructors, lifting operations, and mapping functions, providing a more modular and composable approach to handling side effects and dependency injection via the \RT\ runtime.

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

The TryT monad transformer has been refactored to use external constructor functions (such as \TryT.Succ\, \TryT.Fail\, and \TryT.lift\) rather than internal or direct constructors. This change standardizes how values are lifted into the transformer, providing a consistent API for creating \TryT\ instances from success, failure, or other monadic contexts.

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

The Conduit implementation has been refactored to utilize Transducers, replacing the previous Reader-based source types with MultiListener implementations. This change introduces a channel-based internal queue with a sink (input transducer), a buffer, and a source (output transducer), allowing for more flexible manipulation of values before and after the buffer. The \Conduit.ABC.cs\ file now implements \Conduit\<A, B, C\>\ with methods for posting values, completing the sink, failing with errors, and reducing streams using the new transducer-based approach.

LanguageExt.Streaming/Conduit/Internal · medium confidence

The internal implementation of ConduitT has been refactored to utilize Transducers and System.Threading.Channels for data flow. This change replaces the previous Reader-based source types with MultiListener implementations and updates the conduit pipeline to use a sink, channel, and source structure. As a result, the conduit now leverages transducer composition for mapping, filtering, and folding operations, which may affect how errors are handled and how the stream processes data.

LanguageExt.Streaming/ConduitT/Internal · medium confidence

The \Either\<L, R\>\ type has been refactored to use nested \Left\ and \Right\ case-types within the main \Either\ class, rather than separate top-level types. This change introduces new files (\Either.Left.cs\, \Either.Right.cs\, \Either.Module.cs\) that implement the \Match\, \Map\, \Bind\, and other monadic operations for the \Left\ and \Right\ states. The \IEither\ interface and \README\ documentation have also been updated to reflect this new structure.

LanguageExt.Core/Monads/Alternative Monads/Either, LanguageExt.Core/Monads/Alternative Monads/Fin · medium confidence

The IO monad's internal DSL has been refactored to support \ValueTask\ and async execution models, introducing new record types such as \IOAction\, \IOActions\, \IOApply\, and \IOBind\ to handle synchronous and asynchronous operations more efficiently. The update adds support for lazy evaluation via \IOActionLazy\ and \IOActionsAsync\, and improves the handling of \IOFail\ and \IOCatch\ to better manage error states and exception handling. Additionally, the \IOFold\ and \IOFoldWhile\ operations have been expanded to support both sync and async folding with schedules, allowing for more complex iterative and conditional loop behaviors within the IO monad.

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

The Map implementation in LanguageExt.Core has been refactored to support optimized iteration and standardized functional interfaces. New enumerator structs (MapKeyEnumerator, MapEnumerator, MapValueEnumerator) have been introduced to improve iteration performance. The Map type now implements Functor, Foldable, and MonoidK traits, with corresponding extension methods (MapExtensions, MapOrdExtensions) providing Map, As, ToMap, and other functional operations. This change aligns the Map API with the library's trait-based functional programming model.

LanguageExt.Core/Immutable Collections/Map · high confidence

The \LanguageExt.Sys\ library has been refactored to support the new \Eff\ and \MonadIO\ abstractions. File and directory operations now expose both a legacy \Eff\-based API (e.g., \File\<RT\>\) and a generic \MonadIO\-based API (e.g., \File\<M, RT\>\). This change introduces \ProducerT\-based pipes for streaming file and text reads, enabling more efficient, memory-safe handling of large files and directories. The \Directory\ and \File\ classes now provide a consistent, effect-based interface for all IO operations, including creation, deletion, enumeration, and time manipulation.

LanguageExt.Sys/Sys/IO · high confidence

The Validation monad implementation has been refactored to utilize Alternative and Choice abstractions, introducing new internal helper methods (SuccessI, FailI) and restructuring the Success and Fail state records to align with these patterns. This change modifies the internal architecture of the Validation type, which may affect how the type behaves in edge cases or when interacting with other monadic operations.

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

The internal implementation of the \Seq\ collection has been refactored to use a new \ISeqInternal\ interface with distinct internal types (\SeqStrict\, \SeqLazy\, \SeqConcat\, \SeqEmptyInternal\) to handle different evaluation strategies. This change introduces a new \Enum\<A\>\ helper class for efficient enumeration and caching, and updates the public \Seq\ struct to delegate to these internal types. Users may see changes in performance characteristics for lazy evaluation and concatenation operations, as the library now explicitly manages strict and lazy sequence states internally.

LanguageExt.Core/Immutable Collections/Seq · high confidence

The Eff type now implements standardized Functor and Applicative patterns, adding Map and Apply extension methods to the EffExtensions class. Additionally, new guard support has been added, allowing Guard\<Error, Unit\> instances to be bound and projected within the Eff monad via ToEff, Bind, and SelectMany methods.

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

The Record base class and supporting types now provide structural equality, ordering, and hashing based on the type's fields. Users can opt out of specific behaviors (equality, ordering, hash code, ToString, serialization) using new attributes (e.g., NonEqAttribute, NonOrdAttribute, NonHashAttribute, NonShowAttribute, IgnoreBaseAttribute). The RecordType helper class exposes static functions for these operations, and the TypeInfo extension methods allow reflection-based access to all members including base types.

LanguageExt.Core/DataTypes/Record · medium confidence

The System IO modules—Console, Encoding, Environment, and Time—have been refactored to support the generic \MonadIO\<M\>\ interface alongside the existing \Eff\<RT\>\ support. This change allows these system-level side effects to be executed within any monad that implements \MonadIO\, providing greater flexibility for effect handling and integration with other monadic contexts.

LanguageExt.Sys/Sys · high confidence

The TrieMap class has been refactored to support change events, allowing consumers to track additions, updates, and removals. This includes new methods like AddWithLog, TryAddWithLog, and AddOrUpdateWithLog that return a tuple containing the updated map and a Change record, enabling users to observe mutations as they happen.

LanguageExt.Core/Immutable Collections/TrieMap · medium confidence

The Try monad implementation has been refactored to use external constructor functions (Succ, Fail, lift) and the Fin type for internal state representation, replacing previous internal constructors. This changes how Try instances are created and how success/failure states are managed, potentially affecting code that directly instantiates Try objects or relies on specific internal implementation details.

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

The Unit type now implements IComparable and Monoid interfaces, enabling comparison operators (\>, \>=, \<, \<=) and the + operator for chaining unit operations. It also includes implicit conversions to and from ValueTuple, Seq, Lst, and Iterable types, allowing Unit to be used more flexibly in generic contexts and with standard library collections.

LanguageExt.Core/DataTypes/Unit · high confidence

Added comprehensive unit tests for the IO monad; Added comprehensive unit tests for the Seq type hierarchy; Added in-memory test implementations for system I/O and time; Added law and default implementation tests for core traits; Added null-check test coverage for LanguageExt; Added test runtime for system IO traits; Added tests for F\# Result type conversions; Added tests for Iterator behavior; Added tests for default value checks; Added unit tests for Eff, Array, Atom, Choice, and collection ordering; Added unit tests for EitherT collection traversal; Added unit tests for EitherT traverse operations; Added unit tests for HashSet traverse operations; Added unit tests for IEnumerable traversal of collections; Added unit tests for Identity monad traverse operations; Added unit tests for Lst traversal across various collection types; Added unit tests for Option traverse across collections and sync types; Added unit tests for Traverse operations on Lst types; Added unit tests for nested collection traverse; Added unit tests for synchronous Arr traversal; Added unit tests for synchronous traverse operations on SeqT; Added unit tests for the Schedule system; Added unit tests for the Traverse transformer on Validation types; Added unit tests for the new streaming Source and SourceT APIs; Added unit tests for the new string parsing methods.

The LanguageExt.Core 3.1.9-beta NuGet package specification has been added, defining the package metadata and file structure for .NET Framework 4.5 and .NET Standard 2.0. This enables the package to be properly distributed and recognized by the "Used By" feature on GitHub.

pjv · medium confidence

The project files have been migrated to target .NET 10.0, updating the \TargetFramework\ from previous versions (such as netstandard2.0 or net461) to \net10.0\. Additionally, several dependencies have been updated, including \System.Reactive\ to version 6.0.0 in the test project and \Newtonsoft.Json\ to 13.0.3/13.0.2 in sample projects.

(dependencies) · high confidence

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

• CAI 43 → 43 (-0.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 64 → 61 (-2.3)
• Architecture 95 → 95 (+0.3)
• Maturity 57 → 58 (+0.8)
• Readiness 25 → 24 (-1.4)
• Security 53 → 55 (+1.8)
• Performance 72 → 72 (+0.0)

• BarePragmaDisable (LanguageExt.Core/Immutable Collections/Iterable/DSL/Iterable.Enumerable.cs)
• BarePragmaDisable (LanguageExt.Core/Immutable Collections/Iterable/DSL/Iterable.Singleton.cs)
• BarePragmaDisable (LanguageExt.Core/Immutable Collections/Iterable/DSL/Iterable.SingletonIO.cs)
• BarePragmaDisable (LanguageExt.Core/Immutable Collections/Iterable/DSL/Iterable.Strict.cs)
• BarePragmaDisable repeated across 24 files (LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.cs)
• Bounded contexts not declared
• Build status unknown
• Change coupling: Conduit.cs ↔ ConduitT.cs (LanguageExt.Streaming/Conduit/Conduit.cs)
• Change coupling: Try.Extensions.cs ↔ TryT.Extensions.cs (LanguageExt.Core/Monads/Alternative Monads/Try/Extensions/Try.Extensions.cs)
• CommentedOutCode (LanguageExt.Tests/OptionLazy.cs)
• CommentedOutCode (LanguageExt.Tests/OptionLazy.cs)
• CommentedOutCode (LanguageExt.Tests/OptionLazy.cs)
• CommentedOutCode (LanguageExt.Tests/OptionLazy.cs)
• CommentedOutCode (LanguageExt.Tests/OptionLazy.cs)
• CommentedOutCode (LanguageExt.Tests/OptionLazy.cs)
• CommentedOutCode (LanguageExt.Tests/OptionLazy.cs)
• Duplicated block (10 lines × 2) (LanguageExt.Core/Effects/IO/DSL/IOActions.cs)
• Duplicated block (10 lines × 2) (LanguageExt.Core/Effects/IO/DSL/IOFoldUntil.cs)
• Duplicated block (10 lines × 2) (LanguageExt.Core/Immutable Collections/Set/Internal/Set.Internal.cs)
• Duplicated block (10 lines × 2) (LanguageExt.Core/Monads/Alternative Monads/Validation/Extensions/Validation.Extensions.Apply.cs)
• …and 132 more

• Change coupling: Consumer.cs ↔ Effect.cs (LanguageExt.Streaming/Pipes/Consumer/Consumer.cs)
• Change coupling: Effect.cs ↔ Pipe.cs (LanguageExt.Streaming/Pipes/Effect/Effect.cs)
• CommentedOutCode (LanguageExt.Core/Concurrency/Async/AsyncEnumerable/AsyncEnumberable.Extensions.cs)
• CommentedOutCode (LanguageExt.Core/DataTypes/Range/Range.cs)
• CommentedOutCode (LanguageExt.Core/Immutable Collections/List/Lst.cs)
• CommentedOutCode (LanguageExt.Core/Immutable Collections/Seq/Seq.cs)
• CommentedOutCode (LanguageExt.Core/Immutable Collections/Set/Set.cs)
• CommentedOutCode (LanguageExt.Core/Monads/Alternative Monads/Either/Extensions/Either.Extensions.cs)
• CommentedOutCode (LanguageExt.Core/Monads/Alternative Monads/Either/Extensions/Either.Extensions.cs)
• CommentedOutCode (LanguageExt.Core/Monads/Alternative Monads/Either/Extensions/Either.Extensions.cs)
• CommentedOutCode (LanguageExt.Tests/OptionTTests.cs)
• CommentedOutCode (LanguageExt.Tests/OptionTTests.cs)
• CommentedOutCode (LanguageExt.Tests/OptionUnsafeApply.cs)
• CommentedOutCode (LanguageExt.Tests/TESTING.cs)
• CommentedOutCode (LanguageExt.Tests/TraitTests/ApplicativeLawTests.cs)
• CommentedOutCode (LanguageExt.Tests/TraitTests/FunctorLawTests.cs)
• CommentedOutCode (LanguageExt.Tests/TraitTests/MonadLawsTest.cs)
• CommentedOutCode (Samples/IOExmples/Program.cs)
• CommentedOutCode (Samples/IOExmples/Program.cs)
• CommentedOutCode (Samples/PipesExamples/Program.cs)
• …and 479 more

• Unchanged — 4 HTTP endpoints

• Unchanged — 0 containers · 5 contexts · 7 edges

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

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.