• Public
  • Public/Protected
  • All


Funland is a specification of common algebraic structures for JavaScript, TypeScript and Flow, based on Fantasy Land and compatible with static-land.


For the TypeScript / Flow types, which are very light (no accompanying JavaScript code, just types):

npm install --save funland

For the laws:

npm install --save funland-laws

Usage of laws mostly makes sense in tests, being built for property-based testing, so usage of jsverify is recommended, but not required.


API docs:

Exposed type classes:

Testing the Included Type-class Laws

The included laws are meant for usage with property-based testing, so you'll need something like jsverify as a dependency.

And then you can do something like this:

import * as jv from "jsverify"
import { Setoid } from "funland"
import { Equiv, SetoidLaws } from "funland-laws"

export function setoidCheck<A>(
  genA: jv.Arbitrary<A>,
  F: Setoid<A>,
  lawsRef?: SetoidLaws<A>) {

  const laws = lawsRef || new SetoidLaws<A>(F)
  const eq = (p: Equiv<boolean>) => p.lh === p.rh

  jv.property("setoid.reflexivity", genA,
    x => eq(laws.reflexivity(x)))

  jv.property("setoid.symmetry", genA, genA,
    (x, y) => eq(laws.symmetry(x, y)))

  jv.property("setoid.transitivity", genA, genA, genA,
    (x, y, z) => eq(laws.transitivity(x, y, z)))

Such integration is currently not provided by Funland, however the project's repository has code to use for inspiration, see github.com/.../funland-laws/test-common.

Modules: UMD and ES 2015

The library has been compiled using UMD (Universal Module Definition), so it should work with CommonJS and AMD, for standalone usage in browsers or Node.js.

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.

TypeScript or Flow?

Funland exposes both TypeScript and Flow type annotations out of the box.


All code in this repository is licensed under the MIT license.


Type aliases


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.


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)


  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method

Generated using TypeDoc