@terrygonguet/utils 0.0.11 → 0.0.13

package/dist/functional.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.0.11",
+	"version": "0.0.13",
 	"type": "module",
 	"module": "./dist/index.js",
 	"author": {

package/src/functional/index.ts

@@ -36,10 +36,45 @@ export function findIndex<T>(dataOrPredicate: T[] | Predicate<T>, predicate?: Pr
 	if (typeof dataOrPredicate == "function") {
 		return (data: T[]) => {
 			const idx = data.findIndex(dataOrPredicate)
-			return idx == -1 ? Maybe.None : Maybe.Some(idx)
+			return idx == -1 ? Maybe.None<number>() : Maybe.Some(idx)
 		}
 	} else {
 		const idx = dataOrPredicate.findIndex(predicate!)
-		return idx == -1 ? Maybe.None : Maybe.Some(idx)
+		return idx == -1 ? Maybe.None<number>() : Maybe.Some(idx)
 	}
 }
+
+export function prop<T extends {}, K1 extends keyof T = keyof T>(data: T, key1: K1): Maybe<T[K1]>
+export function prop<
+	T extends {},
+	K1 extends keyof T = keyof T,
+	K2 extends keyof T[K1] = keyof T[K1],
+>(data: T, key1: K1, key2: K2): Maybe<T[K1][K2]>
+export function prop<
+	T extends {},
+	K1 extends keyof T = keyof T,
+	K2 extends keyof T[K1] = keyof T[K1],
+	K3 extends keyof T[K1][K2] = keyof T[K1][K2],
+>(data: T, key1: K1, key2: K2, key: K3): Maybe<T[K1][K2][K3]>
+export function prop<
+	T extends {},
+	K1 extends keyof T = keyof T,
+	K2 extends keyof T[K1] = keyof T[K1],
+	K3 extends keyof T[K1][K2] = keyof T[K1][K2],
+	K4 extends keyof T[K1][K2][K3] = keyof T[K1][K2][K3],
+>(data: T, key1: K1, key2: K2, key: K3, key4: K4): Maybe<T[K1][K2][K3][K4]>
+export function prop<
+	T extends {},
+	K1 extends keyof T = keyof T,
+	K2 extends keyof T[K1] = keyof T[K1],
+	K3 extends keyof T[K1][K2] = keyof T[K1][K2],
+	K4 extends keyof T[K1][K2][K3] = keyof T[K1][K2][K3],
+	K5 extends keyof T[K1][K2][K3][K4] = keyof T[K1][K2][K3][K4],
+>(data: T, key1: K1, key2: K2, key: K3, key4: K4, key5: K5): Maybe<T[K1][K2][K3][K4][K5]>
+
+export function prop(data: any, ...path: string[]) {
+	for (const key of path) {
+		data = data?.[key]
+	}
+	return Maybe.from(data)
+}

package/src/functional/maybe.ts

@@ -1,80 +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(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> = { 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<T, any>(this.value)
-			},
-			toJSON(this: Some<T>) {
-				return { $_kind, $_variant: $_variant_Some, value: this.value }
-			},
-		} satisfies 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: <U>(mapNone?: () => U) => Result.Failure(mapNone?.()),
-		toJSON: () => ({ $_kind, $_variant: $_variant_None }),
-	} satisfies 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!)
 		}
 	},
 	/**
@@ -82,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,80 +1,86 @@
 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
-}
-
-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)
-			},
-			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))
-			},
-			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 }
-			},
-		} satisfies 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)
-			},
-			match(this: Failure<S, F>, _, failureFn) {
-				return failureFn(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 }
-			},
-		} satisfies 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>
@@ -84,8 +90,12 @@ function resultFromMaybe<S, F>(maybe: Maybe<S>, mapNone?: () => F) {
 }
 
 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)
 	},
@@ -94,14 +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>))
+		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
 	},
@@ -123,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/functional/index.d.ts

@@ -12,3 +12,8 @@ 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>;
+export declare function prop<T extends {}, K1 extends keyof T = keyof T>(data: T, key1: K1): Maybe<T[K1]>;
+export declare function prop<T extends {}, K1 extends keyof T = keyof T, K2 extends keyof T[K1] = keyof T[K1]>(data: T, key1: K1, key2: K2): Maybe<T[K1][K2]>;
+export declare function prop<T extends {}, K1 extends keyof T = keyof T, K2 extends keyof T[K1] = keyof T[K1], K3 extends keyof T[K1][K2] = keyof T[K1][K2]>(data: T, key1: K1, key2: K2, key: K3): Maybe<T[K1][K2][K3]>;
+export declare function prop<T extends {}, K1 extends keyof T = keyof T, K2 extends keyof T[K1] = keyof T[K1], K3 extends keyof T[K1][K2] = keyof T[K1][K2], K4 extends keyof T[K1][K2][K3] = keyof T[K1][K2][K3]>(data: T, key1: K1, key2: K2, key: K3, key4: K4): Maybe<T[K1][K2][K3][K4]>;
+export declare function prop<T extends {}, K1 extends keyof T = keyof T, K2 extends keyof T[K1] = keyof T[K1], K3 extends keyof T[K1][K2] = keyof T[K1][K2], K4 extends keyof T[K1][K2][K3] = keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4] = keyof T[K1][K2][K3][K4]>(data: T, key1: K1, key2: K2, key: K3, key4: K4, key5: K5): Maybe<T[K1][K2][K3][K4][K5]>;

package/types/functional/maybe.d.ts

@@ -1,29 +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(this: Maybe<T>): Result<T, undefined>;
-    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,29 +1,50 @@
 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;
+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>>;
+    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;
 };
@@ -34,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 };