feat: clean up tests

* move tests to tests ddirectory
* simplify some option modules
* implement general monad law tests for option and either
* implement more tests for option and either
* add nice names for tests

README.md

@@ -0,0 +1,19 @@
+# hkts
+
+Higher kinded types for [Deno](https://deno.land). As an avid user of [fp-ts](https://github.com/gcanti/fp-ts) I wanted to have a similarly full featured envvironment in Deno. Unfortunately, the fp-ts port to Deno is clunky to use with other functional libraries like [@nll/datum](https://github.com/nullpub/datum), [io-ts](https://github.com/gcanti/io-ts), and [monocle-ts](https://github.com/gcanti/monocle-ts). While I could have ported fp-ts directly, I've come to like the exploratory work done by pelotom in the original [hkts](http://github.com/pelotom/hkts). Thus, I've decided to port the functionality of fp-ts, io-ts, and monocle-ts to Deno using the HKT substitution developed by pelotom.
+
+## Installation
+
+This library is meant to be used with Deno, thus it follows the [Deno imports](https://deno.land/manual/examples/import_export) syntax.
+
+```ts
+import * as O from "https://deno.land/x/hkts/option.ts";
+import { pipe } from "https://deno.land/x/hkts/pipe.ts";
+
+const result = pipe(
+    O.some(1),
+    O.map(n => n + 1),
+    O.chain(n => n % 2 === 0 ? O.none, O.some(n))
+);
+// result = O.none.
+```

fns.ts

@@ -4,8 +4,12 @@
 
 export type Fn<AS extends unknown[], B> = (...as: AS) => B;
 
+export type Nil = undefined | null;
+
+export type NotNil<A> = Exclude<A, Nil>;
+
 /***************************************************************************************************
- * @section Functions
+ * @section Helper Functions
  **************************************************************************************************/
 
 export const curry2 = <A, B, C>(fn: (a: A, b: B) => C) => (a: A) => (b: B): C =>
@@ -25,3 +29,111 @@ export const compose = <A, B>(fab: (a: A) => B) => <C>(fbc: (b: B) => C) => (
 ): C => fbc(fab(a));
 
 export const constant = <A>(a: A) => () => a;
+
+// export const isNil = <A>(a: A): a is Nul
+
+/***************************************************************************************************
+ * @section Pipe
+ * Original pipe function pulled from fp-ts and modified
+ * https://github.com/gcanti/fp-ts/blob/master/src/pipeable.ts
+ **************************************************************************************************/
+
+export function pipe<A>(a: A): A;
+export function pipe<A, B>(a: A, ab: (a: A) => B): B;
+export function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
+export function pipe<A, B, C, D>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D
+): D;
+export function pipe<A, B, C, D, E>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E
+): E;
+export function pipe<A, B, C, D, E, F>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F
+): F;
+export function pipe<A, B, C, D, E, F, G>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G
+): G;
+export function pipe<A, B, C, D, E, F, G, H>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H
+): H;
+export function pipe<A, B, C, D, E, F, G, H, I>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I
+): I;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K
+): K;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (K: K) => L
+): L;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (K: K) => L,
+  end: never
+): L;
+export function pipe(a: unknown, ...fns: Function[]): unknown {
+  return fns.reduce((val, fn) => fn(val), a);
+}

hkts.ts

@@ -38,7 +38,7 @@ export interface Fixed<T> {
  *     type ArrayInstance = FunctorFn<Array<_>>;
  *     // ArrayInstance = <A, B>(fab: (a: A) => B, ta: A[]): B[]
  *     type RecordInstance = FunctorFn<{ value: _ }>;
- *     // PromiseInstance = <A, B>(fab: (a: A) => B, ta: { value: A }): { value: B }
+ *     // RecordInstance = <A, B>(fab: (a: A) => B, ta: { value: A }): { value: B }
  **************************************************************************************************/
 
 // prettier-ignore

option.ts

@@ -1,7 +1,7 @@
 import { compose, identity } from "./fns.ts";
 import { $, _ } from "./hkts.ts";
 import * as SL from "./type-classes.ts";
-import { pipe } from "./pipe.ts";
+import { pipe } from "./fns.ts";
 
 /***************************************************************************************************
  * @section Types
@@ -23,6 +23,8 @@ export const getShow = <A>({ show }: SL.Show<A>): SL.Show<Option<A>> => ({
   show: (ma) => (isNone(ma) ? "None" : `${"Some"}(${show(ma.value)})`),
 });
 
+// export
+
 /***************************************************************************************************
  * @section Destructors
  **************************************************************************************************/
@@ -43,8 +45,8 @@ export const isSome = <A>(m: Option<A>): m is Some<A> => m.tag === "Some";
 
 export const Monad = SL.createMonad<Option<_>>({
   of: some,
-  map: (fab, ta) => pipe(ta, fold(compose(fab)(some), constNone)),
-  join: (tta) => (isNone(tta) ? tta : tta.value),
+  map: (fab, ta) => (isSome(ta) ? some(fab(ta.value)) : ta),
+  join: (tta) => (isSome(tta) ? tta.value : tta),
 });
 
 export const Applicative: SL.Applicative<Option<_>> = {
@@ -59,7 +61,7 @@ export const Apply: SL.Apply<Option<_>> = {
 };
 
 export const Alternative: SL.Alternative<Option<_>> = {
-  of: Monad.of,
+  of: some,
   ap: Monad.ap,
   map: Monad.map,
   zero: constNone,