diff --git a/LICENSE b/LICENSE
index 5d87459..49b2f24 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
The MIT License (MIT)
-Copyright (c) 2020 Sanctuary
+Copyright (c) 2021 Sanctuary
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
diff --git a/README.md b/README.md
index 9bff583..fa82daa 100644
--- a/README.md
+++ b/README.md
@@ -53,7 +53,7 @@ This project provides:
## API
-#### `TypeClass :: (String, String, Array TypeClass, a -> Boolean) -> TypeClass`
+#### `TypeClass :: (String, String, Array TypeClass, a -> Boolean) -> TypeClass`
The arguments are:
@@ -100,299 +100,322 @@ dependencies; `false` otherwise.
to define parametrically polymorphic functions which verify their
type-class constraints at run time.
-#### `Setoid :: TypeClass`
+#### `Setoid :: TypeClass`
`TypeClass` value for [Setoid][].
```javascript
-> Setoid.test (null)
+> Z.Setoid.test (null)
true
+
+> Z.Setoid.test (Useless)
+false
+
+> Z.Setoid.test ([1, 2, 3])
+true
+
+> Z.Setoid.test ([Useless])
+false
```
-#### `Ord :: TypeClass`
+#### `Ord :: TypeClass`
`TypeClass` value for [Ord][].
```javascript
-> Ord.test (0)
+> Z.Ord.test (0)
+true
+
+> Z.Ord.test (Math.sqrt)
+false
+
+> Z.Ord.test ([1, 2, 3])
true
-> Ord.test (Math.sqrt)
+> Z.Ord.test ([Math.sqrt])
false
```
-#### `Semigroupoid :: TypeClass`
+#### `Semigroupoid :: TypeClass`
`TypeClass` value for [Semigroupoid][].
```javascript
-> Semigroupoid.test (Math.sqrt)
+> Z.Semigroupoid.test (Math.sqrt)
true
-> Semigroupoid.test (0)
+> Z.Semigroupoid.test (0)
false
```
-#### `Category :: TypeClass`
+#### `Category :: TypeClass`
`TypeClass` value for [Category][].
```javascript
-> Category.test (Math.sqrt)
+> Z.Category.test (Math.sqrt)
true
-> Category.test (0)
+> Z.Category.test (0)
false
```
-#### `Semigroup :: TypeClass`
+#### `Semigroup :: TypeClass`
`TypeClass` value for [Semigroup][].
```javascript
-> Semigroup.test ('')
+> Z.Semigroup.test ('')
true
-> Semigroup.test (0)
+> Z.Semigroup.test (0)
false
```
-#### `Monoid :: TypeClass`
+#### `Monoid :: TypeClass`
`TypeClass` value for [Monoid][].
```javascript
-> Monoid.test ('')
+> Z.Monoid.test ('')
true
-> Monoid.test (0)
+> Z.Monoid.test (0)
false
```
-#### `Group :: TypeClass`
+#### `Group :: TypeClass`
`TypeClass` value for [Group][].
```javascript
-> Group.test (Sum (0))
+> Z.Group.test (Sum (0))
true
-> Group.test ('')
+> Z.Group.test ('')
false
```
-#### `Filterable :: TypeClass`
+#### `Filterable :: TypeClass`
`TypeClass` value for [Filterable][].
```javascript
-> Filterable.test ({})
+> Z.Filterable.test ({})
true
-> Filterable.test ('')
+> Z.Filterable.test ('')
false
```
-#### `Functor :: TypeClass`
+#### `Functor :: TypeClass`
`TypeClass` value for [Functor][].
```javascript
-> Functor.test ([])
+> Z.Functor.test ([])
true
-> Functor.test ('')
+> Z.Functor.test ('')
false
```
-#### `Bifunctor :: TypeClass`
+#### `Bifunctor :: TypeClass`
`TypeClass` value for [Bifunctor][].
```javascript
-> Bifunctor.test (Pair ('foo') (64))
+> Z.Bifunctor.test (Pair ('foo') (64))
true
-> Bifunctor.test ([])
+> Z.Bifunctor.test ([])
false
```
-#### `Profunctor :: TypeClass`
+#### `Profunctor :: TypeClass`
`TypeClass` value for [Profunctor][].
```javascript
-> Profunctor.test (Math.sqrt)
+> Z.Profunctor.test (Math.sqrt)
true
-> Profunctor.test ([])
+> Z.Profunctor.test ([])
false
```
-#### `Apply :: TypeClass`
+#### `Apply :: TypeClass`
`TypeClass` value for [Apply][].
```javascript
-> Apply.test ([])
+> Z.Apply.test ([])
true
-> Apply.test ('')
+> Z.Apply.test ('')
false
```
-#### `Applicative :: TypeClass`
+#### `Applicative :: TypeClass`
`TypeClass` value for [Applicative][].
```javascript
-> Applicative.test ([])
+> Z.Applicative.test ([])
true
-> Applicative.test ({})
+> Z.Applicative.test ({})
false
```
-#### `Chain :: TypeClass`
+#### `Chain :: TypeClass`
`TypeClass` value for [Chain][].
```javascript
-> Chain.test ([])
+> Z.Chain.test ([])
true
-> Chain.test ({})
+> Z.Chain.test ({})
false
```
-#### `ChainRec :: TypeClass`
+#### `ChainRec :: TypeClass`
`TypeClass` value for [ChainRec][].
```javascript
-> ChainRec.test ([])
+> Z.ChainRec.test ([])
true
-> ChainRec.test ({})
+> Z.ChainRec.test ({})
false
```
-#### `Monad :: TypeClass`
+#### `Monad :: TypeClass`
`TypeClass` value for [Monad][].
```javascript
-> Monad.test ([])
+> Z.Monad.test ([])
true
-> Monad.test ({})
+> Z.Monad.test ({})
false
```
-#### `Alt :: TypeClass`
+#### `Alt :: TypeClass`
`TypeClass` value for [Alt][].
```javascript
-> Alt.test ({})
+> Z.Alt.test ({})
true
-> Alt.test ('')
+> Z.Alt.test ('')
false
```
-#### `Plus :: TypeClass`
+#### `Plus :: TypeClass`
`TypeClass` value for [Plus][].
```javascript
-> Plus.test ({})
+> Z.Plus.test ({})
true
-> Plus.test ('')
+> Z.Plus.test ('')
false
```
-#### `Alternative :: TypeClass`
+#### `Alternative :: TypeClass`
`TypeClass` value for [Alternative][].
```javascript
-> Alternative.test ([])
+> Z.Alternative.test ([])
true
-> Alternative.test ({})
+> Z.Alternative.test ({})
false
```
-#### `Foldable :: TypeClass`
+#### `Foldable :: TypeClass`
`TypeClass` value for [Foldable][].
```javascript
-> Foldable.test ({})
+> Z.Foldable.test ({})
true
-> Foldable.test ('')
+> Z.Foldable.test ('')
false
```
-#### `Traversable :: TypeClass`
+#### `Traversable :: TypeClass`
`TypeClass` value for [Traversable][].
```javascript
-> Traversable.test ([])
+> Z.Traversable.test ([])
true
-> Traversable.test ('')
+> Z.Traversable.test ('')
false
```
-#### `Extend :: TypeClass`
+#### `Extend :: TypeClass`
`TypeClass` value for [Extend][].
```javascript
-> Extend.test ([])
+> Z.Extend.test ([])
true
-> Extend.test ({})
+> Z.Extend.test ({})
false
```
-#### `Comonad :: TypeClass`
+#### `Comonad :: TypeClass`
`TypeClass` value for [Comonad][].
```javascript
-> Comonad.test (Identity (0))
+> Z.Comonad.test (Identity (0))
true
-> Comonad.test ([])
+> Z.Comonad.test ([])
false
```
-#### `Contravariant :: TypeClass`
+#### `Contravariant :: TypeClass`
`TypeClass` value for [Contravariant][].
```javascript
-> Contravariant.test (Math.sqrt)
+> Z.Contravariant.test (Math.sqrt)
true
-> Contravariant.test ([])
+> Z.Contravariant.test ([])
false
```
-#### `equals :: (a, b) -> Boolean`
+#### `equals :: (a, b) -> Boolean`
+
+Returns `true` if its arguments are equal; `false` otherwise.
-Returns `true` if its arguments are of the same type and equal according
-to the type's [`fantasy-land/equals`][] method; `false` otherwise.
+Specifically:
-`fantasy-land/equals` implementations are provided for the following
-built-in types: Null, Undefined, Boolean, Number, Date, RegExp, String,
-Array, Arguments, Error, Object, and Function.
+ - Arguments with different [type identities][] are unequal.
+
+ - If the first argument has a [`fantasy-land/equals`][] method,
+ that method is invoked to determine whether the arguments are
+ equal (`fantasy-land/equals` implementations are provided for the
+ following built-in types: Null, Undefined, Boolean, Number, Date,
+ RegExp, String, Array, Arguments, Error, Object, and Function).
+
+ - Otherwise, the arguments are equal if their
+ [entries][`Object.entries`] are equal (according to this algorithm).
The algorithm supports circular data structures. Two arrays are equal
if they have the same index paths and for each path have equal values.
@@ -401,20 +424,20 @@ are equal even if their internal structures differ. Two objects are equal
if they have the same property paths and for each path have equal values.
```javascript
-> equals (0, -0)
+> Z.equals (0, -0)
true
-> equals (NaN, NaN)
+> Z.equals (NaN, NaN)
true
-> equals (Cons (1, Cons (2, Nil)), Cons (1, Cons (2, Nil)))
+> Z.equals (Cons (1, Cons (2, Nil)), Cons (1, Cons (2, Nil)))
true
-> equals (Cons (1, Cons (2, Nil)), Cons (2, Cons (1, Nil)))
+> Z.equals (Cons (1, Cons (2, Nil)), Cons (2, Cons (1, Nil)))
false
```
-#### `lt :: (a, b) -> Boolean`
+#### `lt :: (a, b) -> Boolean`
Returns `true` if its arguments are of the same type and the first is
less than the second according to the type's [`fantasy-land/lte`][]
@@ -425,17 +448,17 @@ This function is derived from [`lte`](#lte).
See also [`gt`](#gt) and [`gte`](#gte).
```javascript
-> lt (0, 0)
+> Z.lt (0, 0)
false
-> lt (0, 1)
+> Z.lt (0, 1)
true
-> lt (1, 0)
+> Z.lt (1, 0)
false
```
-#### `lte :: (a, b) -> Boolean`
+#### `lte :: (a, b) -> Boolean`
Returns `true` if its arguments are of the same type and the first
is less than or equal to the second according to the type's
@@ -451,17 +474,17 @@ The algorithm supports circular data structures in the same manner as
See also [`lt`](#lt), [`gt`](#gt), and [`gte`](#gte).
```javascript
-> lte (0, 0)
+> Z.lte (0, 0)
true
-> lte (0, 1)
+> Z.lte (0, 1)
true
-> lte (1, 0)
+> Z.lte (1, 0)
false
```
-#### `gt :: (a, b) -> Boolean`
+#### `gt :: (a, b) -> Boolean`
Returns `true` if its arguments are of the same type and the first is
greater than the second according to the type's [`fantasy-land/lte`][]
@@ -472,17 +495,17 @@ This function is derived from [`lte`](#lte).
See also [`lt`](#lt) and [`gte`](#gte).
```javascript
-> gt (0, 0)
+> Z.gt (0, 0)
false
-> gt (0, 1)
+> Z.gt (0, 1)
false
-> gt (1, 0)
+> Z.gt (1, 0)
true
```
-#### `gte :: (a, b) -> Boolean`
+#### `gte :: (a, b) -> Boolean`
Returns `true` if its arguments are of the same type and the first
is greater than or equal to the second according to the type's
@@ -493,17 +516,17 @@ This function is derived from [`lte`](#lte).
See also [`lt`](#lt) and [`gt`](#gt).
```javascript
-> gte (0, 0)
+> Z.gte (0, 0)
true
-> gte (0, 1)
+> Z.gte (0, 1)
false
-> gte (1, 0)
+> Z.gte (1, 0)
true
```
-#### `min :: Ord a => (a, a) -> a`
+#### `min :: Ord a => (a, a) -> a`
Returns the smaller of its two arguments.
@@ -512,17 +535,17 @@ This function is derived from [`lte`](#lte).
See also [`max`](#max).
```javascript
-> min (10, 2)
+> Z.min (10, 2)
2
-> min (new Date ('1999-12-31'), new Date ('2000-01-01'))
+> Z.min (new Date ('1999-12-31'), new Date ('2000-01-01'))
new Date ('1999-12-31')
-> min ('10', '2')
+> Z.min ('10', '2')
'10'
```
-#### `max :: Ord a => (a, a) -> a`
+#### `max :: Ord a => (a, a) -> a`
Returns the larger of its two arguments.
@@ -531,17 +554,17 @@ This function is derived from [`lte`](#lte).
See also [`min`](#min).
```javascript
-> max (10, 2)
+> Z.max (10, 2)
10
-> max (new Date ('1999-12-31'), new Date ('2000-01-01'))
+> Z.max (new Date ('1999-12-31'), new Date ('2000-01-01'))
new Date ('2000-01-01')
-> max ('10', '2')
+> Z.max ('10', '2')
'2'
```
-#### `clamp :: Ord a => (a, a, a) -> a`
+#### `clamp :: Ord a => (a, a, a) -> a`
Takes a lower bound, an upper bound, and a value of the same type.
Returns the value if it is within the bounds; the nearer bound otherwise.
@@ -549,17 +572,17 @@ Returns the value if it is within the bounds; the nearer bound otherwise.
This function is derived from [`min`](#min) and [`max`](#max).
```javascript
-> clamp (0, 100, 42)
+> Z.clamp (0, 100, 42)
42
-> clamp (0, 100, -1)
+> Z.clamp (0, 100, -1)
0
-> clamp ('A', 'Z', '~')
+> Z.clamp ('A', 'Z', '~')
'Z'
```
-#### `compose :: Semigroupoid c => (c j k, c i j) -> c i k`
+#### `compose :: Semigroupoid c => (c j k, c i j) -> c i k`
Function wrapper for [`fantasy-land/compose`][].
@@ -567,11 +590,11 @@ Function wrapper for [`fantasy-land/compose`][].
built-in types: Function.
```javascript
-> compose (Math.sqrt, x => x + 1) (99)
+> Z.compose (Math.sqrt, x => x + 1) (99)
10
```
-#### `id :: Category c => TypeRep c -> c`
+#### `id :: Category c => TypeRep c -> c`
Function wrapper for [`fantasy-land/id`][].
@@ -579,11 +602,11 @@ Function wrapper for [`fantasy-land/id`][].
built-in types: Function.
```javascript
-> id (Function) ('foo')
+> Z.id (Function) ('foo')
'foo'
```
-#### `concat :: Semigroup a => (a, a) -> a`
+#### `concat :: Semigroup a => (a, a) -> a`
Function wrapper for [`fantasy-land/concat`][].
@@ -591,20 +614,20 @@ Function wrapper for [`fantasy-land/concat`][].
built-in types: String, Array, and Object.
```javascript
-> concat ('abc', 'def')
+> Z.concat ('abc', 'def')
'abcdef'
-> concat ([1, 2, 3], [4, 5, 6])
+> Z.concat ([1, 2, 3], [4, 5, 6])
[1, 2, 3, 4, 5, 6]
-> concat ({x: 1, y: 2}, {y: 3, z: 4})
+> Z.concat ({x: 1, y: 2}, {y: 3, z: 4})
{x: 1, y: 3, z: 4}
-> concat (Cons ('foo', Cons ('bar', Cons ('baz', Nil))), Cons ('quux', Nil))
+> Z.concat (Cons ('foo', Cons ('bar', Cons ('baz', Nil))), Cons ('quux', Nil))
Cons ('foo', Cons ('bar', Cons ('baz', Cons ('quux', Nil))))
```
-#### `empty :: Monoid m => TypeRep m -> m`
+#### `empty :: Monoid m => TypeRep m -> m`
Function wrapper for [`fantasy-land/empty`][].
@@ -612,29 +635,29 @@ Function wrapper for [`fantasy-land/empty`][].
built-in types: String, Array, and Object.
```javascript
-> empty (String)
+> Z.empty (String)
''
-> empty (Array)
+> Z.empty (Array)
[]
-> empty (Object)
+> Z.empty (Object)
{}
-> empty (List)
+> Z.empty (List)
Nil
```
-#### `invert :: Group g => g -> g`
+#### `invert :: Group g => g -> g`
Function wrapper for [`fantasy-land/invert`][].
```javascript
-> invert (Sum (5))
+> Z.invert (Sum (5))
Sum (-5)
```
-#### `filter :: Filterable f => (a -> Boolean, f a) -> f a`
+#### `filter :: Filterable f => (a -> Boolean, f a) -> f a`
Function wrapper for [`fantasy-land/filter`][]. Discards every element
which does not satisfy the predicate.
@@ -645,52 +668,52 @@ built-in types: Array and Object.
See also [`reject`](#reject).
```javascript
-> filter (x => x % 2 == 1, [1, 2, 3])
+> Z.filter (x => x % 2 == 1, [1, 2, 3])
[1, 3]
-> filter (x => x % 2 == 1, {x: 1, y: 2, z: 3})
+> Z.filter (x => x % 2 == 1, {x: 1, y: 2, z: 3})
{x: 1, z: 3}
-> filter (x => x % 2 == 1, Cons (1, Cons (2, Cons (3, Nil))))
+> Z.filter (x => x % 2 == 1, Cons (1, Cons (2, Cons (3, Nil))))
Cons (1, Cons (3, Nil))
-> filter (x => x % 2 == 1, Nothing)
+> Z.filter (x => x % 2 == 1, Nothing)
Nothing
-> filter (x => x % 2 == 1, Just (0))
+> Z.filter (x => x % 2 == 1, Just (0))
Nothing
-> filter (x => x % 2 == 1, Just (1))
+> Z.filter (x => x % 2 == 1, Just (1))
Just (1)
```
-#### `reject :: Filterable f => (a -> Boolean, f a) -> f a`
+#### `reject :: Filterable f => (a -> Boolean, f a) -> f a`
Discards every element which satisfies the predicate.
This function is derived from [`filter`](#filter).
```javascript
-> reject (x => x % 2 == 1, [1, 2, 3])
+> Z.reject (x => x % 2 == 1, [1, 2, 3])
[2]
-> reject (x => x % 2 == 1, {x: 1, y: 2, z: 3})
+> Z.reject (x => x % 2 == 1, {x: 1, y: 2, z: 3})
{y: 2}
-> reject (x => x % 2 == 1, Cons (1, Cons (2, Cons (3, Nil))))
+> Z.reject (x => x % 2 == 1, Cons (1, Cons (2, Cons (3, Nil))))
Cons (2, Nil)
-> reject (x => x % 2 == 1, Nothing)
+> Z.reject (x => x % 2 == 1, Nothing)
Nothing
-> reject (x => x % 2 == 1, Just (0))
+> Z.reject (x => x % 2 == 1, Just (0))
Just (0)
-> reject (x => x % 2 == 1, Just (1))
+> Z.reject (x => x % 2 == 1, Just (1))
Nothing
```
-#### `map :: Functor f => (a -> b, f a) -> f b`
+#### `map :: Functor f => (a -> b, f a) -> f b`
Function wrapper for [`fantasy-land/map`][].
@@ -698,64 +721,64 @@ Function wrapper for [`fantasy-land/map`][].
built-in types: Array, Object, and Function.
```javascript
-> map (Math.sqrt, [1, 4, 9])
+> Z.map (Math.sqrt, [1, 4, 9])
[1, 2, 3]
-> map (Math.sqrt, {x: 1, y: 4, z: 9})
+> Z.map (Math.sqrt, {x: 1, y: 4, z: 9})
{x: 1, y: 2, z: 3}
-> map (Math.sqrt, s => s.length) ('Sanctuary')
+> Z.map (Math.sqrt, s => s.length) ('Sanctuary')
3
-> map (Math.sqrt, Pair ('foo') (64))
+> Z.map (Math.sqrt, Pair ('foo') (64))
Pair ('foo') (8)
-> map (Math.sqrt, Nil)
+> Z.map (Math.sqrt, Nil)
Nil
-> map (Math.sqrt, Cons (1, Cons (4, Cons (9, Nil))))
+> Z.map (Math.sqrt, Cons (1, Cons (4, Cons (9, Nil))))
Cons (1, Cons (2, Cons (3, Nil)))
```
-#### `flip :: Functor f => (f (a -> b), a) -> f b`
+#### `flip :: Functor f => (f (a -> b), a) -> f b`
Maps over the given functions, applying each to the given value.
This function is derived from [`map`](#map).
```javascript
-> flip (x => y => x + y, '!') ('foo')
+> Z.flip (x => y => x + y, '!') ('foo')
'foo!'
-> flip ([Math.floor, Math.ceil], 1.5)
+> Z.flip ([Math.floor, Math.ceil], 1.5)
[1, 2]
-> flip ({floor: Math.floor, ceil: Math.ceil}, 1.5)
+> Z.flip ({floor: Math.floor, ceil: Math.ceil}, 1.5)
{floor: 1, ceil: 2}
-> flip (Cons (Math.floor, Cons (Math.ceil, Nil)), 1.5)
+> Z.flip (Cons (Math.floor, Cons (Math.ceil, Nil)), 1.5)
Cons (1, Cons (2, Nil))
```
-#### `bimap :: Bifunctor f => (a -> b, c -> d, f a c) -> f b d`
+#### `bimap :: Bifunctor f => (a -> b, c -> d, f a c) -> f b d`
Function wrapper for [`fantasy-land/bimap`][].
```javascript
-> bimap (s => s.toUpperCase (), Math.sqrt, Pair ('foo') (64))
+> Z.bimap (s => s.toUpperCase (), Math.sqrt, Pair ('foo') (64))
Pair ('FOO') (8)
```
-#### `mapLeft :: Bifunctor f => (a -> b, f a c) -> f b c`
+#### `mapLeft :: Bifunctor f => (a -> b, f a c) -> f b c`
Maps the given function over the left side of a Bifunctor.
```javascript
-> mapLeft (Math.sqrt, Pair (64) (9))
+> Z.mapLeft (Math.sqrt, Pair (64) (9))
Pair (8) (9)
```
-#### `promap :: Profunctor p => (a -> b, c -> d, p b c) -> p a d`
+#### `promap :: Profunctor p => (a -> b, c -> d, p b c) -> p a d`
Function wrapper for [`fantasy-land/promap`][].
@@ -763,11 +786,11 @@ Function wrapper for [`fantasy-land/promap`][].
built-in types: Function.
```javascript
-> promap (Math.abs, x => x + 1, Math.sqrt) (-100)
+> Z.promap (Math.abs, x => x + 1, Math.sqrt) (-100)
11
```
-#### `ap :: Apply f => (f (a -> b), f a) -> f b`
+#### `ap :: Apply f => (f (a -> b), f a) -> f b`
Function wrapper for [`fantasy-land/ap`][].
@@ -775,23 +798,23 @@ Function wrapper for [`fantasy-land/ap`][].
built-in types: Array, Object, and Function.
```javascript
-> ap ([Math.sqrt, x => x * x], [1, 4, 9, 16, 25])
+> Z.ap ([Math.sqrt, x => x * x], [1, 4, 9, 16, 25])
[1, 2, 3, 4, 5, 1, 16, 81, 256, 625]
-> ap ({a: Math.sqrt, b: x => x * x}, {a: 16, b: 10, c: 1})
+> Z.ap ({a: Math.sqrt, b: x => x * x}, {a: 16, b: 10, c: 1})
{a: 4, b: 100}
-> ap (s => n => s.slice (0, n), s => Math.ceil (s.length / 2)) ('Haskell')
+> Z.ap (s => n => s.slice (0, n), s => Math.ceil (s.length / 2)) ('Haskell')
'Hask'
-> ap (Identity (Math.sqrt), Identity (64))
+> Z.ap (Identity (Math.sqrt), Identity (64))
Identity (8)
-> ap (Cons (Math.sqrt, Cons (x => x * x, Nil)), Cons (16, Cons (100, Nil)))
+> Z.ap (Cons (Math.sqrt, Cons (x => x * x, Nil)), Cons (16, Cons (100, Nil)))
Cons (4, Cons (10, Cons (256, Cons (10000, Nil))))
```
-#### `lift2 :: Apply f => (a -> b -> c, f a, f b) -> f c`
+#### `lift2 :: Apply f => (a -> b -> c, f a, f b) -> f c`
Lifts `a -> b -> c` to `Apply f => f a -> f b -> f c` and returns the
result of applying this to the given arguments.
@@ -801,14 +824,14 @@ This function is derived from [`map`](#map) and [`ap`](#ap).
See also [`lift3`](#lift3).
```javascript
-> lift2 (x => y => Math.pow (x, y), [10], [1, 2, 3])
+> Z.lift2 (x => y => Math.pow (x, y), [10], [1, 2, 3])
[10, 100, 1000]
-> lift2 (x => y => Math.pow (x, y), Identity (10), Identity (3))
+> Z.lift2 (x => y => Math.pow (x, y), Identity (10), Identity (3))
Identity (1000)
```
-#### `lift3 :: Apply f => (a -> b -> c -> d, f a, f b, f c) -> f d`
+#### `lift3 :: Apply f => (a -> b -> c -> d, f a, f b, f c) -> f d`
Lifts `a -> b -> c -> d` to `Apply f => f a -> f b -> f c -> f d` and
returns the result of applying this to the given arguments.
@@ -818,23 +841,23 @@ This function is derived from [`map`](#map) and [`ap`](#ap).
See also [`lift2`](#lift2).
```javascript
-> lift3 (x => y => z => x + z + y,
-. ['<', '['],
-. ['>', ']'],
-. ['foo', 'bar', 'baz'])
+> Z.lift3 (x => y => z => x + z + y,
+. ['<', '['],
+. ['>', ']'],
+. ['foo', 'bar', 'baz'])
[ '', '', '',
. '', '[bar>', '[baz>',
. '[foo]', '[bar]', '[baz]' ]
-> lift3 (x => y => z => x + z + y,
-. Identity ('<'),
-. Identity ('>'),
-. Identity ('baz'))
+> Z.lift3 (x => y => z => x + z + y,
+. Identity ('<'),
+. Identity ('>'),
+. Identity ('baz'))
Identity ('')
```
-#### `apFirst :: Apply f => (f a, f b) -> f a`
+#### `apFirst :: Apply f => (f a, f b) -> f a`
Combines two effectful actions, keeping only the result of the first.
Equivalent to Haskell's `(<*)` function.
@@ -844,14 +867,14 @@ This function is derived from [`lift2`](#lift2).
See also [`apSecond`](#apSecond).
```javascript
-> apFirst ([1, 2], [3, 4])
+> Z.apFirst ([1, 2], [3, 4])
[1, 1, 2, 2]
-> apFirst (Identity (1), Identity (2))
+> Z.apFirst (Identity (1), Identity (2))
Identity (1)
```
-#### `apSecond :: Apply f => (f a, f b) -> f b`
+#### `apSecond :: Apply f => (f a, f b) -> f b`
Combines two effectful actions, keeping only the result of the second.
Equivalent to Haskell's `(*>)` function.
@@ -861,14 +884,14 @@ This function is derived from [`lift2`](#lift2).
See also [`apFirst`](#apFirst).
```javascript
-> apSecond ([1, 2], [3, 4])
+> Z.apSecond ([1, 2], [3, 4])
[3, 4, 3, 4]
-> apSecond (Identity (1), Identity (2))
+> Z.apSecond (Identity (1), Identity (2))
Identity (2)
```
-#### `of :: Applicative f => (TypeRep f, a) -> f a`
+#### `of :: Applicative f => (TypeRep f, a) -> f a`
Function wrapper for [`fantasy-land/of`][].
@@ -876,17 +899,17 @@ Function wrapper for [`fantasy-land/of`][].
built-in types: Array and Function.
```javascript
-> of (Array, 42)
+> Z.of (Array, 42)
[42]
-> of (Function, 42) (null)
+> Z.of (Function, 42) (null)
42
-> of (List, 42)
+> Z.of (List, 42)
Cons (42, Nil)
```
-#### `append :: (Applicative f, Semigroup (f a)) => (a, f a) -> f a`
+#### `append :: (Applicative f, Semigroup (f a)) => (a, f a) -> f a`
Returns the result of appending the first argument to the second.
@@ -895,14 +918,14 @@ This function is derived from [`concat`](#concat) and [`of`](#of).
See also [`prepend`](#prepend).
```javascript
-> append (3, [1, 2])
+> Z.append (3, [1, 2])
[1, 2, 3]
-> append (3, Cons (1, Cons (2, Nil)))
+> Z.append (3, Cons (1, Cons (2, Nil)))
Cons (1, Cons (2, Cons (3, Nil)))
```
-#### `prepend :: (Applicative f, Semigroup (f a)) => (a, f a) -> f a`
+#### `prepend :: (Applicative f, Semigroup (f a)) => (a, f a) -> f a`
Returns the result of prepending the first argument to the second.
@@ -911,14 +934,14 @@ This function is derived from [`concat`](#concat) and [`of`](#of).
See also [`append`](#append).
```javascript
-> prepend (1, [2, 3])
+> Z.prepend (1, [2, 3])
[1, 2, 3]
-> prepend (1, Cons (2, Cons (3, Nil)))
+> Z.prepend (1, Cons (2, Cons (3, Nil)))
Cons (1, Cons (2, Cons (3, Nil)))
```
-#### `chain :: Chain m => (a -> m b, m a) -> m b`
+#### `chain :: Chain m => (a -> m b, m a) -> m b`
Function wrapper for [`fantasy-land/chain`][].
@@ -926,37 +949,37 @@ Function wrapper for [`fantasy-land/chain`][].
built-in types: Array and Function.
```javascript
-> chain (x => [x, x], [1, 2, 3])
+> Z.chain (x => [x, x], [1, 2, 3])
[1, 1, 2, 2, 3, 3]
-> chain (x => x % 2 == 1 ? of (List, x) : Nil,
-. Cons (1, Cons (2, Cons (3, Nil))))
+> Z.chain (x => x % 2 == 1 ? Z.of (List, x) : Nil,
+. Cons (1, Cons (2, Cons (3, Nil))))
Cons (1, Cons (3, Nil))
-> chain (n => s => s.slice (0, n),
-. s => Math.ceil (s.length / 2))
-. ('Haskell')
+> Z.chain (n => s => s.slice (0, n),
+. s => Math.ceil (s.length / 2))
+. ('Haskell')
'Hask'
```
-#### `join :: Chain m => m (m a) -> m a`
+#### `join :: Chain m => m (m a) -> m a`
Removes one level of nesting from a nested monadic structure.
This function is derived from [`chain`](#chain).
```javascript
-> join ([[1], [2], [3]])
+> Z.join ([[1], [2], [3]])
[1, 2, 3]
-> join ([[[1, 2, 3]]])
+> Z.join ([[[1, 2, 3]]])
[[1, 2, 3]]
-> join (Identity (Identity (1)))
+> Z.join (Identity (Identity (1)))
Identity (1)
```
-#### `chainRec :: ChainRec m => (TypeRep m, (a -> c, b -> c, a) -> m c, a) -> m b`
+#### `chainRec :: ChainRec m => (TypeRep m, (a -> c, b -> c, a) -> m c, a) -> m b`
Function wrapper for [`fantasy-land/chainRec`][].
@@ -964,7 +987,7 @@ Function wrapper for [`fantasy-land/chainRec`][].
built-in types: Array.
```javascript
-> chainRec (
+> Z.chainRec (
. Array,
. (next, done, s) => s.length == 2 ? [s + '!', s + '?'].map (done)
. : [s + 'o', s + 'n'].map (next),
@@ -973,7 +996,7 @@ built-in types: Array.
['oo!', 'oo?', 'on!', 'on?', 'no!', 'no?', 'nn!', 'nn?']
```
-#### `alt :: Alt f => (f a, f a) -> f a`
+#### `alt :: Alt f => (f a, f a) -> f a`
Function wrapper for [`fantasy-land/alt`][].
@@ -981,20 +1004,20 @@ Function wrapper for [`fantasy-land/alt`][].
built-in types: Array and Object.
```javascript
-> alt ([1, 2, 3], [4, 5, 6])
+> Z.alt ([1, 2, 3], [4, 5, 6])
[1, 2, 3, 4, 5, 6]
-> alt (Nothing, Nothing)
+> Z.alt (Nothing, Nothing)
Nothing
-> alt (Nothing, Just (1))
+> Z.alt (Nothing, Just (1))
Just (1)
-> alt (Just (2), Just (3))
+> Z.alt (Just (2), Just (3))
Just (2)
```
-#### `zero :: Plus f => TypeRep f -> f a`
+#### `zero :: Plus f => TypeRep f -> f a`
Function wrapper for [`fantasy-land/zero`][].
@@ -1002,17 +1025,17 @@ Function wrapper for [`fantasy-land/zero`][].
built-in types: Array and Object.
```javascript
-> zero (Array)
+> Z.zero (Array)
[]
-> zero (Object)
+> Z.zero (Object)
{}
-> zero (Maybe)
+> Z.zero (Maybe)
Nothing
```
-#### `reduce :: Foldable f => ((b, a) -> b, b, f a) -> b`
+#### `reduce :: Foldable f => ((b, a) -> b, b, f a) -> b`
Function wrapper for [`fantasy-land/reduce`][].
@@ -1020,34 +1043,37 @@ Function wrapper for [`fantasy-land/reduce`][].
built-in types: Array and Object.
```javascript
-> reduce ((xs, x) => [x].concat (xs), [], [1, 2, 3])
+> Z.reduce ((xs, x) => [x].concat (xs), [], [1, 2, 3])
[3, 2, 1]
-> reduce (concat, '', Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
+> Z.reduce (Z.concat, '', Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
'foobarbaz'
+
+> Z.reduce (Z.concat, '', {foo: 'x', bar: 'y', baz: 'z'})
+'yzx'
```
-#### `size :: Foldable f => f a -> Integer`
+#### `size :: Foldable f => f a -> Integer`
Returns the number of elements of the given structure.
This function is derived from [`reduce`](#reduce).
```javascript
-> size ([])
+> Z.size ([])
0
-> size (['foo', 'bar', 'baz'])
+> Z.size (['foo', 'bar', 'baz'])
3
-> size (Nil)
+> Z.size (Nil)
0
-> size (Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
+> Z.size (Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
3
```
-#### `all :: Foldable f => (a -> Boolean, f a) -> Boolean`
+#### `all :: Foldable f => (a -> Boolean, f a) -> Boolean`
Returns `true` if all the elements of the structure satisfy the
predicate; `false` otherwise.
@@ -1057,17 +1083,17 @@ This function is derived from [`reduce`](#reduce).
See also [`any`](#any) and [`none`](#none).
```javascript
-> all (Number.isInteger, [])
+> Z.all (Number.isInteger, [])
true
-> all (Number.isInteger, [1, 2, 3])
+> Z.all (Number.isInteger, [1, 2, 3])
true
-> all (Number.isInteger, [0, 0.25, 0.5, 0.75, 1])
+> Z.all (Number.isInteger, [0, 0.25, 0.5, 0.75, 1])
false
```
-#### `any :: Foldable f => (a -> Boolean, f a) -> Boolean`
+#### `any :: Foldable f => (a -> Boolean, f a) -> Boolean`
Returns `true` if any element of the structure satisfies the predicate;
`false` otherwise.
@@ -1077,35 +1103,35 @@ This function is derived from [`reduce`](#reduce).
See also [`all`](#all) and [`none`](#none).
```javascript
-> any (Number.isInteger, [])
+> Z.any (Number.isInteger, [])
false
-> any (Number.isInteger, [1, 2, 3])
+> Z.any (Number.isInteger, [1, 2, 3])
true
-> any (Number.isInteger, [0, 0.25, 0.5, 0.75, 1])
+> Z.any (Number.isInteger, [0, 0.25, 0.5, 0.75, 1])
true
```
-#### `none :: Foldable f => (a -> Boolean, f a) -> Boolean`
+#### `none :: Foldable f => (a -> Boolean, f a) -> Boolean`
Returns `true` if none of the elements of the structure satisfies the
predicate; `false` otherwise.
-This function is derived from [`any`](#any). `none (pred, foldable)` is
-equivalent to `!(any (pred, foldable))`.
+This function is derived from [`any`](#any). `Z.none (pred, foldable)` is
+equivalent to `!(Z.any (pred, foldable))`.
See also [`all`](#all).
```javascript
-> none (Number.isInteger, [])
+> Z.none (Number.isInteger, [])
true
-> none (Number.isInteger, [0, 0.25, 0.5, 0.75, 1])
+> Z.none (Number.isInteger, [0, 0.25, 0.5, 0.75, 1])
false
```
-#### `elem :: (Setoid a, Foldable f) => (a, f a) -> Boolean`
+#### `elem :: (Setoid a, Foldable f) => (a, f a) -> Boolean`
Takes a value and a structure and returns `true` if the
value is an element of the structure; `false` otherwise.
@@ -1114,29 +1140,29 @@ This function is derived from [`equals`](#equals) and
[`reduce`](#reduce).
```javascript
-> elem ('c', ['a', 'b', 'c'])
+> Z.elem ('c', ['a', 'b', 'c'])
true
-> elem ('x', ['a', 'b', 'c'])
+> Z.elem ('x', ['a', 'b', 'c'])
false
-> elem (3, {x: 1, y: 2, z: 3})
+> Z.elem (3, {x: 1, y: 2, z: 3})
true
-> elem (8, {x: 1, y: 2, z: 3})
+> Z.elem (8, {x: 1, y: 2, z: 3})
false
-> elem (0, Just (0))
+> Z.elem (0, Just (0))
true
-> elem (0, Just (1))
+> Z.elem (0, Just (1))
false
-> elem (0, Nothing)
+> Z.elem (0, Nothing)
false
```
-#### `intercalate :: (Monoid m, Foldable f) => (m, f m) -> m`
+#### `intercalate :: (Monoid m, Foldable f) => (m, f m) -> m`
Concatenates the elements of the given structure, separating each pair
of adjacent elements with the given separator.
@@ -1145,26 +1171,26 @@ This function is derived from [`concat`](#concat), [`empty`](#empty),
and [`reduce`](#reduce).
```javascript
-> intercalate (', ', [])
+> Z.intercalate (', ', [])
''
-> intercalate (', ', ['foo', 'bar', 'baz'])
+> Z.intercalate (', ', ['foo', 'bar', 'baz'])
'foo, bar, baz'
-> intercalate (', ', Nil)
+> Z.intercalate (', ', Nil)
''
-> intercalate (', ', Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
+> Z.intercalate (', ', Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
'foo, bar, baz'
-> intercalate ([0, 0, 0], [])
+> Z.intercalate ([0, 0, 0], [])
[]
-> intercalate ([0, 0, 0], [[1], [2, 3], [4, 5, 6], [7, 8], [9]])
+> Z.intercalate ([0, 0, 0], [[1], [2, 3], [4, 5, 6], [7, 8], [9]])
[1, 0, 0, 0, 2, 3, 0, 0, 0, 4, 5, 6, 0, 0, 0, 7, 8, 0, 0, 0, 9]
```
-#### `foldMap :: (Monoid m, Foldable f) => (TypeRep m, a -> m, f a) -> m`
+#### `foldMap :: (Monoid m, Foldable f) => (TypeRep m, a -> m, f a) -> m`
Deconstructs a foldable by mapping every element to a monoid and
concatenating the results.
@@ -1173,11 +1199,11 @@ This function is derived from [`concat`](#concat), [`empty`](#empty),
and [`reduce`](#reduce).
```javascript
-> foldMap (String, f => f.name, [Math.sin, Math.cos, Math.tan])
+> Z.foldMap (String, f => f.name, [Math.sin, Math.cos, Math.tan])
'sincostan'
```
-#### `reverse :: (Applicative f, Foldable f, Monoid (f a)) => f a -> f a`
+#### `reverse :: (Applicative f, Foldable f, Monoid (f a)) => f a -> f a`
Reverses the elements of the given structure.
@@ -1185,14 +1211,14 @@ This function is derived from [`concat`](#concat), [`empty`](#empty),
[`of`](#of), and [`reduce`](#reduce).
```javascript
-> reverse ([1, 2, 3])
+> Z.reverse ([1, 2, 3])
[3, 2, 1]
-> reverse (Cons (1, Cons (2, Cons (3, Nil))))
+> Z.reverse (Cons (1, Cons (2, Cons (3, Nil))))
Cons (3, Cons (2, Cons (1, Nil)))
```
-#### `sort :: (Ord a, Applicative f, Foldable f, Monoid (f a)) => f a -> f a`
+#### `sort :: (Ord a, Applicative f, Foldable f, Monoid (f a)) => f a -> f a`
Performs a [stable sort][] of the elements of the given structure,
using [`lte`](#lte) for comparisons.
@@ -1203,17 +1229,17 @@ This function is derived from [`lte`](#lte), [`concat`](#concat),
See also [`sortBy`](#sortBy).
```javascript
-> sort (['foo', 'bar', 'baz'])
+> Z.sort (['foo', 'bar', 'baz'])
['bar', 'baz', 'foo']
-> sort ([Just (2), Nothing, Just (1)])
+> Z.sort ([Just (2), Nothing, Just (1)])
[Nothing, Just (1), Just (2)]
-> sort (Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
+> Z.sort (Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
Cons ('bar', Cons ('baz', Cons ('foo', Nil)))
```
-#### `sortBy :: (Ord b, Applicative f, Foldable f, Monoid (f a)) => (a -> b, f a) -> f a`
+#### `sortBy :: (Ord b, Applicative f, Foldable f, Monoid (f a)) => (a -> b, f a) -> f a`
Performs a [stable sort][] of the elements of the given structure,
using [`lte`](#lte) to compare the values produced by applying the
@@ -1225,20 +1251,20 @@ This function is derived from [`lte`](#lte), [`concat`](#concat),
See also [`sort`](#sort).
```javascript
-> sortBy (s => s.length, ['red', 'green', 'blue'])
+> Z.sortBy (s => s.length, ['red', 'green', 'blue'])
['red', 'blue', 'green']
-> sortBy (s => s.length, ['black', 'white'])
+> Z.sortBy (s => s.length, ['black', 'white'])
['black', 'white']
-> sortBy (s => s.length, ['white', 'black'])
+> Z.sortBy (s => s.length, ['white', 'black'])
['white', 'black']
-> sortBy (s => s.length, Cons ('red', Cons ('green', Cons ('blue', Nil))))
+> Z.sortBy (s => s.length, Cons ('red', Cons ('green', Cons ('blue', Nil))))
Cons ('red', Cons ('blue', Cons ('green', Nil)))
```
-#### `traverse :: (Applicative f, Traversable t) => (TypeRep f, a -> f b, t a) -> f (t b)`
+#### `traverse :: (Applicative f, Traversable t) => (TypeRep f, a -> f b, t a) -> f (t b)`
Function wrapper for [`fantasy-land/traverse`][].
@@ -1248,28 +1274,28 @@ built-in types: Array and Object.
See also [`sequence`](#sequence).
```javascript
-> traverse (Array, x => x, [[1, 2, 3], [4, 5]])
+> Z.traverse (Array, x => x, [[1, 2, 3], [4, 5]])
[[1, 4], [1, 5], [2, 4], [2, 5], [3, 4], [3, 5]]
-> traverse (Identity, x => Identity (x + 1), [1, 2, 3])
+> Z.traverse (Identity, x => Identity (x + 1), [1, 2, 3])
Identity ([2, 3, 4])
```
-#### `sequence :: (Applicative f, Traversable t) => (TypeRep f, t (f a)) -> f (t a)`
+#### `sequence :: (Applicative f, Traversable t) => (TypeRep f, t (f a)) -> f (t a)`
Inverts the given `t (f a)` to produce an `f (t a)`.
This function is derived from [`traverse`](#traverse).
```javascript
-> sequence (Array, Identity ([1, 2, 3]))
+> Z.sequence (Array, Identity ([1, 2, 3]))
[Identity (1), Identity (2), Identity (3)]
-> sequence (Identity, [Identity (1), Identity (2), Identity (3)])
+> Z.sequence (Identity, [Identity (1), Identity (2), Identity (3)])
Identity ([1, 2, 3])
```
-#### `extend :: Extend w => (w a -> b, w a) -> w b`
+#### `extend :: Extend w => (w a -> b, w a) -> w b`
Function wrapper for [`fantasy-land/extend`][].
@@ -1277,43 +1303,43 @@ Function wrapper for [`fantasy-land/extend`][].
built-in types: Array and Function.
```javascript
-> extend (ss => ss.join (''), ['x', 'y', 'z'])
+> Z.extend (ss => ss.join (''), ['x', 'y', 'z'])
['xyz', 'yz', 'z']
-> extend (f => f ([3, 4]), reverse) ([1, 2])
+> Z.extend (f => f ([3, 4]), Z.reverse) ([1, 2])
[4, 3, 2, 1]
```
-#### `duplicate :: Extend w => w a -> w (w a)`
+#### `duplicate :: Extend w => w a -> w (w a)`
Adds one level of nesting to a comonadic structure.
This function is derived from [`extend`](#extend).
```javascript
-> duplicate (Identity (1))
+> Z.duplicate (Identity (1))
Identity (Identity (1))
-> duplicate ([1])
+> Z.duplicate ([1])
[[1]]
-> duplicate ([1, 2, 3])
+> Z.duplicate ([1, 2, 3])
[[1, 2, 3], [2, 3], [3]]
-> duplicate (reverse) ([1, 2]) ([3, 4])
+> Z.duplicate (Z.reverse) ([1, 2]) ([3, 4])
[4, 3, 2, 1]
```
-#### `extract :: Comonad w => w a -> a`
+#### `extract :: Comonad w => w a -> a`
Function wrapper for [`fantasy-land/extract`][].
```javascript
-> extract (Identity (42))
+> Z.extract (Identity (42))
42
```
-#### `contramap :: Contravariant f => (b -> a, f a) -> f b`
+#### `contramap :: Contravariant f => (b -> a, f a) -> f b`
Function wrapper for [`fantasy-land/contramap`][].
@@ -1321,56 +1347,58 @@ Function wrapper for [`fantasy-land/contramap`][].
built-in types: Function.
```javascript
-> contramap (s => s.length, Math.sqrt) ('Sanctuary')
+> Z.contramap (s => s.length, Math.sqrt) ('Sanctuary')
3
```
-[Alt]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#alt
-[Alternative]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#alternative
-[Applicative]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#applicative
-[Apply]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#apply
-[Bifunctor]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#bifunctor
-[Category]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#category
-[Chain]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#chain
-[ChainRec]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#chainrec
-[Comonad]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#comonad
-[Contravariant]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#contravariant
-[Extend]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#extend
-[FL]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1
-[Filterable]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#filterable
-[Foldable]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#foldable
-[Functor]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#functor
-[Group]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#group
-[Monad]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#monad
-[Monoid]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#monoid
-[Ord]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#ord
-[Plus]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#plus
-[Profunctor]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#profunctor
-[Semigroup]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#semigroup
-[Semigroupoid]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#semigroupoid
-[Setoid]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#setoid
-[Traversable]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#traversable
-[`fantasy-land/alt`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#alt-method
-[`fantasy-land/ap`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#ap-method
-[`fantasy-land/bimap`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#bimap-method
-[`fantasy-land/chain`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#chain-method
-[`fantasy-land/chainRec`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#chainrec-method
-[`fantasy-land/compose`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#compose-method
-[`fantasy-land/concat`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#concat-method
-[`fantasy-land/contramap`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#contramap-method
-[`fantasy-land/empty`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#empty-method
-[`fantasy-land/equals`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#equals-method
-[`fantasy-land/extend`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#extend-method
-[`fantasy-land/extract`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#extract-method
-[`fantasy-land/filter`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#filter-method
-[`fantasy-land/id`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#id-method
-[`fantasy-land/invert`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#invert-method
-[`fantasy-land/lte`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#lte-method
-[`fantasy-land/map`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#map-method
-[`fantasy-land/of`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#of-method
-[`fantasy-land/promap`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#promap-method
-[`fantasy-land/reduce`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#reduce-method
-[`fantasy-land/traverse`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#traverse-method
-[`fantasy-land/zero`]: https://github.com/fantasyland/fantasy-land/tree/v4.0.1#zero-method
+[Alt]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#alt
+[Alternative]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#alternative
+[Applicative]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#applicative
+[Apply]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#apply
+[Bifunctor]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#bifunctor
+[Category]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#category
+[Chain]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#chain
+[ChainRec]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#chainrec
+[Comonad]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#comonad
+[Contravariant]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#contravariant
+[Extend]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#extend
+[FL]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0
+[Filterable]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#filterable
+[Foldable]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#foldable
+[Functor]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#functor
+[Group]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#group
+[Monad]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#monad
+[Monoid]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#monoid
+[Ord]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#ord
+[Plus]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#plus
+[Profunctor]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#profunctor
+[Semigroup]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#semigroup
+[Semigroupoid]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#semigroupoid
+[Setoid]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#setoid
+[Traversable]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#traversable
+[`Object.entries`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
+[`fantasy-land/alt`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#alt-method
+[`fantasy-land/ap`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#ap-method
+[`fantasy-land/bimap`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#bimap-method
+[`fantasy-land/chain`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#chain-method
+[`fantasy-land/chainRec`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#chainrec-method
+[`fantasy-land/compose`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#compose-method
+[`fantasy-land/concat`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#concat-method
+[`fantasy-land/contramap`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#contramap-method
+[`fantasy-land/empty`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#empty-method
+[`fantasy-land/equals`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#equals-method
+[`fantasy-land/extend`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#extend-method
+[`fantasy-land/extract`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#extract-method
+[`fantasy-land/filter`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#filter-method
+[`fantasy-land/id`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#id-method
+[`fantasy-land/invert`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#invert-method
+[`fantasy-land/lte`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#lte-method
+[`fantasy-land/map`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#map-method
+[`fantasy-land/of`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#of-method
+[`fantasy-land/promap`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#promap-method
+[`fantasy-land/reduce`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#reduce-method
+[`fantasy-land/traverse`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#traverse-method
+[`fantasy-land/zero`]: https://github.com/fantasyland/fantasy-land/tree/v5.0.0#zero-method
[stable sort]: https://en.wikipedia.org/wiki/Sorting_algorithm#Stability
+[type identities]: https://github.com/sanctuary-js/sanctuary-type-identifiers/tree/v3.0.0
[type-classes]: https://github.com/sanctuary-js/sanctuary-def#type-classes
diff --git a/index.js b/index.js
index 0ef158d..e38999a 100644
--- a/index.js
+++ b/index.js
@@ -669,7 +669,7 @@
// $ :: (String, Array TypeClass, StrMap (Array Location)) -> TypeClass
const $ = (_name, dependencies, requirements) => {
- const version = '12.1.0'; // updated programmatically
+ const version = '13.0.0'; // updated programmatically
const staticMethods = requirements.filter (req => (
req.location === Constructor
diff --git a/package.json b/package.json
index 07f094f..6882607 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "sanctuary-type-classes",
- "version": "12.1.0",
+ "version": "13.0.0",
"description": "Standard library for Fantasy Land",
"license": "MIT",
"repository": {