ts-data-forge 5.0.1 → 5.1.1

package/src/functional/result.test.mts

@@ -8,8 +8,10 @@ describe('Result test', () => {
     test('creates Ok result', () => {
       const result = Result.ok(42);
 
-      expect(Result.isOk(result)).toBe(true);
-      expect(Result.isErr(result)).toBe(false);
+      assert.isTrue(Result.isOk(result));
+
+      assert.isFalse(Result.isErr(result));
+
       expect(result.value).toBe(42);
 
       expectType<typeof result, Result<number, never>>('<=');
@@ -18,7 +20,8 @@ describe('Result test', () => {
     test('creates Ok result with string', () => {
       const result = Result.ok('success');
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
+
       expect(result.value).toBe('success');
 
       expectType<typeof result, Result<string, never>>('<=');
@@ -29,8 +32,10 @@ describe('Result test', () => {
     test('creates Err result', () => {
       const result = Result.err('error message');
 
-      expect(Result.isErr(result)).toBe(true);
-      expect(Result.isOk(result)).toBe(false);
+      assert.isTrue(Result.isErr(result));
+
+      assert.isFalse(Result.isOk(result));
+
       expect(result.value).toBe('error message');
 
       expectType<typeof result, Result<never, string>>('<=');
@@ -39,7 +44,8 @@ describe('Result test', () => {
     test('creates Err result with number', () => {
       const result = Result.err(404);
 
-      expect(Result.isErr(result)).toBe(true);
+      assert.isTrue(Result.isErr(result));
+
       expect(result.value).toBe(404);
 
       expectType<typeof result, Result<never, number>>('<=');
@@ -49,6 +55,7 @@ describe('Result test', () => {
   describe('isOk', () => {
     test('type guard for Ok results', () => {
       const result: Result<number, string> = Result.ok(42);
+
       if (Result.isOk(result)) {
         expectType<typeof result, Ok<number>>('<=');
 
@@ -59,13 +66,14 @@ describe('Result test', () => {
     test('returns false for Err results', () => {
       const result: Result<number, string> = Result.err('error');
 
-      expect(Result.isOk(result)).toBe(false);
+      assert.isFalse(Result.isOk(result));
     });
   });
 
   describe('isErr', () => {
     test('type guard for Err results', () => {
       const result: Result<number, string> = Result.err('error');
+
       if (Result.isErr(result)) {
         expectType<typeof result, Err<string>>('<=');
 
@@ -76,7 +84,7 @@ describe('Result test', () => {
     test('returns false for Ok results', () => {
       const result: Result<number, string> = Result.ok(42);
 
-      expect(Result.isErr(result)).toBe(false);
+      assert.isFalse(Result.isErr(result));
     });
   });
 
@@ -84,47 +92,52 @@ describe('Result test', () => {
     test('recognizes Ok results', () => {
       const result = Result.ok(42);
 
-      expect(Result.isResult(result)).toBe(true);
+      assert.isTrue(Result.isResult(result));
     });
 
     test('recognizes Err results', () => {
       const result = Result.err('error');
 
-      expect(Result.isResult(result)).toBe(true);
+      assert.isTrue(Result.isResult(result));
     });
 
     test('rejects non-Result values', () => {
-      expect(Result.isResult(42)).toBe(false);
-      expect(Result.isResult('string')).toBe(false);
-      expect(Result.isResult(null)).toBe(false);
-      expect(Result.isResult(undefined)).toBe(false);
-      expect(Result.isResult({})).toBe(false);
-      expect(Result.isResult({ type: 'unknown', value: 42 })).toBe(false);
+      assert.isFalse(Result.isResult(42));
+
+      assert.isFalse(Result.isResult('string'));
+
+      assert.isFalse(Result.isResult(null));
+
+      assert.isFalse(Result.isResult(undefined));
+
+      assert.isFalse(Result.isResult({}));
+
+      assert.isFalse(Result.isResult({ type: 'unknown', value: 42 }));
     });
   });
 
   describe('map', () => {
     test('maps Ok result', () => {
       const result = Result.ok(5);
+
       const mapped = Result.map(result, (x) => x * 2);
 
-      expect(Result.isOk(mapped)).toBe(true);
+      assert.isTrue(Result.isOk(mapped));
+
+      expect(mapped.value).toBe(10);
 
-      if (Result.isOk(mapped)) {
-        expect(mapped.value).toBe(10);
-      }
       expectType<typeof mapped, Result<number, never>>('<=');
     });
 
     test('preserves Err result', () => {
       const result: Result<number, string> = Result.err('error');
+
       const mapped = Result.map(result, (x) => x * 2);
 
-      expect(Result.isErr(mapped)).toBe(true);
+      assert.isTrue(Result.isErr(mapped));
+
+      expect(mapped.value).toBe('error');
 
-      if (Result.isErr(mapped)) {
-        expect(mapped.value).toBe('error');
-      }
       expectType<typeof mapped, Result<number, string>>('<=');
     });
 
@@ -132,104 +145,99 @@ describe('Result test', () => {
       const doubler = Result.map((x: number) => x * 2);
 
       const okResult = Result.ok(5);
+
       const mapped = doubler(okResult);
 
-      expect(Result.isOk(mapped)).toBe(true);
+      assert.isTrue(Result.isOk(mapped));
 
-      if (Result.isOk(mapped)) {
-        expect(mapped.value).toBe(10);
-      }
+      expect(mapped.value).toBe(10);
 
       const errResult: Result<number, string> = Result.err('error');
+
       const mappedErr = doubler(errResult);
 
-      expect(Result.isErr(mappedErr)).toBe(true);
+      assert.isTrue(Result.isErr(mappedErr));
 
-      if (Result.isErr(mappedErr)) {
-        expect(mappedErr.value).toBe('error');
-      }
+      expect(mappedErr.value).toBe('error');
     });
 
     test('should work with pipe when curried', () => {
       const doubler = Result.map((x: number) => x * 2);
+
       const toStringFn = Result.map((x: number) => x.toString());
 
       const result = pipe(Result.ok(5)).map(doubler).map(toStringFn).value;
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
 
-      if (Result.isOk(result)) {
-        expect(result.value).toBe('10');
-      }
+      expect(result.value).toBe('10');
     });
   });
 
   describe('mapErr', () => {
     test('maps Err result', () => {
       const result: Result<number, string> = Result.err('error');
+
       const mapped = Result.mapErr(result, (e) => e.toUpperCase());
 
-      expect(Result.isErr(mapped)).toBe(true);
+      assert.isTrue(Result.isErr(mapped));
+
+      expect(mapped.value).toBe('ERROR');
 
-      if (Result.isErr(mapped)) {
-        expect(mapped.value).toBe('ERROR');
-      }
       expectType<typeof mapped, Result<number, string>>('<=');
     });
 
     test('preserves Ok result', () => {
       const result: Result<number, string> = Result.ok(42);
+
       const mapped = Result.mapErr(result, (e: string) => e.toUpperCase());
 
-      expect(Result.isOk(mapped)).toBe(true);
+      assert.isTrue(Result.isOk(mapped));
 
-      if (Result.isOk(mapped)) {
-        expect(mapped.value).toBe(42);
-      }
-      expectType<typeof mapped, Result<number, string>>('~=');
+      expect(mapped.value).toBe(42);
+
+      expectType<typeof mapped, Ok<number>>('=');
     });
 
     test('should support curried form', () => {
       const errorUppercase = Result.mapErr((e: string) => e.toUpperCase());
 
       const errResult: Result<number, string> = Result.err('error');
+
       const mapped = errorUppercase(errResult);
 
-      expect(Result.isErr(mapped)).toBe(true);
+      assert.isTrue(Result.isErr(mapped));
 
-      if (Result.isErr(mapped)) {
-        expect(mapped.value).toBe('ERROR');
-      }
+      expect(mapped.value).toBe('ERROR');
 
       const okResult: Result<number, string> = Result.ok(42);
+
       const mappedOk = errorUppercase(okResult);
 
-      expect(Result.isOk(mappedOk)).toBe(true);
+      assert.isTrue(Result.isOk(mappedOk));
 
-      if (Result.isOk(mappedOk)) {
-        expect(mappedOk.value).toBe(42);
-      }
+      expect(mappedOk.value).toBe(42);
     });
 
     test('should work with pipe when curried', () => {
       const errorUppercase = Result.mapErr((e: string) => e.toUpperCase());
+
       const errorPrefix = Result.mapErr((e: string) => `ERROR: ${e}`);
 
       const result = pipe(Result.err('failed'))
         .map(errorUppercase)
         .map(errorPrefix).value;
 
-      expect(Result.isErr(result)).toBe(true);
+      assert.isTrue(Result.isErr(result));
 
-      if (Result.isErr(result)) {
-        expect(result.value).toBe('ERROR: FAILED');
-      }
+      expect(result.value).toBe('ERROR: FAILED');
     });
   });
 
   describe('unwrapThrow', () => {
     test('unwraps Ok result', () => {
       const result = Result.ok(42);
+
       const value = Result.unwrapThrow(result);
 
       expect(value).toBe(42);
@@ -247,6 +255,7 @@ describe('Result test', () => {
   describe('unwrapOkOr', () => {
     test('unwraps Ok result', () => {
       const result = Result.ok(42);
+
       const value = Result.unwrapOkOr(result, 0);
 
       expect(value).toBe(42);
@@ -256,6 +265,7 @@ describe('Result test', () => {
 
     test('returns default for Err result', () => {
       const result: Result<number, string> = Result.err('error');
+
       const value = Result.unwrapOkOr(result, 0);
 
       expect(value).toBe(0);
@@ -267,11 +277,13 @@ describe('Result test', () => {
       const unwrapWithDefault = Result.unwrapOkOr(42);
 
       const okResult = Result.ok(100);
+
       const successValue = unwrapWithDefault(okResult);
 
       expect(successValue).toBe(100);
 
       const errResult: Result<number, string> = Result.err('failed');
+
       const defaultValue = unwrapWithDefault(errResult);
 
       expect(defaultValue).toBe(42);
@@ -295,6 +307,7 @@ describe('Result test', () => {
   describe('unwrapErr', () => {
     test('unwraps Err result', () => {
       const result: Result<number, string> = Result.err('error');
+
       const value = Result.unwrapErr(result);
 
       expect(value).toBe('error');
@@ -317,34 +330,34 @@ describe('Result test', () => {
   describe('fold', () => {
     test('folds Ok result', () => {
       const result = Result.ok(42);
+
       const folded = Result.fold(
         result,
         (x) => x * 2,
         () => 0,
       );
 
-      expect(Result.isOk(folded)).toBe(true);
+      assert.isTrue(Result.isOk(folded));
 
-      if (Result.isOk(folded)) {
-        expect(folded.value).toBe(84);
-      }
-      expectType<typeof folded, Result<number, number>>('=');
+      expect(folded.value).toBe(84);
+
+      expectType<typeof folded, Ok<number>>('=');
     });
 
     test('folds Err result', () => {
       const result: Result<number, string> = Result.err('error');
+
       const folded = Result.fold(
         result,
         (x) => x * 2,
         (e) => e.length,
       );
 
-      expect(Result.isErr(folded)).toBe(true);
+      assert.isTrue(Result.isErr(folded));
 
-      if (Result.isErr(folded)) {
-        expect(folded.value).toBe(5); // length of 'error'
-      }
-      expectType<typeof folded, Result<number, number>>('=');
+      expect(folded.value).toBe(5); // length of 'error'
+
+      expectType<typeof folded, Err<number>>('=');
     });
 
     test('should support curried form', () => {
@@ -354,22 +367,20 @@ describe('Result test', () => {
       );
 
       const okResult = Result.ok(42);
+
       const foldedOk = folder(okResult);
 
-      expect(Result.isOk(foldedOk)).toBe(true);
+      assert.isTrue(Result.isOk(foldedOk));
 
-      if (Result.isOk(foldedOk)) {
-        expect(foldedOk.value).toBe(84);
-      }
+      expect(foldedOk.value).toBe(84);
 
       const errResult: Result<number, string> = Result.err('error');
+
       const foldedErr = folder(errResult);
 
-      expect(Result.isErr(foldedErr)).toBe(true);
+      assert.isTrue(Result.isErr(foldedErr));
 
-      if (Result.isErr(foldedErr)) {
-        expect(foldedErr.value).toBe(5);
-      }
+      expect(foldedErr.value).toBe(5);
     });
 
     test('should work with pipe when curried', () => {
@@ -380,19 +391,15 @@ describe('Result test', () => {
 
       const result = pipe(Result.ok(21)).map(folder).value;
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
 
-      if (Result.isOk(result)) {
-        expect(result.value).toBe(42);
-      }
+      expect(result.value).toBe(42);
 
       const errorResult = pipe(Result.err('error')).map(folder).value;
 
-      expect(Result.isErr(errorResult)).toBe(true);
+      assert.isTrue(Result.isErr(errorResult));
 
-      if (Result.isErr(errorResult)) {
-        expect(errorResult.value).toBe(0);
-      }
+      expect(errorResult.value).toBe(0);
     });
   });
 
@@ -403,23 +410,27 @@ describe('Result test', () => {
 
       const result = await Result.fromPromise(asyncFn());
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
+
       expect(Result.unwrapOk(result)).toBe(42);
     });
 
     test('handles async functions that reject', async () => {
       const error = new Error('Async error');
+
       const asyncFn = async (): Promise<number> =>
         Promise.reject(error).then(() => 42);
 
       const result = await Result.fromPromise(asyncFn());
 
-      expect(Result.isErr(result)).toBe(true);
+      assert.isTrue(Result.isErr(result));
+
       expect(Result.unwrapErr(result)).toBe(error);
     });
 
     test('works with different promise types', async () => {
       const stringPromise = Promise.resolve('hello');
+
       const result = await Result.fromPromise(stringPromise);
 
       expect(Result.unwrapOk(result)).toBe('hello');
@@ -456,6 +467,7 @@ describe('Result test', () => {
     test('should support chaining multiple flatMaps', () => {
       const parseNumber = (s: string): Result<number, string> => {
         const n = Number(s);
+
         return Number.isNaN(n) ? Result.err('Not a number') : Result.ok(n);
       };
 
@@ -481,35 +493,32 @@ describe('Result test', () => {
       const divideBy2 = Result.flatMap((x: number) => divide(x, 2));
 
       const okResult = Result.ok(10);
+
       const result = divideBy2(okResult);
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
 
-      if (Result.isOk(result)) {
-        expect(result.value).toBe(5);
-      }
+      expect(result.value).toBe(5);
 
       const divideByZero = Result.flatMap((x: number) => divide(x, 0));
+
       const errorResult = divideByZero(Result.ok(10));
 
-      expect(Result.isErr(errorResult)).toBe(true);
+      assert.isTrue(Result.isErr(errorResult));
 
-      if (Result.isErr(errorResult)) {
-        expect(errorResult.value).toBe('Division by zero');
-      }
+      expect(errorResult.value).toBe('Division by zero');
 
       const initialError = divideBy2(Result.err('initial error'));
 
-      expect(Result.isErr(initialError)).toBe(true);
+      assert.isTrue(Result.isErr(initialError));
 
-      if (Result.isErr(initialError)) {
-        expect(initialError.value).toBe('initial error');
-      }
+      expect(initialError.value).toBe('initial error');
     });
 
     test('should work with pipe when curried', () => {
       const parseNumber = (s: string): Result<number, string> => {
         const n = Number(s);
+
         return Number.isNaN(n) ? Result.err('Not a number') : Result.ok(n);
       };
 
@@ -517,32 +526,35 @@ describe('Result test', () => {
         n > 0 ? Result.ok(n * 2) : Result.err('Not positive');
 
       const parser = Result.flatMap(parseNumber);
+
       const doubler = Result.flatMap(doubleIfPositive);
 
       const result = pipe(Result.ok('42')).map(parser).map(doubler).value;
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
 
-      if (Result.isOk(result)) {
-        expect(result.value).toBe(84);
-      }
+      expect(result.value).toBe(84);
     });
   });
 
   describe('swap', () => {
     test('should swap Ok to Err', () => {
       const okResult = Result.ok(42);
+
       const swapped = Result.swap(okResult);
 
-      expect(Result.isErr(swapped)).toBe(true);
+      assert.isTrue(Result.isErr(swapped));
+
       expect(Result.unwrapErr(swapped)).toBe(42);
     });
 
     test('should swap Err to Ok', () => {
       const errResult = Result.err('error');
+
       const swapped = Result.swap(errResult);
 
-      expect(Result.isOk(swapped)).toBe(true);
+      assert.isTrue(Result.isOk(swapped));
+
       expect(Result.unwrapOk(swapped)).toBe('error');
     });
   });
@@ -550,17 +562,20 @@ describe('Result test', () => {
   describe('toOptional', () => {
     test('should convert Ok to Some-like', () => {
       const okResult = Result.ok(42);
+
       const optional = Result.toOptional(okResult);
 
-      expect(Optional.isSome(optional)).toBe(true);
+      assert.isTrue(Optional.isSome(optional));
+
       expect(Optional.unwrapThrow(optional)).toBe(42);
     });
 
     test('should convert Err to None-like', () => {
       const errResult = Result.err('error');
+
       const optional = Result.toOptional(errResult);
 
-      expect(Optional.isNone(optional)).toBe(true);
+      assert.isTrue(Optional.isNone(optional));
     });
   });
 
@@ -591,6 +606,7 @@ describe('Result test', () => {
   describe('unwrapErrOr', () => {
     test('should return error value for Err result', () => {
       const result = Result.err('error message');
+
       const value = Result.unwrapErrOr(result, 'default');
 
       expect(value).toBe('error message');
@@ -598,6 +614,7 @@ describe('Result test', () => {
 
     test('should return default value for Ok result', () => {
       const result = Result.ok(42);
+
       const value = Result.unwrapErrOr(result, 'default');
 
       expect(value).toBe('default');
@@ -607,11 +624,13 @@ describe('Result test', () => {
       const unwrapErrorWithDefault = Result.unwrapErrOr('unknown error');
 
       const errResult: Result<number, string> = Result.err('failed');
+
       const errorValue = unwrapErrorWithDefault(errResult);
 
       expect(errorValue).toBe('failed');
 
       const okResult: Result<number, string> = Result.ok(42);
+
       const defaultValue = unwrapErrorWithDefault(okResult);
 
       expect(defaultValue).toBe('unknown error');
@@ -637,6 +656,7 @@ describe('Result test', () => {
   describe('expectToBe', () => {
     test('should return value for Ok result', () => {
       const result = Result.ok(42);
+
       const value = Result.expectToBe(result, 'Expected valid number');
 
       expect(value).toBe(42);
@@ -654,6 +674,7 @@ describe('Result test', () => {
       const mustBeOk = Result.expectToBe('Expected successful result');
 
       const okResult = Result.ok('success');
+
       const value = mustBeOk(okResult);
 
       expect(value).toBe('success');
@@ -679,7 +700,9 @@ describe('Result test', () => {
   describe('orElse', () => {
     test('should return the first Result if it is Ok', () => {
       const primary = Result.ok(42);
+
       const fallback = Result.ok(100);
+
       const result = Result.orElse(primary, fallback);
 
       expect(Result.unwrapOk(result)).toBe(42);
@@ -687,7 +710,9 @@ describe('Result test', () => {
 
     test('should return the alternative if the first is Err', () => {
       const primary = Result.err('error');
+
       const fallback = Result.ok('default');
+
       const result = Result.orElse(primary, fallback);
 
       expect(Result.unwrapOk(result)).toBe('default');
@@ -695,7 +720,9 @@ describe('Result test', () => {
 
     test('should return Err if both are Err', () => {
       const primary = Result.err('error1');
+
       const fallback = Result.err('error2');
+
       const result = Result.orElse(primary, fallback);
 
       expect(Result.unwrapErr(result)).toBe('error2');
@@ -705,22 +732,20 @@ describe('Result test', () => {
       const fallbackTo = Result.orElse(Result.ok('fallback'));
 
       const okResult = Result.ok('primary');
+
       const result = fallbackTo(okResult);
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
 
-      if (Result.isOk(result)) {
-        expect(result.value).toBe('primary');
-      }
+      expect(result.value).toBe('primary');
 
       const errResult: Result<string, string> = Result.err('failed');
+
       const fallbackResult = fallbackTo(errResult);
 
-      expect(Result.isOk(fallbackResult)).toBe(true);
+      assert.isTrue(Result.isOk(fallbackResult));
 
-      if (Result.isOk(fallbackResult)) {
-        expect(fallbackResult.value).toBe('fallback');
-      }
+      expect(fallbackResult.value).toBe('fallback');
     });
 
     test('should work with pipe when curried', () => {
@@ -728,26 +753,24 @@ describe('Result test', () => {
 
       const okResult = pipe(Result.ok('original')).map(fallbackTo).value;
 
-      expect(Result.isOk(okResult)).toBe(true);
+      assert.isTrue(Result.isOk(okResult));
 
-      if (Result.isOk(okResult)) {
-        expect(okResult.value).toBe('original');
-      }
+      expect(okResult.value).toBe('original');
 
       const errResult = pipe(Result.err('network error')).map(fallbackTo).value;
 
-      expect(Result.isOk(errResult)).toBe(true);
+      assert.isTrue(Result.isOk(errResult));
 
-      if (Result.isOk(errResult)) {
-        expect(errResult.value).toBe('backup');
-      }
+      expect(errResult.value).toBe('backup');
     });
   });
 
   describe('zip', () => {
     test('should combine two Ok values into a tuple', () => {
       const a = Result.ok(1);
+
       const b = Result.ok('hello');
+
       const zipped = Result.zip(a, b);
 
       assert.deepStrictEqual(Result.unwrapOk(zipped), [1, 'hello']);
@@ -755,7 +778,9 @@ describe('Result test', () => {
 
     test('should return first Err if first is Err', () => {
       const a = Result.err('error1');
+
       const b = Result.ok('hello');
+
       const zipped = Result.zip(a, b);
 
       expect(Result.unwrapErr(zipped)).toBe('error1');
@@ -763,7 +788,9 @@ describe('Result test', () => {
 
     test('should return second Err if second is Err', () => {
       const a = Result.ok(1);
+
       const b = Result.err('error2');
+
       const zipped = Result.zip(a, b);
 
       expect(Result.unwrapErr(zipped)).toBe('error2');
@@ -771,7 +798,9 @@ describe('Result test', () => {
 
     test('should return first Err if both are Err', () => {
       const a = Result.err('error1');
+
       const b = Result.err('error2');
+
       const zipped = Result.zip(a, b);
 
       expect(Result.unwrapErr(zipped)).toBe('error1');
@@ -782,7 +811,8 @@ describe('Result test', () => {
     test('should return Ok when function succeeds', () => {
       const result = Result.fromThrowable(() => 42);
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
+
       expect(Result.unwrapOk(result)).toBe(42);
 
       expectType<typeof result, Result<number, Error>>('<=');
@@ -790,44 +820,45 @@ describe('Result test', () => {
 
     test('should return Ok with object when function succeeds', () => {
       const obj = { name: 'test', value: 123 };
+
       const result = Result.fromThrowable(() => obj);
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
 
       assert.deepStrictEqual(Result.unwrapOk(result), obj);
     });
 
     test('should return Err when function throws Error', () => {
       const errorMessage = 'Something went wrong';
+
       const result = Result.fromThrowable(() => {
         throw new Error(errorMessage);
       });
 
-      expect(Result.isErr(result)).toBe(true);
+      assert.isTrue(Result.isErr(result));
 
-      if (Result.isErr(result)) {
-        const error = result.value;
+      const error = result.value;
 
-        expect(error).toBeInstanceOf(Error);
-        expect(error.message).toBe(errorMessage);
-      }
+      expect(error).toBeInstanceOf(Error);
+
+      expect(error.message).toBe(errorMessage);
     });
 
     test('should return Err when function throws string', () => {
       const errorMessage = 'String error';
+
       const result = Result.fromThrowable(() => {
         // eslint-disable-next-line @typescript-eslint/only-throw-error
         throw errorMessage;
       });
 
-      expect(Result.isErr(result)).toBe(true);
+      assert.isTrue(Result.isErr(result));
 
-      if (Result.isErr(result)) {
-        const error = result.value;
+      const error = result.value;
 
-        expect(error).toBeInstanceOf(Error);
-        expect(error.message).toBe(errorMessage);
-      }
+      expect(error).toBeInstanceOf(Error);
+
+      expect(error.message).toBe(errorMessage);
     });
 
     test('should return Err when function throws non-string primitive', () => {
@@ -836,37 +867,35 @@ describe('Result test', () => {
         throw 404;
       });
 
-      expect(Result.isErr(result)).toBe(true);
+      assert.isTrue(Result.isErr(result));
 
-      if (Result.isErr(result)) {
-        const error = result.value;
+      const error = result.value;
 
-        expect(error).toBeInstanceOf(Error);
-        expect(error.message).toBe('404');
-      }
+      expect(error).toBeInstanceOf(Error);
+
+      expect(error.message).toBe('404');
     });
 
     test('should work with JSON.parse', () => {
       const validJson = '{"key": "value"}';
+
       const invalidJson = '{invalid json}';
 
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       const validResult = Result.fromThrowable(() => JSON.parse(validJson));
 
-      expect(Result.isOk(validResult)).toBe(true);
+      assert.isTrue(Result.isOk(validResult));
 
       assert.deepStrictEqual(Result.unwrapOk(validResult), { key: 'value' });
 
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       const invalidResult = Result.fromThrowable(() => JSON.parse(invalidJson));
 
-      expect(Result.isErr(invalidResult)).toBe(true);
+      assert.isTrue(Result.isErr(invalidResult));
 
-      if (Result.isErr(invalidResult)) {
-        const error = invalidResult.value;
+      const error = invalidResult.value;
 
-        expect(error).toBeInstanceOf(Error);
-      }
+      expect(error).toBeInstanceOf(Error);
     });
 
     test('should work with array access', () => {
@@ -875,20 +904,21 @@ describe('Result test', () => {
       // This won't throw, but demonstrates the pattern
       const result = Result.fromThrowable(() => {
         const index = 5;
+
         const value = arr[index];
+
         if (value === undefined) {
           throw new Error('Index out of bounds');
         }
+
         return value;
       });
 
-      expect(Result.isErr(result)).toBe(true);
+      assert.isTrue(Result.isErr(result));
 
-      if (Result.isErr(result)) {
-        const error = result.value;
+      const error = result.value;
 
-        expect(error.message).toBe('Index out of bounds');
-      }
+      expect(error.message).toBe('Index out of bounds');
     });
 
     test('should preserve function return type', () => {