@nicolastoulemont/std 0.3.0 → 0.5.0

package/dist/gen-DF-FXNdy.mjs

@@ -1,99 +0,0 @@
-import { n as err, r as ok } from "./result-C5tPWR60.mjs";
-
-//#region src/gen/gen.ts
-/**
-* Implementation of unified gen function.
-* Detects sync vs async generator and returns appropriate computation type.
-*/
-function gen(generatorFn) {
-	const runSync = () => {
-		const gen$1 = generatorFn();
-		if (Symbol.asyncIterator in gen$1) throw new Error("Cannot run sync on async generator. This should not happen if types are correct.");
-		const next = gen$1.next();
-		if (next.done !== true) return err(next.value);
-		return ok(next.value);
-	};
-	const runAsync = async () => {
-		const gen$1 = generatorFn();
-		if (Symbol.asyncIterator in gen$1) {
-			const next = await gen$1.next();
-			if (next.done !== true) return err(next.value);
-			return ok(next.value);
-		}
-		return runSync();
-	};
-	const testGen = generatorFn();
-	if (Symbol.asyncIterator in testGen) return {
-		run: runAsync,
-		async *[Symbol.asyncIterator]() {
-			const result = await runAsync();
-			if (!result.ok) {
-				yield result.error;
-				throw new Error("Unreachable: gen should short-circuit on error");
-			}
-			return result.value;
-		}
-	};
-	return {
-		run: runSync,
-		*[Symbol.iterator]() {
-			const result = runSync();
-			if (!result.ok) {
-				yield result.error;
-				throw new Error("Unreachable: Do should short-circuit on error");
-			}
-			return result.value;
-		}
-	};
-}
-/**
-* Implementation of ensure for sync/async predicates.
-*/
-function ensure(predicate, onFail) {
-	return (value) => {
-		const result = predicate(value);
-		const makeYieldable = (passes) => ({ *[Symbol.iterator]() {
-			if (!passes) {
-				yield onFail(value);
-				throw new Error("Unreachable: gen should short-circuit on error");
-			}
-			return value;
-		} });
-		if (result instanceof Promise) return result.then(makeYieldable);
-		return makeYieldable(result);
-	};
-}
-/**
-* Convert a type refinement to a yieldable with type narrowing.
-* Use this to narrow types within a gen computation.
-*
-* Note: Refinements are inherently synchronous (TypeScript type guards).
-*
-* @template T - The input type
-* @template U - The narrowed type (must extend T)
-* @template E - The error type on failure
-* @param refinement - A type guard function
-* @param onFail - A function that creates an error from the failing value
-* @returns A function that takes a value and returns a Yieldable with narrowed type
-*
-* @example
-* ```ts
-* const isString = (v: unknown): v is string => typeof v === "string"
-*
-* const result = gen(function* () {
-*   const str = yield* ensureRefinement(isString, () => "Expected string")(unknownValue)
-*   return str.toUpperCase()  // str is typed as string
-* }).run()
-* ```
-*/
-const ensureRefinement = (refinement, onFail) => (value) => ({ *[Symbol.iterator]() {
-	if (!refinement(value)) {
-		yield onFail(value);
-		throw new Error("Unreachable: gen should short-circuit on error");
-	}
-	return value;
-} });
-
-//#endregion
-export { ensureRefinement as n, gen as r, ensure as t };
-//# sourceMappingURL=gen-DF-FXNdy.mjs.map

