@terrygonguet/utils 0.0.10 → 0.0.12

package/dist/async.js

@@ -1,6 +1,65 @@
-function i(e) {
-  return new Promise((t) => setTimeout(t, e));
+import { findIndex as g } from "./functional.js";
+function h(n) {
+  return new Promise((t) => setTimeout(t, n));
+}
+function x(n, t) {
+  return typeof n == "function" ? p(n, t) : (r) => p(r, n);
+}
+async function p(n, { count: t = 1 / 0, delay: r } = {}) {
+  let o = 0, s;
+  do
+    try {
+      return await n();
+    } catch (c) {
+      switch (s = c, o++, typeof r) {
+        case "number":
+          await h(r);
+          break;
+        case "function":
+          await h(r(o, c));
+          break;
+      }
+    }
+  while (o <= t);
+  throw s;
+}
+function I(n, t, r) {
+  if (typeof n == "function" && typeof t != "function") {
+    const o = n, s = t;
+    return (c) => w(c, o, s);
+  } else {
+    if (Array.isArray(n) && typeof t == "function")
+      return w(n, t, r);
+    throw new Error("Invalid arguments passed to asyncMap");
+  }
+}
+async function w(n, t, { concurrent: r = 5 } = {}) {
+  return new Promise((o, s) => {
+    const c = [], u = [];
+    let i = 0;
+    function y(e) {
+      if (c.length == n.length && u.length == 0)
+        return m();
+      if (e >= n.length)
+        return;
+      const f = n[e];
+      u.push([
+        e,
+        t(f, e, n).then((a) => {
+          c.push([e, a]), g(u, ([l]) => e == l).map((l) => u.splice(l, 1)), y(i);
+        }, s)
+      ]), i++;
+    }
+    function m() {
+      const e = c.sort(([f], [a]) => f - a);
+      o(e.map(([, f]) => f));
+    }
+    for (let e = 0; e < r; e++)
+      y(i);
+  });
 }
 export {
-  i as wait
+  I as asyncMap,
+  h as pause,
+  x as retry
 };

package/dist/functional.js

@@ -1,202 +1,260 @@
-var y = Object.defineProperty;
-var k = (t, e, r) => e in t ? y(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
-var h = (t, e, r) => (k(t, typeof e != "symbol" ? e + "" : e, r), r);
-const i = "@terrygonguet/utils/functional/result", f = "@terrygonguet/utils/functional/result/Success", d = "@terrygonguet/utils/functional/result/Failure";
-function a(t) {
-  return Object.create(
-    {
-      isSuccess: () => !0,
-      isFailure: () => !1,
-      merge(e) {
-        return e(this.value);
-      },
-      map(e) {
-        return a(e(this.value));
-      },
-      flatMap(e) {
-        return e(this.value);
-      },
-      toJSON() {
-        return { $_kind: i, $_variant: f, value: this.value };
-      }
-    },
-    {
-      $_kind: { value: i, enumerable: !1, writable: !1 },
-      $_variant: { value: f, enumerable: !1, writable: !1 },
-      value: { value: t, writable: !1 }
-    }
-  );
+var d = Object.defineProperty;
+var S = (r, e, t) => e in r ? d(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var u = (r, e, t) => (S(r, typeof e != "symbol" ? e + "" : e, t), t);
+const a = "@terrygonguet/utils/functional/result", l = "@terrygonguet/utils/functional/result/Success", w = "@terrygonguet/utils/functional/result/Failure";
+class f {
+  constructor(e) {
+    u(this, "value");
+    Object.defineProperties(this, {
+      $_kind: { value: a, enumerable: !1, writable: !1 },
+      $_variant: { value: l, enumerable: !1, writable: !1 },
+      value: { value: e, writable: !1 }
+    });
+  }
+  isSuccess() {
+    return !0;
+  }
+  isFailure() {
+    return !1;
+  }
+  merge(e) {
+    return e(this.value);
+  }
+  match(e) {
+    return e(this.value);
+  }
+  map(e) {
+    return new f(e(this.value));
+  }
+  flatMap(e) {
+    return e(this.value);
+  }
+  toJSON() {
+    return { $_kind: a, $_variant: l, value: this.value };
+  }
 }
-function c(t) {
-  return Object.create(
-    {
-      isSuccess: () => !1,
-      isFailure: () => !0,
-      merge(e, r) {
-        return r(this.reason);
-      },
-      map() {
-        return this;
-      },
-      flatMap() {
-        return this;
-      },
-      toJSON() {
-        return { $_kind: i, $_variant: d, reason: this.reason };
-      }
-    },
-    {
-      $_kind: { value: i, enumerable: !1, writable: !1 },
-      $_variant: { value: f, enumerable: !1, writable: !1 },
-      reason: { value: t, writable: !1 }
-    }
-  );
+class g {
+  constructor(e) {
+    u(this, "reason");
+    Object.defineProperties(this, {
+      $_kind: { value: a, enumerable: !1, writable: !1 },
+      $_variant: { value: l, enumerable: !1, writable: !1 },
+      reason: { value: e, writable: !1 }
+    });
+  }
+  isSuccess() {
+    return !1;
+  }
+  isFailure() {
+    return !0;
+  }
+  merge(e, t) {
+    return t(this.reason);
+  }
+  match(e, t) {
+    return t(this.reason);
+  }
+  map() {
+    return this;
+  }
+  flatMap() {
+    return this;
+  }
+  toJSON() {
+    return { $_kind: a, $_variant: w, reason: this.reason };
+  }
 }
-const g = {
-  Success: a,
-  Failure: c,
-  try(t) {
-    return new p(t);
+function v(r, e) {
+  return e ? r.toResult(e) : r.toResult();
+}
+const c = {
+  Success(r) {
+    return new f(r);
+  },
+  Failure(r) {
+    return new g(r);
   },
-  fromPromise(t, e, r) {
-    return t.then($(e, a), $(r, c));
+  try(r) {
+    return new y(r);
   },
-  fromMaybe(t, e) {
-    return t.toResult(e);
+  fromPromise(r, e, t) {
+    return r.then(
+      b(e, this.Success),
+      b(t, this.Failure)
+    );
   },
-  JSONReviver(t, e) {
-    if ((e == null ? void 0 : e.$_kind) == i) {
-      const r = e == null ? void 0 : e.$_variant;
-      return r == f ? a(e == null ? void 0 : e.value) : r == d ? c(e == null ? void 0 : e.reason) : e;
+  fromMaybe: v,
+  JSONReviver(r, e) {
+    if ((e == null ? void 0 : e.$_kind) == a) {
+      const t = e == null ? void 0 : e.$_variant;
+      return t == l ? new f(e == null ? void 0 : e.value) : t == w ? new g(e == null ? void 0 : e.reason) : e;
     } else
       return e;
   }
 };
-class p {
+class y {
   constructor(e) {
-    h(this, "tryFn");
-    h(this, "catchFn");
-    this.tryFn = e, this.catchFn = S;
+    u(this, "tryFn");
+    u(this, "catchFn");
+    this.tryFn = e, this.catchFn = p;
   }
   catch(e) {
     return this.catchFn = e, this;
   }
   exec(e) {
     try {
-      const r = a(this.tryFn());
-      return e == null || e(r), r;
-    } catch (r) {
-      const n = c(this.catchFn(r));
+      const t = c.Success(this.tryFn());
+      return e == null || e(t), t;
+    } catch (t) {
+      const n = c.Failure(this.catchFn(t));
       return e == null || e(n), n;
     }
   }
 }
-const u = "@terrygonguet/utils/functional/maybe", _ = "@terrygonguet/utils/functional/maybe/Some", b = "@terrygonguet/utils/functional/maybe/None";
-function l(t) {
-  return Object.create(
-    {
-      isSome: () => !0,
-      isNone: () => !1,
-      orDefault() {
-        return this.value;
-      },
-      map(e) {
-        return l(e(this.value));
-      },
-      flatMap(e) {
-        return e(this.value);
-      },
-      toResult() {
-        return g.Success(this.value);
-      },
-      toJSON() {
-        return { $_kind: u, $_variant: _, value: this.value };
-      }
-    },
-    {
-      $_kind: { value: u, enumerable: !1, writable: !1 },
+const h = "@terrygonguet/utils/functional/maybe", _ = "@terrygonguet/utils/functional/maybe/Some", $ = "@terrygonguet/utils/functional/maybe/None";
+class o {
+  constructor(e) {
+    u(this, "value");
+    Object.defineProperties(this, {
+      $_kind: { value: h, enumerable: !1, writable: !1 },
       $_variant: { value: _, enumerable: !1, writable: !1 },
-      value: { value: t, writable: !1 }
-    }
-  );
+      value: { value: e, writable: !1 }
+    });
+  }
+  isSome() {
+    return !0;
+  }
+  isNone() {
+    return !1;
+  }
+  orDefault() {
+    return this.value;
+  }
+  map(e) {
+    return new o(e(this.value));
+  }
+  flatMap(e) {
+    return e(this.value);
+  }
+  toResult() {
+    return c.Success(this.value);
+  }
+  toJSON() {
+    return { $_kind: h, $_variant: _, value: this.value };
+  }
 }
-const s = Object.create(
-  {
-    isSome: () => !1,
-    isNone: () => !0,
-    orDefault: (t) => t,
-    map: () => s,
-    flatMap: () => s,
-    toResult: (t) => g.Failure(t == null ? void 0 : t()),
-    toJSON: () => ({ $_kind: u, $_variant: b })
+class k {
+  constructor() {
+  }
+  isSome() {
+    return !1;
+  }
+  isNone() {
+    return !0;
+  }
+  orDefault(e) {
+    return e;
+  }
+  map() {
+    return this;
+  }
+  flatMap() {
+    return this;
+  }
+  toResult(e) {
+    return e ? c.Failure(e == null ? void 0 : e()) : c.Failure(void 0);
+  }
+  toJSON() {
+    return { $_kind: h, $_variant: $ };
+  }
+}
+const N = new k(), s = {
+  Some(r) {
+    return new o(r);
   },
-  {
-    $_kind: { value: u, enumerable: !1, writable: !1 },
-    $_variant: { value: b, enumerable: !1, writable: !1 }
-  }
-), o = {
-  Some: l,
-  None: s,
-  from(t) {
-    switch (t) {
+  None() {
+    return N;
+  },
+  from(r) {
+    switch (r) {
       case null:
       case void 0:
-        return s;
+        return this.None();
       default:
-        return l(t);
+        return new o(r);
     }
   },
   /**
    * CAUTION: this method swallows errors and simply returns None!
    * Use `Result.fromPromise()` if you need error details.
    */
-  fromPromise(t, e = S) {
-    return t.then($(e, o.from), O(s));
+  fromPromise(r, e = p) {
+    return r.then(b(e, s.from), M(this.None()));
   },
-  JSONReviver(t, e) {
-    if ((e == null ? void 0 : e.$_kind) == u) {
-      const r = e == null ? void 0 : e.$_variant;
-      return r == _ ? l(e == null ? void 0 : e.value) : r == b ? s : e;
+  JSONReviver(r, e) {
+    if ((e == null ? void 0 : e.$_kind) == h) {
+      const t = e == null ? void 0 : e.$_variant;
+      return t == _ ? new o(e == null ? void 0 : e.value) : t == $ ? s.None() : e;
     } else
       return e;
   }
 };
-var $ = v;
-function v(t, e) {
+var b = F;
+function F(r, e) {
   if (!arguments.length)
     throw new Error(
       "expected at least one (and probably more) function arguments"
     );
-  var r = arguments;
+  var t = arguments;
   return function() {
-    for (var n = r[0].apply(this, arguments), w = r.length, m = 1; m < w; m++)
-      n = r[m].call(this, n);
+    for (var n = t[0].apply(this, arguments), i = t.length, m = 1; m < i; m++)
+      n = t[m].call(this, n);
     return n;
   };
 }
-function S(t) {
+var J = x;
+function x(r, ...e) {
+  if (!arguments.length)
+    throw new Error("expected one value argument and least one function argument");
+  if (!e.length)
+    throw new Error(
+      "expected at least one (and probably more) function arguments"
+    );
+  for (var t = e[0](r), n = e.length, i = 1; i < n; i++)
+    t = e[i](t);
   return t;
 }
-function O(t) {
-  return () => t;
+function p(r) {
+  return r;
 }
-function x(t, e) {
-  return o.from(t.at(e));
+function M(r) {
+  return () => r;
 }
-function J(t, e) {
-  return o.from(t.find(e));
+function j(r, e) {
+  return typeof r == "number" ? (t) => s.from(t.at(r)) : s.from(r.at(e));
 }
-function M(t, e) {
-  const r = t.findIndex(e);
-  return r == -1 ? o.None : o.Some(r);
+function E(r, e) {
+  return typeof r == "function" ? (t) => s.from(t.find(r)) : s.from(r.find(e));
+}
+function O(r, e) {
+  if (typeof r == "function")
+    return (t) => {
+      const n = t.findIndex(r);
+      return n == -1 ? s.None() : s.Some(n);
+    };
+  {
+    const t = r.findIndex(e);
+    return t == -1 ? s.None() : s.Some(t);
+  }
 }
 export {
-  o as Maybe,
-  g as Result,
-  x as at,
-  $ as compose,
-  O as constant,
-  J as find,
-  M as findIndex,
-  S as identity
+  s as Maybe,
+  c as Result,
+  j as at,
+  b as compose,
+  M as constant,
+  E as find,
+  O as findIndex,
+  p as identity,
+  J as pipe
 };

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.0.10",
+	"version": "0.0.12",
 	"type": "module",
-	"module": "./dist/main.js",
+	"module": "./dist/index.js",
 	"author": {
 		"email": "terry@gonguet.com",
 		"name": "Terry Gonguet",
@@ -29,7 +29,7 @@
 	],
 	"exports": {
 		".": {
-			"import": "./dist/main.js"
+			"import": "./dist/index.js"
 		},
 		"./async": {
 			"import": "./dist/async.js"
@@ -40,13 +40,18 @@
 	},
 	"typesVersions": {
 		"*": {
-			"async": ["./types/async.d.ts"],
-			"functional": ["./types/functional/index.d.ts"]
+			"async": [
+				"./types/async.d.ts"
+			],
+			"functional": [
+				"./types/functional/index.d.ts"
+			]
 		}
 	},
-	"types": "./types/main.d.ts",
+	"types": "./types/index.d.ts",
 	"dependencies": {
-		"just-compose": "^2.3.0"
+		"just-compose": "^2.3.0",
+		"just-pipe": "^1.0.0"
 	},
 	"repository": {
 		"type": "git",

package/src/async.ts

@@ -1,3 +1,112 @@
-export function wait(ms: number): Promise<void> {
+import { findIndex } from "./functional/index.ts"
+
+export function pause(ms: number): Promise<void> {
 	return new Promise(resolve => setTimeout(resolve, ms))
-}
+}
+
+interface RetryOptions {
+	count?: number
+	delay?: number | ((retryCount: number, error: any) => number)
+}
+
+export function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>
+export function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>
+export function retry<T>(
+	providerOrOptions: RetryOptions | (() => Promise<T>),
+	options?: RetryOptions,
+) {
+	if (typeof providerOrOptions == "function") return _retry(providerOrOptions, options)
+	else return (provider: () => Promise<T>) => _retry(provider, providerOrOptions)
+}
+
+async function _retry<T>(
+	provider: () => Promise<T>,
+	{ count = Infinity, delay }: RetryOptions = {},
+): Promise<T> {
+	let retryCount = 0
+	let lastError: any
+	do {
+		try {
+			return await provider()
+		} catch (error) {
+			lastError = error
+			retryCount++
+			switch (typeof delay) {
+				case "number":
+					await pause(delay)
+					break
+				case "function":
+					await pause(delay(retryCount, error))
+					break
+			}
+		}
+	} while (retryCount <= count)
+	throw lastError
+}
+
+interface AsyncMapOptions {
+	concurrent?: number
+}
+
+export function asyncMap<T, U>(
+	f: AsyncMapFn<T, U>,
+	options?: AsyncMapOptions,
+): (data: T[]) => Promise<U[]>
+export function asyncMap<T, U>(
+	data: T[],
+	f: AsyncMapFn<T, U>,
+	options?: AsyncMapOptions,
+): Promise<U[]>
+export function asyncMap<T, U>(
+	dataOrF: T[] | AsyncMapFn<T, U>,
+	ForOptions: AsyncMapFn<T, U> | AsyncMapOptions | undefined,
+	options?: AsyncMapOptions,
+): Promise<U[]> | ((data: T[]) => Promise<U[]>) {
+	if (typeof dataOrF == "function" && typeof ForOptions != "function") {
+		const f = dataOrF
+		const options = ForOptions
+		return (data: T[]) => asyncMap_(data, f, options)
+	} else if (Array.isArray(dataOrF) && typeof ForOptions == "function") {
+		const data = dataOrF
+		const f = ForOptions
+		return asyncMap_(data, f, options)
+	} else throw new Error("Invalid arguments passed to asyncMap")
+}
+
+type AsyncMapFn<T, U> = (el: T, i: number, data: T[]) => Promise<U>
+
+async function asyncMap_<T, U>(
+	data: T[],
+	f: AsyncMapFn<T, U>,
+	{ concurrent = 5 }: AsyncMapOptions = {},
+): Promise<U[]> {
+	return new Promise((resolve, reject) => {
+		const resolved: [i: number, result: U][] = []
+		const inFlight: [i: number, promise: Promise<void>][] = []
+
+		let next = 0
+		function queue(i: number) {
+			if (resolved.length == data.length && inFlight.length == 0) return finish()
+			if (i >= data.length) return
+			const el = data[i]
+			inFlight.push([
+				i,
+				f(el, i, data).then(result => {
+					resolved.push([i, result])
+					findIndex(inFlight, ([j]) => i == j).map(j => inFlight.splice(j, 1))
+					queue(next)
+				}, reject),
+			])
+			next++
+		}
+
+		function finish() {
+			const sorted = resolved.sort(([a], [b]) => a - b)
+			resolve(sorted.map(([, value]) => value))
+		}
+
+		for (let i = 0; i < concurrent; i++) {
+			queue(next)
+		}
+	})
+}

package/src/functional/index.ts

@@ -3,6 +3,7 @@ import { Maybe } from "./maybe.ts"
 export * from "./maybe.ts"
 export * from "./result.ts"
 export { default as compose } from "just-compose"
+export { default as pipe } from "just-pipe"
 
 export function identity<T>(value: T) {
 	return value
@@ -12,15 +13,33 @@ export function constant<T>(value: T) {
 	return () => value
 }
 
-export function at<T>(arr: T[], idx: number) {
-	return Maybe.from(arr.at(idx))
+export function at(idx: number): <T>(data: T[]) => Maybe<T>
+export function at<T>(data: T[], idx: number): Maybe<T>
+export function at<T>(dataOrIdx: T[] | number, idx?: number) {
+	if (typeof dataOrIdx == "number") return (data: T[]) => Maybe.from(data.at(dataOrIdx))
+	else return Maybe.from(dataOrIdx.at(idx!))
 }
 
-export function find<T>(arr: T[], predicate: (value: T, idx: number, arr: T[]) => boolean) {
-	return Maybe.from(arr.find(predicate))
+type Predicate<T> = (value: T, idx: number, arr: T[]) => boolean
+
+export function find<T>(predicate: Predicate<T>): (data: T[]) => Maybe<T>
+export function find<T>(data: T[], predicate: Predicate<T>): Maybe<T>
+export function find<T>(dataOrPredicate: T[] | Predicate<T>, predicate?: Predicate<T>) {
+	if (typeof dataOrPredicate == "function")
+		return (data: T[]) => Maybe.from(data.find(dataOrPredicate))
+	else return Maybe.from(dataOrPredicate.find(predicate!))
 }
 
-export function findIndex<T>(arr: T[], predicate: (value: T, idx: number, arr: T[]) => boolean): Maybe<number> {
-	const idx = arr.findIndex(predicate)
-	return idx == -1 ? Maybe.None : Maybe.Some(idx)
+export function findIndex<T>(predicate: Predicate<T>): (data: T[]) => Maybe<number>
+export function findIndex<T>(data: T[], predicate: Predicate<T>): Maybe<number>
+export function findIndex<T>(dataOrPredicate: T[] | Predicate<T>, predicate?: Predicate<T>) {
+	if (typeof dataOrPredicate == "function") {
+		return (data: T[]) => {
+			const idx = data.findIndex(dataOrPredicate)
+			return idx == -1 ? Maybe.None<number>() : Maybe.Some(idx)
+		}
+	} else {
+		const idx = dataOrPredicate.findIndex(predicate!)
+		return idx == -1 ? Maybe.None<number>() : Maybe.Some(idx)
+	}
 }

package/src/functional/maybe.ts

@@ -1,79 +1,98 @@
 import { compose, constant, identity } from "./index.ts"
 import { Result } from "./result.ts"
 
-interface API<T> {
-	isSome(this: Maybe<T>): this is Some<T>
-	isNone(this: Maybe<T>): this is None<T>
-	orDefault(this: Maybe<T>, defaultValue: T): T
-	map<U>(this: Maybe<T>, f: (value: T) => U): Maybe<U>
-	flatMap<U>(this: Maybe<T>, f: (value: T) => Maybe<U>): Maybe<U>
-	toResult<U>(this: Maybe<T>, mapNone?: () => U): Result<T, U>
-	toJSON(this: Maybe<T>): Object
-}
-
-export type Some<T> = { value: T } & API<T>
-export type None<T> = API<T>
-export type Maybe<T> = Some<T> | None<T>
-
 const $_kind = "@terrygonguet/utils/functional/maybe"
 const $_variant_Some = "@terrygonguet/utils/functional/maybe/Some"
 const $_variant_None = "@terrygonguet/utils/functional/maybe/None"
 
-function Some<T>(value: NonNullable<T>): Some<T> {
-	return Object.create(
-		{
-			isSome: () => true,
-			isNone: () => false,
-			orDefault(this: Some<T>) {
-				return this.value
-			},
-			map(this: Some<T>, f) {
-				return Some(f(this.value)!)
-			},
-			flatMap(this: Some<T>, f) {
-				return f(this.value)
-			},
-			toResult(this: Some<T>) {
-				return Result.Success(this.value)
-			},
-			toJSON(this: Some<T>) {
-				return { $_kind, $_variant: $_variant_Some, value: this.value }
-			},
-		} as API<T>,
-		{
+export interface Maybe<T> {
+	isSome(): this is Some<T>
+	isNone(): this is None<T>
+	orDefault(defaultValue: T): T
+	map<U>(f: (value: T) => U): Maybe<U>
+	flatMap<U>(f: (value: T) => Maybe<U>): Maybe<U>
+	toResult(): Result<T, undefined>
+	toResult<U>(mapNone: () => U): Result<T, U>
+	toJSON(): Object
+}
+
+class Some<T> implements Maybe<T> {
+	value!: T
+
+	constructor(value: T) {
+		Object.defineProperties(this, {
 			$_kind: { value: $_kind, enumerable: false, writable: false },
 			$_variant: { value: $_variant_Some, enumerable: false, writable: false },
 			value: { value, writable: false },
-		},
-	)
+		})
+	}
+
+	isSome(): true {
+		return true
+	}
+	isNone(): false {
+		return false
+	}
+	orDefault() {
+		return this.value
+	}
+	map<U>(f: (value: T) => U) {
+		return new Some(f(this.value))
+	}
+	flatMap<U>(f: (value: T) => Maybe<U>) {
+		return f(this.value)
+	}
+	toResult<U>(): Result<T, U> {
+		return Result.Success(this.value)
+	}
+	toJSON(): Object {
+		return { $_kind, $_variant: $_variant_Some, value: this.value }
+	}
 }
 
-const None: None<any> = Object.create(
-	{
-		isSome: () => false,
-		isNone: () => true,
-		orDefault: defaultValue => defaultValue,
-		map: () => None,
-		flatMap: () => None,
-		toResult: mapNone => Result.Failure(mapNone?.()),
-		toJSON: () => ({ $_kind, $_variant: $_variant_None }),
-	} as API<any>,
-	{
-		$_kind: { value: $_kind, enumerable: false, writable: false },
-		$_variant: { value: $_variant_None, enumerable: false, writable: false },
-	},
-)
+class None<T> implements Maybe<T> {
+	constructor() {}
+
+	isSome(): false {
+		return false
+	}
+	isNone(): true {
+		return true
+	}
+	orDefault(defaultValue: T) {
+		return defaultValue
+	}
+	map<U>() {
+		return this as unknown as Maybe<U>
+	}
+	flatMap<U>() {
+		return this as unknown as Maybe<U>
+	}
+	toResult(): Result<T, undefined>
+	toResult<U>(mapNone: () => U): Result<T, U>
+	toResult<U>(mapNone?: () => U) {
+		return mapNone ? Result.Failure<T, U>(mapNone?.()) : Result.Failure<T, undefined>(undefined)
+	}
+	toJSON(): Object {
+		return { $_kind, $_variant: $_variant_None }
+	}
+}
 
+const none = new None()
 export const Maybe = {
-	Some,
-	None,
+	Some<T>(value: T): Maybe<T> {
+		return new Some(value)
+	},
+	None<T>() {
+		return none as Maybe<T>
+	},
 	from<T>(value: T | undefined | null): Maybe<T> {
 		switch (value) {
 			case null:
 			case undefined:
-				return None
+				return this.None()
 			default:
-				return Some(value!)
+				return new Some(value!)
 		}
 	},
 	/**
@@ -81,14 +100,16 @@ export const Maybe = {
 	 * Use `Result.fromPromise()` if you need error details.
 	 */
 	fromPromise<T>(promise: Promise<T>, onResolve: (value: T) => T = identity): Promise<Maybe<T>> {
-		return promise.then(compose(onResolve, Maybe.from), constant(None))
+		return promise.then(compose(onResolve, Maybe.from), constant(this.None()))
 	},
 	JSONReviver(_key: string, value: any) {
 		if (value?.$_kind == $_kind) {
 			const $_variant = value?.$_variant
-			if ($_variant == $_variant_Some) return Some<unknown>(value?.value)
-			else if ($_variant == $_variant_None) return None
+			if ($_variant == $_variant_Some) return new Some<unknown>(value?.value)
+			else if ($_variant == $_variant_None) return Maybe.None()
 			else return value
 		} else return value
 	},
 }
+
+export type { Some, None }

package/src/functional/result.ts

@@ -1,78 +1,101 @@
 import { compose, identity } from "./index.ts"
 import { Maybe } from "./maybe.ts"
 
-interface API<S, F> {
-	isSuccess(this: Result<S, F>): this is Success<S, F>
-	isFailure(this: Result<S, F>): this is Failure<S, F>
-	merge<T>(this: Result<S, F>, f: (value: S) => T, g: (reason: F) => T): T
-	map<S2>(this: Result<S, F>, f: (value: S) => S2): Result<S2, F>
-	flatMap<S2, F2>(this: Result<S, F>, f: (value: S) => Result<S2, F | F2>): Result<S2, F | F2>
-	toJSON(this: Result<S, F>): Object
-}
-
-export type Success<S, F> = { value: S } & API<S, F>
-export type Failure<S, F> = { reason: F } & API<S, F>
-export type Result<S, F> = Success<S, F> | Failure<S, F>
-
 const $_kind = "@terrygonguet/utils/functional/result"
 const $_variant_Success = "@terrygonguet/utils/functional/result/Success"
 const $_variant_Failure = "@terrygonguet/utils/functional/result/Failure"
 
-function Success<S, F>(value: S): Success<S, F> {
-	return Object.create(
-		{
-			isSuccess: () => true,
-			isFailure: () => false,
-			merge<T>(this: Success<S, F>, f: (value: S) => T) {
-				return f(this.value)
-			},
-			map<S2>(this: Success<S, F>, f: (value: S) => S2) {
-				return Success(f(this.value))
-			},
-			flatMap<S2, F2>(this: Success<S, F>, f: (value: S) => Result<S2, F2>) {
-				return f(this.value)
-			},
-			toJSON(this: Success<S, F>) {
-				return { $_kind, $_variant: $_variant_Success, value: this.value }
-			},
-		} as API<S, F>,
-		{
+export interface Result<S, F> {
+	isSuccess(): this is Success<S, F>
+	isFailure(): this is Failure<S, F>
+	merge<T>(whenSuccess: (value: S) => T, whenFailure: (reason: F) => T): T
+	match(onSuccess: (value: S) => void, onFailure: (reason: F) => void): void
+	map<S2>(f: (value: S) => S2): Result<S2, F>
+	flatMap<S2, F2>(f: (value: S) => Result<S2, F | F2>): Result<S2, F | F2>
+	toJSON(): Object
+}
+
+class Success<S, F> implements Result<S, F> {
+	value!: S
+
+	constructor(value: S) {
+		Object.defineProperties(this, {
 			$_kind: { value: $_kind, enumerable: false, writable: false },
 			$_variant: { value: $_variant_Success, enumerable: false, writable: false },
 			value: { value, writable: false },
-		},
-	)
+		})
+	}
+
+	isSuccess(): true {
+		return true
+	}
+	isFailure(): false {
+		return false
+	}
+	merge<T>(whenSuccess: (value: S) => T) {
+		return whenSuccess(this.value)
+	}
+	match(onSuccess: (value: S) => void) {
+		return onSuccess(this.value)
+	}
+	map<S2>(f: (value: S) => S2) {
+		return new Success<S2, F>(f(this.value))
+	}
+	flatMap<S2, F2>(f: (value: S) => Result<S2, F2>): Result<S2, F | F2> {
+		return f(this.value)
+	}
+	toJSON(this: Success<S, F>) {
+		return { $_kind, $_variant: $_variant_Success, value: this.value }
+	}
 }
 
-function Failure<S, F>(reason: F): Failure<S, F> {
-	return Object.create(
-		{
-			isSuccess: () => false,
-			isFailure: () => true,
-			merge<T>(this: Failure<S, F>, _: (value: S) => T, g: (reason: F) => T) {
-				return g(this.reason)
-			},
-			map<S2>(this: Failure<S, F>) {
-				return this as unknown as Result<S2, F>
-			},
-			flatMap<S2, F2>(this: Failure<S, F>) {
-				return this as unknown as Result<S2, F | F2>
-			},
-			toJSON(this: Failure<S, F>) {
-				return { $_kind, $_variant: $_variant_Failure, reason: this.reason }
-			},
-		} as API<S, F>,
-		{
+class Failure<S, F> implements Result<S, F> {
+	reason!: F
+
+	constructor(reason: F) {
+		Object.defineProperties(this, {
 			$_kind: { value: $_kind, enumerable: false, writable: false },
 			$_variant: { value: $_variant_Success, enumerable: false, writable: false },
 			reason: { value: reason, writable: false },
-		},
-	)
+		})
+	}
+
+	isSuccess(): false {
+		return false
+	}
+	isFailure(): true {
+		return true
+	}
+	merge<T>(_: (value: S) => T, whenFailure: (reason: F) => T) {
+		return whenFailure(this.reason)
+	}
+	match(_: (value: S) => void, onFailure: (reason: F) => void) {
+		return onFailure(this.reason)
+	}
+	map<S2>() {
+		return this as unknown as Result<S2, F>
+	}
+	flatMap<S2, F2>() {
+		return this as unknown as Result<S2, F | F2>
+	}
+	toJSON() {
+		return { $_kind, $_variant: $_variant_Failure, reason: this.reason }
+	}
+}
+
+function resultFromMaybe<S>(maybe: Maybe<S>): Result<S, undefined>
+function resultFromMaybe<S, F>(maybe: Maybe<S>, mapNone: () => F): Result<S, F>
+function resultFromMaybe<S, F>(maybe: Maybe<S>, mapNone?: () => F) {
+	return mapNone ? maybe.toResult(mapNone) : maybe.toResult()
 }
 
 export const Result = {
-	Success,
-	Failure,
+	Success<S, F>(value: S): Result<S, F> {
+		return new Success<S, F>(value)
+	},
+	Failure<S, F>(reason: F): Result<S, F> {
+		return new Failure<S, F>(reason)
+	},
 	try<S, F>(tryFn: () => S) {
 		return new TryCatch<S, F>(tryFn)
 	},
@@ -81,16 +104,18 @@ export const Result = {
 		onResolve: (value: S) => S,
 		onReject: (reason: unknown) => F,
 	): Promise<Result<S, F>> {
-		return promise.then(compose(onResolve, Success<S, F>), compose(onReject, Failure<S, F>))
-	},
-	fromMaybe<S, F>(maybe: Maybe<S>, mapNone?: () => F) {
-		return maybe.toResult(mapNone)
+		return promise.then(
+			compose(onResolve, this.Success<S, F>),
+			compose(onReject, this.Failure<S, F>),
+		)
 	},
+	fromMaybe: resultFromMaybe,
 	JSONReviver(_key: string, value: any) {
 		if (value?.$_kind == $_kind) {
 			const $_variant = value?.$_variant
-			if ($_variant == $_variant_Success) return Success<unknown, unknown>(value?.value)
-			else if ($_variant == $_variant_Failure) return Failure<unknown, unknown>(value?.reason)
+			if ($_variant == $_variant_Success) return new Success<unknown, unknown>(value?.value)
+			else if ($_variant == $_variant_Failure)
+				return new Failure<unknown, unknown>(value?.reason)
 			else return value
 		} else return value
 	},
@@ -112,13 +137,15 @@ class TryCatch<S, F> {
 
 	exec(finallyFn?: (result: Result<S, F>) => void): Result<S, F> {
 		try {
-			const result = Success<S, F>(this.tryFn())
+			const result = Result.Success<S, F>(this.tryFn())
 			finallyFn?.(result)
 			return result
 		} catch (error) {
-			const result = Failure<S, F>(this.catchFn(error))
+			const result = Result.Failure<S, F>(this.catchFn(error))
 			finallyFn?.(result)
 			return result
 		}
 	}
 }
+
+export type { Success, Failure }

package/types/async.d.ts

@@ -1 +1,14 @@
-export declare function wait(ms: number): Promise<void>;
+export declare function pause(ms: number): Promise<void>;
+interface RetryOptions {
+    count?: number;
+    delay?: number | ((retryCount: number, error: any) => number);
+}
+export declare function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>;
+export declare function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>;
+interface AsyncMapOptions {
+    concurrent?: number;
+}
+export declare function asyncMap<T, U>(f: AsyncMapFn<T, U>, options?: AsyncMapOptions): (data: T[]) => Promise<U[]>;
+export declare function asyncMap<T, U>(data: T[], f: AsyncMapFn<T, U>, options?: AsyncMapOptions): Promise<U[]>;
+type AsyncMapFn<T, U> = (el: T, i: number, data: T[]) => Promise<U>;
+export {};

package/types/functional/index.d.ts

@@ -2,8 +2,13 @@ import { Maybe } from "./maybe.ts";
 export * from "./maybe.ts";
 export * from "./result.ts";
 export { default as compose } from "just-compose";
+export { default as pipe } from "just-pipe";
 export declare function identity<T>(value: T): T;
 export declare function constant<T>(value: T): () => T;
-export declare function at<T>(arr: T[], idx: number): Maybe<T>;
-export declare function find<T>(arr: T[], predicate: (value: T, idx: number, arr: T[]) => boolean): Maybe<T>;
-export declare function findIndex<T>(arr: T[], predicate: (value: T, idx: number, arr: T[]) => boolean): Maybe<number>;
+export declare function at(idx: number): <T>(data: T[]) => Maybe<T>;
+export declare function at<T>(data: T[], idx: number): Maybe<T>;
+type Predicate<T> = (value: T, idx: number, arr: T[]) => boolean;
+export declare function find<T>(predicate: Predicate<T>): (data: T[]) => Maybe<T>;
+export declare function find<T>(data: T[], predicate: Predicate<T>): Maybe<T>;
+export declare function findIndex<T>(predicate: Predicate<T>): (data: T[]) => Maybe<number>;
+export declare function findIndex<T>(data: T[], predicate: Predicate<T>): Maybe<number>;

package/types/functional/maybe.d.ts

@@ -1,28 +1,45 @@
 import { Result } from "./result.ts";
-interface API<T> {
-    isSome(this: Maybe<T>): this is Some<T>;
-    isNone(this: Maybe<T>): this is None<T>;
-    orDefault(this: Maybe<T>, defaultValue: T): T;
-    map<U>(this: Maybe<T>, f: (value: T) => U): Maybe<U>;
-    flatMap<U>(this: Maybe<T>, f: (value: T) => Maybe<U>): Maybe<U>;
-    toResult<U>(this: Maybe<T>, mapNone?: () => U): Result<T, U>;
-    toJSON(this: Maybe<T>): Object;
+export interface Maybe<T> {
+    isSome(): this is Some<T>;
+    isNone(): this is None<T>;
+    orDefault(defaultValue: T): T;
+    map<U>(f: (value: T) => U): Maybe<U>;
+    flatMap<U>(f: (value: T) => Maybe<U>): Maybe<U>;
+    toResult(): Result<T, undefined>;
+    toResult<U>(mapNone: () => U): Result<T, U>;
+    toJSON(): Object;
 }
-export type Some<T> = {
+declare class Some<T> implements Maybe<T> {
     value: T;
-} & API<T>;
-export type None<T> = API<T>;
-export type Maybe<T> = Some<T> | None<T>;
-declare function Some<T>(value: NonNullable<T>): Some<T>;
+    constructor(value: T);
+    isSome(): true;
+    isNone(): false;
+    orDefault(): T;
+    map<U>(f: (value: T) => U): Some<U>;
+    flatMap<U>(f: (value: T) => Maybe<U>): Maybe<U>;
+    toResult<U>(): Result<T, U>;
+    toJSON(): Object;
+}
+declare class None<T> implements Maybe<T> {
+    constructor();
+    isSome(): false;
+    isNone(): true;
+    orDefault(defaultValue: T): T;
+    map<U>(): Maybe<U>;
+    flatMap<U>(): Maybe<U>;
+    toResult(): Result<T, undefined>;
+    toResult<U>(mapNone: () => U): Result<T, U>;
+    toJSON(): Object;
+}
 export declare const Maybe: {
-    Some: typeof Some;
-    None: None<any>;
-    from<T>(value: T | null | undefined): Maybe<T>;
+    Some<T>(value: T): Maybe<T>;
+    None<T_1>(): Maybe<T_1>;
+    from<T_2>(value: T_2 | null | undefined): Maybe<T_2>;
     /**
      * CAUTION: this method swallows errors and simply returns None!
      * Use `Result.fromPromise()` if you need error details.
      */
-    fromPromise<T_1>(promise: Promise<T_1>, onResolve?: (value: T_1) => T_1): Promise<Maybe<T_1>>;
+    fromPromise<T_3>(promise: Promise<T_3>, onResolve?: (value: T_3) => T_3): Promise<Maybe<T_3>>;
     JSONReviver(_key: string, value: any): any;
 };
-export {};
+export type { Some, None };

package/types/functional/result.d.ts

@@ -1,27 +1,51 @@
 import { Maybe } from "./maybe.ts";
-interface API<S, F> {
-    isSuccess(this: Result<S, F>): this is Success<S, F>;
-    isFailure(this: Result<S, F>): this is Failure<S, F>;
-    merge<T>(this: Result<S, F>, f: (value: S) => T, g: (reason: F) => T): T;
-    map<S2>(this: Result<S, F>, f: (value: S) => S2): Result<S2, F>;
-    flatMap<S2, F2>(this: Result<S, F>, f: (value: S) => Result<S2, F | F2>): Result<S2, F | F2>;
-    toJSON(this: Result<S, F>): Object;
+export interface Result<S, F> {
+    isSuccess(): this is Success<S, F>;
+    isFailure(): this is Failure<S, F>;
+    merge<T>(whenSuccess: (value: S) => T, whenFailure: (reason: F) => T): T;
+    match(onSuccess: (value: S) => void, onFailure: (reason: F) => void): void;
+    map<S2>(f: (value: S) => S2): Result<S2, F>;
+    flatMap<S2, F2>(f: (value: S) => Result<S2, F | F2>): Result<S2, F | F2>;
+    toJSON(): Object;
 }
-export type Success<S, F> = {
+declare class Success<S, F> implements Result<S, F> {
     value: S;
-} & API<S, F>;
-export type Failure<S, F> = {
+    constructor(value: S);
+    isSuccess(): true;
+    isFailure(): false;
+    merge<T>(whenSuccess: (value: S) => T): T;
+    match(onSuccess: (value: S) => void): void;
+    map<S2>(f: (value: S) => S2): Success<S2, F>;
+    flatMap<S2, F2>(f: (value: S) => Result<S2, F2>): Result<S2, F | F2>;
+    toJSON(this: Success<S, F>): {
+        $_kind: string;
+        $_variant: string;
+        value: S;
+    };
+}
+declare class Failure<S, F> implements Result<S, F> {
     reason: F;
-} & API<S, F>;
-export type Result<S, F> = Success<S, F> | Failure<S, F>;
-declare function Success<S, F>(value: S): Success<S, F>;
-declare function Failure<S, F>(reason: F): Failure<S, F>;
+    constructor(reason: F);
+    isSuccess(): false;
+    isFailure(): true;
+    merge<T>(_: (value: S) => T, whenFailure: (reason: F) => T): T;
+    match(_: (value: S) => void, onFailure: (reason: F) => void): void;
+    map<S2>(): Result<S2, F>;
+    flatMap<S2, F2>(): Result<S2, F | F2>;
+    toJSON(): {
+        $_kind: string;
+        $_variant: string;
+        reason: F;
+    };
+}
+declare function resultFromMaybe<S>(maybe: Maybe<S>): Result<S, undefined>;
+declare function resultFromMaybe<S, F>(maybe: Maybe<S>, mapNone: () => F): Result<S, F>;
 export declare const Result: {
-    Success: typeof Success;
-    Failure: typeof Failure;
-    try<S, F>(tryFn: () => S): TryCatch<S, F>;
-    fromPromise<S_1, F_1>(promise: Promise<S_1>, onResolve: (value: S_1) => S_1, onReject: (reason: unknown) => F_1): Promise<Result<S_1, F_1>>;
-    fromMaybe<S_2, F_2>(maybe: Maybe<S_2>, mapNone?: (() => F_2) | undefined): Result<S_2, F_2>;
+    Success<S, F>(value: S): Result<S, F>;
+    Failure<S_1, F_1>(reason: F_1): Result<S_1, F_1>;
+    try<S_2, F_2>(tryFn: () => S_2): TryCatch<S_2, F_2>;
+    fromPromise<S_3, F_3>(promise: Promise<S_3>, onResolve: (value: S_3) => S_3, onReject: (reason: unknown) => F_3): Promise<Result<S_3, F_3>>;
+    fromMaybe: typeof resultFromMaybe;
     JSONReviver(_key: string, value: any): any;
 };
 declare class TryCatch<S, F> {
@@ -31,4 +55,4 @@ declare class TryCatch<S, F> {
     catch(catchFn: (err: unknown) => F): this;
     exec(finallyFn?: (result: Result<S, F>) => void): Result<S, F>;
 }
-export {};
+export type { Success, Failure };