functype 0.49.0 → 0.50.0

package/dist/Brand-BJIRbUKB.d.ts

@@ -0,0 +1,54 @@
+//#region src/branded/Brand.d.ts
+type Brand<K extends string, T> = T & {
+  readonly __brand: K;
+};
+type Unwrap<T> = T extends Brand<string, infer U> ? U : T;
+type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never;
+/**
+ * Brand is a utility for creating nominal typing in TypeScript.
+ * It creates phantom types that exist only at compile time.
+ * At runtime, the branded value IS the primitive value.
+ *
+ * @param _brand
+ * @param value - The value to brand
+ * @returns The value with phantom type brand
+ */
+declare function Brand<K extends string, T>(_brand: K, value: T): Brand<K, T>;
+/**
+ * Helper to unwrap a branded value to its underlying type
+ * Works with both Brand and ValidatedBrand
+ * @param branded - The branded value (can be null or undefined)
+ * @returns The original value without the brand
+ *
+ * Note: Also exported as 'unwrap' from 'functype/branded' for convenience
+ */
+declare function unwrapBrand<K extends string, T>(branded: Brand<K, T>): T;
+declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null): T | null;
+declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | undefined): T | undefined;
+declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null | undefined): T | null | undefined;
+/**
+ * Type guard for checking if a value has a specific brand
+ * @param value - The value to check
+ * @param _brand - The brand to check for (unused at runtime)
+ * @returns True if the value has the specified brand
+ *
+ * Note: Since brands are phantom types that exist only at compile time,
+ * this function can only provide a runtime approximation. It always returns true
+ * for non-null values, as we have no way to actually check the brand at runtime.
+ * This function is primarily for API consistency and documentation purposes.
+ */
+declare function hasBrand<K extends string, T>(value: unknown, _brand: K): value is Brand<K, T>;
+/**
+ * Create a branded type constructor for a specific brand
+ * @param brand - The brand name
+ * @returns A function that brands values with the specified brand
+ */
+declare function createBrander<K extends string, T>(brand: K): (value: T) => Brand<K, T>;
+type BrandedString<K extends string> = Brand<K, string>;
+type BrandedNumber<K extends string> = Brand<K, number>;
+type BrandedBoolean<K extends string> = Brand<K, boolean>;
+declare const BrandedString: <K extends string>(brand: K) => (value: string) => BrandedString<K>;
+declare const BrandedNumber: <K extends string>(brand: K) => (value: number) => BrandedNumber<K>;
+declare const BrandedBoolean: <K extends string>(brand: K) => (value: boolean) => BrandedBoolean<K>;
+//#endregion
+export { ExtractBrand as a, hasBrand as c, BrandedString as i, unwrapBrand as l, BrandedBoolean as n, Unwrap as o, BrandedNumber as r, createBrander as s, Brand as t };

package/dist/{Typeable-lfO2nRVW.d.ts → Tuple-DmywDCE9.d.ts}

