@nicolastoulemont/std 0.1.0

package/dist/index-CvGTIg9L.d.mts

@@ -0,0 +1,211 @@
+import { g as Yieldable, i as Result } from "./result.types-Ce7AEOzj.mjs";
+import { a as Option } from "./option.types-D6TYG_i3.mjs";
+
+//#region src/either/either.types.d.ts
+
+/**
+ * A discriminated union representing a choice between two alternatives.
+ * By convention: Right = correct/preferred, Left = alternative.
+ *
+ * Unlike Result, neither side has inherent error semantics. Use Either when
+ * both outcomes are valid alternatives (e.g., cached vs fresh data).
+ *
+ * Use Result when modeling success/failure with error semantics.
+ *
+ * Implements Yieldable protocol for use in Do computations with yield*.
+ *
+ * @example
+ * ```ts
+ * // Either: Valid alternatives
+ * type DataSource = Either<CachedData, FreshData>
+ *
+ * // Result: Success/failure
+ * type ApiResult = Result<User, ApiError>
+ * ```
+ */
+type Either$1<L, R> = Yieldable<R, L> & ({
+  readonly right: true;
+  readonly value: R;
+} | {
+  readonly right: false;
+  readonly value: L;
+});
+/**
+ * Extract the left type from an Either
+ */
+type LeftValue<E> = E extends {
+  readonly right: false;
+  readonly value: infer L;
+} ? L : never;
+/**
+ * Extract the right type from an Either
+ */
+type RightValue<E> = E extends {
+  readonly right: true;
+  readonly value: infer R;
+} ? R : never;
+/**
+ * Return type for all() with array input - preserves tuple structure
+ */
+type AllArrayReturn<T extends readonly Either$1<unknown, unknown>[]> = Either$1<LeftValue<T[number]>, { -readonly [K in keyof T]: RightValue<T[K]> }>;
+/**
+ * Return type for all() with object input - preserves object structure
+ */
+type AllObjectReturn<T extends Record<string, Either$1<unknown, unknown>>> = Either$1<LeftValue<T[keyof T]>, { -readonly [K in keyof T]: RightValue<T[K]> }>;
+/**
+ * Type-safe interface for map() with async detection
+ * Async overload must come first for proper type inference
+ */
+type EitherMap = {
+  <A, B>(fn: (value: A) => Promise<B>): <L>(either: Either$1<L, A>) => Promise<Either$1<L, B>>;
+  <A, B>(fn: (value: A) => B): <L>(either: Either$1<L, A>) => Either$1<L, B>;
+};
+/**
+ * Type-safe interface for mapLeft() with async detection
+ */
+type EitherMapLeft = {
+  <L1, L2$1>(fn: (value: L1) => Promise<L2$1>): <R>(either: Either$1<L1, R>) => Promise<Either$1<L2$1, R>>;
+  <L1, L2$1>(fn: (value: L1) => L2$1): <R>(either: Either$1<L1, R>) => Either$1<L2$1, R>;
+};
+/**
+ * Type-safe interface for bimap() with async detection
+ */
+type EitherBimap = {
+  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => Promise<L2$1>, fnRight: (right: R1) => Promise<R2$1>): (either: Either$1<L1, R1>) => Promise<Either$1<L2$1, R2$1>>;
+  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => Promise<L2$1>, fnRight: (right: R1) => R2$1): (either: Either$1<L1, R1>) => Promise<Either$1<L2$1, R2$1>>;
+  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => L2$1, fnRight: (right: R1) => Promise<R2$1>): (either: Either$1<L1, R1>) => Promise<Either$1<L2$1, R2$1>>;
+  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => L2$1, fnRight: (right: R1) => R2$1): (either: Either$1<L1, R1>) => Either$1<L2$1, R2$1>;
+};
+/**
+ * Type-safe interface for flatMap() with async detection and left union
+ */
+type EitherFlatMap = {
+  <A, B, L2$1>(fn: (value: A) => Promise<Either$1<L2$1, B>>): <L>(either: Either$1<L, A>) => Promise<Either$1<L | L2$1, B>>;
+  <A, B, L2$1>(fn: (value: A) => Either$1<L2$1, B>): <L>(either: Either$1<L, A>) => Either$1<L | L2$1, B>;
+};
+/**
+ * Type-safe interface for tap() with async detection
+ */
+type EitherTap = {
+  <A>(fn: (value: A) => Promise<void>): <L>(either: Either$1<L, A>) => Promise<Either$1<L, A>>;
+  <A>(fn: (value: A) => void): <L>(either: Either$1<L, A>) => Either$1<L, A>;
+};
+/**
+ * Type-safe interface for tapLeft() with async detection
+ */
+type EitherTapLeft = {
+  <L>(fn: (value: L) => Promise<void>): <R>(either: Either$1<L, R>) => Promise<Either$1<L, R>>;
+  <L>(fn: (value: L) => void): <R>(either: Either$1<L, R>) => Either$1<L, R>;
+};
+/**
+ * Type-safe interface for orElse() with async detection and right union
+ */
+type EitherOrElse = {
+  <L1, L2$1, R2$1>(fn: (left: L1) => Promise<Either$1<L2$1, R2$1>>): <R>(either: Either$1<L1, R>) => Promise<Either$1<L2$1, R | R2$1>>;
+  <L1, L2$1, R2$1>(fn: (left: L1) => Either$1<L2$1, R2$1>): <R>(either: Either$1<L1, R>) => Either$1<L2$1, R | R2$1>;
+};
+/**
+ * Type-safe interface for filter()
+ */
+type EitherFilter = {
+  <R, L2$1>(predicate: (value: R) => boolean, onFail: (value: R) => L2$1): <L>(either: Either$1<L, R>) => Either$1<L | L2$1, R>;
+};
+//#endregion
+//#region src/either/either.d.ts
+
+/**
+ * Combine multiple Eithers into a single Either.
+ * Short-circuits on the first left value.
+ *
+ * Supports both array and object inputs with full type preservation.
+ *
+ * @param eithers - Array or object of Eithers to combine
+ * @returns Either with all right values or first left
+ *
+ * @example
+ * ```ts
+ * // Array form (with const assertion for tuple typing)
+ * all([right(1), right("hello")] as const)
+ * // => right([1, "hello"])
+ *
+ * all([right(1), left("error"), right(3)])
+ * // => left("error")
+ *
+ * // Object form
+ * all({ a: right(1), b: right("hello") })
+ * // => right({ a: 1, b: "hello" })
+ * ```
+ */
+declare function all<const T extends readonly Either$1<unknown, unknown>[]>(eithers: T): AllArrayReturn<T>;
+declare function all<const T extends Record<string, Either$1<unknown, unknown>>>(eithers: T): AllObjectReturn<T>;
+/**
+ * Either namespace containing all utility functions for working with Either types.
+ *
+ * Either represents a value that can be one of two types: Left<L> or Right<R>.
+ * By convention, Right is the "success" or preferred path, while Left represents
+ * an alternative outcome (not necessarily an error, unlike Result).
+ *
+ * Use Either when both outcomes are valid and meaningful, not just success/failure.
+ * For error handling, prefer Result instead.
+ *
+ * @see {@link Result} for success/error semantics
+ * @see {@link Option} for presence/absence semantics
+ *
+ * @example
+ * ```ts
+ * import { Either, pipe } from '@repo/std'
+ * import type { Either as EitherType } from '@repo/std'
+ *
+ * // Either for branching logic (cache vs fresh data)
+ * const fetchOrCache = (id: number): EitherType<CachedData, FreshData> =>
+ *   cache.has(id) ? Either.left(cache.get(id)) : Either.right(fetch(id))
+ *
+ * const result = pipe(
+ *   fetchOrCache(1),
+ *   Either.map(data => data.value),
+ *   Either.unwrapOr(defaultValue)
+ * )
+ *
+ * // Async example
+ * const processed = await pipe(
+ *   Either.right(userId),
+ *   Either.map(async id => await fetchUser(id)),
+ *   Either.flatMap(async user => Either.right(await enrichUser(user)))
+ * )
+ * ```
+ */
+declare const Either: {
+  readonly left: <L>(value: L) => Either$1<L, never>;
+  readonly right: <R>(value: R) => Either$1<never, R>;
+  readonly isLeft: <L, R>(either: Either$1<L, R>) => either is Extract<Either$1<L, R>, {
+    right: false;
+  }>;
+  readonly isRight: <L, R>(either: Either$1<L, R>) => either is Extract<Either$1<L, R>, {
+    right: true;
+  }>;
+  readonly map: EitherMap;
+  readonly mapLeft: EitherMapLeft;
+  readonly bimap: EitherBimap;
+  readonly flatMap: EitherFlatMap;
+  readonly tap: EitherTap;
+  readonly tapLeft: EitherTapLeft;
+  readonly orElse: EitherOrElse;
+  readonly swap: <L, R>() => (either: Either$1<L, R>) => Either$1<R, L>;
+  readonly filter: EitherFilter;
+  readonly all: typeof all;
+  readonly unwrapOr: <R>(defaultValue: R) => <L>(either: Either$1<L, R>) => R;
+  readonly unwrapOrElse: <L, R>(fn: (left: L) => R) => (either: Either$1<L, R>) => R;
+  readonly match: <L, R, U$1>(handlers: {
+    left: (value: L) => U$1;
+    right: (value: R) => U$1;
+  }) => (either: Either$1<L, R>) => U$1;
+  readonly fromResult: <R, E>(result: Result<R, E>) => Either$1<E, R>;
+  readonly toResult: <L, R>(either: Either$1<L, R>) => Result<R, L>;
+  readonly fromOption: <R, L>(option: Option<R>, onNone: () => L) => Either$1<L, R>;
+  readonly toOption: <L, R>(either: Either$1<L, R>) => Option<R>;
+  readonly fromNullable: <R, L>(value: R | null | undefined, onNull: () => L) => Either$1<L, R>;
+  readonly fromPredicate: <R, L>(value: R, predicate: (value: R) => boolean, onFail: (value: R) => L) => Either$1<L, R>;
+};
+//#endregion
+export { EitherFilter as a, EitherMapLeft as c, EitherTapLeft as d, EitherBimap as i, EitherOrElse as l, all as n, EitherFlatMap as o, Either$1 as r, EitherMap as s, Either as t, EitherTap as u };
+//# sourceMappingURL=index-CvGTIg9L.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CvGTIg9L.d.mts","names":[],"sources":["../src/either/either.types.ts","../src/either/either.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-DPVT0yK4.d.mts

