go-go-try 6.1.0 → 6.2.0

package/dist/index.d.cts

@@ -26,6 +26,8 @@ declare function failure<E>(error: E): Failure<E>;
  * // With a promise
  * const [err, result] = await goTry(fetch('https://api.example.com/data'));
  */
+declare function goTry<T>(fn: () => never): Result<string, never>;
+declare function goTry<T>(fn: () => Promise<T>): Promise<Result<string, T>>;
 declare function goTry<T>(promise: Promise<T>): Promise<Result<string, T>>;
 declare function goTry<T>(fn: () => T): Result<string, T>;
 declare function goTry<T>(value: T): Result<string, T>;
@@ -50,6 +52,8 @@ declare function goTry<T>(value: T): Result<string, T>;
  * // With a promise
  * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
  */
+declare function goTryRaw<T, E = Error>(fn: () => never): Result<E, never>;
+declare function goTryRaw<T, E = Error>(fn: () => Promise<T>): Promise<Result<E, T>>;
 declare function goTryRaw<T, E = Error>(promise: Promise<T>): Promise<Result<E, T>>;
 declare function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>;
 declare function goTryRaw<T, E = Error>(value: T): Result<E, T>;

package/dist/index.d.mts

@@ -26,6 +26,8 @@ declare function failure<E>(error: E): Failure<E>;
  * // With a promise
  * const [err, result] = await goTry(fetch('https://api.example.com/data'));
  */
+declare function goTry<T>(fn: () => never): Result<string, never>;
+declare function goTry<T>(fn: () => Promise<T>): Promise<Result<string, T>>;
 declare function goTry<T>(promise: Promise<T>): Promise<Result<string, T>>;
 declare function goTry<T>(fn: () => T): Result<string, T>;
 declare function goTry<T>(value: T): Result<string, T>;
@@ -50,6 +52,8 @@ declare function goTry<T>(value: T): Result<string, T>;
  * // With a promise
  * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
  */
+declare function goTryRaw<T, E = Error>(fn: () => never): Result<E, never>;
+declare function goTryRaw<T, E = Error>(fn: () => Promise<T>): Promise<Result<E, T>>;
 declare function goTryRaw<T, E = Error>(promise: Promise<T>): Promise<Result<E, T>>;
 declare function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>;
 declare function goTryRaw<T, E = Error>(value: T): Result<E, T>;

package/package.json

@@ -1,55 +1,55 @@
 {
-	"name": "go-go-try",
-	"version": "6.1.0",
-	"description": "Tries to execute a sync/async function, returns a result tuple",
-	"license": "MIT",
-	"repository": "thelinuxlich/go-go-try",
-	"author": {
-		"name": "Alisson Cavalcante Agiani",
-		"email": "thelinuxlich@gmail.com"
-	},
-	"type": "module",
-	"main": "./dist/index.cjs",
-	"module": "./dist/index.mjs",
-	"types": "./dist/index.d.mts",
-	"exports": {
-		"require": {
-			"types": "./dist/index.d.cts",
-			"default": "./dist/index.cjs"
-		},
-		"import": {
-			"types": "./dist/index.d.mts",
-			"default": "./dist/index.mjs"
-		}
-	},
-	"engines": {
-		"node": ">=16"
-	},
-	"scripts": {
-		"build": "pkgroll",
-		"lint": "biome lint --write src/*.ts",
-		"test": "npm run build && npm run lint && vitest run"
-	},
-	"keywords": [
-		"errors",
-		"try",
-		"catch",
-		"error handling",
-		"nice-try",
-		"good-try",
-		"neverthrow",
-		"ts-result",
-		"effect",
-		"go-go-try",
-		"gotry",
-		"go-try"
-	],
-	"devDependencies": {
-		"@ark/attest": "^0.46.0",
-		"@biomejs/biome": "^1.9.4",
-		"pkgroll": "^2.12.1",
-		"tsx": "^4.19.3",
-		"typescript": "^5.8.3",
-		"vitest": "^3.1.2"
-	}
+  "name": "go-go-try",
+  "version": "6.2.0",
+  "description": "Tries to execute a sync/async function, returns a result tuple",
+  "license": "MIT",
+  "repository": "thelinuxlich/go-go-try",
+  "author": {
+    "name": "Alisson Cavalcante Agiani",
+    "email": "thelinuxlich@gmail.com"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    },
+    "import": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "scripts": {
+    "build": "pkgroll",
+    "lint": "biome lint --write src/*.ts",
+    "test": "npm run build && npm run lint && vitest run"
+  },
+  "keywords": [
+    "errors",
+    "try",
+    "catch",
+    "error handling",
+    "nice-try",
+    "good-try",
+    "neverthrow",
+    "ts-result",
+    "effect",
+    "go-go-try",
+    "gotry",
+    "go-try"
+  ],
+  "devDependencies": {
+    "@ark/attest": "^0.46.0",
+    "@biomejs/biome": "^1.9.4",
+    "pkgroll": "^2.12.1",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  }
 }