@@ -101,4 +101,78 @@ declare function Typeable<Tag extends string, T>({
  */
 declare function isTypeable<T>(value: unknown, tag: string): value is T;
 //#endregion
-export { Serializable as a, Foldable as c, isTypeable as i, Type as l, Typeable as n, SerializationMethods as o, TypeableParams as r, Pipe as s, ExtractTag as t };
+//#region src/tuple/Tuple.d.ts
+interface Tuple<T extends Type[]> extends Foldable<T[number]>, Pipe<Tuple<T>>, Serializable<Tuple<T>>, Typeable<"Tuple"> {
+  readonly [Symbol.toStringTag]: string;
+  get<K extends number>(index: K): T[K];
+  map<U extends Type[]>(f: (value: T) => U): Tuple<U>;
+  flatMap<U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U>;
+  toArray(): T;
+  length: number;
+  [Symbol.iterator](): Iterator<T[number]>;
+  toString(): string;
+  toValue(): {
+    _tag: "Tuple";
+    value: T;
+  };
+}
+/**
+ * Tuple provides a type-safe, fixed-length array with functional operations.
+ *
+ * @example
+ * // Creating tuples
+ * const t1 = Tuple([1, "hello", true])
+ * const t2 = Tuple.of(1, "hello", true)
+ * const pair = Tuple.pair("key", 42)
+ *
+ * @example
+ * // Type-safe access
+ * const triple = Tuple.triple("x", 10, true)
+ * const first = triple.get(0)  // string
+ * const second = triple.get(1) // number
+ * const third = triple.get(2)  // boolean
+ *
+ * @example
+ * // Functional operations
+ * const doubled = Tuple([1, 2, 3])
+ *   .map(arr => arr.map(x => x * 2))
+ *   .toArray() // [2, 4, 6]
+ */
+declare const Tuple: (<T extends Type[]>(values: T) => Tuple<T>) & {
+  /**
+   * Create a Tuple from multiple arguments
+   * @example
+   * const t = Tuple.of(1, "hello", true)
+   * // TypeScript infers: Tuple<[number, string, boolean]>
+   */
+  of: <T extends Type[]>(...values: T) => Tuple<T>;
+  /**
+   * Create a Tuple of size 2 (pair)
+   * @example
+   * const pair = Tuple.pair("key", 42)
+   * // TypeScript infers: Tuple<[string, number]>
+   */
+  pair: <A extends Type, B extends Type>(first: A, second: B) => Tuple<[A, B]>;
+  /**
+   * Create a Tuple of size 3 (triple)
+   * @example
+   * const triple = Tuple.triple("x", 10, true)
+   * // TypeScript infers: Tuple<[string, number, boolean]>
+   */
+  triple: <A extends Type, B extends Type, C extends Type>(first: A, second: B, third: C) => Tuple<[A, B, C]>;
+  /**
+   * Create an empty Tuple
+   * @example
+   * const empty = Tuple.empty()
+   * // TypeScript infers: Tuple<[]>
+   */
+  empty: () => Tuple<[]>;
+  /**
+   * Create a Tuple from an array (alias for constructor)
+   * @example
+   * const t = Tuple.from([1, 2, 3])
+   */
+  from: <T extends Type[]>(values: T) => Tuple<T>;
+};
+//#endregion
+export { isTypeable as a, Pipe as c, TypeableParams as i, Foldable as l, ExtractTag as n, Serializable as o, Typeable as r, SerializationMethods as s, Tuple as t, Type as u };

package/dist/Tuple-eVwTSeSr.js

@@ -0,0 +1 @@
+function e(e,t){return Object.assign(e,t)}function t(t,n){return e(t,n)}function n(e){if(e===void 0||typeof e==`symbol`||typeof e==`function`)return;let t=new Set;function n(e){if(e===null)return`null`;switch(typeof e){case`string`:return JSON.stringify(e);case`number`:return isFinite(e)?String(e):`null`;case`boolean`:return String(e);case`bigint`:return`"${e}"`;case`undefined`:case`symbol`:case`function`:return}let r=e;if(t.has(r))return`"[Circular]"`;t.add(r);try{if(`toJSON`in r&&typeof r.toJSON==`function`)return n(r.toJSON());if(Array.isArray(r))return`[${r.map(e=>n(e)??`null`).join(`,`)}]`;let e=Object.keys(r).sort(),t=[];for(let i of e){let e=n(r[i]);e!==void 0&&t.push(`${JSON.stringify(i)}:${e}`)}return`{${t.join(`,`)}}`}finally{t.delete(r)}}try{return n(e)}catch{return}}const r=e=>{let t={[Symbol.toStringTag]:`Tuple`,_tag:`Tuple`,map:t=>i(t(e)),flatMap:t=>t(e),get:t=>e[t],toArray:()=>e,length:e.length,[Symbol.iterator](){let t=0;return{next:()=>t<e.length?{value:e[t++],done:!1}:{value:void 0,done:!0}}},fold:(t,n)=>e.length===0?t():n(e[0]),foldLeft:t=>n=>e.reduce(n,t),foldRight:t=>n=>e.reduceRight((e,t)=>n(t,e),t),pipe:e=>e(t),serialize:()=>({toJSON:()=>JSON.stringify({_tag:`Tuple`,value:e}),toYAML:()=>`_tag: Tuple\nvalue: ${n(e)}`,toBinary:()=>Buffer.from(JSON.stringify({_tag:`Tuple`,value:e})).toString(`base64`)}),toValue:()=>({_tag:`Tuple`,value:e}),toString:()=>`Tuple(${e.map(e=>String(e)).join(`, `)})`};return t},i=t(e=>r(e),{of:(...e)=>r(e),pair:(e,t)=>r([e,t]),triple:(e,t,n)=>r([e,t,n]),empty:()=>r([]),from:e=>r(e)});export{e as i,n,t as r,i as t};

package/dist/branded/index.d.ts

@@ -1,54 +1,2 @@
-//#region src/branded/Brand.d.ts
-type Brand<K extends string, T> = T & {
-  readonly __brand: K;
-};
-type Unwrap<T> = T extends Brand<string, infer U> ? U : T;
-type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never;
-/**
- * Brand is a utility for creating nominal typing in TypeScript.
- * It creates phantom types that exist only at compile time.
- * At runtime, the branded value IS the primitive value.
- *
- * @param _brand
- * @param value - The value to brand
- * @returns The value with phantom type brand
- */
-declare function Brand<K extends string, T>(_brand: K, value: T): Brand<K, T>;
-/**
- * Helper to unwrap a branded value to its underlying type
- * Works with both Brand and ValidatedBrand
- * @param branded - The branded value (can be null or undefined)
- * @returns The original value without the brand
- *
- * Note: Also exported as 'unwrap' from 'functype/branded' for convenience
- */
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T>): T;
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null): T | null;
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | undefined): T | undefined;
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null | undefined): T | null | undefined;
-/**
- * Type guard for checking if a value has a specific brand
- * @param value - The value to check
- * @param _brand - The brand to check for (unused at runtime)
- * @returns True if the value has the specified brand
- *
- * Note: Since brands are phantom types that exist only at compile time,
- * this function can only provide a runtime approximation. It always returns true
- * for non-null values, as we have no way to actually check the brand at runtime.
- * This function is primarily for API consistency and documentation purposes.
- */
-declare function hasBrand<K extends string, T>(value: unknown, _brand: K): value is Brand<K, T>;
-/**
- * Create a branded type constructor for a specific brand
- * @param brand - The brand name
- * @returns A function that brands values with the specified brand
- */
-declare function createBrander<K extends string, T>(brand: K): (value: T) => Brand<K, T>;
-type BrandedString<K extends string> = Brand<K, string>;
-type BrandedNumber<K extends string> = Brand<K, number>;
-type BrandedBoolean<K extends string> = Brand<K, boolean>;
-declare const BrandedString: <K extends string>(brand: K) => (value: string) => BrandedString<K>;
-declare const BrandedNumber: <K extends string>(brand: K) => (value: number) => BrandedNumber<K>;
-declare const BrandedBoolean: <K extends string>(brand: K) => (value: boolean) => BrandedBoolean<K>;
-//#endregion
+import { a as ExtractBrand, c as hasBrand, i as BrandedString, l as unwrapBrand, n as BrandedBoolean, o as Unwrap, r as BrandedNumber, s as createBrander, t as Brand } from "../Brand-BJIRbUKB.js";
 export { Brand, BrandedBoolean, BrandedNumber, BrandedString, ExtractBrand, Unwrap, createBrander, hasBrand, unwrapBrand as unwrap, unwrapBrand };

package/dist/cli/exports.js

