package
Standard library for Fantasy Land
npm install sanctuary-type-classesGitHub-flavored package documentation.
Across all versions.
Download trend unavailable.
Runtime metadata.
Estimated unpacked size across 2 packages.
124.0 kB
Includes dependencies.
The Fantasy Land Specification "specifies interoperability of common
algebraic structures" by defining a number of type classes. For each type
class, it states laws which every member of a type must obey in order for
the type to be a member of the type class. In order for the Maybe type to
be considered a Functor, for example, every Maybe a value must have
a fantasy-land/map method which obeys the identity and composition laws.
This project provides:
TypeClass, a function for defining type classes;TypeClass value for each Fantasy Land type class;Setoid Semigroupoid Semigroup Foldable Functor Contravariant Filterable (equals) (compose) (concat) (reduce) (map) (contramap) (filter) | | | \ / | | | | \ | | | \ / | | | | \ | | | \ / | | | | \ | | | \ / | | | | \ | | | \ / | | | | \ | | | | \ () () () () / | | \ \ | / | | \ \ | / / \ \ \ | / \ \ | () / \ () \ | / \ \ / \ \ () () () () / / \ \ / / \ \ / / \ \ / / \ \ / / \ \ () () () () \ / \ / \ \ / \ / \ \ / \ / \ \ / \ / \ \ / \ / \ ()
TypeClass :: (String, String, Array TypeClass, a -> Boolean) -> TypeClassThe arguments are:
true
if the value satisfies the requirements of the type class; false
otherwise.Example:
// hasMethod :: String -> a -> Boolean
const hasMethod = name => x => x != null && typeof x[name] == 'function';
// Foo :: TypeClass
const Foo = Z.TypeClass (
'my-package/Foo',
'http://example.com/my-package#Foo',
[],
hasMethod ('foo')
);
// Bar :: TypeClass
const Bar = Z.TypeClass (
'my-package/Bar',
'http://example.com/my-package#Bar',
[Foo],
hasMethod ('bar')
);Types whose values have a foo method are members of the Foo type class.
Members of the Foo type class whose values have a bar method are also
members of the Bar type class.
Each TypeClass value has a test field: a function which accepts
any JavaScript value and returns true if the value satisfies the
type class's predicate and the predicates of all the type class's
dependencies; false otherwise.
TypeClass values may be used with sanctuary-def
to define parametrically polymorphic functions which verify their
type-class constraints at run time.
Setoid :: TypeClassTypeClass value for Setoid.
> Z.Setoid.test (null)
true
> Z.Setoid.test (Useless)
false
> Z.Setoid.test ([1, 2, 3])
true
> Z.Setoid.test ([Useless])
falseOrd :: TypeClassTypeClass value for Ord.
> Z.Ord.test (0)
true
> Z.Ord.test (Math.sqrt)
false
> Z.Ord.test ([1, 2, 3])
true
> Z.Ord.test ([Math.sqrt])
falseSemigroupoid :: TypeClassTypeClass value for Semigroupoid.
> Z.Semigroupoid.test (Math.sqrt)
true
> Z.Semigroupoid.test (0)
falseCategory :: TypeClassTypeClass value for Category.
> Z.Category.test (Math.sqrt)
true
> Z.Category.test (0)
falseSemigroup :: TypeClassTypeClass value for Semigroup.
> Z.Semigroup.test ('')
true
> Z.Semigroup.test (0)
falseMonoid :: TypeClassTypeClass value for Monoid.
> Z.Monoid.test ('')
true
> Z.Monoid.test (0)
falseGroup :: TypeClassTypeClass value for Group.
> Z.Group.test (Sum (0))
true
> Z.Group.test ('')
falseFilterable :: TypeClassTypeClass value for Filterable.
> Z.Filterable.test ({})
true
> Z.Filterable.test ('')
falseFunctor :: TypeClassTypeClass value for Functor.
> Z.Functor.test ([])
true
> Z.Functor.test ('')
falseBifunctor :: TypeClassTypeClass value for Bifunctor.
> Z.Bifunctor.test (Pair ('foo') (64))
true
> Z.Bifunctor.test ([])
falseProfunctor :: TypeClassTypeClass value for Profunctor.
> Z.Profunctor.test (Math.sqrt)
true
> Z.Profunctor.test ([])
falseApply :: TypeClassTypeClass value for Apply.
> Z.Apply.test ([])
true
> Z.Apply.test ('')
falseApplicative :: TypeClassTypeClass value for Applicative.
> Z.Applicative.test ([])
true
> Z.Applicative.test ({})
falseChain :: TypeClassTypeClass value for Chain.
> Z.Chain.test ([])
true
> Z.Chain.test ({})
falseChainRec :: TypeClassTypeClass value for ChainRec.
> Z.ChainRec.test ([])
true
> Z.ChainRec.test ({})
falseMonad :: TypeClassTypeClass value for Monad.
> Z.Monad.test ([])
true
> Z.Monad.test ({})
falseAlt :: TypeClassTypeClass value for Alt.
> Z.Alt.test ({})
true
> Z.Alt.test ('')
falsePlus :: TypeClassTypeClass value for Plus.
> Z.Plus.test ({})
true
> Z.Plus.test ('')
falseAlternative :: TypeClassTypeClass value for Alternative.
> Z.Alternative.test ([])
true
> Z.Alternative.test ({})
falseFoldable :: TypeClassTypeClass value for Foldable.
> Z.Foldable.test ({})
true
> Z.Foldable.test ('')
falseTraversable :: TypeClassTypeClass value for Traversable.
> Z.Traversable.test ([])
true
> Z.Traversable.test ('')
falseExtend :: TypeClassTypeClass value for Extend.
> Z.Extend.test ([])
true
> Z.Extend.test ({})
falseComonad :: TypeClassTypeClass value for Comonad.
> Z.Comonad.test (Identity (0))
true
> Z.Comonad.test ([])
falseContravariant :: TypeClassTypeClass value for Contravariant.
> Z.Contravariant.test (Math.sqrt)
true
> Z.Contravariant.test ([])
falseequals :: (a, b) -> BooleanReturns true if its arguments are equal; false otherwise.
Specifically:
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 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.
Two arrays which represent [1, [1, [1, [1, [1, ...]]]]], for example,
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.
> Z.equals (0, -0)
true
> Z.equals (NaN, NaN)
true
> Z.equals (Cons (1, Cons (2, Nil)), Cons (1, Cons (2, Nil)))
true
> Z.equals (Cons (1, Cons (2, Nil)), Cons (2, Cons (1, Nil)))
falselt :: (a, b) -> BooleanReturns 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
method; false otherwise.
This function is derived from lte.
> Z.lt (0, 0)
false
> Z.lt (0, 1)
true
> Z.lt (1, 0)
falselte :: (a, b) -> BooleanReturns 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
fantasy-land/lte method; false otherwise.
fantasy-land/lte implementations are provided for the following
built-in types: Null, Undefined, Boolean, Number, Date, String, Array,
Arguments, and Object.
The algorithm supports circular data structures in the same manner as
equals.
> Z.lte (0, 0)
true
> Z.lte (0, 1)
true
> Z.lte (1, 0)
falsegt :: (a, b) -> BooleanReturns 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
method; false otherwise.
This function is derived from lte.
> Z.gt (0, 0)
false
> Z.gt (0, 1)
false
> Z.gt (1, 0)
truegte :: (a, b) -> BooleanReturns 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
fantasy-land/lte method; false otherwise.
This function is derived from lte.
> Z.gte (0, 0)
true
> Z.gte (0, 1)
false
> Z.gte (1, 0)
truemin :: Ord a => (a, a) -> aReturns the smaller of its two arguments.
This function is derived from lte.
See also max.
> Z.min (10, 2)
2
> Z.min (new Date ('1999-12-31'), new Date ('2000-01-01'))
new Date ('1999-12-31')
> Z.min ('10', '2')
'10'max :: Ord a => (a, a) -> aReturns the larger of its two arguments.
This function is derived from lte.
See also min.
> Z.max (10, 2)
10
> Z.max (new Date ('1999-12-31'), new Date ('2000-01-01'))
new Date ('2000-01-01')
> Z.max ('10', '2')
'2'clamp :: Ord a => (a, a, a) -> aTakes 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.
This function is derived from min and max.
> Z.clamp (0, 100, 42)
42
> Z.clamp (0, 100, -1)
0
> Z.clamp ('A', 'Z', '~')
'Z'compose :: Semigroupoid c => (c j k, c i j) -> c i kFunction wrapper for fantasy-land/compose.
fantasy-land/compose implementations are provided for the following
built-in types: Function.
> Z.compose (Math.sqrt, x => x + 1) (99)
10id :: Category c => TypeRep c -> cFunction wrapper for fantasy-land/id.
fantasy-land/id implementations are provided for the following
built-in types: Function.
> Z.id (Function) ('foo')
'foo'concat :: Semigroup a => (a, a) -> aFunction wrapper for fantasy-land/concat.
fantasy-land/concat implementations are provided for the following
built-in types: String, Array, and Object.
> Z.concat ('abc', 'def')
'abcdef'
> Z.concat ([1, 2, 3], [4, 5, 6])
[1, 2, 3, 4, 5, 6]
> Z.concat ({x: 1, y: 2}, {y: 3, z: 4})
{x: 1, y: 3, z: 4}
> Z.concat
empty :: Monoid m => TypeRep m -> mFunction wrapper for fantasy-land/empty.
fantasy-land/empty implementations are provided for the following
built-in types: String, Array, and Object.
> Z.empty (String)
''
> Z.empty (Array)
[]
> Z.empty (Object)
{}
> Z.empty (List)
Nilinvert :: Group g => g -> gFunction wrapper for fantasy-land/invert.
> Z.invert (Sum (5))
Sum (-5)filter :: Filterable f => (a -> Boolean, f a) -> f aFunction wrapper for fantasy-land/filter. Discards every element
which does not satisfy the predicate.
fantasy-land/filter implementations are provided for the following
built-in types: Array and Object.
See also reject.
> Z.filter (x => x % 2 == 1, [1, 2, 3])
[1, 3]
> Z.filter (x => x % 2 == 1, {x: 1, y: 2, z: 3})
{x: 1, z: 3}
> Z.filter (x => x % 2 == 1, Cons (1, Cons (2, Cons
reject :: Filterable f => (a -> Boolean, f a) -> f aDiscards every element which satisfies the predicate.
This function is derived from filter.
> Z.reject (x => x % 2 == 1, [1, 2, 3])
[2]
> Z.reject (x => x % 2 == 1, {x: 1, y: 2, z: 3})
{y: 2}
> Z.reject (x => x % 2 == 1, Cons (1, Cons (2, Cons (3, Nil))))
Cons
map :: Functor f => (a -> b, f a) -> f bFunction wrapper for fantasy-land/map.
fantasy-land/map implementations are provided for the following
built-in types: Array, Object, and Function.
> Z.map (Math.sqrt, [1, 4, 9])
[1, 2, 3]
> Z.map (Math.sqrt, {x: 1, y: 4, z: 9})
{x: 1, y: 2, z: 3}
> Z.map (Math.sqrt, s => s.length) ('Sanctuary')
3
> Z.map (Math.sqrt, Pair ('foo') (64))
Pair ('foo') (8
flip :: Functor f => (f (a -> b), a) -> f bMaps over the given functions, applying each to the given value.
This function is derived from map.
> Z.flip (x => y => x + y, '!') ('foo')
'foo!'
> Z.flip ([Math.floor, Math.ceil], 1.5)
[1, 2]
> Z.flip ({floor: Math.floor, ceil: Math.ceil}, 1.5)
{floor: 1, ceil: 2}
> 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 dFunction wrapper for fantasy-land/bimap.
> Z.bimap (s => s.toUpperCase (), Math.sqrt, Pair ('foo') (64))
Pair ('FOO') (8)mapLeft :: Bifunctor f => (a -> b, f a c) -> f b cMaps the given function over the left side of a Bifunctor.
> Z.mapLeft (Math.sqrt, Pair (64) (9))
Pair (8) (9)promap :: Profunctor p => (a -> b, c -> d, p b c) -> p a dFunction wrapper for fantasy-land/promap.
fantasy-land/promap implementations are provided for the following
built-in types: Function.
> Z.promap (Math.abs, x => x + 1, Math.sqrt) (-100)
11ap :: Apply f => (f (a -> b), f a) -> f bFunction wrapper for fantasy-land/ap.
fantasy-land/ap implementations are provided for the following
built-in types: Array, Object, and Function.
> Z.ap ([Math.sqrt, x => x * x], [1, 4, 9, 16, 25])
[1, 2, 3, 4, 5, 1, 16, 81, 256, 625]
> Z.ap ({a: Math.sqrt, b: x => x * x}, {a: 16, b: 10, c: 1})
{a: 4, b: 100}
> Z.ap (s
lift2 :: Apply f => (a -> b -> c, f a, f b) -> f cLifts a -> b -> c to Apply f => f a -> f b -> f c and returns the
result of applying this to the given arguments.
This function is derived from map and ap.
See also lift3.
> Z.lift2 (x => y => Math.pow (x, y), [10], [1, 2, 3])
[10, 100, 1000]
> 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 dLifts 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.
This function is derived from map and ap.
See also lift2.
> Z.lift3 (x => y => z => x + z + y,
. ['<', '['],
. ['>', ']'],
. ['foo', 'bar', 'baz'])
[ '<foo>', '<bar>', '<baz>',
. '<foo]', '<bar]', '<baz]',
. '[foo>', '[bar>', '[baz>',
. '[foo]', '[bar]', '[baz]' ]
> Z.lift3 (x =>
apFirst :: Apply f => (f a, f b) -> f aCombines two effectful actions, keeping only the result of the first.
Equivalent to Haskell's (<*) function.
This function is derived from lift2.
See also apSecond.
> Z.apFirst ([1, 2], [3, 4])
[1, 1, 2, 2]
> Z.apFirst (Identity (1), Identity (2))
Identity (1)apSecond :: Apply f => (f a, f b) -> f bCombines two effectful actions, keeping only the result of the second.
Equivalent to Haskell's (*>) function.
This function is derived from lift2.
See also apFirst.
> Z.apSecond ([1, 2], [3, 4])
[3, 4, 3, 4]
> Z.apSecond (Identity (1), Identity (2))
Identity (2)of :: Applicative f => (TypeRep f, a) -> f aFunction wrapper for fantasy-land/of.
fantasy-land/of implementations are provided for the following
built-in types: Array and Function.
> Z.of (Array, 42)
[42]
> Z.of (Function, 42) (null)
42
> Z.of (List, 42)
Cons (42, Nil)append :: (Applicative f, Semigroup (f a)) => (a, f a) -> f aReturns the result of appending the first argument to the second.
This function is derived from concat and of.
See also prepend.
> Z.append (3, [1, 2])
[1, 2, 3]
> 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 aReturns the result of prepending the first argument to the second.
This function is derived from concat and of.
See also append.
> Z.prepend (1, [2, 3])
[1, 2, 3]
> Z.prepend (1, Cons (2, Cons (3, Nil)))
Cons (1, Cons (2, Cons (3, Nil)))chain :: Chain m => (a -> m b, m a) -> m bFunction wrapper for fantasy-land/chain.
fantasy-land/chain implementations are provided for the following
built-in types: Array and Function.
> Z.chain (x => [x, x], [1, 2, 3])
[1, 1, 2, 2, 3, 3]
> Z.chain (x => x % 2 == 1 ? Z.of (List, x) : Nil,
. Cons (1, Cons (2, Cons (3, Nil))))
Cons (1, Cons (3, Nil))
> Z.chain (n =>
join :: Chain m => m (m a) -> m aRemoves one level of nesting from a nested monadic structure.
This function is derived from chain.
> Z.join ([[1], [2], [3]])
[1, 2, 3]
> Z.join ([[[1, 2, 3]]])
[[1, 2, 3]]
> Z.join (Identity (Identity (1)))
Identity (1)chainRec :: ChainRec m => (TypeRep m, (a -> c, b -> c, a) -> m c, a) -> m bFunction wrapper for fantasy-land/chainRec.
fantasy-land/chainRec implementations are provided for the following
built-in types: Array.
> Z.chainRec (
. Array,
. (next, done, s) => s.length == 2 ? [s + '!', s + '?'].map (done)
. : [s + 'o', s + 'n'].map (next),
. ''
. )
['oo!', 'oo?', 'on!', 'on?', 'no!', 'no?', 'nn!', 'nn?']alt :: Alt f => (f a, f a) -> f aFunction wrapper for fantasy-land/alt.
fantasy-land/alt implementations are provided for the following
built-in types: Array and Object.
> Z.alt ([1, 2, 3], [4, 5, 6])
[1, 2, 3, 4, 5, 6]
> Z.alt (Nothing, Nothing)
Nothing
> Z.alt (Nothing, Just (1))
Just (1)
> Z.alt (Just (2), Just (3))
Just (2)zero :: Plus f => TypeRep f -> f aFunction wrapper for fantasy-land/zero.
fantasy-land/zero implementations are provided for the following
built-in types: Array and Object.
> Z.zero (Array)
[]
> Z.zero (Object)
{}
> Z.zero (Maybe)
Nothingreduce :: Foldable f => ((b, a) -> b, b, f a) -> bFunction wrapper for fantasy-land/reduce.
fantasy-land/reduce implementations are provided for the following
built-in types: Array and Object.
> Z.reduce ((xs, x) => [x].concat (xs), [], [1, 2, 3])
[3, 2, 1]
> 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 -> IntegerReturns the number of elements of the given structure.
This function is derived from reduce.
> Z.size ([])
0
> Z.size (['foo', 'bar', 'baz'])
3
> Z.size (Nil)
0
> Z.size (Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
3all :: Foldable f => (a -> Boolean, f a) -> BooleanReturns true if all the elements of the structure satisfy the
predicate; false otherwise.
This function is derived from reduce.
> Z.all (Number.isInteger, [])
true
> Z.all (Number.isInteger, [1, 2, 3])
true
> Z.all (Number.isInteger, [0, 0.25, 0.5, 0.75, 1])
falseany :: Foldable f => (a -> Boolean, f a) -> BooleanReturns true if any element of the structure satisfies the predicate;
false otherwise.
This function is derived from reduce.
> Z.any (Number.isInteger, [])
false
> Z.any (Number.isInteger, [1, 2, 3])
true
> Z.any (Number.isInteger, [0, 0.25, 0.5, 0.75, 1])
truenone :: Foldable f => (a -> Boolean, f a) -> BooleanReturns true if none of the elements of the structure satisfies the
predicate; false otherwise.
This function is derived from any. Z.none (pred, foldable) is
equivalent to !(Z.any (pred, foldable)).
See also all.
> Z.none (Number.isInteger, [])
true
> Z.none (Number.isInteger, [0, 0.25, 0.5, 0.75, 1])
falseelem :: (Setoid a, Foldable f) => (a, f a) -> BooleanTakes a value and a structure and returns true if the
value is an element of the structure; false otherwise.
This function is derived from equals and
reduce.
> Z.elem ('c', ['a', 'b', 'c'])
true
> Z.elem ('x', ['a', 'b', 'c'])
false
> Z.elem (3, {x: 1, y: 2, z: 3})
true
> Z.elem (8, {x: 1, y: 2, z: 3})
false
> Z.elem (0, Just (0))
intercalate :: (Monoid m, Foldable f) => (m, f m) -> mConcatenates the elements of the given structure, separating each pair of adjacent elements with the given separator.
This function is derived from concat, empty,
and reduce.
> Z.intercalate (', ', [])
''
> Z.intercalate (', ', ['foo', 'bar', 'baz'])
'foo, bar, baz'
> Z.intercalate (', ', Nil)
''
> Z.intercalate (', ', Cons ('foo', Cons ('bar', Cons ('baz', Nil))))
'foo, bar, baz'
> Z.intercalate ([0, 0, 0], [])
[]
>
foldMap :: (Monoid m, Foldable f) => (TypeRep m, a -> m, f a) -> mDeconstructs a foldable by mapping every element to a monoid and concatenating the results.
This function is derived from concat, empty,
and reduce.
> Z.foldMap (String, f => f.name, [Math.sin, Math.cos, Math.tan])
'sincostan'reverse :: (Applicative f, Foldable f, Monoid (f a)) => f a -> f aReverses the elements of the given structure.
This function is derived from concat, empty,
of, and reduce.
> Z.reverse ([1, 2, 3])
[3, 2, 1]
> 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 aPerforms a stable sort of the elements of the given structure,
using lte for comparisons.
This function is derived from lte, concat,
empty, of, and reduce.
See also sortBy.
> Z.sort (['foo', 'bar', 'baz'])
['bar', 'baz', 'foo']
> Z.sort ([Just (2), Nothing, Just (1)])
[Nothing, Just (1), Just (2)]
> 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 aPerforms a stable sort of the elements of the given structure,
using lte to compare the values produced by applying the
given function to each element of the structure.
This function is derived from lte, concat,
empty, of, and reduce.
See also sort.
> Z.sortBy (s => s.length, ['red', 'green', 'blue'])
['red', 'blue', 'green']
> Z.sortBy (s => s.length, ['black', 'white'])
['black', 'white']
> Z.sortBy (s => s.length, ['white', 'black'])
['white', 'black']
> Z.sortBy (s => s.length, Cons ('red', Cons ('green',
traverse :: (Applicative f, Traversable t) => (TypeRep f, a -> f b, t a) -> f (t b)Function wrapper for fantasy-land/traverse.
fantasy-land/traverse implementations are provided for the following
built-in types: Array and Object.
See also sequence.
> Z.traverse (Array, x => x, [[1, 2, 3], [4, 5]])
[[1, 4], [1, 5], [2, 4], [2, 5], [3, 4], [3, 5]]
> 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)Inverts the given t (f a) to produce an f (t a).
This function is derived from traverse.
> Z.sequence (Array, Identity ([1, 2, 3]))
[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 bFunction wrapper for fantasy-land/extend.
fantasy-land/extend implementations are provided for the following
built-in types: Array and Function.
> Z.extend (ss => ss.join (''), ['x', 'y', 'z'])
['xyz', 'yz', 'z']
> Z.extend (f => f ([3, 4]), Z.reverse) ([1, 2])
[4, 3, 2, 1]duplicate :: Extend w => w a -> w (w a)Adds one level of nesting to a comonadic structure.
This function is derived from extend.
> Z.duplicate (Identity (1))
Identity (Identity (1))
> Z.duplicate ([1])
[[1]]
> Z.duplicate ([1, 2, 3])
[[1, 2, 3], [2, 3], [3]]
> Z.duplicate (Z.reverse) ([1, 2]) ([3, 4])
[4, 3, 2extract :: Comonad w => w a -> aFunction wrapper for fantasy-land/extract.
> Z.extract (Identity (42))
42contramap :: Contravariant f => (b -> a, f a) -> f bFunction wrapper for fantasy-land/contramap.
fantasy-land/contramap implementations are provided for the following
built-in types: Function.
> Z.contramap (s => s.length, Math.sqrt) ('Sanctuary')
3avaq
npmjs@account.avaq.it