sanctuary-identity

Identity is the simplest container type: a value of type Identity a always contains exactly one value, of type a.

Identity a satisfies the following Fantasy Land specifications:

> const Useless = require ('sanctuary-useless')

> const isTypeClass = x =>
.   type (x) === 'sanctuary-type-classes/TypeClass@1'

> S.map (k => k + ' '.repeat (16 - k.length) +
.             (Z[k].test (Identity (Useless)) ? '\u2705   ' :
.              Z[k].test (Identity (['foo'])) ? '\u2705 * ' :
.              /* otherwise */                  '\u274C   '))
.       (S.keys (S.unchecked.filter (isTypeClass) (Z)))
[ 'Setoid          ✅ * ',  // if ‘a’ satisfies Setoid
. 'Ord             ✅ * ',  // if ‘a’ satisfies Ord
. 'Semigroupoid    ❌   ',
. 'Category        ❌   ',
. 'Semigroup       ✅ * ',  // if ‘a’ satisfies Semigroup
. 'Monoid          ❌   ',
. 'Group           ❌   ',
. 'Filterable      ❌   ',
. 'Functor         ✅   ',
. 'Bifunctor       ❌   ',
. 'Profunctor      ❌   ',
. 'Apply           ✅   ',
. 'Applicative     ✅   ',
. 'Chain           ✅   ',
. 'ChainRec        ✅   ',
. 'Monad           ✅   ',
. 'Alt             ❌   ',
. 'Plus            ❌   ',
. 'Alternative     ❌   ',
. 'Foldable        ✅   ',
. 'Traversable     ✅   ',
. 'Extend          ✅   ',
. 'Comonad         ✅   ',
. 'Contravariant   ❌   ' ]

Identity :: a -⁠> Identity a

Identity's sole data constructor. Additionally, it serves as the Identity type representative.

> Identity (42)
Identity (42)

Identity.fantasy-land/of :: a -⁠> Identity a

of (Identity) (x) is equivalent to Identity (x).

> S.of (Identity) (42)
Identity (42)

Identity.fantasy-land/chainRec :: ((a -⁠> c, b -⁠> c, a) -⁠> Identity c, a) -⁠> Identity b

> Z.chainRec (
.   Identity,
.   (next, done, x) => Identity (x >= 0 ? done (x * x) : next (x + 1)),
.   8
. )
Identity (64)

> Z.chainRec (
.   Identity,
.   (next, done, x) => Identity (x >= 0 ? done (x * x) : next (x + 1)),
.   -8
. )
Identity (0)

Identity#@@show :: Showable a => Identity a ~> () -⁠> String

show (Identity (x)) is equivalent to 'Identity (' + show (x) + ')'.

> show (Identity (['foo', 'bar', 'baz']))
'Identity (["foo", "bar", "baz"])'

Identity#fantasy-land/equals :: Setoid a => Identity a ~> Identity a -⁠> Boolean

Identity (x) is equal to Identity (y) iff x is equal to y according to Z.equals.

> S.equals (Identity ([1, 2, 3])) (Identity ([1, 2, 3]))
true

> S.equals (Identity ([1, 2, 3])) (Identity ([3, 2, 1]))
false

Identity#fantasy-land/lte :: Ord a => Identity a ~> Identity a -⁠> Boolean

Identity (x) is less than or equal to Identity (y) iff x is less than or equal to y according to Z.lte.

> S.filter (S.lte (Identity (1)))
.          ([Identity (0), Identity (1), Identity (2)])
[Identity (0), Identity (1)]

Identity#fantasy-land/concat :: Semigroup a => Identity a ~> Identity a -⁠> Identity a

concat (Identity (x)) (Identity (y)) is equivalent to Identity (concat (x) (y)).

> S.concat (Identity ([1, 2, 3])) (Identity ([4, 5, 6]))
Identity ([1, 2, 3, 4, 5, 6])

Identity#fantasy-land/map :: Identity a ~> (a -⁠> b) -⁠> Identity b

map (f) (Identity (x)) is equivalent to Identity (f (x)).

> S.map (Math.sqrt) (Identity (64))
Identity (8)

Identity#fantasy-land/ap :: Identity a ~> Identity (a -⁠> b) -⁠> Identity b

ap (Identity (f)) (Identity (x)) is equivalent to Identity (f (x)).

> S.ap (Identity (Math.sqrt)) (Identity (64))
Identity (8)

Identity#fantasy-land/chain :: Identity a ~> (a -⁠> Identity b) -⁠> Identity b

chain (f) (Identity (x)) is equivalent to f (x).

> S.chain (n => Identity (n + 1)) (Identity (99))
Identity (100)

Identity#fantasy-land/reduce :: Identity a ~> ((b, a) -⁠> b, b) -⁠> b

reduce (f) (x) (Identity (y)) is equivalent to f (x) (y).

> S.reduce (S.concat) ([1, 2, 3]) (Identity ([4, 5, 6]))
[1, 2, 3, 4, 5, 6]

Identity#fantasy-land/traverse :: Applicative f => Identity a ~> (TypeRep f, a -⁠> f b) -⁠> f (Identity b)

traverse (_) (f) (Identity (x)) is equivalent to map (Identity) (f (x)).

> S.traverse (Array) (x => [x + 1, x + 2, x + 3]) (Identity (100))
[Identity (101), Identity (102), Identity (103)]

Identity#fantasy-land/extend :: Identity a ~> (Identity a -⁠> b) -⁠> Identity b

extend (f) (Identity (x)) is equivalent to Identity (f (Identity (x))).

> S.extend (S.reduce (S.add) (1)) (Identity (99))
Identity (100)

Identity#fantasy-land/extract :: Identity a ~> () -⁠> a

extract (Identity (x)) is equivalent to x.

> S.extract (Identity (42))
42