@@ -1 +1 @@
-import{a as e,i as t,n,r,t as i}from"../full-interfaces-DzRVS-A-.js";export{n as CATEGORIES,i as FULL_INTERFACES,r as INTERFACES,t as TYPES,e as VERSION};
+import{a as e,i as t,n,r,t as i}from"../full-interfaces-DVRjnPWW.js";export{n as CATEGORIES,i as FULL_INTERFACES,r as INTERFACES,t as TYPES,e as VERSION};

package/dist/cli/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import{P as e}from"../Valuable-GZAXcYok.js";import{Option as t}from"../option/index.js";import{List as n}from"../list/index.js";import{a as r,i,n as a,r as o,t as s}from"../full-interfaces-DzRVS-A-.js";const c=()=>{let e=n([`functype ${r} - Scala-inspired FP for TypeScript`,``]);return n(Object.entries(a)).foldLeft(e)((e,[r,a])=>{let o=e.add(r.toUpperCase());return n(a).foldLeft(o)((e,n)=>t(i[n]).fold(()=>e,t=>{let r=t.interfaces.length>0?` [${t.interfaces.join(`, `)}]`:``;return e.add(`  ${n}${r}`).add(`    ${t.description}`)})).add(``)}).concat(n([`Use: npx functype <Type> for details`,`Use: npx functype interfaces for interface reference`])).toArray().join(`
-`)},l=(e,r)=>{let i=r.interfaces.length>0?` [${r.interfaces.join(`, `)}]`:``,a=n([`create`,`transform`,`extract`,`check`,`other`]),o=n([`${e}<T>${i}`,``,r.description,``]);return a.foldLeft(o)((e,i)=>t(r.methods[i]).filter(e=>e.length>0).fold(()=>e,t=>{let r=e.add(i.toUpperCase());return n(t).foldLeft(r)((e,t)=>e.add(`  ${t}`)).add(``)})).toArray().join(`
+import{Ct as e,W as t,ht as n}from"../src-ByDeJzWj.js";import{a as r,i,n as a,r as o,t as s}from"../full-interfaces-DVRjnPWW.js";const c=()=>{let t=n([`functype ${r} - Scala-inspired FP for TypeScript`,``]);return n(Object.entries(a)).foldLeft(t)((t,[r,a])=>{let o=t.add(r.toUpperCase());return n(a).foldLeft(o)((t,n)=>e(i[n]).fold(()=>t,e=>{let r=e.interfaces.length>0?` [${e.interfaces.join(`, `)}]`:``;return t.add(`  ${n}${r}`).add(`    ${e.description}`)})).add(``)}).concat(n([`Use: npx functype <Type> for details`,`Use: npx functype interfaces for interface reference`])).toArray().join(`
+`)},l=(t,r)=>{let i=r.interfaces.length>0?` [${r.interfaces.join(`, `)}]`:``,a=n([`create`,`transform`,`extract`,`check`,`other`]),o=n([`${t}<T>${i}`,``,r.description,``]);return a.foldLeft(o)((t,i)=>e(r.methods[i]).filter(e=>e.length>0).fold(()=>t,e=>{let r=t.add(i.toUpperCase());return n(e).foldLeft(r)((e,t)=>e.add(`  ${t}`)).add(``)})).toArray().join(`
 `).trimEnd()},u=()=>{let e=n([`INTERFACES`,``]);return n(Object.entries(o)).foldLeft(e)((e,[t,r])=>{let i=r.extends?` extends ${r.extends}`:``,a=e.add(`${t}<A>${i}`).add(`  ${r.description}`);return n(r.methods).foldLeft(a)((e,t)=>e.add(`  ${t}`)).add(``)}).toArray().join(`
-`).trimEnd()},d=e=>JSON.stringify(e,null,2),f=()=>({version:r,categories:a,types:i}),p=e=>t(i[e]).map(t=>({name:e,data:t})).or(n(Object.entries(i)).find(([t])=>t.toLowerCase()===e.toLowerCase()).map(([e,t])=>({name:e,data:t}))).orUndefined(),m=()=>Object.keys(i),h=()=>o,g=e=>{let t=n(e.slice(2));return{flags:{json:t.contains(`--json`),full:t.contains(`--full`),help:t.exists(e=>e===`--help`||e===`-h`)},args:t.filter(e=>!e.startsWith(`--`)&&e!==`-h`)}},_=e=>t(s[e]).or(n(Object.entries(s)).find(([t])=>t.toLowerCase()===e.toLowerCase()).map(([,e])=>e)),v=()=>{let e=n([`FULL INTERFACE DEFINITIONS`,`=`.repeat(60),``]);return n(Object.entries(s)).foldLeft(e)((e,[t,r])=>e.concat(n([`// ${t}`,r,``,`-`.repeat(60),``]))).toArray().join(`
+`).trimEnd()},d=e=>JSON.stringify(e,null,2),f=()=>({version:r,categories:a,types:i}),p=t=>e(i[t]).map(e=>({name:t,data:e})).or(n(Object.entries(i)).find(([e])=>e.toLowerCase()===t.toLowerCase()).map(([e,t])=>({name:e,data:t}))).orUndefined(),m=()=>Object.keys(i),h=()=>o,g=e=>{let t=n(e.slice(2));return{flags:{json:t.contains(`--json`),full:t.contains(`--full`),help:t.exists(e=>e===`--help`||e===`-h`)},args:t.filter(e=>!e.startsWith(`--`)&&e!==`-h`)}},_=t=>e(s[t]).or(n(Object.entries(s)).find(([e])=>e.toLowerCase()===t.toLowerCase()).map(([,e])=>e)),v=()=>{let e=n([`FULL INTERFACE DEFINITIONS`,`=`.repeat(60),``]);return n(Object.entries(s)).foldLeft(e)((e,[t,r])=>e.concat(n([`// ${t}`,r,``,`-`.repeat(60),``]))).toArray().join(`
 `).trimEnd()},y=()=>{console.log(`functype - API documentation for LLMs
 
 USAGE
@@ -24,4 +24,4 @@ EXAMPLES
   npx functype Option --json # Option as JSON
   npx functype Option --full # Full TypeScript interface
   npx functype --full       # All full interfaces (large output!)
-`)},b=e=>{console.error(`Unknown type: ${e}`),console.error(``),console.error(`Available types: ${m().join(`, `)}`),console.error(``),console.error(`Use: npx functype interfaces - for interface reference`),process.exit(1)},x=e=>console.log(e),S=(e,n)=>t(p(e)).fold(()=>b(e),e=>{n.full?_(e.name).fold(()=>x(n.json?d({[e.name]:e.data}):l(e.name,e.data)),t=>x(n.json?d({[e.name]:{...e.data,fullInterface:t}}):t)):x(n.json?d({[e.name]:e.data}):l(e.name,e.data))});(()=>{let{flags:t,args:n}=g(process.argv);e(!0).when(()=>t.help,()=>y()).when(()=>n.isEmpty,()=>t.full?x(t.json?d(s):v()):x(t.json?d(f()):c())).when(()=>n.headOption.contains(`interfaces`),()=>x(t.json?d(h()):u())).default(()=>n.headOption.fold(()=>x(t.json?d(f()):c()),e=>S(e,t)))})();
+`)},b=e=>{console.error(`Unknown type: ${e}`),console.error(``),console.error(`Available types: ${m().join(`, `)}`),console.error(``),console.error(`Use: npx functype interfaces - for interface reference`),process.exit(1)},x=e=>console.log(e),S=(t,n)=>e(p(t)).fold(()=>b(t),e=>{n.full?_(e.name).fold(()=>x(n.json?d({[e.name]:e.data}):l(e.name,e.data)),t=>x(n.json?d({[e.name]:{...e.data,fullInterface:t}}):t)):x(n.json?d({[e.name]:e.data}):l(e.name,e.data))});(()=>{let{flags:e,args:n}=g(process.argv);t(!0).when(()=>e.help,()=>y()).when(()=>n.isEmpty,()=>e.full?x(e.json?d(s):v()):x(e.json?d(f()):c())).when(()=>n.headOption.contains(`interfaces`),()=>x(e.json?d(h()):u())).default(()=>n.headOption.fold(()=>x(e.json?d(f()):c()),t=>S(t,e)))})();

