fp-ts

What is fp-ts?

The fp-ts npm package is a library for functional programming in TypeScript. It provides developers with tools to write code in a functional style, leveraging concepts like type-safe functional combinators, monads, and other abstractions that enable expressive and concise code.

What are fp-ts's main functionalities?

Option Type

The Option type represents encapsulation of an optional value. A value of type Option<T> can either be some<T> if it exists or none if it does not. This is useful for handling cases where a value might be missing without resorting to null or undefined.

import { Option, some, none } from 'fp-ts/Option';

function find<T>(predicate: (a: T) => boolean, arr: T[]): Option<T> {
  for (const item of arr) {
    if (predicate(item)) {
      return some(item);
    }
  }
  return none;
}

const result = find(x => x > 10, [1, 2, 3]);
console.log(result); // output: none

Either Type

The Either type represents a value of one of two possible types (a disjoint union). An instance of Either is either an instance of left or right. It is useful for error handling where left can be used to hold an error value and right can hold a success value.

import { Either, left, right } from 'fp-ts/Either';

function divide(a: number, b: number): Either<string, number> {
  return b === 0 ? left('Cannot divide by zero') : right(a / b);
}

const result = divide(10, 0);
console.log(result); // output: left('Cannot divide by zero')

IO Type

The IO type represents a computation that can perform side effects when executed. It is a way to manage side effects in a functional way by deferring their execution.

import { IO } from 'fp-ts/IO';

const log: IO<void> = () => console.log('Hello, fp-ts!');

log(); // output: 'Hello, fp-ts!'

Function Composition

Function composition is a core concept in functional programming, allowing you to combine multiple functions into a single function. The flow function from fp-ts helps you to compose functions easily.

import { flow } from 'fp-ts/function';

const toUpperCase = (s: string) => s.toUpperCase();
const exclaim = (s: string) => `${s}!`;
const shout = flow(toUpperCase, exclaim);

console.log(shout('hello')); // output: 'HELLO!'

Other packages similar to fp-ts

ramda

Ramda is a popular functional programming library for JavaScript. It emphasizes a functional style and provides many utilities for working with functions and data. Compared to fp-ts, Ramda is less focused on type safety and does not provide as many abstractions related to category theory.

sanctuary

Sanctuary is a functional programming library that provides type-safe functional data types and utility functions. It is similar to fp-ts in its emphasis on type safety and functional programming concepts, but it has its own set of abstractions and API design choices.

README

Functional programming in TypeScript

Inspired by PureScript, static-land, Scala.

The idea (faking higher kinded types in TypeScript) is based on Lightweight higher-kinded polymorphism

Installation

To install the stable version:

npm install --save fp-ts

TypeScript compatibility

The stable version is tested against TypeScript 3.2.1, but should run with TypeScript 2.3.0+ too

Note. If you are running < typescript@3.0.1 you have to polyfill unknown.

You can use unknown-ts as a polyfill.

Ecosystem

• io-ts - TypeScript compatible runtime type system for IO validation
• monocle-ts - Functional optics: a (partial) porting of scala monocle to TypeScript
• newtype-ts - Implementation of newtypes in TypeScript
• logging-ts - Composable loggers for TypeScript
• fp-ts-routing - A type-safe bidirectional routing library for TypeScript
• parser-ts - String parser combinators for TypeScript
• remote-data-ts - RemoteData type (check this article)
• retry-ts - Retry combinators for monadic actions that may fail
• fp-ts-local-storage - fp-ts bindings for LocalStorage

Bindings

• fp-ts-rxjs - fp-ts bindings for RxJS
• fp-ts-fluture - fp-ts bindings for Fluture
• fp-ts-most - fp-ts bindings for @most/core

Documentation

• API Reference
• fp-ts for PureScripters / Haskellers
• Comparison with ramda

Internals

• How HKT, URI2HKT, URIS and Type work

Examples

• Free monad
• MTL-style
• OptionT monad transformer
  • ArrayOption
  • TaskOption
• EitherT monad transformer
  • EitherOption
• StateT monad transformer
  • StateIO
  • StateTaskEither
• Reader monad
• ReaderT monad transformer
  • ReaderIO
• Applicative composition
  • TaskValidation
• Type safe finite state machines with IxIO
• Moore machines
• Debugging with Trace
• fantas-eel-and-specification - Code for the Fantas, Eel, and Specification blog series on functional programming by Tom Harding

Type Classes

License

The MIT License (MIT)