feat: fork()

Author: timvandam

src/result-async.ts

@@ -203,6 +203,13 @@ export class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     return this._promise.then((res) => res.match(ok, _err))
   }
 
+  fork<A, B, C, D>(
+    ok: (t: T) => Result<A, B> | ResultAsync<A, B>,
+    err: (e: E) => Result<C, D> | ResultAsync<C, D>,
+  ): ResultAsync<A | C, B | D> {
+    return new ResultAsync(this._promise.then(async (res) => res.match(ok, err)))
+  }
+
   unwrapOr<A>(t: A): Promise<T | A> {
     return this._promise.then((res) => res.unwrapOr(t))
   }

src/result.ts

@@ -275,6 +275,25 @@ interface IResult<T, E> {
    */
   match<A, B = A>(ok: (t: T) => A, err: (e: E) => B): A | B
 
+  /**
+   * Similar to `match` except the functions must return a new `Result`.
+   *
+   * @param ok
+   * @param err
+   */
+  fork<A, B, C, D>(ok: (t: T) => Result<A, B>, err: (e: E) => Result<C, D>): Result<A | C, B | D>
+
+  /**
+   * Similar to `fork` except the functions must return a new `ResultAsync`.
+   *
+   * @param ok
+   * @param err
+   */
+  asyncFork<A, B, C, D>(
+    ok: (t: T) => Result<A, B> | ResultAsync<A, B>,
+    err: (e: E) => Result<C, D> | ResultAsync<C, D>,
+  ): ResultAsync<A | C, B | D>
+
   /**
    * @deprecated will be removed in 9.0.0.
    *
@@ -394,6 +413,17 @@ export class Ok<T, E> implements IResult<T, E> {
     return ok(this.value)
   }
 
+  fork<A, B, C, D>(ok: (t: T) => Result<A, B>, _err: (e: E) => Result<C, D>): Result<A | C, B | D> {
+    return ok(this.value)
+  }
+
+  asyncFork<A, B, C, D>(
+    ok: (t: T) => Result<A, B> | ResultAsync<A, B>,
+    _err: (e: E) => Result<C, D> | ResultAsync<C, D>,
+  ): ResultAsync<A | C, B | D> {
+    return new ResultAsync(Promise.resolve(ok(this.value)))
+  }
+
   safeUnwrap(): Generator<Err<never, E>, T> {
     const value = this.value
     /* eslint-disable-next-line require-yield */
@@ -493,6 +523,17 @@ export class Err<T, E> implements IResult<T, E> {
     return err(this.error)
   }
 
+  fork<A, B, C, D>(_ok: (t: T) => Result<A, B>, err: (e: E) => Result<C, D>): Result<A | C, B | D> {
+    return err(this.error)
+  }
+
+  asyncFork<A, B, C, D>(
+    _ok: (t: T) => Result<A, B> | ResultAsync<A, B>,
+    err: (e: E) => Result<C, D> | ResultAsync<C, D>,
+  ): ResultAsync<A | C, B | D> {
+    return new ResultAsync(Promise.resolve(err(this.error)))
+  }
+
   safeUnwrap(): Generator<Err<never, E>, T> {
     const error = this.error
     return (function* () {

tests/index.test.ts

@@ -17,6 +17,25 @@ import {
 
 import { vitest, describe, expect, it } from 'vitest'
 
+const x = ok<number, string>(123).fork(
+  (x) => ok(x + 321),
+  (y) => ok('y + 444'),
+)
+
+ok<number, string>(123)
+  .asyncFork(
+    (x) => okAsync(x + 321),
+    (y) => okAsync('y + 444'),
+  )
+  .map((x) => x - 321)
+
+okAsync<number, string>(123)
+  .fork(
+    (x) => okAsync(x + 321),
+    (y) => okAsync('y + 444'),
+  )
+  .map((x) => x - 321)
+
 describe('Result.Ok', () => {
   it('Creates an Ok value', () => {
     const okVal = ok(12)
@@ -288,6 +307,19 @@ describe('Result.Ok', () => {
     expect(errMapper).not.toHaveBeenCalled()
   })
 
+  it('Forks on an Ok', () => {
+    const okMapper = vitest.fn((_val) => ok('weeeeee'))
+    const errMapper = vitest.fn((_val) => err('wooooo'))
+
+    const forked = ok(12).fork(okMapper, errMapper)
+
+    expect(forked.isOk()).toBe(true)
+    expect(forked).toBeInstanceOf(Ok)
+    expect(forked._unsafeUnwrap()).toBe('weeeeee')
+    expect(okMapper).toHaveBeenCalledTimes(1)
+    expect(errMapper).not.toHaveBeenCalled()
+  })
+
   it('Unwraps without issue', () => {
     const okVal = ok(12)
 
@@ -450,6 +482,19 @@ describe('Result.Err', () => {
     expect(errMapper).toHaveBeenCalledTimes(1)
   })
 
+  it('Forks on an Err', () => {
+    const okMapper = vitest.fn((_val) => ok('weeeeee'))
+    const errMapper = vitest.fn((_val) => err('wooooo'))
+
+    const forked = err(12).fork(okMapper, errMapper)
+
+    expect(forked.isErr()).toBe(true)
+    expect(forked).toBeInstanceOf(Err)
+    expect(forked._unsafeUnwrapErr()).toBe('wooooo')
+    expect(okMapper).not.toHaveBeenCalled()
+    expect(errMapper).toHaveBeenCalledTimes(1)
+  })
+
   it('Throws when you unwrap an Err', () => {
     const errVal = err('woopsies')
 
@@ -1171,6 +1216,32 @@ describe('ResultAsync', () => {
     })
   })
 
+  describe('fork', () => {
+    it('Forks on an Ok', async () => {
+      const okMapper = vitest.fn((_val) => ok('weeeeee'))
+      const errMapper = vitest.fn((_val) => err('wooooo'))
+
+      const forked = await okAsync(12).fork(okMapper, errMapper)
+
+      expect(forked.isOk()).toBe(true)
+      expect(forked._unsafeUnwrap()).toBe('weeeeee')
+      expect(okMapper).toHaveBeenCalledTimes(1)
+      expect(errMapper).not.toHaveBeenCalled()
+    })
+
+    it('Forks on an Error', async () => {
+      const okMapper = vitest.fn((_val) => ok('weeeeee'))
+      const errMapper = vitest.fn((_val) => err('wooooo'))
+
+      const forked = await errAsync('bad').fork(okMapper, errMapper)
+
+      expect(forked.isErr()).toBe(true)
+      expect(forked._unsafeUnwrapErr()).toBe('wooooo')
+      expect(okMapper).not.toHaveBeenCalled()
+      expect(errMapper).toHaveBeenCalledTimes(1)
+    })
+  })
+
   describe('unwrapOr', () => {
     it('returns a promise to the result value on an Ok', async () => {
       const unwrapped = await okAsync(12).unwrapOr(10)