package/dist/do/index.d.ts

@@ -1,184 +1,2 @@
-import { mn as Doable, nn as Reshapeable, pn as DoResult } from "../Functype-rgysbeU6.js";
-import { Try } from "../try/index.js";
-import { Option } from "../option/index.js";
-import { List } from "../list/index.js";
-import { Either } from "../either/index.js";
-
-//#region src/do/index.d.ts
-type OptionLike = {
-  _tag: "Some" | "None";
-  isSome(): boolean;
-  get(): unknown;
-};
-type EitherLike = {
-  _tag: "Left" | "Right";
-  isLeft(): boolean;
-  isRight(): boolean;
-  value: unknown;
-};
-type ListLike = {
-  _tag: "List";
-  toArray(): unknown[];
-};
-type TryLike = {
-  _tag: "Success" | "Failure";
-  isSuccess(): boolean;
-  get(): unknown;
-};
-/**
- * Executes a generator-based monadic comprehension
- * Returns the same monad type as the first yielded monad (Scala semantics)
- *
- * - Option comprehensions return Option (None on short-circuit)
- * - Either comprehensions return Either (Left with error on short-circuit)
- * - List comprehensions return List (empty or cartesian product)
- * - Try comprehensions return Try (Failure with error on short-circuit)
- *
- * Type Inference Notes:
- * - TypeScript infers the correct return type for homogeneous comprehensions
- * - For mixed monad types, TypeScript returns a union type
- * - Use DoTyped<T> or type assertions for mixed scenarios
- *
- * @example
- * ```typescript
- * // Option comprehension returns Option:
- * const result = Do(function* () {
- *   const x = yield* $(Option(5));
- *   const y = yield* $(Option(10));
- *   return x + y;
- * });
- * // result: Option(15)
- *
- * // Either comprehension returns Either:
- * const result = Do(function* () {
- *   const x = yield* $(Right(5));
- *   const y = yield* $(Left("error"));
- *   return x + y;
- * });
- * // result: Left("error") - error is preserved
- *
- * // List comprehension returns List with cartesian product:
- * const result = Do(function* () {
- *   const x = yield* $(List([1, 2]));
- *   const y = yield* $(List([3, 4]));
- *   return x + y;
- * });
- * // result: List([4, 5, 5, 6])
- *
- * // Mixed types - use type assertion or DoTyped:
- * const result = Do(function* () {
- *   const x = yield* $(Option(5));
- *   const y = yield* $(Right<string, number>(10));
- *   return x + y;
- * }) as Option<number>;
- * // result: Option(15)
- * ```
- *
- * @param gen - Generator function that yields monads and returns a result
- * @returns The same monad type as the first yield
- */
-declare function Do<T>(gen: () => Generator<OptionLike, T, unknown>): Option<T>;
-declare function Do<L, R>(gen: () => Generator<EitherLike, R, unknown>): Either<L, R>;
-declare function Do<T>(gen: () => Generator<ListLike, T, unknown>): List<T>;
-declare function Do<T>(gen: () => Generator<TryLike, T, unknown>): Try<T>;
-declare function Do<T>(gen: () => Generator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>): Reshapeable<T>;
-declare function Do<T>(gen: () => Generator<unknown, T, unknown>): unknown;
-/**
- * Executes an async generator-based monadic comprehension
- * Returns the same monad type as the first yielded monad
- *
- * @example
- * ```typescript
- * const result = await DoAsync(async function* () {
- *   const user = yield* $(await fetchUser(id));       // Promise<Option<User>> → User
- *   const profile = yield* $(await getProfile(user)); // Promise<Either<Error, Profile>> → Profile
- *   return { user, profile };
- * });
- * // result type matches first yield
- * ```
- *
- * @param gen - Async generator function that yields monads/promises and returns a result
- * @returns Promise of the same monad type as first yield
- */
-declare function DoAsync<T>(gen: () => AsyncGenerator<OptionLike, T, unknown>): Promise<Option<T>>;
-declare function DoAsync<L, R>(gen: () => AsyncGenerator<EitherLike, R, unknown>): Promise<Either<L, R>>;
-declare function DoAsync<T>(gen: () => AsyncGenerator<ListLike, T, unknown>): Promise<List<T>>;
-declare function DoAsync<T>(gen: () => AsyncGenerator<TryLike, T, unknown>): Promise<Try<T>>;
-declare function DoAsync<T>(gen: () => AsyncGenerator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>): Promise<Reshapeable<T>>;
-declare function DoAsync<T>(gen: () => AsyncGenerator<unknown, T, unknown>): Promise<unknown>;
-/**
- * Helper function to check if a value implements the Doable interface
- * @param value - Value to check
- * @returns True if the value implements Doable
- */
-declare function isDoCapable<T>(value: unknown): value is Doable<T>;
-/**
- * Manually unwrap a monad using the Doable interface
- * Useful for testing or when you need to unwrap outside of a Do-comprehension
- *
- * @param monad - Monad to unwrap
- * @returns The unwrapped value
- * @throws Error if the monad cannot be unwrapped
- */
-declare function unwrap<T>(monad: Doable<T>): T;
-/**
- * Type helper for Do-notation generators.
- * Provides better type hints in IDEs.
- *
- * @example
- * ```typescript
- * const result = Do(function* (): DoGenerator<number> {
- *   const x = yield* $(List([1, 2]))  // x is still unknown but return type is clear
- *   const y = yield* $(List([3, 4]))
- *   return x + y
- * })
- * ```
- */
-type DoGenerator<T, TYield = unknown> = Generator<TYield, T, unknown>;
-/**
- * Extracts values from monads in Do-notation with type inference.
- * The '$' symbol is the universal extraction operator in functional programming.
- *
- * @example
- * ```typescript
- * const result = Do(function* () {
- *   const x = yield* $(Option(5))        // x: number
- *   const y = yield* $(List([1, 2, 3]))  // y: number (for cartesian product)
- *   const name = yield* $(Right("Alice")) // name: string
- *   return `${name}: ${x + y}`
- * })
- * ```
- *
- * @param monad - Any monad that can be unwrapped (Option, Either, List, Try, etc.)
- * @returns A generator that yields the monad and returns its extracted value
- */
-declare function $<T>(monad: Option<T>): Generator<Option<T>, T, T>;
-declare function $<L, R>(monad: Either<L, R>): Generator<Either<L, R>, R, R>;
-declare function $<T>(monad: List<T>): Generator<List<T>, T, T>;
-declare function $<T>(monad: Try<T>): Generator<Try<T>, T, T>;
-declare function $<T>(monad: Doable<T>): Generator<Doable<T>, T, T>;
-declare function $<M>(monad: M): Generator<M, InferYieldType<M>, InferYieldType<M>>;
-type InferYieldType<M> = M extends {
-  isSome(): boolean;
-  get(): infer T;
-} ? T : M extends {
-  isRight(): boolean;
-  value: infer R;
-} ? R : M extends {
-  toArray(): (infer T)[];
-} ? T : M extends {
-  isSuccess(): boolean;
-  get(): infer T;
-} ? T : M extends Doable<infer T> ? T : unknown;
-declare const NoneError: (message?: string) => Error;
-interface LeftErrorType<L> extends Error {
-  value: L;
-}
-declare const LeftError: <L>(value: L, message?: string) => LeftErrorType<L>;
-declare const EmptyListError: (message?: string) => Error;
-interface FailureErrorType extends Error {
-  cause: Error;
-}
-declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
-//#endregion
-export { $, Do, DoAsync, DoGenerator, type DoResult, type Doable, EmptyListError, FailureError, FailureErrorType, LeftError, LeftErrorType, NoneError, isDoCapable, unwrap };
+import { Gn as Doable, Wn as DoResult, a as EmptyListError, c as LeftError, d as isDoCapable, f as unwrap, i as DoGenerator, l as LeftErrorType, n as Do, o as FailureError, r as DoAsync, s as FailureErrorType, t as $, u as NoneError } from "../index-OdnROQtM.js";
+export { $, Do, DoAsync, DoGenerator, DoResult, Doable, EmptyListError, FailureError, FailureErrorType, LeftError, LeftErrorType, NoneError, isDoCapable, unwrap };