package/src/index.test.ts

@@ -3,368 +3,398 @@ import { assert, describe, test } from 'vitest'
 import { type Result, goTry, goTryRaw, isFailure, isSuccess } from './index.js'
 
 test(`value returned by callback is used when callback doesn't throw`, async () => {
-	const fn = () => 'value'
-
-	// Test with function
-	const result1 = goTry(fn)
-	const result2 = goTryRaw(fn)
-
-	// Test destructuring
-	const [err1, value] = result1
-	const [err2, value2] = result2
-
-	// Test type guards
-	assert.equal(isSuccess(result1), true)
-	assert.equal(isSuccess(result2), true)
-	assert.equal(isFailure(result1), false)
-	assert.equal(isFailure(result2), false)
-
-	// Test values
-	assert.equal(value, 'value')
-	assert.equal(value2, 'value')
-	assert.equal(err1, undefined)
-	assert.equal(err2, undefined)
+  const fn = () => 'value'
+
+  // Test with function
+  const result1 = goTry(fn)
+  const result2 = goTryRaw(fn)
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test type guards
+  assert.equal(isSuccess(result1), true)
+  assert.equal(isSuccess(result2), true)
+  assert.equal(isFailure(result1), false)
+  assert.equal(isFailure(result2), false)
+
+  // Test values
+  assert.equal(value, 'value')
+  assert.equal(value2, 'value')
+  assert.equal(err1, undefined)
+  assert.equal(err2, undefined)
 })
 
 test('if function throws undefined, err should be "undefined"', async () => {
-	const fn = () => {
-		throw undefined
-	}
-
-	// Test with function that throws undefined
-	const result1 = goTry(fn)
-	const result2 = goTryRaw(fn)
-
-	// Test destructuring
-	const [err1, value] = result1
-	const [err2, value2] = result2
-
-	// Test type guards
-	assert.equal(isSuccess(result1), false)
-	assert.equal(isSuccess(result2), false)
-	assert.equal(isFailure(result1), true)
-	assert.equal(isFailure(result2), true)
-
-	// Test values
-	assert.equal(value, undefined)
-	assert.equal(value2, undefined)
-	assert.equal(err1, 'undefined')
-	assert.equal(typeof err2, 'object')
+  const fn = () => {
+    throw undefined
+  }
+
+  // Test with function that throws undefined
+  const result1 = goTry(fn)
+  const result2 = goTryRaw(fn)
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test type guards
+  assert.equal(isSuccess(result1), false)
+  assert.equal(isSuccess(result2), false)
+  assert.equal(isFailure(result1), true)
+  assert.equal(isFailure(result2), true)
+
+  // Test values
+  assert.equal(value, undefined)
+  assert.equal(value2, undefined)
+  assert.equal(err1, 'undefined')
+  assert.equal(typeof err2, 'object')
 })
 
 test('if callback throws, value should be undefined and err should contain the error message', async () => {
-	const fn = () => {
-		return JSON.parse('{/') as string
-	}
-
-	// Test with function that throws
-	const result1 = goTry(fn)
-	const result2 = goTryRaw(fn)
-
-	// Test destructuring
-	const [err1, value] = result1
-	const [err2, value2] = result2
-
-	// Test type guards
-	assert.equal(isSuccess(result1), false)
-	assert.equal(isSuccess(result2), false)
-	assert.equal(isFailure(result1), true)
-	assert.equal(isFailure(result2), true)
-
-	// Test values
-	assert.equal(value, undefined)
-	assert.equal(value2, undefined)
-	assert.equal(typeof err1, 'string')
-	assert.equal(typeof err2, 'object')
-	assert.equal(typeof err2?.message, 'string')
+  const fn = () => {
+    return JSON.parse('{/') as string
+  }
+
+  // Test with function that throws
+  const result1 = goTry(fn)
+  const result2 = goTryRaw(fn)
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test type guards
+  assert.equal(isSuccess(result1), false)
+  assert.equal(isSuccess(result2), false)
+  assert.equal(isFailure(result1), true)
+  assert.equal(isFailure(result2), true)
+
+  // Test values
+  assert.equal(value, undefined)
+  assert.equal(value2, undefined)
+  assert.equal(typeof err1, 'string')
+  assert.equal(typeof err2, 'object')
+  assert.equal(typeof err2?.message, 'string')
 })
 
 test('first parameter accepts promises and makes the function async', async () => {
-	const promise = Promise.resolve('value')
-
-	// Test with promise
-	const result1 = await goTry(promise)
-	const result2 = await goTryRaw(promise)
-
-	// Test destructuring
-	const [err1, value] = result1
-	const [err2, value2] = result2
-
-	// Test type guards
-	assert.equal(isSuccess(result1), true)
-	assert.equal(isSuccess(result2), true)
-	assert.equal(isFailure(result1), false)
-	assert.equal(isFailure(result2), false)
-
-	// Test values
-	assert.equal(value, 'value')
-	assert.equal(value2, 'value')
-	assert.equal(err1, undefined)
-	assert.equal(err2, undefined)
+  const promise = Promise.resolve('value')
+
+  // Test with promise
+  const result1 = await goTry(promise)
+  const result2 = await goTryRaw(promise)
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test type guards
+  assert.equal(isSuccess(result1), true)
+  assert.equal(isSuccess(result2), true)
+  assert.equal(isFailure(result1), false)
+  assert.equal(isFailure(result2), false)
+
+  // Test values
+  assert.equal(value, 'value')
+  assert.equal(value2, 'value')
+  assert.equal(err1, undefined)
+  assert.equal(err2, undefined)
+})
+
+test("if it's a function returning a Promise, should unwrap the value correctly to T", async () => {
+  const fn = () => Promise.resolve('value')
+
+  // Test with function that returns a promise
+  const result1 = await goTry(fn)
+  const result2 = await goTryRaw(fn)
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  attest<string | undefined>(err1)
+  attest<string | undefined>(value)
+
+  attest<Error | undefined>(err2)
+  attest<string | undefined>(value2)
+
+  // Test type guards
+  assert.equal(isSuccess(result1), true)
+  assert.equal(isSuccess(result2), true)
+  assert.equal(isFailure(result1), false)
+  assert.equal(isFailure(result2), false)
+
+  // Test values
+  assert.equal(value, 'value')
+  assert.equal(value2, 'value')
+  assert.equal(err1, undefined)
+  assert.equal(err2, undefined)
 })
 
 test('if async callback throws, value should be undefined and err should contain the error message', async () => {
-	const promise = Promise.reject(new Error('error'))
-
-	// Test with promise that rejects
-	const result1 = await goTry(promise)
-	const result2 = await goTryRaw<Error>(promise)
-
-	// Test destructuring
-	const [err, value] = result1
-	const [err2, value2] = result2
-
-	// Test type guards
-	assert.equal(isSuccess(result1), false)
-	assert.equal(isSuccess(result2), false)
-	assert.equal(isFailure(result1), true)
-	assert.equal(isFailure(result2), true)
-
-	// Test values
-	assert.equal(value, undefined)
-	assert.equal(value2, undefined)
-	assert.equal(err, 'error')
-	assert.equal(typeof err2, 'object')
-	assert.equal(err2?.message, 'error')
+  const promise = Promise.reject(new Error('error'))
+
+  // Test with promise that rejects
+  const result1 = await goTry(promise)
+  const result2 = await goTryRaw<Error>(promise)
+
+  // Test destructuring
+  const [err, value] = result1
+  const [err2, value2] = result2
+
+  // Test type guards
+  assert.equal(isSuccess(result1), false)
+  assert.equal(isSuccess(result2), false)
+  assert.equal(isFailure(result1), true)
+  assert.equal(isFailure(result2), true)
+
+  // Test values
+  assert.equal(value, undefined)
+  assert.equal(value2, undefined)
+  assert.equal(err, 'error')
+  assert.equal(typeof err2, 'object')
+  assert.equal(err2?.message, 'error')
 })
 
 test('direct values work too', () => {
-	// Test with direct value
-	const result1 = goTry('value')
-	const result2 = goTryRaw('value')
-
-	// Test destructuring
-	const [err1, value] = result1
-	const [err2, value2] = result2
-
-	// Test values
-	assert.equal(value, 'value')
-	assert.equal(value2, 'value')
-	assert.equal(err1, undefined)
-	assert.equal(err2, undefined)
+  // Test with direct value
+  const result1 = goTry('value')
+  const result2 = goTryRaw('value')
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test values
+  assert.equal(value, 'value')
+  assert.equal(value2, 'value')
+  assert.equal(err1, undefined)
+  assert.equal(err2, undefined)
 })
 
 test('async functions work correctly', async () => {
-	// Define an async function
-	function asyncFn() {
-		return Promise.resolve(42)
-	}
-
-	// Test with async function
-	const result1 = await goTry(asyncFn())
-	const result2 = await goTryRaw(asyncFn())
-
-	// Test destructuring
-	const [err1, value] = result1
-	const [err2, value2] = result2
-
-	// Test values
-	assert.equal(value, 42)
-	assert.equal(value2, 42)
-	assert.equal(err1, undefined)
-	assert.equal(err2, undefined)
+  // Define an async function
+  function asyncFn() {
+    return Promise.resolve(42)
+  }
+
+  // Test with async function
+  const result1 = await goTry(asyncFn())
+  const result2 = await goTryRaw(asyncFn())
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test values
+  assert.equal(value, 42)
+  assert.equal(value2, 42)
+  assert.equal(err1, undefined)
+  assert.equal(err2, undefined)
 })
 
 test('async functions that throw work correctly', async () => {
-	// Define an async function that throws
-	async function asyncFnThatThrows() {
-		await 1
-		throw new Error('async error')
-	}
-
-	// Test with async function that throws
-	const result1 = await goTry(asyncFnThatThrows())
-	const result2 = await goTryRaw(asyncFnThatThrows())
-
-	// Test destructuring
-	const [err1, value] = result1
-	const [err2, value2] = result2
-
-	// Test values
-	assert.equal(value, undefined)
-	assert.equal(value2, undefined)
-	assert.equal(err1, 'async error')
-	assert.equal(typeof err2, 'object')
-	assert.equal(err2?.message, 'async error')
+  // Define an async function that throws
+  async function asyncFnThatThrows() {
+    await 1
+    throw new Error('async error')
+  }
+
+  // Test with async function that throws
+  const result1 = await goTry(asyncFnThatThrows())
+  const result2 = await goTryRaw(asyncFnThatThrows())
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test values
+  assert.equal(value, undefined)
+  assert.equal(value2, undefined)
+  assert.equal(err1, 'async error')
+  assert.equal(typeof err2, 'object')
+  assert.equal(err2?.message, 'async error')
 })
 
 describe('goTry type tests', () => {
-	test('synchronous function returns correct types', () => {
-		const fn = () => 'value'
-		const result = goTry(fn)
-
-		// Check the result type
-		attest<Result<string, string>>(result)
-
-		// Check the destructured types
-		const [err, value] = result
-		attest<string | undefined>(err)
-		attest<string | undefined>(value)
-
-		// When destructured, the types should be narrowed correctly
-		if (err === undefined) {
-			attest<string>(value)
-		} else {
-			attest<undefined>(value)
-		}
-	})
-
-	test('direct value returns correct types', () => {
-		const result = goTry('value')
-
-		// Check the result type
-		attest<Result<string, string>>(result)
-
-		// Check the destructured types
-		const [err, value] = result
-		attest<string | undefined>(err)
-		attest<string | undefined>(value)
-
-		// When destructured, the types should be narrowed correctly
-		if (err === undefined) {
-			attest<string>(value)
-		} else {
-			attest<undefined>(value)
-		}
-	})
-
-	test('promise returns correct types', async () => {
-		const promise = Promise.resolve('value')
-		const result = await goTry(promise)
-
-		// Check the result type
-		attest<Result<string, string>>(result)
-
-		// Check the destructured types
-		const [err, value] = result
-		attest<string | undefined>(err)
-		attest<string | undefined>(value)
-
-		// When destructured, the types should be narrowed correctly
-		if (err === undefined) {
-			attest<string>(value)
-		} else {
-			attest<undefined>(value)
-		}
-	})
-
-	test('async function returns correct types', async () => {
-		const asyncFn = async () => 'value'
-		const result = await goTry(asyncFn())
-
-		// Check the result type
-		attest<Result<string, string>>(result)
-
-		// Check the destructured types
-		const [err, value] = result
-		attest<string | undefined>(err)
-		attest<string | undefined>(value)
-
-		// When destructured, the types should be narrowed correctly
-		if (err === undefined) {
-			attest<string>(value)
-		} else {
-			attest<undefined>(value)
-		}
-	})
+  test('synchronous function returns correct types', () => {
+    const fn = () => 'value'
+    const result = goTry(fn)
+
+    // Check the result type
+    attest<Result<string, string>>(result)
+
+    // Check the destructured types
+    const [err, value] = result
+    attest<string | undefined>(err)
+    attest<string | undefined>(value)
+
+    // When destructured, the types should be narrowed correctly
+    if (err === undefined) {
+      attest<string>(value)
+    } else {
+      attest<undefined>(value)
+    }
+  })
+
+  test('direct value returns correct types', () => {
+    const result = goTry('value')
+
+    // Check the result type
+    attest<Result<string, string>>(result)
+
+    // Check the destructured types
+    const [err, value] = result
+    attest<string | undefined>(err)
+    attest<string | undefined>(value)
+
+    // When destructured, the types should be narrowed correctly
+    if (err === undefined) {
+      attest<string>(value)
+    } else {
+      attest<undefined>(value)
+    }
+  })
+
+  test('promise returns correct types', async () => {
+    const promise = Promise.resolve('value')
+    const result = await goTry(promise)
+
+    // Check the result type
+    attest<Result<string, string>>(result)
+
+    // Check the destructured types
+    const [err, value] = result
+    attest<string | undefined>(err)
+    attest<string | undefined>(value)
+
+    // When destructured, the types should be narrowed correctly
+    if (err === undefined) {
+      attest<string>(value)
+    } else {
+      attest<undefined>(value)
+    }
+  })
+
+  test('async function returns correct types', async () => {
+    const asyncFn = async () => 'value'
+    const result = await goTry(asyncFn())
+
+    // Check the result type
+    attest<Result<string, string>>(result)
+
+    // Check the destructured types
+    const [err, value] = result
+    attest<string | undefined>(err)
+    attest<string | undefined>(value)
+
+    // When destructured, the types should be narrowed correctly
+    if (err === undefined) {
+      attest<string>(value)
+    } else {
+      attest<undefined>(value)
+    }
+  })
 })
 
 describe('goTryRaw type tests', () => {
-	test('type inference works correctly', () => {
-		const fn = () => 'value'
-		const result = goTryRaw(fn)
-
-		// Check the result type
-		attest<Result<Error, string>>(result)
-
-		// Check the destructured types
-		const [err, value] = result
-		attest<Error | undefined>(err)
-		attest<string | undefined>(value)
-
-		// When destructured, the types should be narrowed correctly
-		if (err === undefined) {
-			attest<string>(value)
-		} else {
-			attest<undefined>(value)
-		}
-	})
-	test('synchronous function returns correct types', () => {
-		const fn = () => 'value'
-		const result = goTryRaw(fn)
-
-		// Check the result type
-		attest<Result<Error, string>>(result)
-
-		// Check the destructured types
-		const [err, value] = result
-		attest<Error | undefined>(err)
-		attest<string | undefined>(value)
-
-		// When destructured, the types should be narrowed correctly
-		if (err === undefined) {
-			attest<string>(value)
-		} else {
-			attest<undefined>(value)
-		}
-	})
-
-	test('direct value returns correct types', () => {
-		const result = goTryRaw('value')
-
-		// Check the result type
-		attest<Result<Error, string>>(result)
-
-		// Check the destructured types
-		const [err, value] = result
-		attest<Error | undefined>(err)
-		attest<string | undefined>(value)
-
-		// When destructured, the types should be narrowed correctly
-		if (err === undefined) {
-			attest<string>(value)
-		} else {
-			attest<undefined>(value)
-		}
-	})
-
-	test('promise returns correct types', async () => {
-		const promise = Promise.resolve('value')
-		const result = await goTryRaw(promise)
-
-		// Check the result type
-		attest<Result<Error, string>>(result)
-
-		// Check the destructured types
-		const [err, value] = result
-		attest<Error | undefined>(err)
-		attest<string | undefined>(value)
-
-		// When destructured, the types should be narrowed correctly
-		if (err === undefined) {
-			attest<string>(value)
-		} else {
-			attest<undefined>(value)
-		}
-	})
-
-	test('async function returns correct types', async () => {
-		const asyncFn = async () => 'value'
-		const result = await goTryRaw(asyncFn())
-
-		// Check the result type
-		attest<Result<Error, string>>(result)
-
-		// Check the destructured types
-		const [err, value] = result
-		attest<Error | undefined>(err)
-		attest<string | undefined>(value)
-
-		// When destructured, the types should be narrowed correctly
-		if (err === undefined) {
-			attest<string>(value)
-		} else {
-			attest<undefined>(value)
-		}
-	})
+  test('type inference works correctly', () => {
+    const fn = () => 'value'
+    const result = goTryRaw(fn)
+
+    // Check the result type
+    attest<Result<Error, string>>(result)
+
+    // Check the destructured types
+    const [err, value] = result
+    attest<Error | undefined>(err)
+    attest<string | undefined>(value)
+
+    // When destructured, the types should be narrowed correctly
+    if (err === undefined) {
+      attest<string>(value)
+    } else {
+      attest<undefined>(value)
+    }
+  })
+  test('synchronous function returns correct types', () => {
+    const fn = () => 'value'
+    const result = goTryRaw(fn)
+
+    // Check the result type
+    attest<Result<Error, string>>(result)
+
+    // Check the destructured types
+    const [err, value] = result
+    attest<Error | undefined>(err)
+    attest<string | undefined>(value)
+
+    // When destructured, the types should be narrowed correctly
+    if (err === undefined) {
+      attest<string>(value)
+    } else {
+      attest<undefined>(value)
+    }
+  })
+
+  test('direct value returns correct types', () => {
+    const result = goTryRaw('value')
+
+    // Check the result type
+    attest<Result<Error, string>>(result)
+
+    // Check the destructured types
+    const [err, value] = result
+    attest<Error | undefined>(err)
+    attest<string | undefined>(value)
+
+    // When destructured, the types should be narrowed correctly
+    if (err === undefined) {
+      attest<string>(value)
+    } else {
+      attest<undefined>(value)
+    }
+  })
+
+  test('promise returns correct types', async () => {
+    const promise = Promise.resolve('value')
+    const result = await goTryRaw(promise)
+
+    // Check the result type
+    attest<Result<Error, string>>(result)
+
+    // Check the destructured types
+    const [err, value] = result
+    attest<Error | undefined>(err)
+    attest<string | undefined>(value)
+
+    // When destructured, the types should be narrowed correctly
+    if (err === undefined) {
+      attest<string>(value)
+    } else {
+      attest<undefined>(value)
+    }
+  })
+
+  test('async function returns correct types', async () => {
+    const asyncFn = async () => 'value'
+    const result = await goTryRaw(asyncFn())
+
+    // Check the result type
+    attest<Result<Error, string>>(result)
+
+    // Check the destructured types
+    const [err, value] = result
+    attest<Error | undefined>(err)
+    attest<string | undefined>(value)
+
+    // When destructured, the types should be narrowed correctly
+    if (err === undefined) {
+      attest<string>(value)
+    } else {
+      attest<undefined>(value)
+    }
+  })
 })

