@terrygonguet/utils 0.0.9 → 0.0.11

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,66 +1,8 @@
-var p = Object.defineProperty;
-var S = (t, e, r) => e in t ? p(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
-var f = (t, e, r) => (S(t, typeof e != "symbol" ? e + "" : e, r), r);
-const s = "@terrygonguet/utils/functional/maybe", _ = "@terrygonguet/utils/functional/maybe/Some", h = "@terrygonguet/utils/functional/maybe/None";
-function u(t) {
-  return Object.create(
-    {
-      isSome: () => !0,
-      isNone: () => !1,
-      orDefault() {
-        return this.value;
-      },
-      map(e) {
-        return u(e(this.value));
-      },
-      flatMap(e) {
-        return e(this.value);
-      },
-      toJSON() {
-        return { $_kind: s, $_variant: _, value: this.value };
-      }
-    },
-    {
-      $_kind: { value: s, enumerable: !1, writable: !1 },
-      $_variant: { value: _, enumerable: !1, writable: !1 },
-      value: { value: t, writable: !1 }
-    }
-  );
-}
-const a = Object.create(
-  {
-    isSome: () => !1,
-    isNone: () => !0,
-    orDefault: $,
-    map: () => a,
-    flatMap: () => a,
-    toJSON: () => ({ $_kind: s, $_variant: h })
-  },
-  {
-    $_kind: { value: s, enumerable: !1, writable: !1 },
-    $_variant: { value: h, enumerable: !1, writable: !1 }
-  }
-), y = {
-  Some: u,
-  None: a,
-  from(t) {
-    switch (t) {
-      case null:
-      case void 0:
-        return a;
-      default:
-        return u(t);
-    }
-  },
-  JSONReviver(t, e) {
-    if ((e == null ? void 0 : e.$_kind) == s) {
-      const r = e == null ? void 0 : e.$_variant;
-      return r == _ ? u(e == null ? void 0 : e.value) : r == h ? a : e;
-    } else
-      return e;
-  }
-}, i = "@terrygonguet/utils/functional/result", o = "@terrygonguet/utils/functional/result/Success", b = "@terrygonguet/utils/functional/result/Failure";
-function c(t) {
+var d = Object.defineProperty;
+var v = (t, e, r) => e in t ? d(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var _ = (t, e, r) => (v(t, typeof e != "symbol" ? e + "" : e, r), r);
+const o = "@terrygonguet/utils/functional/result", m = "@terrygonguet/utils/functional/result/Success", p = "@terrygonguet/utils/functional/result/Failure";
+function i(t) {
   return Object.create(
     {
       isSuccess: () => !0,
@@ -68,24 +10,27 @@ function c(t) {
       merge(e) {
         return e(this.value);
       },
+      match(e) {
+        return e(this.value);
+      },
       map(e) {
-        return c(e(this.value));
+        return i(e(this.value));
       },
       flatMap(e) {
         return e(this.value);
       },
       toJSON() {
-        return { $_kind: i, $_variant: o, value: this.value };
+        return { $_kind: o, $_variant: m, value: this.value };
       }
     },
     {
-      $_kind: { value: i, enumerable: !1, writable: !1 },
-      $_variant: { value: o, enumerable: !1, writable: !1 },
+      $_kind: { value: o, enumerable: !1, writable: !1 },
+      $_variant: { value: m, enumerable: !1, writable: !1 },
       value: { value: t, writable: !1 }
     }
   );
 }
-function m(t) {
+function f(t) {
   return Object.create(
     {
       isSuccess: () => !1,
@@ -93,6 +38,9 @@ function m(t) {
       merge(e, r) {
         return r(this.reason);
       },
+      match(e, r) {
+        return r(this.reason);
+      },
       map() {
         return this;
       },
@@ -100,72 +48,182 @@ function m(t) {
         return this;
       },
       toJSON() {
-        return { $_kind: i, $_variant: b, reason: this.reason };
+        return { $_kind: o, $_variant: p, reason: this.reason };
       }
     },
     {
-      $_kind: { value: i, enumerable: !1, writable: !1 },
-      $_variant: { value: o, enumerable: !1, writable: !1 },
+      $_kind: { value: o, enumerable: !1, writable: !1 },
+      $_variant: { value: m, enumerable: !1, writable: !1 },
       reason: { value: t, writable: !1 }
     }
   );
 }
-const v = {
-  Success: c,
-  Failure: m,
+function y(t, e) {
+  return e ? t.toResult(e) : t.toResult();
+}
+const w = {
+  Success: i,
+  Failure: f,
   try(t) {
-    return new d(t);
+    return new k(t);
+  },
+  fromPromise(t, e, r) {
+    return t.then($(e, i), $(r, f));
   },
+  fromMaybe: y,
   JSONReviver(t, e) {
-    if ((e == null ? void 0 : e.$_kind) == i) {
+    if ((e == null ? void 0 : e.$_kind) == o) {
       const r = e == null ? void 0 : e.$_variant;
-      return r == o ? c(e == null ? void 0 : e.value) : r == b ? m(e == null ? void 0 : e.reason) : e;
+      return r == m ? i(e == null ? void 0 : e.value) : r == p ? f(e == null ? void 0 : e.reason) : e;
     } else
       return e;
   }
 };
-class d {
+class k {
   constructor(e) {
-    f(this, "tryFn");
-    f(this, "catchFn");
-    this.tryFn = e, this.catchFn = $;
+    _(this, "tryFn");
+    _(this, "catchFn");
+    this.tryFn = e, this.catchFn = S;
   }
   catch(e) {
     return this.catchFn = e, this;
   }
   exec(e) {
     try {
-      const r = c(this.tryFn());
+      const r = i(this.tryFn());
       return e == null || e(r), r;
     } catch (r) {
-      const n = m(this.catchFn(r));
+      const n = f(this.catchFn(r));
       return e == null || e(n), n;
     }
   }
 }
-var N = w;
-function w(t, e) {
+const c = "@terrygonguet/utils/functional/maybe", b = "@terrygonguet/utils/functional/maybe/Some", g = "@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 w.Success(this.value);
+      },
+      toJSON() {
+        return { $_kind: c, $_variant: b, value: this.value };
+      }
+    },
+    {
+      $_kind: { value: c, enumerable: !1, writable: !1 },
+      $_variant: { value: b, enumerable: !1, writable: !1 },
+      value: { value: t, writable: !1 }
+    }
+  );
+}
+const u = Object.create(
+  {
+    isSome: () => !1,
+    isNone: () => !0,
+    orDefault: (t) => t,
+    map: () => u,
+    flatMap: () => u,
+    toResult: (t) => w.Failure(t == null ? void 0 : t()),
+    toJSON: () => ({ $_kind: c, $_variant: g })
+  },
+  {
+    $_kind: { value: c, enumerable: !1, writable: !1 },
+    $_variant: { value: g, enumerable: !1, writable: !1 }
+  }
+), s = {
+  Some: l,
+  None: u,
+  from(t) {
+    switch (t) {
+      case null:
+      case void 0:
+        return u;
+      default:
+        return l(t);
+    }
+  },
+  /**
+   * 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, s.from), M(u));
+  },
+  JSONReviver(t, e) {
+    if ((e == null ? void 0 : e.$_kind) == c) {
+      const r = e == null ? void 0 : e.$_variant;
+      return r == b ? l(e == null ? void 0 : e.value) : r == g ? u : e;
+    } else
+      return e;
+  }
+};
+var $ = x;
+function x(t, e) {
   if (!arguments.length)
     throw new Error(
       "expected at least one (and probably more) function arguments"
     );
   var r = arguments;
   return function() {
-    for (var n = r[0].apply(this, arguments), g = r.length, l = 1; l < g; l++)
-      n = r[l].call(this, n);
+    for (var n = r[0].apply(this, arguments), a = r.length, h = 1; h < a; h++)
+      n = r[h].call(this, n);
     return n;
   };
 }
-function $(t) {
+var J = N;
+function N(t, ...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 r = e[0](t), n = e.length, a = 1; a < n; a++)
+    r = e[a](r);
+  return r;
+}
+function S(t) {
   return t;
 }
-function O(t) {
+function M(t) {
   return () => t;
 }
+function F(t, e) {
+  return typeof t == "number" ? (r) => s.from(r.at(t)) : s.from(t.at(e));
+}
+function j(t, e) {
+  return typeof t == "function" ? (r) => s.from(r.find(t)) : s.from(t.find(e));
+}
+function O(t, e) {
+  if (typeof t == "function")
+    return (r) => {
+      const n = r.findIndex(t);
+      return n == -1 ? s.None : s.Some(n);
+    };
+  {
+    const r = t.findIndex(e);
+    return r == -1 ? s.None : s.Some(r);
+  }
+}
 export {
-  y as Maybe,
-  v as Result,
-  N as compose,
-  O as constant,
-  $ as identity
+  s as Maybe,
+  w as Result,
+  F as at,
+  $ as compose,
+  M as constant,
+  j as find,
+  O as findIndex,
+  S as identity,
+  J as pipe
 };

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.0.9",
+	"version": "0.0.11",
 	"type": "module",
-	"module": "./dist/main.js",
+	"module": "./dist/index.js",
 	"author": {
 		"email": "terry@gonguet.com",
 		"name": "Terry Gonguet",
@@ -29,21 +29,29 @@
 	],
 	"exports": {
 		".": {
-			"types": "./types/main.d.ts",
-			"import": "./dist/main.js"
+			"import": "./dist/index.js"
 		},
 		"./async": {
-			"types": "./types/async.d.ts",
 			"import": "./dist/async.js"
 		},
 		"./functional": {
-			"types": "./types/functional/index.d.ts",
 			"import": "./dist/functional.js"
 		}
 	},
-	"types": "./types/main.d.ts",
+	"typesVersions": {
+		"*": {
+			"async": [
+				"./types/async.d.ts"
+			],
+			"functional": [
+				"./types/functional/index.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

@@ -1,6 +1,9 @@
+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
@@ -9,3 +12,34 @@ export function identity<T>(value: T) {
 export function constant<T>(value: T) {
 	return () => value
 }
+
+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!))
+}
+
+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>(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 : Maybe.Some(idx)
+		}
+	} else {
+		const idx = dataOrPredicate.findIndex(predicate!)
+		return idx == -1 ? Maybe.None : Maybe.Some(idx)
+	}
+}

package/src/functional/maybe.ts

@@ -1,4 +1,5 @@
-import { identity } from "./index.ts"
+import { compose, constant, identity } from "./index.ts"
+import { Result } from "./result.ts"
 
 interface API<T> {
 	isSome(this: Maybe<T>): this is Some<T>
@@ -6,6 +7,8 @@ interface API<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(this: Maybe<T>): Result<T, undefined>
+	toResult<U>(this: Maybe<T>, mapNone: () => U): Result<T, U>
 	toJSON(this: Maybe<T>): Object
 }
 
@@ -31,10 +34,13 @@ function Some<T>(value: NonNullable<T>): Some<T> {
 			flatMap(this: Some<T>, f) {
 				return f(this.value)
 			},
+			toResult(this: Some<T>) {
+				return Result.Success<T, any>(this.value)
+			},
 			toJSON(this: Some<T>) {
 				return { $_kind, $_variant: $_variant_Some, value: this.value }
 			},
-		} as API<T>,
+		} satisfies API<T>,
 		{
 			$_kind: { value: $_kind, enumerable: false, writable: false },
 			$_variant: { value: $_variant_Some, enumerable: false, writable: false },
@@ -47,11 +53,12 @@ const None: None<any> = Object.create(
 	{
 		isSome: () => false,
 		isNone: () => true,
-		orDefault: identity,
+		orDefault: defaultValue => defaultValue,
 		map: () => None,
 		flatMap: () => None,
+		toResult: <U>(mapNone?: () => U) => Result.Failure(mapNone?.()),
 		toJSON: () => ({ $_kind, $_variant: $_variant_None }),
-	} as API<any>,
+	} satisfies API<any>,
 	{
 		$_kind: { value: $_kind, enumerable: false, writable: false },
 		$_variant: { value: $_variant_None, enumerable: false, writable: false },
@@ -70,6 +77,13 @@ export const Maybe = {
 				return Some(value!)
 		}
 	},
+	/**
+	 * CAUTION: this method swallows errors and simply returns None!
+	 * 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))
+	},
 	JSONReviver(_key: string, value: any) {
 		if (value?.$_kind == $_kind) {
 			const $_variant = value?.$_variant

package/src/functional/result.ts

@@ -1,9 +1,11 @@
-import { identity } from "./index.ts"
+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
+	match(this: Result<S, F>, successFn: (value: S) => void, failureFn: (reason: F) => void): void
 	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
@@ -25,6 +27,9 @@ function Success<S, F>(value: S): Success<S, F> {
 			merge<T>(this: Success<S, F>, f: (value: S) => T) {
 				return f(this.value)
 			},
+			match(this: Success<S, F>, successFn) {
+				return successFn(this.value)
+			},
 			map<S2>(this: Success<S, F>, f: (value: S) => S2) {
 				return Success(f(this.value))
 			},
@@ -34,7 +39,7 @@ function Success<S, F>(value: S): Success<S, F> {
 			toJSON(this: Success<S, F>) {
 				return { $_kind, $_variant: $_variant_Success, value: this.value }
 			},
-		} as API<S, F>,
+		} satisfies API<S, F>,
 		{
 			$_kind: { value: $_kind, enumerable: false, writable: false },
 			$_variant: { value: $_variant_Success, enumerable: false, writable: false },
@@ -51,6 +56,9 @@ function Failure<S, F>(reason: F): Failure<S, F> {
 			merge<T>(this: Failure<S, F>, _: (value: S) => T, g: (reason: F) => T) {
 				return g(this.reason)
 			},
+			match(this: Failure<S, F>, _, failureFn) {
+				return failureFn(this.reason)
+			},
 			map<S2>(this: Failure<S, F>) {
 				return this as unknown as Result<S2, F>
 			},
@@ -60,7 +68,7 @@ function Failure<S, F>(reason: F): Failure<S, F> {
 			toJSON(this: Failure<S, F>) {
 				return { $_kind, $_variant: $_variant_Failure, reason: this.reason }
 			},
-		} as API<S, F>,
+		} satisfies API<S, F>,
 		{
 			$_kind: { value: $_kind, enumerable: false, writable: false },
 			$_variant: { value: $_variant_Success, enumerable: false, writable: false },
@@ -69,12 +77,26 @@ function Failure<S, F>(reason: F): Failure<S, F> {
 	)
 }
 
+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,
 	try<S, F>(tryFn: () => S) {
 		return new TryCatch<S, F>(tryFn)
 	},
+	fromPromise<S, F>(
+		promise: Promise<S>,
+		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: resultFromMaybe,
 	JSONReviver(_key: string, value: any) {
 		if (value?.$_kind == $_kind) {
 			const $_variant = value?.$_variant

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

@@ -1,5 +1,14 @@
+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(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,9 +1,12 @@
+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(this: Maybe<T>): Result<T, undefined>;
+    toResult<U>(this: Maybe<T>, mapNone: () => U): Result<T, U>;
     toJSON(this: Maybe<T>): Object;
 }
 export type Some<T> = {
@@ -16,6 +19,11 @@ export declare const Maybe: {
     Some: typeof Some;
     None: None<any>;
     from<T>(value: T | null | undefined): Maybe<T>;
+    /**
+     * 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>>;
     JSONReviver(_key: string, value: any): any;
 };
 export {};

package/types/functional/result.d.ts

@@ -1,7 +1,9 @@
+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;
+    match(this: Result<S, F>, successFn: (value: S) => void, failureFn: (reason: F) => void): void;
     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;
@@ -15,10 +17,14 @@ export type Failure<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>;
+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: typeof resultFromMaybe;
     JSONReviver(_key: string, value: any): any;
 };
 declare class TryCatch<S, F> {