package/dist/do/index.js

@@ -1 +1 @@
-import{Option as e}from"../option/index.js";import{Try as t}from"../try/index.js";import{List as n}from"../list/index.js";import{Left as r,Right as i}from"../either/index.js";function a(e){if(!e||typeof e!=`object`||!(`_tag`in e))return`unknown`;switch(e._tag){case`Some`:case`None`:return`Option`;case`Left`:case`Right`:return`Either`;case`List`:return`List`;case`Success`:case`Failure`:return`Try`;default:return`unknown`}}const o={Option:{of:t=>e(t),empty:()=>e.none()},Either:{of:e=>i(e),empty:e=>r(e)},List:{of:e=>n([e]),empty:()=>n([])},Try:{of:e=>t(()=>e),empty:e=>t(()=>{throw e??Error(`Try failed`)})}};function s(e){let t=e(),r=null,i;function s(l){let u=t.next(l);if(u.done)return i?i.of(u.value):n([u.value]);let d=u.value;if(typeof d!=`object`||!d)throw Error(`Do-notation error: All yielded values must be monadic. Use yield* $(Option(value)), yield* $(Right(value)), etc. Raw values should be assigned directly without yielding.`);if(!r&&`_tag`in d&&(r=a(d),r!==`unknown`&&r in o&&(i=o[r]),r===`List`))return c(e);if(`doUnwrap`in d){let e=d.doUnwrap();if(!e.ok){if(!i)return n([]);if(!e.empty&&`error`in e){if(r===`Either`)return i.empty(e.error);if(r===`Try`)return i.empty(e.error instanceof Error?e.error:Error(String(e.error)))}return i.empty()}return s(e.value)}throw Error(`Do-notation error: All yielded values must be monadic. Use yield* $(Option(value)), yield* $(Right(value)), etc. Raw values should be assigned directly without yielding.`)}return s()}function c(e){function t(e){if(typeof e!=`object`||!e||!(`doUnwrap`in e))return[e];let t=e;if(`toArray`in t){let e=t.toArray();return e.length===0?[]:e}let n=t.doUnwrap();return n.ok?[n.value]:[]}function r(n){let i=e(),a=[],o=[],s=0;function c(e){let l=i.next(e);if(l.done){a.push(l.value);return}if(s<n.length){let e=n[s];o.push(e),s++,c(e);return}let u=t(l.value);if(u.length!==0)if(u.length>1){let e=u.flatMap(e=>r([...o,e]));a.push(...e)}else o.push(u[0]),s++,c(u[0])}return c(void 0),a}return n(r([]))}async function l(e){let t=e(),r=null,i;async function s(e){let c=await t.next(e);if(c.done)return i?i.of(c.value):n([c.value]);let l=await Promise.resolve(c.value);if(typeof l!=`object`||!l)return s(l);if(!r&&`_tag`in l&&(r=a(l),r!==`unknown`&&r in o&&(i=o[r])),`doUnwrap`in l){let e=l.doUnwrap();if(!e.ok){if(!i)return n([]);if(!e.empty&&`error`in e){if(r===`Either`)return i.empty(e.error);if(r===`Try`)return i.empty(e.error instanceof Error?e.error:Error(String(e.error)))}return i.empty()}return s(e.value)}return s(l)}return s()}function u(e){return typeof e==`object`&&!!e&&`doUnwrap`in e&&typeof e.doUnwrap==`function`}function d(e){let t=e.doUnwrap();if(t.ok)return t.value;throw`error`in t?t.error:Error(`Cannot unwrap empty monad`)}function*f(e){return yield e}const p=(e=`Cannot unwrap None in Do-notation`)=>{let t=Error(e),n=Object.create(Error.prototype);return n.message=t.message,n.stack=t.stack,n.name=`NoneError`,n},m=(e,t=`Cannot unwrap Left in Do-notation`)=>{let n=Error(t),r=Object.create(Error.prototype);return r.message=n.message,r.stack=n.stack,r.name=`LeftError`,r.value=e,r},h=(e=`Cannot unwrap empty List in Do-notation`)=>{let t=Error(e),n=Object.create(Error.prototype);return n.message=t.message,n.stack=t.stack,n.name=`EmptyListError`,n},g=(e,t=`Cannot unwrap Failure in Do-notation`)=>{let n=Error(t),r=Object.create(Error.prototype);return r.message=n.message,r.stack=n.stack,r.name=`FailureError`,r.cause=e,r};export{f as $,s as Do,l as DoAsync,h as EmptyListError,g as FailureError,m as LeftError,p as NoneError,u as isDoCapable,d as unwrap};
+import{A as e,D as t,F as n,M as r,N as i,O as a,P as o,j as s,k as c}from"../src-ByDeJzWj.js";export{t as $,a as Do,c as DoAsync,e as EmptyListError,s as FailureError,r as LeftError,i as NoneError,o as isDoCapable,n as unwrap};