package/src/index.ts

@@ -5,54 +5,54 @@ export type Result<E, T> = Success<T> | Failure<E>
 export type MaybePromise<T> = T | Promise<T>
 
 export function isSuccess<E, T>(result: Result<E, T>): result is Success<T> {
-	return result[0] === undefined
+  return result[0] === undefined
 }
 export function isFailure<E, T>(result: Result<E, T>): result is Failure<E> {
-	return result[0] !== undefined
+  return result[0] !== undefined
 }
 
 export function success<T>(value: T): Success<T> {
-	return [undefined, value] as const
+  return [undefined, value] as const
 }
 
 export function failure<E>(error: E): Failure<E> {
-	return [error, undefined] as const
+  return [error, undefined] as const
 }
 
 function getErrorMessage(error: unknown): string {
-	if (error === undefined) return 'undefined'
+  if (error === undefined) return 'undefined'
 
-	if (typeof error === 'string') return error
+  if (typeof error === 'string') return error
 
-	if (
-		typeof error === 'object' &&
-		error !== null &&
-		'message' in error &&
-		typeof (error as Record<string, unknown>).message === 'string'
-	) {
-		return (error as { message: string }).message
-	}
+  if (
+    typeof error === 'object' &&
+    error !== null &&
+    'message' in error &&
+    typeof (error as Record<string, unknown>).message === 'string'
+  ) {
+    return (error as { message: string }).message
+  }
 
-	try {
-		return JSON.stringify(error)
-	} catch {
-		// fallback in case there's an error stringifying the error
-		// with circular references for example.
-		return String(error)
-	}
+  try {
+    return JSON.stringify(error)
+  } catch {
+    // fallback in case there's an error stringifying the error
+    // with circular references for example.
+    return String(error)
+  }
 }
 
 function isPromise<T>(value: unknown): value is Promise<T> {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		'then' in value &&
-		typeof (value as { then: unknown }).then === 'function'
-	)
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'then' in value &&
+    typeof (value as { then: unknown }).then === 'function'
+  )
 }
 
 function isError(value: unknown): value is Error {
-	return value instanceof Error
+  return value instanceof Error
 }
 
 /**
@@ -75,24 +75,26 @@ function isError(value: unknown): value is Error {
  * // With a promise
  * const [err, result] = await goTry(fetch('https://api.example.com/data'));
  */
