ts-data-forge 5.0.0 → 5.1.0

package/src/functional/ternary-result/impl/ternary-result-from-throwable.mts

@@ -1,3 +1,4 @@
+import { isError } from '@sindresorhus/is';
 import { unknownToString } from '../../../others/index.mjs';
 import { err } from './ternary-result-err.mjs';
 import { ok } from './ternary-result-ok.mjs';
@@ -9,11 +10,13 @@ import { ok } from './ternary-result-ok.mjs';
  *
  * ```ts
  * const success = TernaryResult.fromThrowable(() => 1 + 1);
+ *
  * const failure = TernaryResult.fromThrowable(() => {
  *   throw new Error('boom');
  * });
  *
  * assert.deepStrictEqual(success, TernaryResult.ok(2));
+ *
  * assert.ok(TernaryResult.isErr(failure));
  * ```
  */
@@ -23,9 +26,10 @@ export const fromThrowable = <T,>(
   try {
     return ok(fn());
   } catch (error) {
-    if (Error.isError(error)) {
+    if (isError(error)) {
       return err(error);
     }
+
     return err(new Error(unknownToString(error)));
   }
 };

package/src/functional/ternary-result/impl/ternary-result-is-ok.mts

@@ -15,6 +15,7 @@ import { type NarrowToOk } from './types.mjs';
  *
  * if (TernaryResult.isOk(maybeNumber)) {
  *   const value: number = maybeNumber.value;
+ *
  *   assert.strictEqual(value, 42);
  * }
  * ```

package/src/functional/ternary-result/impl/ternary-result-is-ternary-result.mts

@@ -8,11 +8,15 @@ import { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';
  *
  * ```ts
  * const okValue = TernaryResult.ok('done');
+ *
  * const warnValue = TernaryResult.warn('done', 'retry later');
+ *
  * const notResult = { $$tag: 'ts-data-forge::Result.ok' };
  *
  * assert.ok(TernaryResult.isTernaryResult(okValue));
+ *
  * assert.ok(TernaryResult.isTernaryResult(warnValue));
+ *
  * assert.ok(!TernaryResult.isTernaryResult(notResult));
  * ```
  */

package/src/functional/ternary-result/impl/ternary-result-is-warn.mts

@@ -15,6 +15,7 @@ import { type NarrowToWarn } from './types.mjs';
  *
  * if (TernaryResult.isWarn(maybeWarn)) {
  *   assert.strictEqual(maybeWarn.value, 'value');
+ *
  *   assert.strictEqual(maybeWarn.warning, 'check logs');
  * }
  * ```

package/src/functional/ternary-result/impl/ternary-result-map-err.mts

@@ -9,15 +9,18 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  *
  * ```ts
  * const errValue = TernaryResult.err('boom');
+ *
  * const mappedErr = TernaryResult.mapErr(errValue, (error) =>
  *   error.toUpperCase(),
  * );
+ *
  * const warnPassthrough = TernaryResult.mapErr(
  *   TernaryResult.warn(2, 'slow'),
  *   (error: string) => `${error}!`,
  * );
  *
  * assert.deepStrictEqual(mappedErr, TernaryResult.err('BOOM'));
+ *
  * assert.deepStrictEqual(warnPassthrough, TernaryResult.warn(2, 'slow'));
  * ```
  */
@@ -41,10 +44,13 @@ export function mapErr<R extends UnknownTernaryResult, E2>(
   switch (args.length) {
     case 2: {
       const [result, mapFn] = args;
+
       return mapErrImpl(result, mapFn);
     }
+
     case 1: {
       const [mapFn] = args;
+
       return (result: R) => mapErrImpl(result, mapFn);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-map-warn.mts

@@ -9,13 +9,16 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  *
  * ```ts
  * const warnValue = TernaryResult.warn(2, 'slow');
+ *
  * const mappedWarn = TernaryResult.mapWarn(warnValue, (warning) => `${warning}!`);
+ *
  * const okPassthrough = TernaryResult.mapWarn(
  *   TernaryResult.ok(3),
  *   (value: number) => value * 2,
  * );
  *
  * assert.deepStrictEqual(mappedWarn, TernaryResult.warn(2, 'slow!'));
+ *
  * assert.deepStrictEqual(okPassthrough, TernaryResult.ok(3));
  * ```
  */
@@ -39,10 +42,13 @@ export function mapWarn<R extends UnknownTernaryResult, W2>(
   switch (args.length) {
     case 2: {
       const [result, mapFn] = args;
+
       return mapWarnImpl(result, mapFn);
     }
+
     case 1: {
       const [mapFn] = args;
+
       return (result: R) => mapWarnImpl(result, mapFn);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-map.mts

@@ -11,21 +11,27 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  *
  * ```ts
  * const okNumber = TernaryResult.ok(5);
+ *
  * const warnValue = TernaryResult.warn(5, 'slow');
+ *
  * const errValue = TernaryResult.err('bad');
  *
  * const doubled = TernaryResult.map(okNumber, (value) => value * 2);
+ *
  * const warnPassthrough = TernaryResult.map(
  *   warnValue,
  *   (value: number) => value * 2,
  * );
+ *
  * const errPassthrough = TernaryResult.map(
  *   errValue,
  *   (value: number) => value * 2,
  * );
  *
  * assert.deepStrictEqual(doubled, TernaryResult.ok(10));
+ *
  * assert.deepStrictEqual(warnPassthrough, TernaryResult.warn(10, 'slow'));
+ *
  * assert.deepStrictEqual(errPassthrough, errValue);
  * ```
  */
@@ -49,10 +55,13 @@ export function map<R extends UnknownTernaryResult, S2>(
   switch (args.length) {
     case 2: {
       const [result, mapFn] = args;
+
       return mapImpl(result, mapFn);
     }
+
     case 1: {
       const [mapFn] = args;
+
       return (result: R) => mapImpl(result, mapFn);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-ok.mts

@@ -14,7 +14,7 @@ import { OkTypeTagName } from './tag.mjs';
  * });
  * ```
  */
-export const ok = <S,>(value: S): TernaryOk<S> => ({
+export const ok = <const S,>(value: S): TernaryOk<S> => ({
   $$tag: OkTypeTagName,
   value,
 });

package/src/functional/ternary-result/impl/ternary-result-or-else.mts

@@ -14,10 +14,12 @@ import { type NarrowToOk, type NarrowToWarn } from './types.mjs';
  *   TernaryResult.orElse(TernaryResult.ok('value'), fallback),
  *   TernaryResult.ok('value'),
  * );
+ *
  * assert.deepStrictEqual(
  *   TernaryResult.orElse(TernaryResult.warn('value', 'warn'), fallback),
  *   TernaryResult.warn('value', 'warn'),
  * );
+ *
  * assert.deepStrictEqual(
  *   TernaryResult.orElse(TernaryResult.err('err'), fallback),
  *   fallback,
@@ -47,10 +49,13 @@ export function orElse<
   switch (args.length) {
     case 2: {
       const [result, alternative] = args;
+
       return orElseImpl(result, alternative);
     }
+
     case 1: {
       const [alternative] = args;
+
       return (result: R) => orElseImpl(result, alternative);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-to-optional.mts

@@ -10,9 +10,11 @@ import { type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okValue = TernaryResult.ok(7);
+ *
  * const warnValue = TernaryResult.warn(7, 'warn');
  *
  * assert.deepStrictEqual(TernaryResult.toOptional(okValue), Optional.some(7));
+ *
  * assert.deepStrictEqual(TernaryResult.toOptional(warnValue), Optional.some(7));
  * ```
  */

package/src/functional/ternary-result/impl/ternary-result-unwrap-err-or.mts

@@ -10,9 +10,11 @@ import { type UnwrapErr } from './types.mjs';
  * const okValue = TernaryResult.ok('value');
  *
  * assert.strictEqual(TernaryResult.unwrapErrOr(okValue, 'default'), 'default');
+ *
  * const unwrapErr = TernaryResult.unwrapErrOr('fallback error');
  *
  * assert.strictEqual(unwrapErr(TernaryResult.err('boom')), 'boom');
+ *
  * assert.strictEqual(
  *   unwrapErr(TernaryResult.warn('value', 'warn')),
  *   'fallback error',
@@ -35,10 +37,13 @@ export function unwrapErrOr<R extends UnknownTernaryResult, D>(
   switch (args.length) {
     case 2: {
       const [result, defaultValue] = args;
+
       return unwrapErr(result) ?? defaultValue;
     }
+
     case 1: {
       const [defaultValue] = args;
+
       return (result: R) => unwrapErr(result) ?? defaultValue;
     }
   }

package/src/functional/ternary-result/impl/ternary-result-unwrap-err-throw.mts

@@ -13,6 +13,7 @@ import { variantName } from './variant-name.mjs';
  * const errValue = TernaryResult.err('boom');
  *
  * assert.strictEqual(TernaryResult.unwrapErrThrow(errValue), 'boom');
+ *
  * assert.throws(
  *   () => TernaryResult.unwrapErrThrow(TernaryResult.ok('value')),
  *   /Expected Err/u,

package/src/functional/ternary-result/impl/ternary-result-unwrap-err.mts

@@ -8,9 +8,11 @@ import { type UnwrapErr } from './types.mjs';
  *
  * ```ts
  * const errValue = TernaryResult.err('fail');
+ *
  * const okValue = TernaryResult.ok('value');
  *
  * assert.strictEqual(TernaryResult.unwrapErr(errValue), 'fail');
+ *
  * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
  * assert.strictEqual(TernaryResult.unwrapErr(okValue), undefined);
  * ```

package/src/functional/ternary-result/impl/ternary-result-unwrap-ok-or.mts

@@ -10,9 +10,11 @@ import { type UnwrapOk } from './types.mjs';
  * const errValue = TernaryResult.err('err');
  *
  * assert.strictEqual(TernaryResult.unwrapOkOr(errValue, 0), 0);
+ *
  * const unwrapWithDefault = TernaryResult.unwrapOkOr('fallback');
  *
  * assert.strictEqual(unwrapWithDefault(TernaryResult.ok(5)), 5);
+ *
  * assert.strictEqual(
  *   unwrapWithDefault(TernaryResult.warn('warn-value', 'warn')),
  *   'warn-value',
@@ -35,10 +37,13 @@ export function unwrapOkOr<R extends UnknownTernaryResult, D>(
   switch (args.length) {
     case 2: {
       const [result, defaultValue] = args;
+
       return unwrapOk(result) ?? defaultValue;
     }
+
     case 1: {
       const [defaultValue] = args;
+
       return (result: R) => unwrapOk(result) ?? defaultValue;
     }
   }

package/src/functional/ternary-result/impl/ternary-result-unwrap-ok.mts

@@ -9,13 +9,16 @@ import { type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okValue = TernaryResult.ok(3);
+ *
  * const warnValue = TernaryResult.warn(4, 'warn');
  *
  * assert.strictEqual(TernaryResult.unwrapOk(okValue), 3);
+ *
  * assert.strictEqual(TernaryResult.unwrapOk(warnValue), 4);
  * ```
  */
 export function unwrapOk<R extends TernaryOk<unknown>>(result: R): UnwrapOk<R>;
+
 export function unwrapOk<R extends UnknownTernaryResult>(
   result: R,
 ): UnwrapOk<R> | undefined;

package/src/functional/ternary-result/impl/ternary-result-unwrap-throw.mts

@@ -12,6 +12,7 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  * const okValue = TernaryResult.ok('ready');
  *
  * assert.strictEqual(TernaryResult.unwrapThrow(okValue), 'ready');
+ *
  * assert.throws(
  *   () => TernaryResult.unwrapThrow(TernaryResult.warn('warn', 'warned')),
  *   /Expected Ok/u,

package/src/functional/ternary-result/impl/ternary-result-unwrap-warn-or.mts

@@ -10,9 +10,11 @@ import { type UnwrapWarn } from './types.mjs';
  * const okValue = TernaryResult.ok('value');
  *
  * assert.strictEqual(TernaryResult.unwrapWarnOr(okValue, 'warn'), 'warn');
+ *
  * const unwrapWarn = TernaryResult.unwrapWarnOr('fallback warn');
  *
  * assert.strictEqual(unwrapWarn(TernaryResult.warn('value', 'slow')), 'slow');
+ *
  * assert.strictEqual(unwrapWarn(TernaryResult.err('err')), 'fallback warn');
  * ```
  */
@@ -32,10 +34,13 @@ export function unwrapWarnOr<R extends UnknownTernaryResult, D>(
   switch (args.length) {
     case 2: {
       const [result, defaultValue] = args;
+
       return unwrapWarn(result) ?? defaultValue;
     }
+
     case 1: {
       const [defaultValue] = args;
+
       return (result: R) => unwrapWarn(result) ?? defaultValue;
     }
   }

package/src/functional/ternary-result/impl/ternary-result-unwrap-warn-throw.mts

@@ -12,6 +12,7 @@ import { variantName } from './variant-name.mjs';
  * const warnValue = TernaryResult.warn('pending', 'check logs');
  *
  * assert.strictEqual(TernaryResult.unwrapWarnThrow(warnValue), 'check logs');
+ *
  * assert.throws(
  *   () => TernaryResult.unwrapWarnThrow(TernaryResult.err('err')),
  *   /Expected Warn/u,

package/src/functional/ternary-result/impl/ternary-result-unwrap-warn.mts

@@ -8,9 +8,11 @@ import { type UnwrapWarn } from './types.mjs';
  *
  * ```ts
  * const warnValue = TernaryResult.warn('ok', 'careful');
+ *
  * const okValue = TernaryResult.ok('ok');
  *
  * assert.strictEqual(TernaryResult.unwrapWarn(warnValue), 'careful');
+ *
  * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
  * assert.strictEqual(TernaryResult.unwrapWarn(okValue), undefined);
  * ```

package/src/functional/ternary-result/impl/ternary-result-warn.mts

@@ -16,7 +16,10 @@ import { WarnTypeTagName } from './tag.mjs';
  * });
  * ```
  */
-export const warn = <S, W>(value: S, warning: W): TernaryWarn<S, W> => ({
+export const warn = <const S, const W>(
+  value: S,
+  warning: W,
+): TernaryWarn<S, W> => ({
   $$tag: WarnTypeTagName,
   value,
   warning,

package/src/functional/ternary-result/impl/ternary-result-zip.mts

@@ -10,20 +10,24 @@ import { warn } from './ternary-result-warn.mjs';
  *
  * ```ts
  * const okPair = TernaryResult.zip(TernaryResult.ok('left'), TernaryResult.ok(1));
+ *
  * const warnPair = TernaryResult.zip(
  *   TernaryResult.warn('left', 'warn'),
  *   TernaryResult.ok(1),
  * );
+ *
  * const errPair = TernaryResult.zip(
  *   TernaryResult.ok('left'),
  *   TernaryResult.err('err'),
  * );
  *
  * assert.deepStrictEqual(okPair, TernaryResult.ok(['left', 1] as const));
+ *
  * assert.deepStrictEqual(
  *   warnPair,
  *   TernaryResult.warn(['left', 1] as const, 'warn'),
  * );
+ *
  * assert.deepStrictEqual(errPair, TernaryResult.err('err'));
  * ```
  */

package/src/functional/ternary-result.test.mts

@@ -5,47 +5,65 @@ import { TernaryResult } from './ternary-result/index.mjs';
 describe('TernaryResult test', () => {
   test('constructors and guards', () => {
     const ok = TernaryResult.ok(1);
+
     const warn = TernaryResult.warn(1, 'caution');
+
     const err = TernaryResult.err(new Error('boom'));
 
     expect(TernaryResult.isOk(ok)).toBe(true);
+
     expect(TernaryResult.isWarn(warn)).toBe(true);
+
     expect(TernaryResult.isErr(err)).toBe(true);
+
     expect(TernaryResult.isTernaryResult(ok)).toBe(true);
+
     expect(TernaryResult.isTernaryResult({})).toBe(false);
 
     expectType<typeof ok, TernaryResult<number, never, never>>('<=');
+
     expectType<typeof warn, TernaryResult<number, never, string>>('<=');
+
     expectType<typeof err, TernaryResult<never, Error, never>>('<=');
   });
 
   test('map transforms Ok and Warn success values', () => {
     const ok = TernaryResult.ok(2);
+
     const warn = TernaryResult.warn(2, 'check');
+
     const err = TernaryResult.err('fail');
 
     const double = TernaryResult.map((value: number) => value * 2);
 
     expect(TernaryResult.unwrapOk(double(ok))).toBe(4);
+
     expect(TernaryResult.unwrapOk(double(warn))).toBe(4);
+
     expect(TernaryResult.unwrapWarn(double(warn))).toBe('check');
+
     expect(TernaryResult.unwrapErr(double(err))).toBe('fail');
   });
 
   test('mapWarn and mapErr leave other variants untouched', () => {
     const warn = TernaryResult.warn(2, 'slow');
+
     const err = TernaryResult.err('err');
 
     const warnMessage = TernaryResult.mapWarn(
       (warning: string) => `${warning}!`,
     );
+
     const errUpper = TernaryResult.mapErr((value: string) =>
       value.toUpperCase(),
     );
 
     expect(TernaryResult.unwrapWarn(warnMessage(warn))).toBe('slow!');
+
     expect(TernaryResult.unwrapOk(warnMessage(warn))).toBe(2);
+
     expect(TernaryResult.unwrapWarn(errUpper(warn))).toBe('slow');
+
     expect(TernaryResult.unwrapErr(errUpper(err))).toBe('ERR');
   });
 
@@ -56,17 +74,22 @@ describe('TernaryResult test', () => {
         : TernaryResult.ok(Number(value));
 
     const warn = TernaryResult.warn('3', 'slow');
+
     const err = TernaryResult.err('bad');
 
     const okResult = TernaryResult.flatMap(TernaryResult.ok('3'), parse);
+
     const warnResult = TernaryResult.flatMap(warn, parse);
+
     const errResult = TernaryResult.flatMap(err, parse);
 
     expect(TernaryResult.unwrapOk(okResult)).toBe(3);
+
     expect(TernaryResult.isWarn(warnResult)).toBe(true);
 
     if (TernaryResult.isWarn(warnResult)) {
       expect(warnResult.value).toBe(3);
+
       expect(warnResult.warning).toBe('slow');
     }
 
@@ -80,12 +103,14 @@ describe('TernaryResult test', () => {
       (w: string) => ({ warning: w }),
       (e: string) => ({ message: e }),
     );
+
     const warn = TernaryResult.fold(
       TernaryResult.warn(2, 'heads up'),
       (x) => x * 2,
       (w: string) => ({ warning: w }),
       (e: string) => ({ message: e }),
     );
+
     const err = TernaryResult.fold(
       TernaryResult.err('boom'),
       (x) => x,
@@ -94,11 +119,13 @@ describe('TernaryResult test', () => {
     );
 
     expect(TernaryResult.unwrapOk(value)).toBe(2);
+
     expect(TernaryResult.unwrapOk(warn)).toBe(4);
 
     assert.deepStrictEqual(TernaryResult.unwrapWarn(warn), {
       warning: 'heads up',
     });
+
     assert.deepStrictEqual(TernaryResult.unwrapErr(err), { message: 'boom' });
   });
 
@@ -109,10 +136,12 @@ describe('TernaryResult test', () => {
       TernaryResult.orElse(TernaryResult.ok('value'), fallback),
       TernaryResult.ok('value'),
     );
+
     assert.deepStrictEqual(
       TernaryResult.orElse(TernaryResult.warn('value', 'warn'), fallback),
       TernaryResult.warn('value', 'warn'),
     );
+
     assert.deepStrictEqual(
       TernaryResult.orElse(TernaryResult.err('err'), fallback),
       fallback,
@@ -121,14 +150,21 @@ describe('TernaryResult test', () => {
 
   test('unwrap helpers', () => {
     const warn = TernaryResult.warn('value', 'careful');
+
     const err = TernaryResult.err('broken');
 
     expect(TernaryResult.unwrapOk(TernaryResult.ok(3))).toBe(3);
+
     expect(TernaryResult.unwrapOk(warn)).toBe('value');
+
     expect(TernaryResult.unwrapWarn(warn)).toBe('careful');
+
     expect(TernaryResult.unwrapErr(err)).toBe('broken');
+
     expect(TernaryResult.unwrapOkOr(err, 0)).toBe(0);
+
     expect(TernaryResult.unwrapWarnOr(err, 'default')).toBe('default');
+
     expect(TernaryResult.unwrapErrOr(warn, 'default')).toBe('default');
   });
 
@@ -136,9 +172,11 @@ describe('TernaryResult test', () => {
     expect(() =>
       TernaryResult.unwrapThrow(TernaryResult.warn('notice', 'warned')),
     ).toThrow(/Warn/u);
+
     expect(() =>
       TernaryResult.unwrapWarnThrow(TernaryResult.err('no warn')),
     ).toThrow(/Err/u);
+
     expect(() =>
       TernaryResult.unwrapErrThrow(TernaryResult.ok('no err')),
     ).toThrow(/Ok/u);
@@ -146,6 +184,7 @@ describe('TernaryResult test', () => {
 
   test('expectToBe unwraps Ok values', () => {
     expect(TernaryResult.expectToBe(TernaryResult.ok('v'), 'msg')).toBe('v');
+
     expect(() =>
       TernaryResult.expectToBe(TernaryResult.err('x'), 'missing'),
     ).toThrow(/missing/u);
@@ -153,22 +192,28 @@ describe('TernaryResult test', () => {
 
   test('zip prefers Err over Warn or Ok.', () => {
     const ok = TernaryResult.ok('x');
+
     const warn = TernaryResult.warn('warn', 'warned');
+
     const err = TernaryResult.err('err');
 
     assert.deepStrictEqual(
       TernaryResult.zip(ok, TernaryResult.ok(1)),
       TernaryResult.ok(['x', 1] as const),
     );
+
     assert.deepStrictEqual(
       TernaryResult.zip(ok, warn),
       TernaryResult.warn(['x', 'warn'] as const, 'warned'),
     );
+
     assert.deepStrictEqual(
       TernaryResult.zip(warn, ok),
       TernaryResult.warn(['warn', 'x'] as const, 'warned'),
     );
+
     assert.deepStrictEqual(TernaryResult.zip(ok, err), err);
+
     assert.deepStrictEqual(TernaryResult.zip(err, warn), err);
   });
 
@@ -177,6 +222,7 @@ describe('TernaryResult test', () => {
       TernaryResult.toOptional(TernaryResult.ok(1)),
       Optional.some(1),
     );
+
     assert.deepStrictEqual(
       TernaryResult.toOptional(TernaryResult.warn(1, 'warn')),
       Optional.some(1),
@@ -211,4 +257,49 @@ describe('TernaryResult test', () => {
 
     expect(TernaryResult.isErr(errorResult)).toBe(true);
   });
+
+  test('unwrapOkOr curried version', () => {
+    const unwrap = TernaryResult.unwrapOkOr(999);
+
+    expect(unwrap(TernaryResult.ok(42))).toBe(42);
+
+    expect(unwrap(TernaryResult.warn(10, 'notice'))).toBe(10);
+
+    expect(unwrap(TernaryResult.err('error'))).toBe(999);
+  });
+
+  test('unwrapWarnOr curried version', () => {
+    const unwrap = TernaryResult.unwrapWarnOr('default');
+
+    expect(unwrap(TernaryResult.warn(1, 'alert'))).toBe('alert');
+
+    expect(unwrap(TernaryResult.ok(5))).toBe('default');
+
+    expect(unwrap(TernaryResult.err('fail'))).toBe('default');
+  });
+
+  test('unwrapErrOr curried version', () => {
+    const unwrap = TernaryResult.unwrapErrOr('fallback');
+
+    expect(unwrap(TernaryResult.err('bad'))).toBe('bad');
+
+    expect(unwrap(TernaryResult.ok(3))).toBe('fallback');
+
+    expect(unwrap(TernaryResult.warn(1, 'note'))).toBe('fallback');
+  });
+
+  test('orElse curried version', () => {
+    const fallback = TernaryResult.ok('backup');
+
+    const useBackup = TernaryResult.orElse(fallback);
+
+    assert.deepStrictEqual(useBackup(TernaryResult.ok(1)), TernaryResult.ok(1));
+
+    assert.deepStrictEqual(
+      useBackup(TernaryResult.warn(2, 'w')),
+      TernaryResult.warn(2, 'w'),
+    );
+
+    assert.deepStrictEqual(useBackup(TernaryResult.err('e')), fallback);
+  });
 });