@terrygonguet/utils 0.0.10 → 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,8 +1,8 @@
-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) {
+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,
@@ -10,24 +10,27 @@ function a(t) {
       merge(e) {
         return e(this.value);
       },
+      match(e) {
+        return e(this.value);
+      },
       map(e) {
-        return a(e(this.value));
+        return i(e(this.value));
       },
       flatMap(e) {
         return e(this.value);
       },
       toJSON() {
-        return { $_kind: i, $_variant: f, value: this.value };
+        return { $_kind: o, $_variant: m, value: this.value };
       }
     },
     {
-      $_kind: { value: i, enumerable: !1, writable: !1 },
-      $_variant: { value: f, enumerable: !1, writable: !1 },
+      $_kind: { value: o, enumerable: !1, writable: !1 },
+      $_variant: { value: m, enumerable: !1, writable: !1 },
       value: { value: t, writable: !1 }
     }
   );
 }
-function c(t) {
+function f(t) {
   return Object.create(
     {
       isSuccess: () => !1,
@@ -35,6 +38,9 @@ function c(t) {
       merge(e, r) {
         return r(this.reason);
       },
+      match(e, r) {
+        return r(this.reason);
+      },
       map() {
         return this;
       },
@@ -42,40 +48,41 @@ function c(t) {
         return this;
       },
       toJSON() {
-        return { $_kind: i, $_variant: d, reason: this.reason };
+        return { $_kind: o, $_variant: p, reason: this.reason };
       }
     },
     {
-      $_kind: { value: i, enumerable: !1, writable: !1 },
-      $_variant: { value: f, enumerable: !1, writable: !1 },
+      $_kind: { value: o, enumerable: !1, writable: !1 },
+      $_variant: { value: m, enumerable: !1, writable: !1 },
       reason: { value: t, writable: !1 }
     }
   );
 }
-const g = {
-  Success: a,
-  Failure: c,
+function y(t, e) {
+  return e ? t.toResult(e) : t.toResult();
+}
+const w = {
+  Success: i,
+  Failure: f,
   try(t) {
-    return new p(t);
+    return new k(t);
   },
   fromPromise(t, e, r) {
-    return t.then($(e, a), $(r, c));
-  },
-  fromMaybe(t, e) {
-    return t.toResult(e);
+    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 == f ? a(e == null ? void 0 : e.value) : r == d ? c(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 p {
+class k {
   constructor(e) {
-    h(this, "tryFn");
-    h(this, "catchFn");
+    _(this, "tryFn");
+    _(this, "catchFn");
     this.tryFn = e, this.catchFn = S;
   }
   catch(e) {
@@ -83,15 +90,15 @@ class p {
   }
   exec(e) {
     try {
-      const r = a(this.tryFn());
+      const r = i(this.tryFn());
       return e == null || e(r), r;
     } catch (r) {
-      const n = c(this.catchFn(r));
+      const n = f(this.catchFn(r));
       return e == null || e(n), n;
     }
   }
 }
-const u = "@terrygonguet/utils/functional/maybe", _ = "@terrygonguet/utils/functional/maybe/Some", b = "@terrygonguet/utils/functional/maybe/None";
+const c = "@terrygonguet/utils/functional/maybe", b = "@terrygonguet/utils/functional/maybe/Some", g = "@terrygonguet/utils/functional/maybe/None";
 function l(t) {
   return Object.create(
     {
@@ -107,41 +114,41 @@ function l(t) {
         return e(this.value);
       },
       toResult() {
-        return g.Success(this.value);
+        return w.Success(this.value);
       },
       toJSON() {
-        return { $_kind: u, $_variant: _, value: this.value };
+        return { $_kind: c, $_variant: b, value: this.value };
       }
     },
     {
-      $_kind: { value: u, enumerable: !1, writable: !1 },
-      $_variant: { value: _, enumerable: !1, writable: !1 },
+      $_kind: { value: c, enumerable: !1, writable: !1 },
+      $_variant: { value: b, enumerable: !1, writable: !1 },
       value: { value: t, writable: !1 }
     }
   );
 }
-const s = Object.create(
+const u = 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 })
+    map: () => u,
+    flatMap: () => u,
+    toResult: (t) => w.Failure(t == null ? void 0 : t()),
+    toJSON: () => ({ $_kind: c, $_variant: g })
   },
   {
-    $_kind: { value: u, enumerable: !1, writable: !1 },
-    $_variant: { value: b, enumerable: !1, writable: !1 }
+    $_kind: { value: c, enumerable: !1, writable: !1 },
+    $_variant: { value: g, enumerable: !1, writable: !1 }
   }
-), o = {
+), s = {
   Some: l,
-  None: s,
+  None: u,
   from(t) {
     switch (t) {
       case null:
       case void 0:
-        return s;
+        return u;
       default:
         return l(t);
     }
@@ -151,52 +158,72 @@ const s = Object.create(
    * Use `Result.fromPromise()` if you need error details.
    */
   fromPromise(t, e = S) {
-    return t.then($(e, o.from), O(s));
+    return t.then($(e, s.from), M(u));
   },
   JSONReviver(t, e) {
-    if ((e == null ? void 0 : e.$_kind) == u) {
+    if ((e == null ? void 0 : e.$_kind) == c) {
       const r = e == null ? void 0 : e.$_variant;
-      return r == _ ? l(e == null ? void 0 : e.value) : r == b ? s : e;
+      return r == b ? l(e == null ? void 0 : e.value) : r == g ? u : e;
     } else
       return e;
   }
 };
-var $ = v;
-function v(t, 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), w = r.length, m = 1; m < w; m++)
-      n = r[m].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;
   };
 }
+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 x(t, e) {
-  return o.from(t.at(e));
+function F(t, e) {
+  return typeof t == "number" ? (r) => s.from(r.at(t)) : s.from(t.at(e));
 }
-function J(t, e) {
-  return o.from(t.find(e));
+function j(t, e) {
+  return typeof t == "function" ? (r) => s.from(r.find(t)) : s.from(t.find(e));
 }
-function M(t, e) {
-  const r = t.findIndex(e);
-  return r == -1 ? o.None : o.Some(r);
+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 {
-  o as Maybe,
-  g as Result,
-  x as at,
+  s as Maybe,
+  w as Result,
+  F as at,
   $ as compose,
-  O as constant,
-  J as find,
-  M as findIndex,
-  S as identity
+  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.10",
+	"version": "0.0.11",
 	"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 : Maybe.Some(idx)
+		}
+	} else {
+		const idx = dataOrPredicate.findIndex(predicate!)
+		return idx == -1 ? Maybe.None : Maybe.Some(idx)
+	}
 }

package/src/functional/maybe.ts

@@ -7,7 +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<U>(this: Maybe<T>, mapNone?: () => U): Result<T, U>
+	toResult(this: Maybe<T>): Result<T, undefined>
+	toResult<U>(this: Maybe<T>, mapNone: () => U): Result<T, U>
 	toJSON(this: Maybe<T>): Object
 }
 
@@ -34,12 +35,12 @@ function Some<T>(value: NonNullable<T>): Some<T> {
 				return f(this.value)
 			},
 			toResult(this: Some<T>) {
-				return Result.Success(this.value)
+				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 },
@@ -55,9 +56,9 @@ const None: None<any> = Object.create(
 		orDefault: defaultValue => defaultValue,
 		map: () => None,
 		flatMap: () => None,
-		toResult: mapNone => Result.Failure(mapNone?.()),
+		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 },

package/src/functional/result.ts

@@ -5,6 +5,7 @@ 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
@@ -26,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))
 			},
@@ -35,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 },
@@ -52,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>
 			},
@@ -61,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 },
@@ -70,6 +77,12 @@ 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,
@@ -83,9 +96,7 @@ export const Result = {
 	): 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)
-	},
+	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

@@ -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

@@ -5,7 +5,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<U>(this: Maybe<T>, mapNone?: () => U): Result<T, 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> = {

package/types/functional/result.d.ts

@@ -3,6 +3,7 @@ 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;
@@ -16,12 +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<S_2, F_2>(maybe: Maybe<S_2>, mapNone?: (() => F_2) | undefined): Result<S_2, F_2>;
+    fromMaybe: typeof resultFromMaybe;
     JSONReviver(_key: string, value: any): any;
 };
 declare class TryCatch<S, F> {