package/dist/gen-DF-FXNdy.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"gen-DF-FXNdy.mjs","names":["gen"],"sources":["../src/gen/gen.ts"],"sourcesContent":["import { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { SyncComputation, AsyncComputation, GenGenerator, AsyncGenGenerator, Yieldable } from \"./gen.types\"\n\n/**\n * Create a computation from a sync generator function.\n * Returns a SyncComputation where run() returns Result directly (no Promise).\n *\n * @template A - The success value type\n * @template E - The error type\n * @param generatorFn - A function that returns a sync generator\n * @returns SyncComputation<A, E>\n *\n * @see {@link run} for immediate execution without storing the computation\n *\n * @example\n * ```ts\n * const result = gen(function* () {\n *   const a = yield* Result.yield(divide(10, 2))\n *   const b = yield* Result.yield(divide(a, 2))\n *   return b\n * }).run()\n * // Type: Result<number, \"DivisionByZero\">\n * ```\n */\nexport function gen<A, E>(generatorFn: () => GenGenerator<A, E>): SyncComputation<A, E>\n\n/**\n * Create a computation from an async generator function.\n * Returns an AsyncComputation where run() returns Promise<Result>.\n *\n * @template A - The success value type\n * @template E - The error type\n * @param generatorFn - A function that returns an async generator\n * @returns AsyncComputation<A, E>\n *\n * @see {@link run} for immediate execution without storing the computation\n *\n * @example\n * ```ts\n * const result = await gen(async function* () {\n *   const data = yield* Result.yield(await fetchData(1))\n *   return data\n * }).run()\n * // Type: Promise<Result<string, \"NetworkError\">>\n * ```\n */\nexport function gen<A, E>(generatorFn: () => AsyncGenGenerator<A, E>): AsyncComputation<A, E>\n\n/**\n * Implementation of unified gen function.\n * Detects sync vs async generator and returns appropriate computation type.\n */\nexport function gen<A, E>(\n  generatorFn: () => GenGenerator<A, E> | AsyncGenGenerator<A, E>,\n): SyncComputation<A, E> | AsyncComputation<A, E> {\n  // Helper to run sync generator\n  const runSync = (): Result<A, E> => {\n    const gen = generatorFn()\n\n    // Detect async generator at runtime (safety check)\n    if (Symbol.asyncIterator in gen) {\n      throw new Error(\"Cannot run sync on async generator. This should not happen if types are correct.\")\n    }\n\n    const syncGen = gen\n    const next = syncGen.next()\n\n    // If not done, an error was yielded (short-circuit)\n    if (next.done !== true) {\n      return err(next.value)\n    }\n\n    return ok(next.value)\n  }\n\n  // Helper to run async generator\n  const runAsync = async (): Promise<Result<A, E>> => {\n    const gen = generatorFn()\n\n    if (Symbol.asyncIterator in gen) {\n      // Async generator path\n      const asyncGen = gen\n      const next = await asyncGen.next()\n\n      if (next.done !== true) {\n        return err(next.value)\n      }\n      return ok(next.value)\n    }\n    // Sync generator can also use run() - just runs synchronously\n    return runSync()\n  }\n\n  // Check if we're dealing with async generator\n  // We need to call it once to check the type\n  const testGen = generatorFn()\n  const isAsync = Symbol.asyncIterator in testGen\n\n  if (isAsync) {\n    // Return AsyncComputation with Symbol.asyncIterator for nesting\n    return {\n      run: runAsync,\n      async *[Symbol.asyncIterator](): AsyncGenerator<E, A, unknown> {\n        const result = await runAsync()\n        if (!result.ok) {\n          yield result.error\n          throw new Error(\"Unreachable: gen should short-circuit on error\")\n        }\n        return result.value\n      },\n    } as AsyncComputation<A, E>\n  }\n  // Return SyncComputation (with Symbol.iterator for nesting)\n  return {\n    run: runSync,\n    *[Symbol.iterator](): Generator<E, A, unknown> {\n      const result = runSync()\n      if (!result.ok) {\n        yield result.error\n        // This line is never reached because outer Do stops iteration on first yield\n        // But TypeScript needs a return statement for the A type\n        throw new Error(\"Unreachable: Do should short-circuit on error\")\n      }\n      return result.value\n    },\n  } as SyncComputation<A, E>\n}\n\n// ============================================================================\n// Predicate Bridge Functions\n// ============================================================================\n\n/**\n * Convert a sync predicate to a yieldable.\n * Use this to validate values within a gen computation.\n *\n * @template T - The value type to validate\n * @template E - The error type on failure\n * @param predicate - A sync predicate function\n * @param onFail - A function that creates an error from the failing value\n * @returns A function that takes a value and returns a Yieldable\n *\n * @example\n * ```ts\n * const isPositive = (n: number) => n > 0\n *\n * const result = gen(function* () {\n *   const value = yield* ensure(isPositive, n => `${n} must be positive`)(userInput)\n *   return value * 2\n * }).run()\n * ```\n */\nexport function ensure<T, E>(predicate: (value: T) => boolean, onFail: (value: T) => E): (value: T) => Yieldable<T, E>\n\n/**\n * Convert an async predicate to an async yieldable.\n * Use this to validate values within an async gen computation.\n *\n * @template T - The value type to validate\n * @template E - The error type on failure\n * @param predicate - An async predicate function\n * @param onFail - A function that creates an error from the failing value\n * @returns A function that takes a value and returns a Promise<Yieldable>\n *\n * @example\n * ```ts\n * const isAvailable = async (id: number) => await checkAvailability(id)\n *\n * const result = await gen(async function* () {\n *   const id = yield* await ensure(isAvailable, id => `${id} not available`)(userId)\n *   return `user-${id}`\n * }).run()\n * ```\n */\nexport function ensure<T, E>(\n  predicate: (value: T) => Promise<boolean>,\n  onFail: (value: T) => E,\n): (value: T) => Promise<Yieldable<T, E>>\n\n/**\n * Implementation of ensure for sync/async predicates.\n */\nexport function ensure<T, E>(\n  predicate: (value: T) => boolean | Promise<boolean>,\n  onFail: (value: T) => E,\n): (value: T) => Yieldable<T, E> | Promise<Yieldable<T, E>> {\n  return (value: T) => {\n    const result = predicate(value)\n\n    const makeYieldable = (passes: boolean): Yieldable<T, E> => ({\n      *[Symbol.iterator](): Generator<E, T, unknown> {\n        if (!passes) {\n          yield onFail(value)\n          throw new Error(\"Unreachable: gen should short-circuit on error\")\n        }\n        return value\n      },\n    })\n\n    if (result instanceof Promise) {\n      return result.then(makeYieldable)\n    }\n    return makeYieldable(result)\n  }\n}\n\n/**\n * Convert a type refinement to a yieldable with type narrowing.\n * Use this to narrow types within a gen computation.\n *\n * Note: Refinements are inherently synchronous (TypeScript type guards).\n *\n * @template T - The input type\n * @template U - The narrowed type (must extend T)\n * @template E - The error type on failure\n * @param refinement - A type guard function\n * @param onFail - A function that creates an error from the failing value\n * @returns A function that takes a value and returns a Yieldable with narrowed type\n *\n * @example\n * ```ts\n * const isString = (v: unknown): v is string => typeof v === \"string\"\n *\n * const result = gen(function* () {\n *   const str = yield* ensureRefinement(isString, () => \"Expected string\")(unknownValue)\n *   return str.toUpperCase()  // str is typed as string\n * }).run()\n * ```\n */\nexport const ensureRefinement =\n  <T, U extends T, E>(refinement: (value: T) => value is U, onFail: (value: T) => E) =>\n  (value: T): Yieldable<U, E> => ({\n    *[Symbol.iterator](): Generator<E, U, unknown> {\n      if (!refinement(value)) {\n        yield onFail(value)\n        throw new Error(\"Unreachable: gen should short-circuit on error\")\n      }\n      return value\n    },\n  })\n"],"mappings":";;;;;;;AAqDA,SAAgB,IACd,aACgD;CAEhD,MAAM,gBAA8B;EAClC,MAAMA,QAAM,aAAa;AAGzB,MAAI,OAAO,iBAAiBA,MAC1B,OAAM,IAAI,MAAM,mFAAmF;EAIrG,MAAM,OADUA,MACK,MAAM;AAG3B,MAAI,KAAK,SAAS,KAChB,QAAO,IAAI,KAAK,MAAM;AAGxB,SAAO,GAAG,KAAK,MAAM;;CAIvB,MAAM,WAAW,YAAmC;EAClD,MAAMA,QAAM,aAAa;AAEzB,MAAI,OAAO,iBAAiBA,OAAK;GAG/B,MAAM,OAAO,MADIA,MACW,MAAM;AAElC,OAAI,KAAK,SAAS,KAChB,QAAO,IAAI,KAAK,MAAM;AAExB,UAAO,GAAG,KAAK,MAAM;;AAGvB,SAAO,SAAS;;CAKlB,MAAM,UAAU,aAAa;AAG7B,KAFgB,OAAO,iBAAiB,QAItC,QAAO;EACL,KAAK;EACL,QAAQ,OAAO,iBAAgD;GAC7D,MAAM,SAAS,MAAM,UAAU;AAC/B,OAAI,CAAC,OAAO,IAAI;AACd,UAAM,OAAO;AACb,UAAM,IAAI,MAAM,iDAAiD;;AAEnE,UAAO,OAAO;;EAEjB;AAGH,QAAO;EACL,KAAK;EACL,EAAE,OAAO,YAAsC;GAC7C,MAAM,SAAS,SAAS;AACxB,OAAI,CAAC,OAAO,IAAI;AACd,UAAM,OAAO;AAGb,UAAM,IAAI,MAAM,gDAAgD;;AAElE,UAAO,OAAO;;EAEjB;;;;;AAyDH,SAAgB,OACd,WACA,QAC0D;AAC1D,SAAQ,UAAa;EACnB,MAAM,SAAS,UAAU,MAAM;EAE/B,MAAM,iBAAiB,YAAsC,EAC3D,EAAE,OAAO,YAAsC;AAC7C,OAAI,CAAC,QAAQ;AACX,UAAM,OAAO,MAAM;AACnB,UAAM,IAAI,MAAM,iDAAiD;;AAEnE,UAAO;KAEV;AAED,MAAI,kBAAkB,QACpB,QAAO,OAAO,KAAK,cAAc;AAEnC,SAAO,cAAc,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BhC,MAAa,oBACS,YAAsC,YACzD,WAA+B,EAC9B,EAAE,OAAO,YAAsC;AAC7C,KAAI,CAAC,WAAW,MAAM,EAAE;AACtB,QAAM,OAAO,MAAM;AACnB,QAAM,IAAI,MAAM,iDAAiD;;AAEnE,QAAO;GAEV"}

