fix: type narrowing

src/result.test.ts

@@ -1,4 +1,4 @@
-import { expect, test, describe, beforeEach } from 'vitest';
+import { expect, test, describe, expectTypeOf } from 'vitest';
 import { Result } from './result';
 
 describe('Result', () => {
@@ -43,4 +43,38 @@ describe('Result', () => {
       expect(result.getError()).toBe(error);
     });
   });
+
+  describe('Type narrowing', () => {
+    const createResult = (valid: boolean): Result<number> => {
+      return valid ? Result.ok(10) : Result.error(new Error('message'));
+    };
+
+    test('isOk() narrows both branches', () => {
+      for (const valid of [true, false]) {
+        const result = createResult(valid);
+
+        if (result.isOk()) {
+          expectTypeOf(result.getValue()).toEqualTypeOf<number>();
+          expect(result.getValue()).toBe(10);
+        } else {
+          expectTypeOf(result.getError()).toEqualTypeOf<Error>();
+          expect(result.getError()).toBeInstanceOf(Error);
+        }
+      }
+    });
+
+    test('isError() narrows both branches', () => {
+      for (const valid of [true, false]) {
+        const result = createResult(valid);
+
+        if (result.isError()) {
+          expectTypeOf(result.getError()).toEqualTypeOf<Error>();
+          expect(result.getError()).toBeInstanceOf(Error);
+        } else {
+          expectTypeOf(result.getValue()).toEqualTypeOf<number>();
+          expect(result.getValue()).toBe(10);
+        }
+      }
+    });
+  });
 });

src/result.ts

@@ -1,4 +1,16 @@
-export class Result<T> {
+interface Ok<T> extends ResultImpl<T> {
+  getValue(): T;
+  getError(): undefined;
+}
+
+interface Err<T> extends ResultImpl<T> {
+  getValue(): undefined;
+  getError(): Error;
+}
+
+export type Result<T> = Ok<T> | Err<T>;
+
+class ResultImpl<T> {
   private readonly ok: boolean;
   private readonly value?: T | undefined;
   private readonly error?: Error | undefined;
@@ -10,18 +22,18 @@ export class Result<T> {
   }
 
   static ok<T>(value?: T): Result<T> {
-    return new Result<T>(true, value);
+    return new ResultImpl<T>(true, value) as Result<T>;
   }
 
   static error<T>(error: Error): Result<T> {
-    return new Result<T>(false, undefined, error);
+    return new ResultImpl<T>(false, undefined, error) as Result<T>;
   }
 
-  isOk(): boolean {
+  isOk(): this is Ok<T> {
     return this.ok;
   }
 
-  isError(): boolean {
+  isError(): this is Err<T> {
     return !this.ok;
   }
 
@@ -33,3 +45,5 @@ export class Result<T> {
     return this.error;
   }
 }
+
+export const Result = ResultImpl;