Socket
Socket
Sign inDemoInstall

sanctuary-type-classes

Package Overview
Dependencies
1
Maintainers
2
Versions
36
Alerts
File Explorer

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

sanctuary-type-classes

Standard library for Fantasy Land


Version published
Maintainers
2
Weekly downloads
49,448
decreased by-13.02%

Weekly downloads

Readme

Source

sanctuary-type-classes

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;
  • one TypeClass value for each Fantasy Land type class;
  • lawful Fantasy Land methods for JavaScript's built-in types;
  • one function for each Fantasy Land method; and
  • several functions derived from these functions.

Type-class hierarchy

 Setoid   Semigroupoid  Semigroup   Foldable        Functor      Contravariant  Filterable
(equals)    (compose)    (concat)   (reduce)         (map)        (contramap)    (filter)
    |           |           |           \         / | | | | \
    |           |           |            \       /  | | | |  \
    |           |           |             \     /   | | | |   \
    |           |           |              \   /    | | | |    \
    |           |           |               \ /     | | | |     \
   Ord      Category     Monoid         Traversable | | | |      \
  (lte)       (id)       (empty)        (traverse)  / | | \       \
                            |                      /  | |  \       \
                            |                     /   / \   \       \
                            |             Profunctor /   \ Bifunctor \
                            |              (promap) /     \ (bimap)   \
                            |                      /       \           \
                          Group                   /         \           \
                         (invert)               Alt        Apply      Extend
                                               (alt)        (ap)     (extend)
                                                /           / \           \
                                               /           /   \           \
                                              /           /     \           \
                                             /           /       \           \
                                            /           /         \           \
                                          Plus    Applicative    Chain      Comonad
                                         (zero)       (of)      (chain)    (extract)
                                            \         / \         / \
                                             \       /   \       /   \
                                              \     /     \     /     \
                                               \   /       \   /       \
                                                \ /         \ /         \
                                            Alternative    Monad     ChainRec
                                                                    (chainRec)

API

TypeClass :: (String, String, Array TypeClass, a -⁠> Boolean) -⁠> TypeClass

The arguments are:

  • the name of the type class, prefixed by its npm package name;
  • the documentation URL of the type class;
  • an array of dependencies; and
  • a predicate which accepts any JavaScript value and returns 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 :: TypeClass

TypeClass value for Setoid.

> Z.Setoid.test (null)
true

> Z.Setoid.test (Useless)
false

> Z.Setoid.test ([1, 2, 3])
true

> Z.Setoid.test ([Useless])
false
Ord :: TypeClass

TypeClass 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])
false
Semigroupoid :: TypeClass

TypeClass value for Semigroupoid.

> Z.Semigroupoid.test (Math.sqrt)
true

> Z.Semigroupoid.test (0)
false
Category :: TypeClass

TypeClass value for Category.

> Z.Category.test (Math.sqrt)
true

> Z.Category.test (0)
false
Semigroup :: TypeClass

TypeClass value for Semigroup.

> Z.Semigroup.test ('')
true

> Z.Semigroup.test (0)
false
Monoid :: TypeClass

TypeClass value for Monoid.

> Z.Monoid.test ('')
true

> Z.Monoid.test (0)
false
Group :: TypeClass

TypeClass value for Group.

> Z.Group.test (Sum (0))
true

> Z.Group.test ('')
false
Filterable :: TypeClass

TypeClass value for Filterable.

> Z.Filterable.test ({})
true

> Z.Filterable.test ('')
false
Functor :: TypeClass

TypeClass value for Functor.

> Z.Functor.test ([])
true

> Z.Functor.test ('')
false
Bifunctor :: TypeClass

TypeClass value for Bifunctor.

> Z.Bifunctor.test (Pair ('foo') (64))
true

> Z.Bifunctor.test ([])
false
Profunctor :: TypeClass

TypeClass value for Profunctor.

> Z.Profunctor.test (Math.sqrt)
true

> Z.Profunctor.test ([])
false
Apply :: TypeClass

TypeClass value for Apply.

> Z.Apply.test ([])
true

> Z.Apply.test ('')
false
Applicative :: TypeClass

TypeClass value for Applicative.

> Z.Applicative.test ([])
true

> Z.Applicative.test ({})
false
Chain :: TypeClass

TypeClass value for Chain.

> Z.Chain.test ([])
true

> Z.Chain.test ({})
false
ChainRec :: TypeClass

TypeClass value for ChainRec.

> Z.ChainRec.test ([])
true

> Z.ChainRec.test ({})
false
Monad :: TypeClass

TypeClass value for Monad.

> Z.Monad.test ([])
true

> Z.Monad.test ({})
false
Alt :: TypeClass

TypeClass value for Alt.

> Z.Alt.test ({})
true

> Z.Alt.test ('')
false
Plus :: TypeClass

TypeClass value for Plus.

> Z.Plus.test ({})
true

> Z.Plus.test ('')
false
Alternative :: TypeClass

TypeClass value for Alternative.

