funland-laws


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

funland-laws is a sub-project of Funland
exposing type-class laws for usage in tests.

Usage

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.

$3

API docs:

- funland (core)
- funland-laws (laws)

Exposed type classes:

- Setoid (api / laws / static-land)
- Functor (api / laws / static-land)
- Apply (api / laws / static-land)
- Applicative (api / laws / static-land)
- Chain (api / laws / static-land)
- ChainRec (api / laws / static-land)
- Monad (api / laws / static-land)

$3

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

`sh
npm install funland-laws --save-dev

npm install jsverify --save-dev

For jsverify types (for TypeScript):


npm install @types/jsverify --save-dev
`

And then you can do something like this:

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

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

const laws = lawsRef || new SetoidLaws(F)
const eq = (p: Equiv) => 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.

$3

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.

License

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