prevent passing a specific error type for .fromThrowable without providing an error mapping function

.changeset/grumpy-hats-unite.md

@@ -0,0 +1,5 @@
+---
+'neverthrow': minor
+---
+
+prevent passing a specific error type for `.fromThrowable` without providing an error mapping function

src/result-async.ts

@@ -42,17 +42,26 @@ export class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     return new ResultAsync(newPromise)
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromThrowable<A extends readonly any[], R>(
+    fn: (...args: A) => Promise<R>,
+  ): (...args: A) => ResultAsync<R, unknown>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromThrowable<A extends readonly any[], R, E>(
+    fn: (...args: A) => Promise<R>,
+    errorFn: (err: unknown) => E,
+  ): (...args: A) => ResultAsync<R, E>
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static fromThrowable<A extends readonly any[], R, E>(
     fn: (...args: A) => Promise<R>,
     errorFn?: (err: unknown) => E,
-  ): (...args: A) => ResultAsync<R, E> {
+  ): (...args: A) => ResultAsync<R, E | unknown> {
     return (...args) => {
       return new ResultAsync(
         (async () => {
           try {
             return new Ok(await fn(...args))
-          } catch (error) {
+          } catch (error: unknown) {
             return new Err(errorFn ? errorFn(error) : error)
           }
         })(),

src/result.ts

@@ -17,18 +17,33 @@ export namespace Result {
    * arguments but returning `Ok` if successful, `Err` if the function throws
    *
    * @param fn function to wrap with ok on success or err on failure
-   * @param errorFn when an error is thrown, this will wrap the error result if provided
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  export function fromThrowable<Fn extends (...args: readonly any[]) => any>(
+    fn: Fn,
+  ): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, unknown>
+  /**
+   * Wraps a function with a try catch, creating a new function with the same
+   * arguments but returning `Ok` if successful, `Err` if the function throws
+   *
+   * @param fn function to wrap with ok on success or err on failure
+   * @param errorFn when an error is thrown, this will wrap the error result
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  export function fromThrowable<Fn extends (...args: readonly any[]) => any, E>(
+    fn: Fn,
+    errorFn: (e: unknown) => E,
+  ): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   export function fromThrowable<Fn extends (...args: readonly any[]) => any, E>(
     fn: Fn,
     errorFn?: (e: unknown) => E,
-  ): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E> {
+  ): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E | unknown> {
     return (...args) => {
       try {
         const result = fn(...args)
         return ok(result)
-      } catch (e) {
+      } catch (e: unknown) {
         return err(errorFn ? errorFn(e) : e)
       }
     }