+export function goTry<T>(fn: () => never): Result<string, never>
+export function goTry<T>(fn: () => Promise<T>): Promise<Result<string, T>>
 export function goTry<T>(promise: Promise<T>): Promise<Result<string, T>>
 export function goTry<T>(fn: () => T): Result<string, T>
 export function goTry<T>(value: T): Result<string, T>
 export function goTry<T>(
-	value: T | Promise<T> | (() => T | Promise<T>),
+  value: T | Promise<T> | (() => T | Promise<T>),
 ): Result<string, T> | Promise<Result<string, T>> {
-	try {
-		const result =
-			typeof value === 'function' ? (value as () => T | Promise<T>)() : value
-		if (isPromise<T>(result)) {
-			return result
-				.then((resolvedValue) => success<T>(resolvedValue))
-				.catch((err) => failure<string>(getErrorMessage(err)))
-		}
-		return success<T>(result)
-	} catch (err) {
-		return failure<string>(getErrorMessage(err))
-	}
+  try {
+    const result =
+      typeof value === 'function' ? (value as () => T | Promise<T>)() : value
+    if (isPromise<T>(result)) {
+      return result
+        .then((resolvedValue) => success<T>(resolvedValue))
+        .catch((err) => failure<string>(getErrorMessage(err)))
+    }
+    return success<T>(result)
+  } catch (err) {
+    return failure<string>(getErrorMessage(err))
+  }
 }
 
 /**
@@ -116,37 +118,41 @@ export function goTry<T>(
  * // With a promise
  * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
  */
