feat(interface): create interfaces which comprise monad

All of the interfaces which comprise basic monads with at least one type argument are added.
Functor, Apply, Chain, Applicative, and Monad are added, as well as HKT, which is used for
type-level mapping enabling higher kinded types.

README.md

@@ -5,3 +5,12 @@
 
 A static-land and fantasy-land compliant library containing interfaces for common type-classes and
 common instances of them.
+
+## Documentation
+
+[Theory and Usage][theory-doc]
+
+[API Docs][api-doc]
+
+[api-doc]: https://williamareynolds.github.io/ts-cat/
+[theory-doc]: https://github.com/williamareynolds/ts-cat/wiki

src/Applicative.ts

@@ -0,0 +1,6 @@
+import { Type, URIs } from './HKT'
+import { ApplyS1 } from './Apply'
+
+export interface ApplicativeS1<F extends URIs> extends ApplyS1<F> {
+  readonly of: <A>(a: A) => Type<F, A>
+}

src/Apply.ts

@@ -0,0 +1,10 @@
+import { Type, URIs } from './HKT'
+import { Functor1, FunctorS1 } from './Functor'
+
+export interface Apply1<F extends URIs, A> extends Functor1<F, A> {
+  readonly ap: <B>(fab: Type<F, (a: A) => B>) => Type<F, B>
+}
+
+export interface ApplyS1<F extends URIs> extends FunctorS1<F> {
+  readonly ap: <A, B>(fab: Type<F, (a: A) => B>, fa: Type<F, A>) => Type<F, B>
+}

src/Chain.ts

@@ -0,0 +1,10 @@
+import { Type, URIs } from './HKT'
+import { Apply1, ApplyS1 } from './Apply'
+
+export interface Chain1<F extends URIs, A> extends Apply1<F, A> {
+  chain: <B>(mab: Type<F, (a: A) => Type<F, B>>) => Type<F, B>
+}
+
+export interface ChainS1<F extends URIs> extends ApplyS1<F> {
+  chain: <A, B>(mab: Type<F, (a: A) => Type<F, B>>, ma: Type<F, A>) => Type<F, B>
+}

src/Functor.ts

@@ -0,0 +1,17 @@
+import { Type, Type2, URI2s, URIs } from './HKT'
+
+export interface Functor1<F extends URIs, A> {
+  readonly map: <B>(f: (a: A) => B) => Type<F, B>
+}
+
+export interface FunctorS1<F extends URIs> {
+  readonly map: <A, B>(f: (a: A) => B, fa: Type<F, A>) => Type<F, B>
+}
+
+export interface Functor2<F extends URI2s, A, B> {
+  readonly map: <C>(f: (b: B) => C) => Type2<F, A, C>
+}
+
+export interface FunctorS2<F extends URI2s> {
+  readonly map: <A, B, C>(f: (b: B) => C, fab: Type2<F, A, B>) => Type2<F, A, C>
+}

src/HKT.ts

@@ -0,0 +1,21 @@
+export interface HKT<URI, A> {
+  _URI: URI
+  _A: A
+}
+
+export interface URItoHKT<A> {}
+
+export type URIs = keyof URItoHKT<any>
+
+export type Type<URI extends URIs, A> = URItoHKT<A>[URI]
+
+export interface HKT2<URI, A, B> {
+  _URI: URI
+  _A: A
+}
+
+export interface URItoHKT2<A, B> {}
+
+export type URI2s = keyof URItoHKT2<any, any>
+
+export type Type2<URI extends URI2s, A, B> = URItoHKT2<A, B>[URI]

src/Monad.ts

@@ -0,0 +1,10 @@
+import { Chain1, ChainS1 } from './Chain'
+import { Type, URIs } from './HKT'
+import { Apply1 } from './Apply'
+import { ApplicativeS1 } from './Applicative'
+
+export interface Monad1<M extends URIs, A> extends Apply1<M, A>, Chain1<M, A> {}
+
+export interface MonadS1<M extends URIs> extends ApplicativeS1<M>, ChainS1<M> {
+  pure: <A>(a: A) => Type<M, A>
+}

test/ts-cat.test.ts

@@ -1,8 +1,8 @@
-import DummyClass from '../src/ts-cat'
-
 /**
  * Dummy test
  */
+import DummyClass from '../src/ts-cat'
+
 describe('Dummy test', () => {
   it('works if true is truthy', () => {
     expect(true).toBeTruthy()

tslint.json

@@ -2,5 +2,8 @@
   "extends": [
     "tslint-config-standard",
     "tslint-config-prettier"
-  ]
-}
+  ],
+  "rules": {
+    "class-name": false
+  }
+}