fix: unwrap Result typed objects

Author: johannschopplich

README.md

@@ -82,6 +82,12 @@ type Result<T, E> = Ok<T> | Err<E>
 
 The `Ok` type wraps a successful value.
 
+**Example:**
+
+```ts
+const result = new Ok(42)
+```
+
 **Type Definition:**
 
 ```ts
@@ -92,16 +98,16 @@ declare class Ok<T> {
 }
 ```
 
+### `Err`
+
+The `Err` type wraps an error value.
+
 **Example:**
 
 ```ts
-const result = new Ok(42)
+const result = new Err('Something went wrong')
 ```
 
-### `Err`
-
-The `Err` type wraps an error value.
-
 **Type Definition:**
 
 ```ts
@@ -112,12 +118,6 @@ declare class Err<E> {
 }
 ```
 
-**Example:**
-
-```ts
-const result = new Err('Something went wrong')
-```
-
 ### `ok`
 
 Shorthand function to create an `Ok` result. Use it to wrap a successful value.
@@ -152,20 +152,21 @@ function trySafe<T, E = unknown>(promise: Promise<T>): Promise<Result<T, E>>
 
 ### `unwrap`
 
-Unwraps a `Result` and returns a tuple with the value and error: `{ value, error }`.
+Unwraps a `Result`, `Ok`, or `Err` value and returns the value or error in an object. If the result is an `Ok`, the object contains the value and an `undefined` error. If the result is an `Err`, the object contains an `undefined` value and the error.
 
-**Type Definition:**
+**Example:**
 
 ```ts
-function unwrap<T>(result: Ok<T>): { value: T, error: undefined }
-function unwrap<E>(result: Err<E>): { value: undefined, error: E }
+const result = trySafe(() => JSON.parse('{"foo":"bar"}'))
+const { value, error } = unwrap(result)
 ```
 
-**Example:**
+**Type Definition:**
 
 ```ts
-const result = trySafe(() => JSON.parse('{"foo":"bar"}'))
-const { value, error } = unwrap(result)
+function unwrap<T>(result: Ok<T>): { value: T, error: undefined }
+function unwrap<E>(result: Err<E>): { value: undefined, error: E }
+function unwrap<T, E>(result: Result<T, E>): { value: T, error: undefined } | { value: undefined, error: E }
 ```
 
 ## Examples

src/index.ts

@@ -42,6 +42,7 @@ export function trySafe<T, E = unknown>(
 
 export function unwrap<T>(result: Ok<T>): { value: T, error: undefined }
 export function unwrap<E>(result: Err<E>): { value: undefined, error: E }
+export function unwrap<T, E>(result: Result<T, E>): { value: T, error: undefined } | { value: undefined, error: E }
 export function unwrap<T, E>(
   result: Result<T, E>,
 ): { value: T, error: undefined } | { value: undefined, error: E } {

test/index.test.ts

@@ -29,14 +29,14 @@ describe('result type tests', () => {
   })
 
   it('handles failed synchronous operations', () => {
-    const result = trySafe(() => {
+    const result = trySafe<never, Error>(() => {
       throw new Error('test')
     })
     expect(result).toBeInstanceOf(Err)
     assertErr(result)
     expect(result.error).toBeInstanceOf(Error)
-    expect((result as Err<Error>).error.message).toBe('test')
-    expectTypeOf(result).toMatchTypeOf<Err< unknown>>()
+    expect(result.error.message).toBe('test')
+    expectTypeOf(result).toMatchTypeOf<Err<unknown>>()
   })
 
   it('handles successful asynchronous operations', async () => {
@@ -48,11 +48,11 @@ describe('result type tests', () => {
   })
 
   it('handles failed asynchronous operations', async () => {
-    const result = await trySafe(Promise.reject(new Error('test')))
+    const result = await trySafe<never, Error>(Promise.reject(new Error('test')))
     expect(result).toBeInstanceOf(Err)
     assertErr(result)
     expect(result.error).toBeInstanceOf(Error)
-    expect((result as Err<Error>).error.message).toBe('test')
+    expect(result.error.message).toBe('test')
     expectTypeOf(result).toMatchTypeOf<Err<unknown>>()
   })
 
@@ -84,19 +84,26 @@ describe('result type tests', () => {
   })
 
   it('unwraps an Ok result', () => {
-    const result = ok(42)
+    const result = ok(1)
     const unwrapped = unwrap(result)
-    expect(unwrapped).toEqual({ value: 42, error: undefined })
+    expect(unwrapped).toEqual({ value: 1, error: undefined })
     expectTypeOf(unwrapped).toMatchTypeOf<{ value: number, error: undefined }>()
   })
 
   it('unwraps an Err result', () => {
-    const error = new Error('test error')
+    const error = new Error('test')
     const result = err(error)
     const unwrapped = unwrap(result)
     expect(unwrapped).toEqual({ value: undefined, error })
     expectTypeOf(unwrapped).toMatchTypeOf<{ value: undefined, error: Error }>()
   })
+
+  it('unwraps a result with type inference', () => {
+    const result = trySafe(() => 1)
+    const unwrapped = unwrap(result)
+    expect(unwrapped).toEqual({ value: 1, error: undefined })
+    expectTypeOf(unwrapped).toMatchTypeOf<{ value: unknown, error: unknown }>()
+  })
 })
 
 function assertOk<T, E>(result: Result<T, E>): asserts result is Ok<T> {