Added Result.match()

dist/result/api/match.d.ts

@@ -0,0 +1,3 @@
+import { ResultUnion } from "../interfaces.js";
+export declare function match<T, E, U>(source: ResultUnion<T, E>, onOk: (v: T) => U, onErr: (e: E) => U): U;
+//# sourceMappingURL=match.d.ts.map

dist/result/api/match.js

@@ -0,0 +1,8 @@
+export function match(source, onOk, onErr) {
+    if (source.type === "Ok") {
+        return onOk(source.value);
+    }
+    else {
+        return onErr(source.value);
+    }
+}

dist/result/index.js

@@ -22,6 +22,7 @@ import { unwrapErr } from "./api/unwrapErr.js";
 import { unwrapErrOr } from "./api/unwrapErrOr.js";
 import { unionOk } from "./api/unionOk.js";
 import { unionErr } from "./api/unionErr.js";
+import { match } from "./api/match.js";
 export function createResult(result) {
     const api = {
         inner: () => result,
@@ -45,6 +46,7 @@ export function createResult(result) {
         or: (new_value) => or(api, new_value),
         ok: () => ok(api),
         err: () => err(api),
+        match: (onOk, onErr) => match(result, onOk, onErr),
     };
     return api;
 }

dist/result/interfaces.d.ts

@@ -248,5 +248,26 @@ export interface Result<T, Err> {
      * ```
      */
     err(): Option<Err>;
+    /**
+     * This function is functional alternative to hand-written conditions for `Result<T, Err>`
+     *
+     * It takes two functions as arguments:
+     * - What to return if Ok
+     * - What to return if Err
+     *
+     * # Notice
+     * Both functions must return the same type
+     *
+     * # Example
+     * ```ts
+     * const data = Ok("coolvalue");
+     * const result = match(
+     *   (v) => v + "!",
+     *   (err) => err
+     * );
+     * assert(result, "coolvalue!");
+     * ```
+     */
+    match<U>(onOk: (v: T) => U, onErr: (e: Err) => U): U;
 }
 //# sourceMappingURL=interfaces.d.ts.map

src/result/api/match.ts

@@ -0,0 +1,13 @@
+import { ResultUnion } from "../interfaces.js";
+
+export function match<T, E, U>(
+  source: ResultUnion<T, E>,
+  onOk: (v: T) => U,
+  onErr: (e: E) => U
+): U {
+  if (source.type === "Ok") {
+    return onOk(source.value);
+  } else {
+    return onErr(source.value);
+  }
+}

src/result/index.ts

@@ -24,6 +24,7 @@ import { unwrapErrOr } from "./api/unwrapErrOr.js";
 import type { Result, ResultUnion, Ok, Err } from "./interfaces.js";
 import { unionOk } from "./api/unionOk.js";
 import { unionErr } from "./api/unionErr.js";
+import { match } from "./api/match.js";
 
 export function createResult<T, E>(result: ResultUnion<T, E>): Result<T, E> {
   const api: Result<T, E> = {
@@ -48,6 +49,7 @@ export function createResult<T, E>(result: ResultUnion<T, E>): Result<T, E> {
     or: (new_value) => or(api, new_value),
     ok: () => ok(api),
     err: () => err(api),
+    match: (onOk, onErr) => match(result, onOk, onErr),
   };
   return api;
 }

src/result/interfaces.ts

@@ -250,4 +250,25 @@ export interface Result<T, Err> {
    * ```
    */
   err(): Option<Err>;
+  /**
+   * This function is functional alternative to hand-written conditions for `Result<T, Err>`
+   *
+   * It takes two functions as arguments:
+   * - What to return if Ok
+   * - What to return if Err
+   *
+   * # Notice
+   * Both functions must return the same type
+   *
+   * # Example
+   * ```ts
+   * const data = Ok("coolvalue");
+   * const result = match(
+   *   (v) => v + "!",
+   *   (err) => err
+   * );
+   * assert(result, "coolvalue!");
+   * ```
+   */
+  match<U>(onOk: (v: T) => U, onErr: (e: Err) => U): U;
 }

src/result/result.test.ts

@@ -167,3 +167,19 @@ test(`.tryFn()`, (t) => {
     }).eq(Ok("good"))
   );
 });
+test(`.match()`, (t) => {
+  t.is(
+    Ok("v").match(
+      (v) => v,
+      (e) => e
+    ),
+    "v"
+  );
+  t.is(
+    Err("e").match(
+      (v) => v,
+      (e) => e
+    ),
+    "e"
+  );
+});