gcanti/fp-ts

Features

• Pure Functional TypeScript Abstractions - Applies pure functional patterns with immutable data types and type classes for composable TypeScript code.
• Data Lenses - Ships composable lenses, prisms, and traversals for immutable nested data manipulation.
• Monads and Functional Tools - Combines stateless functions using Monad and Applicative abstractions for predictable data flows.
• Effectful Array Traversals - Provides Traversable instances for applying effectful functions to array elements.
• Computational Context Mappings - Transforms values inside computational contexts like Option or Task while preserving structure.
• Optional Value Types - Provides an Option type that distinguishes between Some and None values.
• Functor Transformations - Applies functions to the contents of an optional container without altering the container structure.
• Nullable to Optional Conversions - Provides a function to convert nullable values into Option, eliminating null checks.
• Option to Nullable Conversions - Extracts the inner value from an Option, returning null when absent.
• Optional Chaining - Ships monadic chaining for Option that short-circuits on absent values.
• Optional Value Transformations - Applies a function to the inner value of an Option, preserving the empty state.
• Asynchronous Task Composition - Chains tasks so the output of one feeds into the next, preserving only the final result.
• Contextual Function Lifting - Transforms functions to operate on values wrapped in a context across multiple arguments.
• Pure Value Effects - Wraps a pure value into an effect that succeeds with that value when executed.
• Functorial Mapping - Transforms values inside a computational context while preserving the structure of that context.
• Higher-Kinded Type Simulation - Simulates higher-kinded types in TypeScript to enable generic abstractions over type constructors.
• Lazy Asynchronous Task Management - Models and composes lazy async computations with Task, handling concurrency and sequencing.
• Lazy Asynchronous Task Modeling - Represents delayed or concurrent operations using a lazy, composable Task type.
• Monadic Sequential Composition - Chains computations so each step's output feeds into the next for ordered transformations.
• Pure Functions - Combines small pure functions into larger structures using composition utilities.
• Effectful Sequencing - Converts a collection of effectful computations into a single computation returning a collection of results.
• Algebraic Data Types - Encodes domain logic using sum and product types to make invalid states unrepresentable.
• Traversable & Foldable Abstractions - Provides Traversable and Foldable type classes for effectful iteration over structures.
• Type Classes - Provides category-theory-based type classes like Functor, Applicative, and Monad.
• Pure State Transitions - Implements a State monad for modeling stateful computations as pure state transitions.
• Asynchronous Task Encapsulation - Wraps async operations in lazy Task values for composable concurrency without callbacks.
• Computation Array Traversal - Provides Traversable instances for applying effectful computations to array elements.
• Concurrent Effect Combinators - Executes multiple asynchronous effects in parallel and aggregates their results into joint types.
• Record - Combines multiple named effectful computations into a single effect producing a record of results.
• Algebraic Data Type Validations - Validates runtime data against algebraic type schemas using Either, Option, and Validation.
• Effectful Function Compositions - Composes effectful computations in sequence, passing each output as the next input.
• Effect Lifting - Transforms functions returning simple wrappers into functions returning complex effect types.
• Nested Functor Mapping - Provides nested functor mapping for applying transformations through multiple functor layers.
• Error Accumulators - Combines multiple Either values, collecting all failure messages into a single error using a Semigroup.
• Validation Error Aggregators - Accumulates multiple validation failures into a single structured collection instead of short-circuiting.
• Effect Type Widening - Provides type-level widening of error and environment types when composing effectful operations.
• Failure Recovery - Provides fallback values or computations when an Either holds a failure.
• Either Value Extractions - Wraps computation results as either a success value or a failure with an associated error.
• Applicative Effect Handling - Provides applicative functor instances for combining effectful computations while preserving inner values.
• Functional Optics - Provides composable lenses, prisms, and traversals for immutable nested data manipulation.
• Lazy Effect Encapsulation - Wraps synchronous and asynchronous side effects into pure, composable values.
• Functor Compositions - Provides functor composition utilities for mapping through nested computational contexts.
• Monadic Computation Chaining - Chains dependent effectful operations where each step passes its result to the next via Monad.
• Monadic Flattening - Removes nesting from monadic containers like Either of Either using Chain.
• Applicative Lifting - Wraps a plain value into a computational context for use with applicative operations.
• Monoid Operations - Combines multiple values of the same type using an associative operation and identity element.
• Optional Value Types - Models absent values with Option to eliminate null checks and runtime errors.
• Option for Nullable Values - Wraps nullable values in an Option type for safe, null-free operations.
• Either Error Transformations - Uses Either to encode fallible computations with explicit typed error handling.
• Type Class Polymorphism - Maps shared behaviors to data types through type class instances obeying mathematical laws.
• Reader-Based Dependency Injection - Threads a read-only environment through computations using the Reader type for dependency injection.
• Semigroup Operations - Ships Semigroup and Monoid abstractions for merging values of the same type.
• Sequential Effect Execution - Executes individual side-effectful computations in a strict linear sequence.
• Effectful Result Transformations - Applies pure functions to the result of effectful computations, producing new transformed effects.
• Side Effect Modeling - Wraps synchronous and asynchronous side effects into pure values for deferred composition.
• Stateful Computation Modeling - Provides a State type for threading state through pure functional computations.
• Error Handling - Represents fallible computations with typed errors using the Either data type.
• Effect Flattening - Flattens nested monadic structures like Task of Task into a single effect.
• Collection Filtering - Produces new collections containing only elements that satisfy a specific predicate.
• Applicative Value Aggregations - Concatenates inner values of applicative functors using a provided Monoid instance.
• Nullable and Optional Conversions - Converts between nullable types and Option, enabling safe null handling.
• Optional Fallbacks - Returns a fallback value when an Option is None.
• Optional Value Combinations - Combines two Option values using an associative Semigroup operation.
• Optional Value Comparisons - Implements equality and ordering comparisons for optional values.
• Optional Value Extractions - Provides operations to extract the inner value or a default when absent.
• Optional Value Processing - Reduces an Option to a single value by handling both Some and None cases.
• Optional Value Filtering - Filters an Option's inner value by a predicate, returning None on failure.
• Computed Field Additions - Ships computed field additions for incremental record construction within functorial contexts.
• Asynchronous Array Sequencing - Transforms an array of tasks into a single task yielding an array of results.
• Task Result Discarders - Provides combinators to run two tasks and discard the result of either the first or the second.
• Contravariant Transformations - Adapts input types of functions using the Contravariant type class to reuse logic across different data shapes.
• Bifunctor Mappings - Maps over both sides of a data type like Either using the Bifunctor abstraction.
• Functorial Value Bindings - Supports functorial value bindings for adding computed fields to functorial structures.
• Monad Transformer Stacks - Combines multiple computational contexts by stacking monad transformers for effect composition.
• Monadic Do Notation - Binds intermediate task results to named fields inside do-notation blocks for readable composition.
• Total Order Definitions - Provides an Ord type class for defining total orderings for custom types.
• Newtypes - Wraps primitive types in distinct types with zero runtime overhead to enforce domain constraints.
• Effect Discarding Sequencers - Provides combinators that sequence effects while discarding the second result, enabling ordered pipelines.
• Effect Tuple Sequencers - Provides combinators for sequencing effectful computations into a tuple of results.
• Runtime Data Validation - Provides runtime schema validation for checking data structures against type definitions.
• Algebraic Type Class Instances - Allows defining custom type class instances for user-defined data types.
• Constant Functor Application - Implements constant functor application for pointful-style mapping operations.
• Custom Equality Definitions - Provides an Eq type class for defining type-safe custom equality comparisons.
• Runtime Schema Validations - Checks data structures against type schemas at runtime to ensure structural integrity.
• Kleisli Arrow Transformations - Ships utilities for lifting Kleisli arrows between different monadic contexts.
• Equality and Ordering Interfaces - Provides Eq and Ord type classes for generic equality and ordering across data types.
• Exception to Option Adapters - Converts exception-throwing thunks into optional values returning None on exception.
• Either Folding - Provides Either folding to reduce both success and failure branches into a single result.
• Either Success Chaining - Chains functions on the success value of an Either, producing a new Either without unwrapping.
• Either Success Transformations - Maps functions over the success value of an Either while preserving the failure channel.
• Functor Named Bindings - Provides functor named bindings to attach names to values inside functorial structures.
• Monoid Context Lifting - Lifts monoidal concatenation into an applicative context for wrapped value combination.
• Exception to Absent Value Conversions - Wraps exception-throwing computations into optional values that return absent on failure.
• Either Default Extractions - Provides Either default extraction to unwrap success values or return a fallback on failure.
• Either to Option Conversions - Discards the error side of an Either, returning None for Left and Some for Right.
• Natural Transformation Conversions - Transforms one effect type into another using natural transformations for interoperation.
• Option and Either Interconversions - Provides bidirectional conversion between Option and Either types.
• Nullable to Either Conversions - Converts nullable values into an Either, with a default error for null or undefined.
• Option to Either Conversions - Converts an Option into an Either, providing a default error value when absent.
• Either Predicate Checks - Checks the success value of an Either against a predicate, returning a Left on failure.
• Parallel Task Execution - Provides combinators for executing multiple tasks concurrently and combining their results.
• Optional Equality Testing - Checks structural equality of Option values using an Eq instance.
• Sequential Task Execution - Executes multiple tasks one after another using a sequential applicative instance.
• Exception to Either Executions - Runs fallible functions and returns results as Either values with caught errors.
• Side Effect Discarding - Executes an effect for its side effects while discarding the result to maintain the original value pipeline.
• Seeded Pseudorandom Generation - Generates structured, seeded pseudorandom test data from type definitions for property-based testing.

Star history