[dsch] introducing Result.apply method

src/Err.ts

@@ -91,6 +91,10 @@ export class ErrImpl<E> implements Err<E> {
   biChain<S, F>(_: unknown, errFn: (error: E) => Result<S, F>): Result<S, F> {
     return errFn(this.error);
   }
+
+  apply() {
+    return this;
+  }
 }
 
 Object.defineProperty(ErrImpl, 'name', { enumerable: false, value: 'Err' });

src/Ok.ts

@@ -1,4 +1,5 @@
-import type { AsyncOk, Ok, Result } from './types';
+import { resolveOks } from './resolve-args';
+import type { AsyncOk, ErrTypeOf, Ok, ResolveOks, Result } from './types';
 
 export class OkImpl<T> implements Ok<T> {
   constructor(public readonly value: T) {}
@@ -87,6 +88,19 @@ export class OkImpl<T> implements Ok<T> {
   biChain<S, F>(okFn: (data: T) => Result<S, F>): Result<S, F> {
     return okFn(this.value);
   }
+
+  apply<Args extends any[], R = never>(
+    this: OkImpl<(...args: ResolveOks<Args>) => R>,
+    ...args: Args
+  ): Result<R, ErrTypeOf<Args[number]>> {
+    if (typeof this.value !== 'function') {
+      throw new TypeError('Result.value is not a function', { cause: this });
+    }
+
+    const argValues = resolveOks(args);
+
+    return Array.isArray(argValues) ? ok(this.value(...argValues)) : argValues;
+  }
 }
 
 Object.defineProperty(OkImpl, 'name', { enumerable: false, value: 'Ok' });

src/resolve-args.ts

@@ -0,0 +1,20 @@
+import { isResult } from './guards';
+import { Err, ErrTypeOf, ResolveOks } from './types';
+
+export const resolveOks = <PR extends any[]>(
+  args: PR,
+): ResolveOks<PR> | Err<ErrTypeOf<PR[number]>> => {
+  const argValues = [] as any[];
+
+  for (const arg of args) {
+    if (!isResult(arg)) {
+      argValues.push(arg);
+    } else if (arg.isErr) {
+      return arg as Err<ErrTypeOf<PR[number]>>;
+    } else {
+      argValues.push(arg.value);
+    }
+  }
+
+  return argValues as ResolveOks<PR>;
+};