https://github.com/eilvelia/contravariant

Contravariant functors in JavaScript + Flow with correct type inference
https://github.com/eilvelia/contravariant

fantasy-land functional-programming

Last synced: 25 days ago
JSON representation

Contravariant functors in JavaScript + Flow with correct type inference

• Host: GitHub
• URL: https://github.com/eilvelia/contravariant
• Owner: eilvelia
• License: mit
• Created: 2018-11-14T01:16:25.000Z (about 6 years ago)
• Default Branch: master
• Last Pushed: 2018-11-14T16:59:55.000Z (about 6 years ago)
• Last Synced: 2025-01-04T20:43:44.143Z (about 1 month ago)
• Topics: fantasy-land, functional-programming
• Language: JavaScript
• Homepage:
• Size: 101 KB
• Stars: 1
• Watchers: 2
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# contravariant

[![npm](https://img.shields.io/npm/v/contravariant.svg)](https://www.npmjs.com/package/contravariant)

[![Build Status](https://travis-ci.org/Bannerets/contravariant.svg?branch=master)](https://travis-ci.org/Bannerets/contravariant)

Contravariant functors in JavaScript with [Flow](https://flow.org/).

Mainly inspired by haskell [contravariant](https://hackage.haskell.org/package/contravariant).

See [src/index.js](src/index.js) and [test/index.test.js](test/index.test.js).

## Installation

```console

$ npm install contravariant

```

## API

`interface IContravariant<-A>`

- `contramap(fn: B => A): IContravariant`


---

`class Predicate<-A>`

- `constructor(f: A => boolean)`

- `getPredicate(): A => boolean`

- `contramap(fn: B => A): Predicate`


---

`class Comparison<-A>`

- `constructor(f: (A, A) => number)`

- `getComparison(): (A, A) => number`

- `contramap(fn: B => A): Comparison`


`function defaultComparison(): Comparison`

---

`class Equivalence<-A>`

- `constructor(f: (A, A) => boolean)`

- `getEquivalence(): (A, A) => boolean`

- `contramap(fn: B => A): Equivalence`


`function defaultEquivalence(): Equivalence`


---

`class Op<+A, -B>`

- `constructor(f: B => A)`

- `getOp(): B => A`

- `contramap(fn: BB => B): Op`


---

### Profunctors

`interface IProfunctor<-B, +C>`

- `promap(fn1: A => B, fn2: C => D): IProfunctor`


---

`class Arrow<-B, +C>`

- `constructor(f: B => C)`

- `getArrow(): B => C`

- `promap(fn1: A => B, fn2: C => D): Arrow`

- `lmap(fn1: A => B): Arrow`

- `rmap(fn2: C => D): Arrow`


## See also

- https://hackage.haskell.org/package/contravariant-1.5/docs/Data-Functor-Contravariant.html

- https://gist.github.com/Bannerets/07a71802e3468d252924091a65ac2b3c

- https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/profunctors

- https://www.fpcomplete.com/blog/2016/11/covariance-contravariance

- https://hackage.haskell.org/package/profunctors-5.3/docs/Data-Profunctor.html

- https://github.com/fantasyland/fantasy-land#contravariant

- https://github.com/fantasyland/fantasy-land#profunctor