package/dist/index-B3z7T6Dz.d.mts

@@ -1,57 +0,0 @@
-import { i as Result } from "./result.types-Bd8a43Fg.mjs";
-
-//#region src/fn/fn.d.ts
-
-/**
- * Convenience wrapper around gen() that executes the computation immediately
- * and returns the Result directly.
- *
- * Use this when you want inline execution without storing the computation.
- * For deferred execution, use gen() directly.
- *
- * @see {@link gen} for deferred/composable computations
- *
- * @example
- * ```typescript
- * // Sync computation
- * const result = fn(function* () {
- *   const a = yield* divide(10, 2)
- *   const b = yield* divide(a, 2)
- *   return b
- * })  // Result<number, "DivisionByZero">
- *
- * // Async computation
- * const user = await fn(async function* () {
- *   const data = yield* await fetchUser(1)
- *   return data.name
- * })  // Promise<Result<string, "NotFound">>
- *
- * // Type accumulation
- * const result = fn(function* () {
- *   const a = yield* divide(10, 2)      // "DivisionByZero"
- *   const b = yield* findUser(a)         // "NotFound"
- *   return b.name
- * })  // Result<string, "DivisionByZero" | "NotFound">
- * ```
- */
-/**
- * Execute a sync generator computation immediately.
- *
- * @template A - The success value type
- * @template E - The error type (union of all yielded error types)
- * @param generatorFn - A function returning a sync generator
- * @returns Result<A, E> directly
- */
-declare function fn<A, E>(generatorFn: () => Generator<E, A, unknown>): Result<A, E>;
-/**
- * Execute an async generator computation immediately.
- *
- * @template A - The success value type
- * @template E - The error type (union of all yielded error types)
- * @param generatorFn - A function returning an async generator
- * @returns Promise<Result<A, E>>
- */
-declare function fn<A, E>(generatorFn: () => AsyncGenerator<E, A, unknown>): Promise<Result<A, E>>;
-//#endregion
-export { fn as t };
-//# sourceMappingURL=index-B3z7T6Dz.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-B3z7T6Dz.d.mts","names":[],"sources":["../src/fn/fn.ts"],"sourcesContent":[],"mappings":";;;;;;AA4CA;;;;;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAVgB,4BAA4B,UAAU,GAAG,cAAc,OAAW,GAAG;;;;;;;;;iBAUrE,4BAA4B,eAAe,GAAG,cAAc,QAAQ,OAAW,GAAG"}

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

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

package/dist/index-BFhV56qy.d.mts

@@ -1,105 +0,0 @@
-import { i as Result } from "./result.types-Bd8a43Fg.mjs";
-
-//#region src/brand/brand.types.d.ts
-
-/**
- * Unique symbol for brand keys to ensure true nominal typing.
- * Using a symbol prevents collision with actual property keys.
- */
-declare const BrandSymbol: unique symbol;
-/**
- * A brand type that adds nominal typing to TypeScript.
- * The brand exists only at the type level - no runtime cost.
- *
- * @template K - The brand key (typically a string literal type)
- */
-type Brand$1<K extends string> = {
-  readonly [BrandSymbol]: K;
-};
-/**
- * Create a branded type by intersecting a base type with a brand.
- * The resulting type is structurally compatible with T but nominally unique.
- *
- * @template T - The base type to brand
- * @template K - The brand key (string literal)
- *
- * @example
- * ```ts
- * type UserId = Branded<string, "UserId">
- * type OrderId = Branded<string, "OrderId">
- *
- * // UserId and OrderId are incompatible even though both are strings
- * declare const userId: UserId
- * declare const orderId: OrderId
- * userId = orderId // Type error!
- * ```
- */
-type Branded<T, K extends string> = T & Brand$1<K>;
-/**
- * Extract the base type from a branded type.
- * Useful for working with the underlying value.
- *
- * @template B - A branded type
- */
-type Unbrand<B> = B extends Branded<infer T, string> ? T : B;
-/**
- * Extract the brand key from a branded type.
- *
- * @template B - A branded type
- */
-type BrandKey<B> = B extends Brand$1<infer K> ? K : never;
-/**
- * A validation function that checks if a value can be branded.
- * Returns true if the value passes validation, false otherwise.
- *
- * @template T - The base type being validated
- */
-type Validator<T> = (value: T) => boolean;
-/**
- * Error type returned when brand validation fails.
- * Contains the original value and error message for debugging.
- *
- * @template T - The type of the value that failed validation
- */
-type BrandError<T = unknown> = {
-  readonly __typename: "BrandError";
-  readonly value: T;
-  readonly message: string;
-};
-//#endregion
-//#region src/brand/brand.d.ts
-
-/**
- * Brand namespace containing utilities for nominal typing in TypeScript.
- *
- * Brand types add type-level distinctiveness to primitive types without
- * any runtime overhead. This prevents accidental mixing of semantically
- * different values that share the same structural type.
- *
- * @example
- * ```ts
- * import { Brand } from "@repo/std"
- * import type { Branded } from "@repo/std"
- *
- * // Define branded types
- * type UserId = Branded<string, "UserId">
- * type Email = Branded<string, "Email">
- *
- * // Create values
- * const userId = Brand.make<UserId>("user-123")
- * const isValidEmail = Brand.is<Email>(s => s.includes("@"))
- *
- * // Type safety
- * function sendEmail(email: Email) { ... }
- * sendEmail(userId) // Type error! UserId is not Email
- * ```
- */
-declare const Brand: {
-  readonly make: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
-  readonly unsafeMake: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
-  readonly is: <T, K extends string>(validator: Validator<T>) => ((value: T) => value is Branded<T, K>);
-  readonly refine: <B extends Branded<unknown, string>>(validator: Validator<Unbrand<B>>, errorMessage?: string | ((value: Unbrand<B>) => string)) => ((value: Unbrand<B>) => Result<B, BrandError<Unbrand<B>>>);
-};
-//#endregion
-export { Branded as a, BrandKey as i, Brand$1 as n, Unbrand as o, BrandError as r, Validator as s, Brand as t };
-//# sourceMappingURL=index-BFhV56qy.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BFhV56qy.d.mts","names":[],"sources":["../src/brand/brand.types.ts","../src/brand/brand.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAYA,cARc,WAQG,EAAA,OACL,MAAA;AAqBZ;;;;;AAQA;AAAyB,KA9Bb,OA8Ba,CAAA,UAAA,MAAA,CAAA,GAAA;EAAU,UA7BvB,WAAA,CA6BuB,EA7BT,CA6BS;CAA+B;;AAOlE;AAQA;AAiBA;;;;ACqFA;;;;;;;;;;;AApF2E,KDzC/D,OCyC+D,CAAA,CAAA,EAAA,UAAA,MAAA,CAAA,GDzChC,CCyCgC,GDzC5B,OCyC4B,CDzCtB,CCyCsB,CAAA;;;;;;;AA+C9D,KDhFD,OCgFC,CAAA,CAAA,CAAA,GDhFY,CCgFZ,SDhFsB,OCgFtB,CAAA,KAAA,EAAA,EAAA,MAAA,CAAA,GAAA,CAAA,GDhFqD,CCgFrD;;;;;;AAE+C,KD3EhD,QC2EgD,CAAA,CAAA,CAAA,GD3ElC,CC2EkC,SD3ExB,OC2EwB,CAAA,KAAA,EAAA,CAAA,GAAA,CAAA,GAAA,KAAA;;;;;;;KDnEhD,uBAAuB;;;;;;;KAiBvB;;kBAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCmFL;4BAlIkB,iCAAiC,QAAQ,OAAK;kCAoBxC,iCAAiC,QAAQ,OAAK;gDA0BhC,UAAU,gBAAc,eAAe,QAAQ,GAAG;8BA8CpE,qCACpB,UAAU,QAAQ,sCACI,QAAQ,4BAC/B,QAAQ,OAAO,OAAW,GAAG,WAAW,QAAQ"}

package/dist/index-BLG9B4bn.d.mts

@@ -1,116 +0,0 @@
-import { _ as GenGenerator, d as AsyncComputation, f as AsyncGenGenerator, v as SyncComputation, y as Yieldable } from "./result.types-Bd8a43Fg.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>;
-/**
- * Convert a sync predicate to a yieldable.
- * Use this to validate values within a gen computation.
- *
- * @template T - The value type to validate
- * @template E - The error type on failure
- * @param predicate - A sync predicate function
- * @param onFail - A function that creates an error from the failing value
- * @returns A function that takes a value and returns a Yieldable
- *
- * @example
- * ```ts
- * const isPositive = (n: number) => n > 0
- *
- * const result = gen(function* () {
- *   const value = yield* ensure(isPositive, n => `${n} must be positive`)(userInput)
- *   return value * 2
- * }).run()
- * ```
- */
-declare function ensure<T, E>(predicate: (value: T) => boolean, onFail: (value: T) => E): (value: T) => Yieldable<T, E>;
-/**
- * Convert an async predicate to an async yieldable.
- * Use this to validate values within an async gen computation.
- *
- * @template T - The value type to validate
- * @template E - The error type on failure
- * @param predicate - An async predicate function
- * @param onFail - A function that creates an error from the failing value
- * @returns A function that takes a value and returns a Promise<Yieldable>
- *
- * @example
- * ```ts
- * const isAvailable = async (id: number) => await checkAvailability(id)
- *
- * const result = await gen(async function* () {
- *   const id = yield* await ensure(isAvailable, id => `${id} not available`)(userId)
- *   return `user-${id}`
- * }).run()
- * ```
- */
-declare function ensure<T, E>(predicate: (value: T) => Promise<boolean>, onFail: (value: T) => E): (value: T) => Promise<Yieldable<T, E>>;
-/**
- * Convert a type refinement to a yieldable with type narrowing.
- * Use this to narrow types within a gen computation.
- *
- * Note: Refinements are inherently synchronous (TypeScript type guards).
- *
- * @template T - The input type
- * @template U - The narrowed type (must extend T)
- * @template E - The error type on failure
- * @param refinement - A type guard function
- * @param onFail - A function that creates an error from the failing value
- * @returns A function that takes a value and returns a Yieldable with narrowed type
- *
- * @example
- * ```ts
- * const isString = (v: unknown): v is string => typeof v === "string"
- *
- * const result = gen(function* () {
- *   const str = yield* ensureRefinement(isString, () => "Expected string")(unknownValue)
- *   return str.toUpperCase()  // str is typed as string
- * }).run()
- * ```
- */
-declare const ensureRefinement: <T, U extends T, E>(refinement: (value: T) => value is U, onFail: (value: T) => E) => (value: T) => Yieldable<U, E>;
-//#endregion
-export { ensureRefinement as n, gen as r, ensure as t };
-//# sourceMappingURL=index-BLG9B4bn.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BLG9B4bn.d.mts","names":[],"sources":["../src/gen/gen.ts"],"sourcesContent":[],"mappings":";;;;;;AAyBA;;;;;;;;AAsBA;;;;;;;;AA0GA;;;AAAqF,iBAhIrE,GAgIqE,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,WAAA,EAAA,GAAA,GAhIxC,YAgIwC,CAhI3B,CAgI2B,EAhIxB,CAgIwB,CAAA,CAAA,EAhInB,eAgImB,CAhIH,CAgIG,EAhIA,CAgIA,CAAA;;;;;;AAsBrF;;;;;;;;;;;AAuDA;;;;AAC4E,iBAxL5D,GAwL4D,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,WAAA,EAAA,GAAA,GAxL/B,iBAwL+B,CAxLb,CAwLa,EAxLV,CAwLU,CAAA,CAAA,EAxLL,gBAwLK,CAxLY,CAwLZ,EAxLe,CAwLf,CAAA;;;;;;;;;;;;;;;;;;;;;iBA9E5D,gCAAgC,+BAA+B,MAAM,YAAY,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;iBAsBpG,gCACK,MAAM,kCACT,MAAM,YACb,MAAM,QAAQ,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;cAoDzB,gCACG,0BAA0B,eAAe,mBAAmB,MAAM,cACxE,MAAI,UAAU,GAAG"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BR7takNf.d.mts","names":[],"sources":["../src/err/err.types.ts","../src/err/err.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;AAWA;;;;;;;;AAGyB,KAdb,aAca,CAAA,YAAA,MAAA,EAAA,aAAA,MAAA,GAAA,MAAA,CAAA,GAAA;EAAS,SAAA,UAAA,EAbX,GAaW;AASlC,CAAA,GArBI,QAqBQ,CArBC,IAqBD,CAAA;;;;;;;;AAkBA,KA9BA,mBA8BwB,CAAA,YAAW,MAAA,EAAA,aAAA,MAAA,GAAA,MAAA,CAAA,GA9BqC,KA8BrC,GA7B7C,QA6B6C,CA7BpC,IA6BoC,CAAA,GAAA;EAanC,SAAA,UAAS,EAzCI,GAyCJ;uBAxCI,UAAU,oBAAoB,KAAK;;;AC5BM;;;;;AAU7D,KD2BO,kBC3BI,CAAA,YAAmB,MAAA,CAAA,GAAA;EAkEnB,IAAA,CAAA,aAAW,MAAA,GAAA,MAAA,CAAA,CAAA,GAAA,IAAA,EAAA,MDrCR,ICqCQ,SAAA,KAAA,GAAA,EAAA,GAAA,CAAA,IAAA,EDrCyB,ICqCzB,CAAA,CAAA,EDpCtB,mBCoCsB,CDpCF,GCoCE,EDpCG,ICoCH,CAAA;EAA0B,SAAA,UAAA,EDnC9B,GCmC8B;CAAyB;;;AAqG9E;;;;;;;;;AA3I0E,KDiB9D,QCjB8D,CAAA,CAAA,CAAA,GDiBhD,CCjBgD,SDiBtC,aCjBsC,CAAA,KAAA,IAAA,CAAA,GAAA,GAAA,GAAA,KAAA;;;;;;;;;;;;KD8B9D,eAAe,UAAU;;;AAtDrC;;;KCTK,MDWD,CAAA,UCXkB,WDWlB,CAAA,MAAA,CAAA,CAAA,GCXyC,IDWzC,CCX8C,CDW9C,EAAA,YAAA,CAAA;;AASJ;;KCfK,WDgBM,CAAA,IAAA,CAAA,GAAA,MChBoB,IDgBpB,SAAA,KAAA,GAAA,IAAA,GAAA,KAAA;;;;;;;;AAWX;;;;;;;;AAkBA;AAaA;;;;ACpEkE;;;;;AAKjB;AAuEjD;;;;;AAqGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBArGgB,qCAAqC,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqGjE;8BA7ImB,0BACzB,oBACF,YAAY,OAAO,yBAAyB,WAAW,OAAO,OAAO;0BAwF7C,0BAA0B,kDAAgD"}

package/dist/index-BiFc2xWF.d.mts

@@ -1,211 +0,0 @@
-import { i as Result, y as Yieldable } from "./result.types-Bd8a43Fg.mjs";
-import { a as Option } from "./option.types-eqVODMIy.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-BiFc2xWF.d.mts.map

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

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