package/dist/either/index.d.ts

@@ -1,188 +1,2 @@
-import { an as AsyncMonad, dn as Extractable, mn as Doable, n as FunctypeBase, nn as Reshapeable, rn as Promisable } from "../Functype-rgysbeU6.js";
-import { l as Type } from "../Typeable-lfO2nRVW.js";
-import { Option } from "../option/index.js";
-import { List } from "../list/index.js";
-
-//#region src/either/Either.d.ts
-/**
- * Either type module
- * @module Either
- * @category Core
- */
-interface Either<L extends Type, R extends Type> extends FunctypeBase<R, "Left" | "Right">, Promisable<R>, Doable<R>, Reshapeable<R>, Extractable<R> {
-  readonly _tag: "Left" | "Right";
-  value: L | R;
-  isLeft(): this is Either<L, R> & {
-    readonly _tag: "Left";
-    value: L;
-  };
-  isRight(): this is Either<L, R> & {
-    readonly _tag: "Right";
-    value: R;
-  };
-  orElse: (defaultValue: R) => R;
-  orThrow: (error?: Error) => R;
-  or(alternative: Either<L, R>): Either<L, R>;
-  orNull: () => R | null;
-  orUndefined: () => R | undefined;
-  readonly map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
-  ap: <U extends Type>(ff: Either<L, (value: R) => U>) => Either<L, U>;
-  merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R, R1]>;
-  mapAsync: <U extends Type>(f: (value: R) => Promise<U>) => Promise<Either<L, U>>;
-  flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>;
-  flatMapAsync: <U extends Type>(f: (value: R) => Promise<Either<L, U>>) => Promise<Either<L, U>>;
-  toOption: () => Option<R>;
-  toList: () => List<R>;
-  toString: () => string;
-  [Symbol.iterator]: () => Iterator<R>;
-  yield: () => Generator<R, void, unknown>;
-  traverse: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U[]>;
-  lazyMap: <U extends Type>(f: (value: R) => U) => Generator<Either<L, U>, void, unknown>;
-  tap: (f: (value: R) => void) => Either<L, R>;
-  tapLeft: (f: (value: L) => void) => Either<L, R>;
-  mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R>;
-  bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R) => R2) => Either<L2, R2>;
-  fold: <T extends Type>(onLeft: (value: L) => T, onRight: (value: R) => T) => T;
-  swap: () => Either<R, L>;
-  /**
-   * Pipes the value through the provided function based on whether this is a Left or Right
-   * @param onLeft - The function to apply if this is a Left
-   * @param onRight - The function to apply if this is a Right
-   * @returns The result of applying the appropriate function
-   */
-  pipeEither<U extends Type>(onLeft: (value: L) => U, onRight: (value: R) => U): U;
-  /**
-   * Pipes the Either value through the provided function
-   * @param f - The function to apply to the value (Left or Right)
-   * @returns The result of applying the function to the value
-   */
-  pipe<U extends Type>(f: (value: L | R) => U): U;
-  /**
-   * Pattern matches over the Either, applying a handler function based on the variant
-   * @param patterns - Object with handler functions for Left and Right variants
-   * @returns The result of applying the matching handler function
-   */
-  match<T>(patterns: {
-    Left: (value: L) => T;
-    Right: (value: R) => T;
-  }): T;
-  /**
-   * Returns the value and tag for inspection
-   */
-  toValue(): {
-    _tag: "Left" | "Right";
-    value: L | R;
-  };
-  /**
-   * Custom JSON serialization that excludes getter properties
-   */
-  toJSON(): {
-    _tag: "Left" | "Right";
-    value: L | R;
-  };
-}
-type TestEither<L extends Type, R extends Type> = Either<L, R> & AsyncMonad<R>;
-declare const Right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
-declare const Left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
-declare const isRight: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
-  value: R;
-};
-declare const isLeft: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
-  value: L;
-};
-declare const tryCatch: <L extends Type, R extends Type>(f: () => R, onError: (error: unknown) => L) => Either<L, R>;
-declare const TypeCheckRight: <L extends Type, R extends Type>(value: R) => TestEither<L, R>;
-declare const TypeCheckLeft: <L extends Type, R extends Type>(value: L) => TestEither<L, R>;
-declare const tryCatchAsync: <L extends Type, R extends Type>(f: () => Promise<R>, onError: (error: unknown) => L) => Promise<Either<L, R>>;
-declare const Either: (<L extends Type, R extends Type>(value: R | L, isRight: boolean) => Either<L, R>) & {
-  /**
-   * Creates a Left instance
-   * @param value - The left value
-   * @returns Left Either
-   */
-  left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
-  /**
-   * Creates a Right instance
-   * @param value - The right value
-   * @returns Right Either
-   */
-  right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
-  /**
-   * Type guard to check if an Either is Right
-   * @param either - The Either to check
-   * @returns True if Either is Right
-   */
-  isRight: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
-    value: R;
-  };
-  /**
-   * Type guard to check if an Either is Left
-   * @param either - The Either to check
-   * @returns True if Either is Left
-   */
-  isLeft: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
-    value: L;
-  };
-  /**
-   * Combines an array of Eithers into a single Either containing an array
-   * @param eithers - Array of Either values
-   * @returns Either with array of values or first Left encountered
-   */
-  sequence: <L extends Type, R extends Type>(eithers: Either<L, R>[]) => Either<L, R[]>;
-  /**
-   * Maps an array through a function that returns Either, then sequences the results
-   * @param arr - Array of values
-   * @param f - Function that returns Either
-   * @returns Either with array of results or first Left encountered
-   */
-  traverse: <L extends Type, R extends Type, U extends Type>(arr: R[], f: (value: R) => Either<L, U>) => Either<L, U[]>;
-  /**
-   * Creates an Either from a nullable value
-   * @param value - The value that might be null or undefined
-   * @param leftValue - The value to use for Left if value is null/undefined
-   * @returns Right if value is not null/undefined, Left otherwise
-   */
-  fromNullable: <L extends Type, R extends Type>(value: R | null | undefined, leftValue: L) => Either<L, R>;
-  /**
-   * Creates an Either based on a predicate
-   * @param value - The value to test
-   * @param predicate - The predicate function
-   * @param leftValue - The value to use for Left if predicate fails
-   * @returns Right if predicate passes, Left otherwise
-   */
-  fromPredicate: <L extends Type, R extends Type>(value: R, predicate: (value: R) => boolean, leftValue: L) => Either<L, R>;
-  /**
-   * Applicative apply - applies a wrapped function to a wrapped value
-   * @param eitherF - Either containing a function
-   * @param eitherV - Either containing a value
-   * @returns Either with function applied to value
-   */
-  ap: <L extends Type, R extends Type, U extends Type>(eitherF: Either<L, (value: R) => U>, eitherV: Either<L, R>) => Either<L, U>;
-  /**
-   * Creates an Either from a Promise
-   * @param promise - The Promise to convert
-   * @param onRejected - Function to convert rejection reason to Left value
-   * @returns Promise that resolves to Either
-   */
-  fromPromise: <L, R>(promise: Promise<R>, onRejected: (reason: unknown) => L) => Promise<Either<L, R>>;
-  /**
-   * Creates an Either from JSON string
-   * @param json - The JSON string
-   * @returns Either instance
-   */
-  fromJSON: <L extends Type, R extends Type>(json: string) => Either<L, R>;
-  /**
-   * Creates an Either from YAML string
-   * @param yaml - The YAML string
-   * @returns Either instance
-   */
-  fromYAML: <L extends Type, R extends Type>(yaml: string) => Either<L, R>;
-  /**
-   * Creates an Either from binary string
-   * @param binary - The binary string
-   * @returns Either instance
-   */
-  fromBinary: <L extends Type, R extends Type>(binary: string) => Either<L, R>;
-};
-//#endregion
+import { S as tryCatchAsync, _ as TypeCheckLeft, b as isRight, g as TestEither, h as Right, m as Left, p as Either, v as TypeCheckRight, x as tryCatch, y as isLeft } from "../index-OdnROQtM.js";
 export { Either, Left, Right, TestEither, TypeCheckLeft, TypeCheckRight, isLeft, isRight, tryCatch, tryCatchAsync };

