From 8036187127fe1a7a0bf0ba9e1eddf3a878403ecb Mon Sep 17 00:00:00 2001 From: David Chambers Date: Wed, 19 Jan 2022 11:22:08 +0100 Subject: [PATCH] Version 13.0.0 --- LICENSE | 2 +- README.md | 686 +++++++++++++++++++++++++++------------------------ index.js | 2 +- package.json | 2 +- 4 files changed, 360 insertions(+), 332 deletions(-) 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": {