> Z.Alternative.test ([])
true

> Z.Alternative.test ({})
false
Foldable :: TypeClass

TypeClass value for Foldable.

> Z.Foldable.test ({})
true

> Z.Foldable.test ('')
false
Traversable :: TypeClass

TypeClass value for Traversable.

> Z.Traversable.test ([])
true

> Z.Traversable.test ('')
false
Extend :: TypeClass

TypeClass value for Extend.

> Z.Extend.test ([])
true

> Z.Extend.test ({})
false
Comonad :: TypeClass

TypeClass value for Comonad.

> Z.Comonad.test (Identity (0))
true

> Z.Comonad.test ([])
false
Contravariant :: TypeClass

TypeClass value for Contravariant.

> Z.Contravariant.test (Math.sqrt)
true

> Z.Contravariant.test ([])
false
equals :: (a, b) -⁠> Boolean

Returns 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)))
false
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 method; false otherwise.

This function is derived from lte.

See also gt and gte.

> Z.lt (0, 0)
false

> Z.lt (0, 1)
true

> Z.lt (1, 0)
false
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 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.

See also lt, gt, and gte.

> Z.lte (0, 0)
true

> Z.lte (0, 1)
true

> Z.lte (1, 0)
false
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 method; false otherwise.

This function is derived from lte.

See also lt and gte.

> Z.gt (0, 0)
false

> Z.gt (0, 1)
false

> Z.gt (1, 0)
true
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 fantasy-land/lte method; false otherwise.

This function is derived from lte.

See also lt and gt.

> Z.gte (0, 0)
true

> Z.gte (0, 1)
false

> Z.gte (1, 0)
true
min :: Ord a => (a, a) -⁠> a

Returns 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) -⁠> a

Returns 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) -⁠> 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.

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 k

Function 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)
10
id :: Category c => TypeRep c -⁠> c

Function 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) -⁠> a

Function 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 (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

Function 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)
Nil
invert :: Group g => g -⁠> g

Function wrapper for fantasy-land/invert.

> Z.invert (Sum (5))
Sum (-5)
filter :: Filterable f => (a -⁠> Boolean, f a) -⁠> f a

Function 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 (3, Nil))))
Cons (1, Cons (3, Nil))

> Z.filter (x => x % 2 == 1, Nothing)
Nothing

> Z.filter (x => x % 2 == 1, Just (0))
Nothing

> Z.filter (x => x % 2 == 1, Just (1))
Just (1)
reject :: Filterable f => (a -⁠> Boolean, f a) -⁠> f a

Discards 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 (2, Nil)

> Z.reject (x => x % 2 == 1, Nothing)
Nothing

> Z.reject (x => x % 2 == 1, Just (0))
Just (0)

> Z.reject (x => x % 2 == 1, Just (1))
Nothing
map :: Functor f => (a -⁠> b, f a) -⁠> f b

Function 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)

> Z.map (Math.sqrt, Nil)
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

Maps 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 d

Function 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 c

Maps 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 d

Function 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)
11
ap :: Apply f => (f (a -⁠> b), f a) -⁠> f b

Function 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 => n => s.slice (0, n), s => Math.ceil (s.length / 2)) ('Haskell')
'Hask'

> Z.ap (Identity (Math.sqrt), Identity (64))
Identity (8)

> 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

Lifts 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 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.

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 => y => z => x + z + y,
.          Identity ('<'),
.          Identity ('>'),
.          Identity ('baz'))
Identity ('<baz>')
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.

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 b

Combines 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 a

Function 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 a

Returns 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 a

Returns 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 b

Function 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 => s => s.slice (0, n),
.          s => Math.ceil (s.length / 2))
.         ('Haskell')
'Hask'
join :: Chain m => m (m a) -⁠> m a

Removes 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 b

Function 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 a

Function 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 a

Function 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)
Nothing
reduce :: Foldable f => ((b, a) -⁠> b, b, f a) -⁠> b

Function 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 -⁠> Integer

Returns 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))))
3
all :: Foldable f => (a -⁠> Boolean, f a) -⁠> Boolean

Returns true if all the elements of the structure satisfy the predicate; false otherwise.

This function is derived from reduce.

See also any and none.

> 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])
false
any :: Foldable f => (a -⁠> Boolean, f a) -⁠> Boolean

Returns true if any element of the structure satisfies the predicate; false otherwise.

This function is derived from reduce.

See also all and none.

> 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])
true
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. 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])
false
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.

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))
true

> Z.elem (0, Just (1))
false

> Z.elem (0, Nothing)
false
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.

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], [])
[]

> 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

Deconstructs 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 a

Reverses 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 a

Performs 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 a

Performs 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', 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)

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 b

Function 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, 2, 1]
extract :: Comonad w => w a -⁠> a

Function wrapper for fantasy-land/extract.

> Z.extract (Identity (42))
42
contramap :: Contravariant f => (b -⁠> a, f a) -⁠> f b

Function 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')
3

FAQs

Last updated on 19 Jan 2022

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc