@nicolastoulemont/std 0.6.0 → 0.7.0

package/dist/{index-B2l8_CiD.d.mts → index-DEAWPlcI.d.mts}

@@ -1,7 +1,22 @@
-import { a as ResultFromTry, c as ResultMatch, d as ResultUnwrapOr, f as ResultUnwrapOrElse, i as ResultFlatMap, l as ResultOrElse, n as ResultAll, o as ResultMap, r as ResultFilter, s as ResultMapErr, t as Result$1, u as ResultTap } from "./result.types-HHDzgSTV.mjs";
+import { a as ResultFromTry, c as ResultMatch, d as ResultUnwrapOr, f as ResultUnwrapOrElse, i as ResultFlatMap, l as ResultOrElse, n as ResultAll, o as ResultMap, r as ResultFilter, s as ResultMapErr, t as Result$1, u as ResultTap } from "./result.types-_xDAei3-.mjs";
 
 //#region src/result/result.d.ts
-
+declare namespace result_d_exports {
+  export { Result, all, err, filter, flatMap, fromTry, isErr, isOk, map, mapErr, match, ok, orElse, tap, try_ as try, unwrapOr, unwrapOrElse };
+}
+/**
+ * Re-exported `Result` type.
+ *
+ * @example
+ * ```ts
+ * import type { Result } from "@nicolastoulemont/std"
+ *
+ * type Example = Result.Result<unknown, unknown>
+ * ```
+ *
+ * @category Re-exports
+ */
+type Result<T, E> = Result$1<T, E>;
 /**
  * Create a successful Result.
  *
@@ -10,8 +25,13 @@ import { a as ResultFromTry, c as ResultMatch, d as ResultUnwrapOr, f as ResultU
  *
  * @example
  * ```ts
- * ok(42) // { _tag: "Ok", value: 42 }
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const value = Result.ok(42)
+ * // => { _tag: "Ok", value: 42 }
  * ```
+ *
+ * @category Constructors
  */
 declare const ok: <T>(value: T) => Result$1<T, never>;
 /**
@@ -22,8 +42,13 @@ declare const ok: <T>(value: T) => Result$1<T, never>;
  *
  * @example
  * ```ts
- * err('something went wrong') // { _tag: "Err", error: 'something went wrong' }
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const value = Result.err("boom")
+ * // => { _tag: "Err", error: "boom" }
  * ```
+ *
+ * @category Constructors
  */
 declare const err: <E>(error: E) => Result$1<never, E>;
 /**
@@ -34,11 +59,13 @@ declare const err: <E>(error: E) => Result$1<never, E>;
  *
  * @example
  * ```ts
- * const result = ok(42)
- * if (isOk(result)) {
- *   console.log(result.value) // TypeScript knows value exists
- * }
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const isOk = Result.isOk(Result.ok(1))
+ * // => true
  * ```
+ *
+ * @category Guards
  */
 declare const isOk: <T, E>(result: Result$1<T, E>) => result is Extract<Result$1<T, E>, {
   _tag: "Ok";
@@ -51,11 +78,13 @@ declare const isOk: <T, E>(result: Result$1<T, E>) => result is Extract<Result$1
  *
  * @example
  * ```ts
- * const result = err('oops')
- * if (isErr(result)) {
- *   console.log(result.error) // TypeScript knows error exists
- * }
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const isErr = Result.isErr(Result.err("boom"))
+ * // => true
  * ```
+ *
+ * @category Guards
  */
 declare const isErr: <T, E>(result: Result$1<T, E>) => result is Extract<Result$1<T, E>, {
   _tag: "Err";
@@ -77,21 +106,17 @@ declare const isErr: <T, E>(result: Result$1<T, E>) => result is Extract<Result$
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * map(ok(5), n => n * 2) // { _tag: "Ok", value: 10 }
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   ok(5),
- *   map(n => n * 2)
- * ) // { _tag: "Ok", value: 10 }
- *
- * // Async usage
- * await pipe(
- *   ok(userId),
- *   map(async id => await fetchName(id))
- * ) // Promise<Result<string, E>>
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const input = Result.ok(2)
+ * const dataFirst = Result.map(input, (n) => n + 1)
+ * // => { _tag: "Ok", value: 3 }
+ *
+ * const dataLast = Result.map((n: number) => n + 1)(input)
+ * // => { _tag: "Ok", value: 3 }
  * ```
+ *
+ * @category Mapping
  */
 declare const map: ResultMap;
 /**
@@ -111,22 +136,17 @@ declare const map: ResultMap;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * mapErr(err({ code: 404 }), e => `Error: ${e.code}`)
- * // { _tag: "Err", error: 'Error: 404' }
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   err({ code: 404 }),
- *   mapErr(e => `Error: ${e.code}`)
- * ) // { _tag: "Err", error: 'Error: 404' }
- *
- * // Async usage
- * await pipe(
- *   err(errorCode),
- *   mapErr(async code => await translateError(code))
- * ) // Promise<Result<T, string>>
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const input = Result.err("missing")
+ * const dataFirst = Result.mapErr(input, (msg) => msg.toUpperCase())
+ * // => { _tag: "Err", error: "MISSING" }
+ *
+ * const dataLast = Result.mapErr((msg: string) => msg.toUpperCase())(input)
+ * // => { _tag: "Err", error: "MISSING" }
  * ```
+ *
+ * @category Mapping
  */
 declare const mapErr: ResultMapErr;
 /**
@@ -146,24 +166,17 @@ declare const mapErr: ResultMapErr;
  *
  * @example
  * ```ts
- * const divide = (a: number, b: number) =>
- *   b === 0 ? err('division by zero') : ok(a / b)
- *
- * // Data-first (direct call)
- * flatMap(ok(10), n => divide(n, 2)) // { _tag: "Ok", value: 5 }
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   ok(10),
- *   flatMap(n => divide(n, 2))
- * ) // { _tag: "Ok", value: 5 }
- *
- * // Async usage
- * await pipe(
- *   ok(userId),
- *   flatMap(async id => ok(await fetchUser(id)))
- * ) // Promise<Result<User, E>>
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const input = Result.ok(2)
+ * const dataFirst = Result.flatMap(input, (n) => Result.ok(n + 1))
+ * // => { _tag: "Ok", value: 3 }
+ *
+ * const dataLast = Result.flatMap((n: number) => Result.ok(n + 1))(input)
+ * // => { _tag: "Ok", value: 3 }
  * ```
+ *
+ * @category Sequencing
  */
 declare const flatMap: ResultFlatMap;
 /**
@@ -184,23 +197,22 @@ declare const flatMap: ResultFlatMap;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * tap(ok(42), console.log) // logs 42, returns { _tag: "Ok", value: 42 }
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   ok(42),
- *   tap(console.log),  // logs 42
- *   map(n => n * 2)
- * ) // { _tag: "Ok", value: 84 }
- *
- * // Async usage
- * await pipe(
- *   ok(42),
- *   tap(async v => await logToServer(v)),
- *   map(n => n * 2)
- * ) // Promise<Result<84, E>>
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * let seen = 0
+ * const input = Result.ok(2)
+ * const dataFirst = Result.tap(input, (n) => {
+ *   seen = n
+ * })
+ * // => { _tag: "Ok", value: 2 }
+ *
+ * const dataLast = Result.tap((n: number) => {
+ *   seen = n
+ * })(input)
+ * // => { _tag: "Ok", value: 2 }
  * ```
+ *
+ * @category Sequencing
  */
 declare const tap: ResultTap;
 /**
@@ -220,30 +232,17 @@ declare const tap: ResultTap;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * orElse(err('cache miss'), () => ok(defaultValue))
- * // { _tag: "Ok", value: defaultValue }
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   err('cache miss'),
- *   orElse(() => ok(defaultValue))
- * ) // { _tag: "Ok", value: defaultValue }
- *
- * // Async recovery
- * await pipe(
- *   err('cache miss'),
- *   orElse(async () => ok(await fetchFromAPI()))
- * ) // Promise<Result<T, E2>>
- *
- * // Chain multiple fallbacks
- * pipe(
- *   err('not found'),
- *   orElse(() => tryCache()),
- *   orElse(() => tryAPI()),
- *   orElse(() => ok(fallback))
- * )
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const input = Result.err("missing") as Result.Result<number, string>
+ * const dataFirst = Result.orElse(input, () => Result.ok(0))
+ * // => { _tag: "Ok", value: 0 }
+ *
+ * const dataLast = Result.orElse(() => Result.ok(0))(input)
+ * // => { _tag: "Ok", value: 0 }
  * ```
+ *
+ * @category Error Handling
  */
 declare const orElse: ResultOrElse;
 /**
@@ -261,27 +260,17 @@ declare const orElse: ResultOrElse;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * filter(ok(5), n => n > 10, n => `${n} is too small`)
- * // { _tag: "Err", error: '5 is too small' }
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   ok(5),
- *   filter(n => n > 10, n => `${n} is too small`)
- * ) // { _tag: "Err", error: '5 is too small' }
- *
- * pipe(
- *   ok(15),
- *   filter(n => n > 10, n => `${n} is too small`)
- * ) // { _tag: "Ok", value: 15 }
- *
- * // With complex validation
- * pipe(
- *   ok(user),
- *   filter(u => u.age >= 18, u => ({ code: 'UNDERAGE', user: u }))
- * )
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const input = Result.ok(3)
+ * const dataFirst = Result.filter(input, (n) => n > 0, (n) => `${n} must be positive`)
+ * // => { _tag: "Ok", value: 3 }
+ *
+ * const dataLast = Result.filter((n: number) => n > 0, (n) => `${n} must be positive`)(input)
+ * // => { _tag: "Ok", value: 3 }
  * ```
+ *
+ * @category Filtering
  */
 declare const filter: ResultFilter;
 /**
@@ -296,18 +285,13 @@ declare const filter: ResultFilter;
  *
  * @example
  * ```ts
- * // Array form - tuple types inferred automatically for up to 6 elements
- * const [num, str] = pipe(
- *   Result.all([parseNumber(input), parseString(other)]),
- *   Result.unwrapOr([0, ''])
- * )
- *
- * // Object form - returns Result<{ user: User, config: Config }, E>
- * pipe(
- *   Result.all({ user: fetchUser(id), config: loadConfig() }),
- *   Result.tap(({ user, config }) => console.log(user.name, config.theme))
- * )
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const combined = Result.all([Result.ok(1), Result.ok(2)] as const)
+ * // => { _tag: "Ok", value: [1, 2] }
  * ```
+ *
+ * @category Combining
  */
 declare const all: ResultAll;
 /**
@@ -324,14 +308,17 @@ declare const all: ResultAll;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * unwrapOr(ok(42), 0) // 42
- * unwrapOr(err('oops'), 0) // 0
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const input = Result.err("missing") as Result.Result<number, string>
+ * const dataFirst = Result.unwrapOr(input, 0)
+ * // => 0
  *
- * // Data-last (curried for pipe)
- * pipe(ok(42), unwrapOr(0)) // 42
- * pipe(err('oops'), unwrapOr(0)) // 0
+ * const dataLast = Result.unwrapOr(0)(input)
+ * // => 0
  * ```
+ *
+ * @category Getters
  */
 declare const unwrapOr: ResultUnwrapOr;
 /**
@@ -346,15 +333,17 @@ declare const unwrapOr: ResultUnwrapOr;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * unwrapOrElse(err({ code: 404 }), e => `Error ${e.code}`) // 'Error 404'
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   err({ code: 404 }),
- *   unwrapOrElse(e => `Error ${e.code}`)
- * ) // 'Error 404'
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const input = Result.err("missing") as Result.Result<number, string>
+ * const dataFirst = Result.unwrapOrElse(input, () => 0)
+ * // => 0
+ *
+ * const dataLast = Result.unwrapOrElse(() => 0)(input)
+ * // => 0
  * ```
+ *
+ * @category Getters
  */
 declare const unwrapOrElse: ResultUnwrapOrElse;
 /**
@@ -369,21 +358,23 @@ declare const unwrapOrElse: ResultUnwrapOrElse;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * match(ok(42), {
- *   Ok: n => `Got ${n}`,
- *   Err: e => `Error: ${e}`
- * }) // 'Got 42'
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   ok(42),
- *   match({
- *     Ok: n => `Got ${n}`,
- *     Err: e => `Error: ${e}`
- *   })
- * ) // 'Got 42'
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const input = Result.ok(2) as Result.Result<number, string>
+ * const dataFirst = Result.match(input, {
+ *   Ok: (value) => `ok:${value}` ,
+ *   Err: (error) => `err:${error}` ,
+ * })
+ * // => "ok:2"
+ *
+ * const dataLast = Result.match({
+ *   Ok: (value: number) => `ok:${value}` ,
+ *   Err: (error: string) => `err:${error}` ,
+ * })(input)
+ * // => "ok:2"
  * ```
+ *
+ * @category Pattern Matching
  */
 declare const match: ResultMatch;
 /**
@@ -399,68 +390,16 @@ declare const match: ResultMatch;
  *
  * @example
  * ```ts
- * // Simple callback
- * fromTry(() => JSON.parse('{"valid": true}'))
- *
- * // Object form with custom error mapping
- * fromTry({
- *   try: () => JSON.parse(input),
- *   catch: (e) => ({ type: "ParseError" as const, message: String(e) })
- * })
+ * import { Result } from "@nicolastoulemont/std"
  *
- * // Async with custom catch
- * await fromTry({
- *   try: () => fetch('/api/user'),
- *   catch: (e) => new NetworkError(String(e))
- * })
+ * const parsed = Result.fromTry(() => Number.parseInt("42", 10))
+ * // => { _tag: "Ok", value: 42 }
  * ```
- */
-declare const fromTry: ResultFromTry;
-/**
- * Result namespace containing all utility functions for working with Result types.
- *
- * Result represents either success (`Ok`) or failure (`Err`). Use this for operations
- * that can fail with typed errors.
  *
- * @see {@link Option} for presence/absence semantics (no error information)
- * @see {@link Either} for two valid outcomes (not just success/failure)
- *
- * @example
- * ```ts
- * import { Result, pipe } from '@nicolastoulemont/std'
- * import type { Result as ResultType } from '@nicolastoulemont/std'
- *
- * const divide = (a: number, b: number): ResultType<number, string> =>
- *   b === 0 ? Result.err('division by zero') : Result.ok(a / b)
- *
- * const result = pipe(
- *   divide(10, 2),
- *   Result.map(n => n * 2),
- *   Result.unwrapOr(0)
- * )
- * ```
+ * @category Constructors
  */
-declare const Result: {
-  readonly ok: <T>(value: T) => Result$1<T, never>;
-  readonly err: <E>(error: E) => Result$1<never, E>;
-  readonly isOk: <T, E>(result: Result$1<T, E>) => result is Extract<Result$1<T, E>, {
-    _tag: "Ok";
-  }>;
-  readonly isErr: <T, E>(result: Result$1<T, E>) => result is Extract<Result$1<T, E>, {
-    _tag: "Err";
-  }>;
-  readonly map: ResultMap;
-  readonly mapErr: ResultMapErr;
-  readonly flatMap: ResultFlatMap;
-  readonly tap: ResultTap;
-  readonly orElse: ResultOrElse;
-  readonly filter: ResultFilter;
-  readonly all: ResultAll;
-  readonly unwrapOr: ResultUnwrapOr;
-  readonly unwrapOrElse: ResultUnwrapOrElse;
-  readonly match: ResultMatch;
-  readonly try: ResultFromTry;
-};
+declare const fromTry: ResultFromTry;
+declare const try_: ResultFromTry;
 //#endregion
-export { flatMap as a, isOk as c, match as d, ok as f, unwrapOrElse as g, unwrapOr as h, filter as i, map as l, tap as m, all as n, fromTry as o, orElse as p, err as r, isErr as s, Result as t, mapErr as u };
-//# sourceMappingURL=index-B2l8_CiD.d.mts.map
+export { result_d_exports as t };
+//# sourceMappingURL=index-DEAWPlcI.d.mts.map

package/dist/index-DEAWPlcI.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DEAWPlcI.d.mts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;KA4DY,eAAe,SAAW,GAAG;;;;;;;;;;AAAzC;;;;;AAwBA;;AAA4C,cAA/B,EAA+B,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAAf,CAAe,EAAA,GAAX,QAAW,CAAA,CAAA,EAAA,KAAA,CAAA;;;AAkC5C;;;;;AAsCA;;;;;;;;;AAmBa,cAzDA,GA0DU,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EA1DO,CA0DP,EAAA,GA1DW,QA0DX,CAAA,KAAA,EA1D6B,CA0D7B,CAAA;;;;;;;;;AAoCvB;AAwCA;AAwCA;AAwCA;AAwCA;AA+BA;AAqCA;AAkDA;AA6Ba,cA3WA,IA8WZ,EAAA,CAAA,CAAA,EAH0B,CAAA,CAAA,CAAA,MAAA,EA3WQ,QA8WlC,CA9W6C,CA8W7C,EA9WgD,CA8WhD,CAAA,EAAA,GAAA,MAAA,IA9W+D,OA8W/D,CA9WuE,QA8WvE,CA9WkF,CA8WlF,EA9WqF,CA8WrF,CAAA,EAAA;EAgCY,IAAA,EAAA,IAIZ;AA4BD,CAAA,CAAA;AA0BC;;;;;;;;;;;;;;;;cArbY,sBAAuB,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqC1E,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BR,QAAQ;;;;;;;;;;;;;;;;;;;;;cAqCR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDL,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;cA6BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCd,OAAO;;;;;;;;;;;;;;;;;;;;;;cAgCP,SAAS;cA6BhB,MAAI"}