Skip to content
master
Go to file
Code

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

README.md

Fantasy Land

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

About

🌈 Fantasy Land -compliant Identity type

Topics

Resources

License

Sponsor this project

 
Learn more about GitHub Sponsors

Packages

No packages published
You can’t perform that action at this time.