@@ -0,0 +1,50 @@
+import { d as AsyncComputation, f as AsyncGenGenerator, h as SyncComputation, m as GenGenerator } from "./result.types-Ce7AEOzj.mjs";
+
+//#region src/gen/gen.d.ts
+
+/**
+ * Create a computation from a sync generator function.
+ * Returns a SyncComputation where run() returns Result directly (no Promise).
+ *
+ * @template A - The success value type
+ * @template E - The error type
+ * @param generatorFn - A function that returns a sync generator
+ * @returns SyncComputation<A, E>
+ *
+ * @see {@link run} for immediate execution without storing the computation
+ *
+ * @example
+ * ```ts
+ * const result = gen(function* () {
+ *   const a = yield* Result.yield(divide(10, 2))
+ *   const b = yield* Result.yield(divide(a, 2))
+ *   return b
+ * }).run()
+ * // Type: Result<number, "DivisionByZero">
+ * ```
+ */
+declare function gen<A, E>(generatorFn: () => GenGenerator<A, E>): SyncComputation<A, E>;
+/**
+ * Create a computation from an async generator function.
+ * Returns an AsyncComputation where run() returns Promise<Result>.
+ *
+ * @template A - The success value type
+ * @template E - The error type
+ * @param generatorFn - A function that returns an async generator
+ * @returns AsyncComputation<A, E>
+ *
+ * @see {@link run} for immediate execution without storing the computation
+ *
+ * @example
+ * ```ts
+ * const result = await gen(async function* () {
+ *   const data = yield* Result.yield(await fetchData(1))
+ *   return data
+ * }).run()
+ * // Type: Promise<Result<string, "NetworkError">>
+ * ```
+ */
+declare function gen<A, E>(generatorFn: () => AsyncGenGenerator<A, E>): AsyncComputation<A, E>;
+//#endregion
+export { gen as t };
+//# sourceMappingURL=index-DPVT0yK4.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DPVT0yK4.d.mts","names":[],"sources":["../src/gen/gen.ts"],"sourcesContent":[],"mappings":";;;;;;AAyBA;;;;;;;;AAsBA;;;;;;;;;;;iBAtBgB,6BAA6B,aAAa,GAAG,KAAK,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;iBAsBrE,6BAA6B,kBAAkB,GAAG,KAAK,iBAAiB,GAAG"}

