funfix-types

Sub-project of Funfix exposing type classes inspired by Haskell's standard library and by Typelevel Cats.

Summary of type classes:


Eq	type class for determining equality between instances of the same type and that obeys the laws defined in EqLaws
Functor	type class exposing `map` and that obeys the laws defined in FunctorLaws
Apply	type class that extends `Functor`, exposing `ap` and that obeys the laws defined in ApplyLaws
Applicative	type class that extends `Functor` and `Apply`, exposing `pure` and that obeys the laws defined in ApplicativeLaws
ApplicativeError	type class that extends `Applicative`, for applicative types that can raise errors or recover from them and that obeys the laws defined in ApplicativeErrorLaws
FlatMap	type class that extends `Functor` and `Apply`, exposing `flatMap` and `tailRecM` and that obeys the laws defined in FlatMapLaws
Monad	type class that extends `Applicative` and `FlatMap` and that obeys the laws defined in MonadLaws
MonadError	type class that extends `ApplicativeError` and `Monad`, for monads that can raise or recover from errors and that obeys the laws defined in MonadErrorLaws
CoflatMap	type class that extends `Functor`, the dual of `FlatMap`, obeying the laws defined in CoflatMapLaws
Comonad	type class that extends `CoflatMap`, the dual of `Monad`, for data types that providing `extract`, obeying the laws defined in ComonadLaws

More is coming 😉

Usage

You can depend on the whole funfix library, by adding it to package.json:

npm install --save funfix

In this case imports are like:

import { Monad } from "funfix"

Or for finer grained dependency management, the project can depend only on funfix-types:

npm install --save funfix-types

In this case imports are like:

import { Monad } from "funfix-types"

Modules: UMD and ES 2015

The library has been compiled using UMD (Universal Module Definition), so it should work with CommonJS and AMD.

But it also provides a module definition in package.json, thus providing compatibility with ECMAScript 2015 modules, for usage when used with a modern JS engine, or when bundling with a tool chain that understands ES2015 modules, like Rollup or Webpack.

Index

Interfaces

Type aliases

Variables

Functions

Type aliases

Constructor

Constructor: object | object

Given a type T representing instances of a class C, the type Constructor<T> is the type of the class C.

This type emulates Class from Flow.

Note that in TypeScript constructors can also be protected or private and unfortunately specifying { new(): T } is thus insufficient. Which is why, for classes without a public constructor, we have to specify a _funErasure (static) member as a property, to help the compiler infer type T.

Example:

class NumBox { constructor(public num: number) {} }
class GenBox<A> { constructor(public a: A) {} }

function getDefault<F>(ref: Constructor<F>): Option<F> {
  if ((ref as any)._default) return Some(ref._default)
  return None
}

(NumBox as any)._default = new NumBox(10)
(GenBox as any)._default = new GenBox("value")

const r1: Option<NumBox> = getDefault(NumBox)
const r2: Option<GenBox<any>> = getDefault(GenBox)

And for classes with a private constructor:

class PrivateBox<A> {
  private constructor(public a: A) {}

  static _funErasure: PrivateBox<any> // leaving undefined
}

const F = PrivateBox as any
F._default = new F("hello")

const r: Option<PrivateBox<any>> = getDefault(NumBox)