feat(std): add try-catch (#15)

* feat(std): added without-throw

* refactor: improve

* refactor: simplify structure, unknown by default

* refactor: rename to `try-catch`

---------

Co-authored-by: 藍+85CD <50108258+kwaa@users.noreply.github.com>

Author: nekomeowww

docs/content/docs/packages/std/utils/try-catch.mdx

@@ -0,0 +1,43 @@
+---
+title: Try Catch
+description: Convert throwing functions into data/error objects.
+---
+
+## tryCatch
+
+```ts twoslash
+import { tryCatch } from '@moeru/std/try-catch'
+
+const parseJSON = (text: string) => JSON.parse(text)
+
+const { data, error } = tryCatch(() => parseJSON('{"hello":"world"}'))
+
+if (error)
+  console.error('Failed to parse JSON', error)
+else
+  console.log(data.hello)
+```
+
+## tryCatchAsync
+
+```ts twoslash
+import { tryCatchAsync } from '@moeru/std/try-catch'
+
+const fetchJSON = async (url: string) => {
+  const res = await fetch(url)
+  if (!res.ok)
+    throw new Error(res.statusText)
+  return res.json()
+}
+
+const { data, error } = await tryCatchAsync(() => fetchJSON('https://example.com/data.json'))
+
+if (error)
+  console.error('Request failed', error)
+else
+  console.log(data)
+```
+
+## Remarks
+
+This wrapper keeps your call sites non-throwing and therefore easier to compose. It is a lightweight alternative to result libraries—if you need richer ergonomics (matching, chaining, etc.) consider adopting a full Result/Try monad.

packages/std/package.json

@@ -22,6 +22,7 @@
     "./set-interval": "./src/set-interval/index.ts",
     "./sleep": "./src/sleep/index.ts",
     "./trampoline": "./src/trampoline/index.ts",
+    "./try-catch": "./src/try-catch/index.ts",
     "./with-retry": "./src/with-retry/index.ts"
   },
   "files": [

packages/std/src/index.ts

@@ -5,4 +5,5 @@ export * from './merge'
 export * from './set-interval'
 export * from './sleep'
 export * from './trampoline'
+export * from './try-catch'
 export * from './with-retry'

packages/std/src/try-catch/index.ts

@@ -0,0 +1,24 @@
+export type TryCatchResult<T> = { data: T, error: undefined } | { data: undefined, error: unknown }
+
+/** @see {@link https://std.moeru.ai/docs/packages/std/utils/without-throw} */
+export const tryCatch = <
+  T extends () => unknown,
+>(fn: T): TryCatchResult<ReturnType<T>> => {
+  try {
+    return { data: fn() as ReturnType<T>, error: undefined }
+  }
+  catch (error) {
+    return { data: undefined, error }
+  }
+}
+
+export const tryCatchAsync = async <
+  T extends () => Promise<unknown>,
+>(fn: T): Promise<TryCatchResult<Awaited<ReturnType<T>>>> => {
+  try {
+    return { data: await fn() as Awaited<ReturnType<T>>, error: undefined }
+  }
+  catch (error) {
+    return { data: undefined, error }
+  }
+}