package/dist/index-DgOAEEpu.d.mts

@@ -0,0 +1,79 @@
+import { a as ResultFilter, c as ResultMapErr, i as Result$1, l as ResultOrElse, n as AllObjectReturn, o as ResultFlatMap, r as FromTryReturn, s as ResultMap, t as AllArrayReturn, u as ResultTap } from "./result.types-Ce7AEOzj.mjs";
+
+//#region src/result/result.d.ts
+
+/**
+ * Combine multiple Results into a single Result.
+ * Supports both array and object inputs.
+ *
+ * - If all Results are ok, returns ok with all values
+ * - If any Result is an error, returns the first error (short-circuits)
+ *
+ * @example
+ * ```ts
+ * // Array form (use `as const` for tuple types) - returns Result<[number, string], E>
+ * const [num, str] = pipe(
+ *   Result.all([parseNumber(input), parseString(other)] as const),
+ *   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))
+ * )
+ * ```
+ */
+declare function all<T extends readonly Result$1<unknown, unknown>[]>(results: T): AllArrayReturn<T>;
+declare function all<T extends Record<string, Result$1<unknown, unknown>>>(results: T): AllObjectReturn<T>;
+/**
+ * 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 '@repo/std'
+ * import type { Result as ResultType } from '@repo/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)
+ * )
+ * ```
+ */
+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>, {
+    ok: true;
+  }>;
+  readonly isErr: <T, E>(result: Result$1<T, E>) => result is Extract<Result$1<T, E>, {
+    ok: false;
+  }>;
+  readonly map: ResultMap;
+  readonly mapErr: ResultMapErr;
+  readonly flatMap: ResultFlatMap;
+  readonly tap: ResultTap;
+  readonly orElse: ResultOrElse;
+  readonly filter: ResultFilter;
+  readonly all: typeof all;
+  readonly unwrapOr: <T>(defaultValue: T) => <E>(result: Result$1<T, E>) => T;
+  readonly unwrapOrElse: <E, T>(fn: (error: E) => T) => (result: Result$1<T, E>) => T;
+  readonly match: <T, E, U>(handlers: {
+    ok: (value: T) => U;
+    err: (error: E) => U;
+  }) => (result: Result$1<T, E>) => U;
+  readonly fromTry: <T>(fn: () => T) => FromTryReturn<T>;
+};
+//#endregion
+export { all as n, Result as t };
+//# sourceMappingURL=index-DgOAEEpu.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DgOAEEpu.d.mts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;iBAqVgB,uBAAuB,uCAAyC,IAAI,eAAe;iBACnF,cAAc,eAAe,sCAAwC,IAAI,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;cA2K5F;0BApegB,MAAI,SAAW;2BAoBd,MAAI,gBAAkB;gCA2BjB,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;iCAgBlD,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;;;;;;;;uCAiSnE,kBACN,SAAW,GAAG,OAAK;4CAkBZ,MAAM,eAChB,SAAW,GAAG,OAAK;;gBAqBM,MAAM;iBAAgB,MAAM;iBACrD,SAAW,GAAG,OAAK;kCA+CO,MAAI,cAAc"}