Fp Ts

fp-ts is a TypeScript library that brings pure functional programming patterns to the language through algebraic data types, type class abstractions, and composable combinators. It provides foundational data types like Option for optional values, Either for typed error handling, and Task for lazy asynchronous computations, all designed to make invalid states unrepresentable and side effects explicit. The library is built on category theory concepts, offering type classes such as Functor, Applicative, Monad, Semigroup, and Monoid with lawful instances for common data structures.

The library distinguishes itself through its comprehensive set of functional abstractions that enable predictable composition of pure functions and effects. It includes a composable optics system with lenses, prisms, and traversals for immutable nested data manipulation, runtime schema validation for checking data against type definitions, and monad transformer layering for combining multiple computational contexts. fp-ts also simulates higher-kinded types in TypeScript, enabling generic abstractions over type constructors that are not natively supported by the language.

Beyond its core abstractions, fp-ts provides tools for asynchronous effect management with Task composition including parallel execution, sequential chaining, and race conditions. It supports error handling through Either and Validation with multiple error accumulation, stateful computations via the State type, dependency injection through Reader, and output accumulation with Writer. The library also offers property-based testing with seeded pseudorandom data generation, bidirectional route parsing and generation, and type-safe local storage persistence.

The library is distributed as a single npm package with comprehensive API documentation generated from annotated source code, and includes community-curated tutorials and recipes for learning functional programming patterns.

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.

Istoric stele

gcantifp-ts

Name: gcanti/fp-ts
Author: gcanti

View on GitHub

11,523 stele514 fork-uriTypeScriptMIT7 vizualizărigcanti.github.io/fp-ts

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.

Alternative open-source pentru Fp Ts

Proiecte open-source similare, clasificate după numărul de funcționalități comune cu Fp Ts.

typelevel/cats
typelevel/cats
5,447Vezi pe GitHub
Cats is a Scala functional programming library and type class library designed to implement algebraic patterns and functional abstractions. It provides a standardized set of interfaces and a modular toolkit of functional wrappers and containers to enable ad-hoc polymorphism and generic programming across disparate types. The project serves as a functional abstraction standard, offering a monad transformer suite to compose nested effectful contexts and handle multiple computational side effects within a single pipeline. It further enables the construction of embedded domain-specific languages
Scala
Vezi pe GitHub5,447
purescript/purescript
purescript/purescript
8,832Vezi pe GitHub
PureScript is a statically typed, purely functional programming language that compiles to JavaScript. It is designed as a cross-platform frontend language for building safe web applications, utilizing a static type system and a JavaScript compiler to ensure program correctness across browser and server environments. The language is distinguished by its emphasis on mathematical purity, featuring a robust type system with first-class support for monads. It provides a sophisticated toolset for static verification, including algebraic data types, type classes, and automatic type inference to reje
Haskellalt-jshaskelljavascript
Vezi pe GitHub8,832
dry-python/returns
dry-python/returns
4,310Vezi pe GitHub
Returns is a functional programming library for Python that provides type-safe containers for managing state, error handling, and optionality. It serves as a monadic container library and a type-safe error handling framework, replacing traditional try-catch blocks and null checks with Result and Optional containers to treat exceptions as data. The project is distinguished by its use of a specialized Mypy static analysis plugin to validate functional pipelines and emulate higher kinded types. It provides mechanisms for isolating side effects through IO containers and offers a framework for typ
Python
Vezi pe GitHub4,310
borgo-lang/borgo
borgo-lang/borgo
4,640Vezi pe GitHub
Borgo is a statically typed language and compiler that transforms high-level syntax into Go source code. It functions as a transpiler designed to leverage the Go runtime while introducing a type system centered on algebraic data types and result-based error handling. The language distinguishes itself by replacing Go's multiple return values with result and option types, using a dedicated operator for concise error propagation. It implements sum types with exhaustive pattern matching and provides a tool to generate bindings for existing Go packages, automatically converting multi-value returns
Rustcompilergolangprogramming-language
Vezi pe GitHub4,640

Vezi toate cele 30 alternative pentru Fp Ts

Întrebări frecvente

Ce face gcanti/fp-ts?

Care sunt principalele funcționalități ale gcanti/fp-ts?

Principalele funcționalități ale gcanti/fp-ts sunt: Pure Functional TypeScript Abstractions, Data Lenses, Monads and Functional Tools, Effectful Array Traversals, Computational Context Mappings, Optional Value Types, Functor Transformations, Nullable to Optional Conversions.

Care sunt câteva alternative open-source pentru gcanti/fp-ts?

Alternativele open-source pentru gcanti/fp-ts includ: typelevel/cats — Cats is a Scala functional programming library and type class library designed to implement algebraic patterns and… purescript/purescript — PureScript is a statically typed, purely functional programming language that compiles to JavaScript. It is designed… dry-python/returns — Returns is a functional programming library for Python that provides type-safe containers for managing state, error… mostlyadequate/mostly-adequate-guide — This project is a comprehensive educational guide and curriculum for applying functional programming principles and… louthy/language-ext — language-ext is a functional programming framework for C# that provides a suite of immutable data structures and… borgo-lang/borgo — Borgo is a statically typed language and compiler that transforms high-level syntax into Go source code. It functions…