+export function goTryRaw<T, E = Error>(fn: () => never): Result<E, never>
 export function goTryRaw<T, E = Error>(
-	promise: Promise<T>,
+  fn: () => Promise<T>,
+): Promise<Result<E, T>>
+export function goTryRaw<T, E = Error>(
+  promise: Promise<T>,
 ): Promise<Result<E, T>>
 export function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>
 export function goTryRaw<T, E = Error>(value: T): Result<E, T>
 export function goTryRaw<T, E = Error>(
-	value: T | Promise<T> | (() => T | Promise<T>),
+  value: T | Promise<T> | (() => T | Promise<T>),
 ): Result<E, T> | Promise<Result<E, T>> {
-	try {
-		const result =
-			typeof value === 'function' ? (value as () => T | Promise<T>)() : value
-		if (isPromise<T>(result)) {
-			return result
-				.then((resolvedValue) => success<T>(resolvedValue))
-				.catch((err) => {
-					if (err === undefined) {
-						return failure<E>(new Error('undefined') as unknown as E)
-					}
-					return failure<E>(
-						isError(err)
-							? (err as unknown as E)
-							: (new Error(String(err)) as unknown as E),
-					)
-				})
-		}
-		return success<T>(result)
-	} catch (err) {
-		return failure<E>(
-			isError(err)
-				? (err as unknown as E)
-				: (new Error(String(err)) as unknown as E),
-		)
-	}
+  try {
+    const result =
+      typeof value === 'function' ? (value as () => T | Promise<T>)() : value
+    if (isPromise<T>(result)) {
+      return result
+        .then((resolvedValue) => success<T>(resolvedValue))
+        .catch((err) => {
+          if (err === undefined) {
+            return failure<E>(new Error('undefined') as unknown as E)
+          }
+          return failure<E>(
+            isError(err)
+              ? (err as unknown as E)
+              : (new Error(String(err)) as unknown as E),
+          )
+        })
+    }
+    return success<T>(result)
+  } catch (err) {
+    return failure<E>(
+      isError(err)
+        ? (err as unknown as E)
+        : (new Error(String(err)) as unknown as E),
+    )
+  }
 }