package/dist/either/index.js

@@ -1,2 +1 @@
-import{nt as e}from"../Valuable-GZAXcYok.js";import{n as t,t as n}from"../stringify-DepodSy0.js";import{None as r,Some as i}from"../option/index.js";import{Try as a}from"../try/index.js";import{List as o}from"../list/index.js";const s=t=>({[Symbol.toStringTag]:`Either`,_tag:`Right`,value:t,isLeft(){return!1},isRight(){return!0},orElse:e=>t,orThrow:()=>t,or:e=>l(t),orNull:()=>t,orUndefined:()=>t,map:e=>l(e(t)),ap:e=>e._tag===`Right`?l(e.value(t)):u(e.value),mapAsync:e=>e(t).then(e=>l(e)).catch(e=>Promise.resolve(u(e))),merge:e=>e.isLeft()?u(e.value):l([t,e.value]),flatMap:e=>e(t),flatMapAsync:e=>e(t).catch(e=>u(e)),toOption:()=>i(t),toList:()=>o([t]),toEither:e=>l(t),toTry:()=>a(()=>t),toJSON(){return{_tag:`Right`,value:t}},toString:()=>`Right(${n(t)})`,*[Symbol.iterator](){yield t},*yield(){yield t},traverse:e=>{let n=e(t);return n.isLeft()?u(n.value):l([n.value])},*lazyMap(e){yield l(e(t))},tap:e=>(e(t),l(t)),tapLeft:e=>l(t),mapLeft:e=>l(t),bimap:(e,n)=>l(n(t)),fold:(e,n)=>n(t),foldLeft:e=>n=>n(e,t),foldRight:e=>n=>n(t,e),match:e=>e.Right(t),swap:()=>u(t),toPromise:()=>Promise.resolve(t),toValue:()=>({_tag:`Right`,value:t}),pipeEither:(e,n)=>n(t),pipe:e=>e(t),serialize:()=>e(`Right`,t),get size(){return 1},get isEmpty(){return!1},contains:e=>t===e,reduce:e=>t,reduceRight:e=>t,count:e=>e(t)?1:0,find:e=>e(t)?i(t):r(),exists:e=>e(t),forEach:e=>e(t),doUnwrap(){return{ok:!0,value:t}}}),c=t=>({[Symbol.toStringTag]:`Either`,_tag:`Left`,value:t,isLeft(){return!0},isRight(){return!1},orElse:e=>e,orThrow:e=>{throw e??t},or:e=>e,orNull:()=>null,orUndefined:()=>void 0,map:e=>u(t),ap:e=>u(t),mapAsync:e=>Promise.resolve(u(t)),merge:e=>u(t),flatMap:e=>u(t),flatMapAsync:e=>Promise.resolve(u(t)),toOption:()=>r(),toList:()=>o(),toEither:e=>u(e),toTry:()=>a(()=>{throw Error(String(t))}),toJSON(){return{_tag:`Left`,value:t}},toString:()=>`Left(${n(t)})`,*[Symbol.iterator](){},*yield(){},traverse:e=>u(t),*lazyMap(e){yield u(t)},tap:e=>u(t),tapLeft:e=>(e(t),u(t)),mapLeft:e=>u(e(t)),bimap:(e,n)=>u(e(t)),fold:(e,n)=>e(t),foldLeft:e=>t=>e,foldRight:e=>t=>e,match:e=>e.Left(t),swap:()=>l(t),toPromise:()=>Promise.reject(t),toValue:()=>({_tag:`Left`,value:t}),pipeEither:(e,n)=>e(t),pipe:e=>e(t),serialize:()=>e(`Left`,t),get size(){return 0},get isEmpty(){return!0},contains:e=>!1,reduce:e=>{throw Error(`Cannot reduce a Left`)},reduceRight:e=>{throw Error(`Cannot reduceRight a Left`)},count:e=>0,find:e=>r(),exists:e=>!1,forEach:e=>{},doUnwrap(){return{ok:!1,empty:!1,error:t}}}),l=e=>s(e),u=e=>c(e),d=e=>e.isRight(),f=e=>e.isLeft(),p=(e,t)=>{try{return l(e())}catch(e){return u(t(e))}},m=e=>s(e);console.assert(m);const h=e=>c(e);console.assert(h);const g=async(e,t)=>{try{return l(await e())}catch(e){return u(t(e))}},_=(e,t)=>t?l(e):u(e),v={left:e=>u(e),right:e=>l(e),isRight:e=>e.isRight(),isLeft:e=>e.isLeft(),sequence:e=>e.reduce((e,t)=>e.isLeft()?e:t.isLeft()?u(t.value):e.map(e=>[...e,t.value]),l([])),traverse:(e,t)=>v.sequence(e.map(t)),fromNullable:(e,t)=>e==null?u(t):l(e),fromPredicate:(e,t,n)=>t(e)?l(e):u(n),ap:(e,t)=>e.flatMap(e=>t.map(e)),fromPromise:async(e,t)=>{try{return l(await e)}catch(e){return u(t(e))}},fromJSON:e=>{let t=JSON.parse(e);return t._tag===`Right`?l(t.value):u(t.value)},fromYAML:e=>{let t=e.split(`
-`),n=t[0]?.split(`: `)[1],r=t[1]?.split(`: `)[1];if(!n||!r)throw Error(`Invalid YAML format for Either`);let i=JSON.parse(r);return n===`Right`?l(i):u(i)},fromBinary:e=>{let t=Buffer.from(e,`base64`).toString();return v.fromJSON(t)}},y=t(_,v);export{y as Either,u as Left,l as Right,h as TypeCheckLeft,m as TypeCheckRight,f as isLeft,d as isRight,p as tryCatch,g as tryCatchAsync};
+import{ct as e,dt as t,ft as n,lt as r,mt as i,ot as a,pt as o,st as s,ut as c}from"../src-ByDeJzWj.js";export{a as Either,s as Left,e as Right,r as TypeCheckLeft,c as TypeCheckRight,t as isLeft,n as isRight,o as tryCatch,i as tryCatchAsync};