louthy/language-ext

Features

• Functional Programming Frameworks - Ships a complete functional programming framework for C# featuring immutable data structures and monadic types.
• Pure Functional Logic Implementations - Implements pure functional programming patterns in C# using monads and higher-kinded type traits.
• Immutable Data Structures - Implements persistent hash maps that allow modifying key-value pairs without mutating the original structure.
• Immutable Queues - Implements a persistent FIFO queue where every operation returns a new version of the structure.
• Immutable Sequences - Provides high-performance ordered collections using persistent arrays and AVL trees.
• Immutable Sets - Provides immutable set implementations using self-balancing AVL trees for efficient lookups.
• Immutable Maps - Provides persistent hash maps and sorted maps for immutable key-value storage.
• Immutable Array Updates - Provides fixed-size immutable array structures where every modification returns a new version.
• Value-Flow Pipelines - Connects reusable sources, sinks, and conduits into pipelines for processing value flows.
• Lock-Free Atomic Containers - Implements lock-free atomic references using compare-and-swap operations for thread-safe synchronous updates.
• Spin-Loop Updates - Updates immutable data structures using lock-free spin loops to ensure thread-safe, synchronous changes.
• Lazy Sequences - Provides lightweight lazy sequence wrappers that support functional patterns without forcing immediate evaluation.
• Higher-Kinded Type Simulation - Simulates higher-kinded generics using traits to define common behaviors across different type constructors.
• Monadic Pipelines - Executes a sequence of operations where the result of one effect is fed into the next to create a pipeline.
• Persistent Data Structures - Provides persistent, immutable data structures where modifications create new versions while sharing existing data.
• Immutable - Implements a persistent LIFO stack where modifications produce new versions.
• Immutable Data Structures - Provides persistent, thread-safe immutable data structures including lists, maps, and sets.
• Side Effect Management - Provides a monadic effect container to isolate impure operations and maintain purity in application logic.
• Functional Programming - Provides a comprehensive set of immutable types and pure functions to implement declarative functional programming patterns.
• Compositional Stream Pipelines - Provides compositional stream types to handle complex data flow and transformations.
• Lock-Free State Management - Provides lock-free state management and software transactional memory to coordinate shared state across threads.
• Monadic Error Handling - Utilizes monadic containers like Option and Either to handle optionality and failure without exceptions.
• Monadic Containers - Implements a suite of monadic containers, including Effect and Option, for side-effect and optional value management.
• Functional Error Capture - Represents computation results as successful values or failures containing detailed error information.
• Functional Stream Composers - Uses functional operators to connect sources and sinks into closed effects for data flow.
• Optional Value Types - Provides optional value types to explicitly handle the absence of data and avoid null-pointer exceptions.
• Software Transactional Memory Systems - Implements a software transactional memory system for atomic, consistent, and isolated updates across shared references.
• Side Effect Isolation - Isolates side effects by wrapping impure I/O operations in containers to maintain pure business logic.
• Closed Pipeline Composition - Fuses producers, pipes, and consumers into closed systems to create reusable streaming components.
• Lazy Sequence Composition - Concatenates multiple lazy sequences or ranges into a single continuous sequence.
• Monadic Set Traversals - Maps set elements to monadic actions and collects the results into a combined output.
• Ordered Set Queries - Enables retrieval of specific items, ranges, and neighbors based on the ordering of the set.
• Conflict Resolution Strategies - Applies deterministic strategies like last-write-wins to reconcile conflicting versions of values in distributed state.
• Open Stream Processing - Provides open sources and sinks for direct public manipulation and reduction of data.
• Data Versioning - Provides historical version tracking for map entries to enable retrieval of previous states.
• Sequence Property Analysis - Implements checks for emptiness, item counts, and retrieval of the first and last elements.
• Vector Clock Resolutions - Provides conflict resolution for distributed state by merging vector clocks to track causal ancestry.
• Streaming Aggregators - Folds stream values into a final aggregated state or collects them into a sequence.
• Concurrent Map Implementations - Provides thread-safe key-value structures optimized for high-concurrency updates using atomic operations.
• Sequence Transformations - Applies mapping functions to each element of a lazy sequence to produce a new transformed sequence.
• Stream Filters - Removes items from a stream based on a predicate to yield only values that satisfy the condition.
• Streaming Parsers - Implements memory-efficient streaming parsers using a combinator-based approach.
• Sequence Concatenation - Allows appending single items or ranges from various collection types to an existing sequence.
• Immutable Sequence Updates - Supports adding individual items to the beginning or end of a sequence lazily.
• Generic Traits - Implements higher-kinded generic programming via traits for common functional abstractions like Functors and Monads.
• Integer Range Generators - Generates on-demand sequences of integers or characters based on start, count, and step.
• Monadic Filters - Prevents values from proceeding through an effect chain if they do not satisfy a specific predicate.
• Monadic Lifting - Converts plain values and exceptions into the effect monad for integration into functional pipelines.
• Monadic Transformations - Maps and transforms success and failure states of effects to modify output values and types.
• Parser Combinators - Provides a functional parser-combinator toolkit for building complex structural text analyzers from simple functions.
• Safe Access Methods - Provides safe access to the head, tail, or specific index of a collection using types that handle missing elements.
• Sequence Deconstructions - Provides mechanisms to split sequences into head and tail for use in functional pattern matching.
• Sequence Iteration - Supports both pure functional and impure iteration over elements in a sequence.
• Functional State Management - Provides functional state management containers to track and transform application state and configuration.
• Monadic State Modeling - Implements reader, writer, and state monads for managing environment configuration and state transitions.
• Causal Ordering Timestamps - Tracks distributed event ordering using vector clocks to resolve conflicts in decentralized systems.
• Vector Clocks - Implements vector clocks for causality tracking and deterministic data conflict resolution in distributed environments.
• Causal Value Versioning - Implements value versioning using vector clocks and timestamps to track changes across different actors.
• Compositional Transformation Pipelines - Provides a system for fusing producers and consumers into closed, constant-memory data transformation pipelines.
• Cumulative Error Collection - Collects multiple validation failures across an operation before aborting instead of failing fast.
• Monadic Recovery - Intercepts failure states within effects to map them to success values or trigger recovery effects.
• Compositional Streaming Pipelines - Implements a compositional system for processing asynchronous data flows using reusable sources, sinks, and conduits.
• Stream Source Generators - Converts collections, channels, or singleton values into streams for state aggregation.
• Streaming Data Transformations - Implements data transformation via transducers and internal buffers within a streaming pipeline.
• Set Transformations - Creates new sets by applying mapping functions or filtering elements of an existing set.
• Stream Composition - Bridges open stream components (sources/sinks) into closed pipe components for concurrent composition.
• Stream Combinators - Merges, concatenates, or zips multiple data sources into a single stream.
• Functional Programming - Functional language extensions and concurrency primitives.

Star history