functype 0.12.0 → 0.14.0

package/dist/do/index.d.ts

@@ -0,0 +1,240 @@
+import { O as Option, E as Either, L as List, T as Try, y as Reshapeable, d as DoProtocol } from '../Either-D4P39LPj.js';
+export { D as DO_PROTOCOL, a as DoResult } from '../Either-D4P39LPj.js';
+import '../Typeable-CitTP1ay.js';
+
+/**
+ * Generator-based Do-notation for monadic comprehensions
+ * Provides Scala-like for-comprehension syntax using JavaScript generators
+ *
+ * ## Scala Equivalents
+ *
+ * Functype:  `const x = yield* $(Option(5))`
+ * Scala:     `x <- Some(5)`
+ *
+ * Functype:  `return x + y`
+ * Scala:     `yield x + y`
+ *
+ * ## Core Concepts
+ *
+ * - **Generators**: Use `yield* $(monad)` to extract values from monads
+ * - **Short-circuiting**: None/Left/Failure automatically propagates
+ * - **Type inference**: The $ helper provides proper TypeScript types
+ * - **First monad wins**: Return type matches the first yielded monad
+ * - **Cartesian products**: Multiple List yields create all combinations
+ *
+ * ## Usage Rules
+ *
+ * 1. All yielded values MUST be monadic (Option, Either, List, Try)
+ * 2. Use the $ helper for type inference: `yield* $(Option(value))`
+ * 3. Raw values should be assigned directly without yielding
+ * 4. Mixed monad types are supported via Reshapeable interface
+ *
+ * @example
+ * // Basic Option chaining (Scala: for { x <- Some(5); y <- Some(10) } yield x + y)
+ * const result = Do(function* () {
+ *   const x = yield* $(Option(5))        // Extract from Option
+ *   const y = yield* $(Option(10))       // Extract from another Option
+ *   return x + y                         // Return final value
+ * })
+ * // result: Option<number> with value 15
+ *
+ * @example
+ * // List comprehension (Scala: for { x <- List(1,2); y <- List(10,20) } yield (x,y))
+ * const pairs = Do(function* () {
+ *   const x = yield* $(List([1, 2]))     // Iterates: 1, 2
+ *   const y = yield* $(List([10, 20]))   // Iterates: 10, 20
+ *   return { x, y }                      // All combinations
+ * })
+ * // pairs: List([{x:1,y:10}, {x:1,y:20}, {x:2,y:10}, {x:2,y:20}])
+ *
+ * @example
+ * // Error propagation with Either
+ * const validate = Do(function* () {
+ *   const email = yield* $(validateEmail(input))  // Either<string, Email>
+ *   const user = yield* $(fetchUser(email))       // Either<string, User>
+ *   const saved = yield* $(saveUser(user))        // Either<string, Result>
+ *   return saved
+ * })
+ * // If any step returns Left, entire chain short-circuits with that error
+ *
+ * @see {@link https://github.com/jordanburke/functype/blob/main/docs/do-notation.md} Full documentation
+ * @module Do
+ */
+
+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 Do protocol
+ * @param value - Value to check
+ * @returns True if the value implements DoProtocol
+ */
+declare function isDoCapable<T>(value: unknown): value is DoProtocol<T>;
+/**
+ * Manually unwrap a monad using the Do protocol
+ * 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: DoProtocol<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: DoProtocol<T>): Generator<DoProtocol<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 DoProtocol<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;
+
+export { $, Do, DoAsync, type DoGenerator, DoProtocol, EmptyListError, FailureError, type FailureErrorType, LeftError, type LeftErrorType, NoneError, isDoCapable, unwrap };

package/dist/do/index.mjs

@@ -0,0 +1,2 @@
+export{P as $,a as DO_PROTOCOL,L as Do,M as DoAsync,S as EmptyListError,T as FailureError,R as LeftError,Q as NoneError,N as isDoCapable,O as unwrap}from'../chunk-7VZBQDNM.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/do/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/either/index.d.ts

@@ -1,2 +1,2 @@
-export { E as Either, c as Left, R as Right, b as TestEither, f as TypeCheckLeft, e as TypeCheckRight, d as isLeft, i as isRight, t as tryCatch, g as tryCatchAsync } from '../Either-DgkP4DUw.js';
-import '../Serializable-CK9upOU0.js';
+export { E as Either, f as Left, R as Right, e as TestEither, j as TypeCheckLeft, h as TypeCheckRight, g as isLeft, i as isRight, t as tryCatch, k as tryCatchAsync } from '../Either-D4P39LPj.js';
+import '../Typeable-CitTP1ay.js';

package/dist/either/index.mjs

@@ -1,2 +1,2 @@
-export{q as Either,j as Left,i as Right,o as TypeCheckLeft,n as TypeCheckRight,l as isLeft,k as isRight,m as tryCatch,p as tryCatchAsync}from'../chunk-VXULTLLY.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
+export{u as Either,n as Left,m as Right,s as TypeCheckLeft,r as TypeCheckRight,p as isLeft,o as isRight,q as tryCatch,t as tryCatchAsync}from'../chunk-7VZBQDNM.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/fpromise/index.d.ts

@@ -1,5 +1,5 @@
-import { E as Either } from '../Either-DgkP4DUw.js';
-import { T as Type } from '../Serializable-CK9upOU0.js';
+import { E as Either } from '../Either-D4P39LPj.js';
+import { T as Type } from '../Typeable-CitTP1ay.js';
 
 /**
  * Error context information that provides additional metadata about errors.

package/dist/fpromise/index.mjs

@@ -1,2 +1,2 @@
-export{K as FPromise,J as FPromiseCompanion}from'../chunk-VXULTLLY.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
+export{X as FPromise,W as FPromiseCompanion}from'../chunk-7VZBQDNM.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/index.d.ts

@@ -1,16 +1,146 @@
 import { Brand } from './branded/index.js';
 export { BrandedBoolean, BrandedNumber, BrandedString, ExtractBrand, Unbrand, createBrander, hasBrand, unbrand } from './branded/index.js';
-import { O as Option, E as Either, L as List, F as FunctypeBase, a as Extractable, T as Traversable, M as Matchable } from './Either-DgkP4DUw.js';
-export { A as Applicative, q as AsyncMonad, C as Collection, o as CollectionOps, p as ContainerOps, r as Functor, j as Functype, k as FunctypeCollection, c as Left, l as MatchableUtils, s as Monad, N as None, m as OptionConstructor, P as Promisable, R as Right, n as Set, S as Some, b as TestEither, f as TypeCheckLeft, e as TypeCheckRight, h as isExtractable, d as isLeft, i as isRight, t as tryCatch, g as tryCatchAsync } from './Either-DgkP4DUw.js';
-import { T as Type, a as Typeable, F as Foldable, P as Pipe, S as Serializable } from './Serializable-CK9upOU0.js';
-export { E as ExtractTag, b as SerializationMethods, c as TypeableParams, i as isTypeable } from './Serializable-CK9upOU0.js';
+import { L as List, O as Option, E as Either, D as DO_PROTOCOL, a as DoResult, T as Try, F as FunctypeBase, b as Extractable, c as Traversable, M as Matchable } from './Either-D4P39LPj.js';
+export { A as Applicative, v as AsyncMonad, C as Collection, s as CollectionOps, u as ContainerOps, d as DoProtocol, w as Functor, m as Functype, n as FunctypeCollection, f as Left, o as MatchableUtils, x as Monad, N as None, p as OptionConstructor, P as Promisable, R as Right, q as Set, S as Some, e as TestEither, j as TypeCheckLeft, h as TypeCheckRight, r as TypeNames, l as isExtractable, g as isLeft, i as isRight, t as tryCatch, k as tryCatchAsync } from './Either-D4P39LPj.js';
+import { T as Type, F as Foldable, P as Pipe, S as Serializable, a as Typeable } from './Typeable-CitTP1ay.js';
+export { E as ExtractTag, b as SerializationMethods, c as TypeableParams, i as isTypeable } from './Typeable-CitTP1ay.js';
 import { FPromise } from './fpromise/index.js';
 export { ErrorContext, FPromiseCompanion } from './fpromise/index.js';
-import { Try } from './try/index.js';
-export { TypeNames } from './try/index.js';
+export { $, Do, DoAsync, DoGenerator, EmptyListError, FailureError, FailureErrorType, LeftError, LeftErrorType, NoneError, isDoCapable, unwrap } from './do/index.js';
 export { Map, SafeTraversable } from './map/index.js';
 export { Tuple } from './tuple/index.js';
 
+/**
+ * LazyList provides lazy evaluation for list operations.
+ * Operations are deferred until the list is materialized.
+ *
+ * @example
+ * // Basic lazy evaluation
+ * const result = LazyList([1, 2, 3, 4, 5])
+ *   .map(x => x * 2)
+ *   .filter(x => x > 5)
+ *   .toArray() // [6, 8, 10]
+ *
+ * @example
+ * // Infinite sequences with take
+ * const fibonacci = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
+ *   .map(([a]) => a)
+ *   .take(10)
+ *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+ */
+interface LazyList<A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Serializable<LazyList<A>>, Typeable<"LazyList"> {
+    [Symbol.iterator](): Iterator<A>;
+    map<B extends Type>(f: (a: A) => B): LazyList<B>;
+    flatMap<B extends Type>(f: (a: A) => LazyList<B>): LazyList<B>;
+    filter(predicate: (a: A) => boolean): LazyList<A>;
+    take(n: number): LazyList<A>;
+    drop(n: number): LazyList<A>;
+    takeWhile(predicate: (a: A) => boolean): LazyList<A>;
+    dropWhile(predicate: (a: A) => boolean): LazyList<A>;
+    concat(other: LazyList<A>): LazyList<A>;
+    zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>;
+    toList(): List<A>;
+    toArray(): A[];
+    forEach(f: (a: A) => void): void;
+    reduce<B extends Type>(f: (acc: B, a: A) => B, initial: B): B;
+    find(predicate: (a: A) => boolean): Option<A>;
+    some(predicate: (a: A) => boolean): boolean;
+    every(predicate: (a: A) => boolean): boolean;
+    count(): number;
+    first(): Option<A>;
+    last(): Option<A>;
+    toString(): string;
+}
+/**
+ * Lazy list implementation for efficient deferred computation
+ * @example
+ * // Process large datasets efficiently
+ * const result = LazyList.range(1, 1000000)
+ *   .filter(x => x % 2 === 0)
+ *   .map(x => x * x)
+ *   .take(5)
+ *   .toArray() // [4, 16, 36, 64, 100]
+ *
+ * @example
+ * // Infinite sequences
+ * const primes = LazyList.iterate(2, n => n + 1)
+ *   .filter(isPrime)
+ *   .take(10)
+ *   .toArray() // First 10 prime numbers
+ *
+ * @example
+ * // Combining operations
+ * const evens = LazyList.range(0, 100, 2)
+ * const odds = LazyList.range(1, 100, 2)
+ * const combined = evens.zip(odds)
+ *   .map(([e, o]) => e + o)
+ *   .take(5)
+ *   .toArray() // [1, 5, 9, 13, 17]
+ */
+declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>) & {
+    /**
+     * Create an empty LazyList
+     * @example
+     * const empty = LazyList.empty<number>()
+     * empty.toArray() // []
+     */
+    empty: <A extends Type>() => LazyList<A>;
+    /**
+     * Create a LazyList from a single value
+     * @example
+     * const single = LazyList.of(42)
+     *   .map(x => x * 2)
+     *   .toArray() // [84]
+     */
+    of: <A extends Type>(value: A) => LazyList<A>;
+    /**
+     * Create a LazyList from multiple values
+     */
+    from: <A extends Type>(...values: A[]) => LazyList<A>;
+    /**
+     * Create an infinite LazyList by repeatedly applying a function
+     * @example
+     * // Powers of 2
+     * const powers = LazyList.iterate(1, x => x * 2)
+     *   .take(10)
+     *   .toArray() // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+     *
+     * @example
+     * // Fibonacci sequence
+     * const fib = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
+     *   .map(([a]) => a)
+     *   .take(8)
+     *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13]
+     */
+    iterate: <A extends Type>(initial: A, f: (a: A) => A) => LazyList<A>;
+    /**
+     * Create an infinite LazyList by repeatedly calling a function
+     */
+    generate: <A extends Type>(f: () => A) => LazyList<A>;
+    /**
+     * Create a LazyList of numbers from start to end (exclusive)
+     * @example
+     * LazyList.range(1, 6).toArray() // [1, 2, 3, 4, 5]
+     * LazyList.range(0, 10, 2).toArray() // [0, 2, 4, 6, 8]
+     * LazyList.range(10, 0, -1).toArray() // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+     *
+     * @example
+     * // Sum of squares from 1 to 100
+     * const sum = LazyList.range(1, 101)
+     *   .map(x => x * x)
+     *   .reduce((a, b) => a + b, 0) // 338350
+     */
+    range: (start: number, end: number, step?: number) => LazyList<number>;
+    /**
+     * Create a LazyList that repeats a value n times (or infinitely if n is not provided)
+     */
+    repeat: <A extends Type>(value: A, n?: number) => LazyList<A>;
+    /**
+     * Create a LazyList that cycles through an iterable infinitely
+     */
+    cycle: <A extends Type>(iterable: Iterable<A>) => LazyList<A>;
+};
+
 interface ValidatedBrandCompanion<K extends string, T> {
     readonly brand: K;
     readonly validate: (value: T) => boolean;
@@ -534,11 +664,13 @@ declare const Match: (<T extends Type, R extends Type>(value: T) => Match<T, R>)
 
 /**
  * Base Object from which most other objects inherit
+ * Now includes automatic Do-notation support via DO_PROTOCOL
  * @param type - The type name for the object
  * @param body - The implementation body
  */
-declare function Base<T>(type: string, body: T): T & {
+declare function Base<T extends Record<string, unknown>>(type: string, body: T): T & {
     toString(): string;
+    [DO_PROTOCOL](): DoResult<unknown>;
     _tag: string;
 };
 
@@ -716,6 +848,7 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
      */
     AsyncWithProgress: <U = T>(t: (updateProgress: (percent: number) => void) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, onProgress: (percent: number) => void, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
     toString(): string;
+    [DO_PROTOCOL](): DoResult<unknown>;
     _tag: string;
 }) & {
     /**
@@ -1036,137 +1169,6 @@ declare const TypedError: (<T extends ErrorCode>(code: T, message: ErrorMessage<
     hasCode: <T extends ErrorCode>(error: TypedError<ErrorCode>, code: T) => error is TypedError<T>;
 };
 
-/**
- * LazyList provides lazy evaluation for list operations.
- * Operations are deferred until the list is materialized.
- *
- * @example
- * // Basic lazy evaluation
- * const result = LazyList([1, 2, 3, 4, 5])
- *   .map(x => x * 2)
- *   .filter(x => x > 5)
- *   .toArray() // [6, 8, 10]
- *
- * @example
- * // Infinite sequences with take
- * const fibonacci = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
- *   .map(([a]) => a)
- *   .take(10)
- *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
- */
-interface LazyList<A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Serializable<LazyList<A>>, Typeable<"LazyList"> {
-    [Symbol.iterator](): Iterator<A>;
-    map<B extends Type>(f: (a: A) => B): LazyList<B>;
-    flatMap<B extends Type>(f: (a: A) => LazyList<B>): LazyList<B>;
-    filter(predicate: (a: A) => boolean): LazyList<A>;
-    take(n: number): LazyList<A>;
-    drop(n: number): LazyList<A>;
-    takeWhile(predicate: (a: A) => boolean): LazyList<A>;
-    dropWhile(predicate: (a: A) => boolean): LazyList<A>;
-    concat(other: LazyList<A>): LazyList<A>;
-    zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>;
-    toList(): List<A>;
-    toArray(): A[];
-    forEach(f: (a: A) => void): void;
-    reduce<B extends Type>(f: (acc: B, a: A) => B, initial: B): B;
-    find(predicate: (a: A) => boolean): Option<A>;
-    some(predicate: (a: A) => boolean): boolean;
-    every(predicate: (a: A) => boolean): boolean;
-    count(): number;
-    first(): Option<A>;
-    last(): Option<A>;
-    toString(): string;
-}
-/**
- * Lazy list implementation for efficient deferred computation
- * @example
- * // Process large datasets efficiently
- * const result = LazyList.range(1, 1000000)
- *   .filter(x => x % 2 === 0)
- *   .map(x => x * x)
- *   .take(5)
- *   .toArray() // [4, 16, 36, 64, 100]
- *
- * @example
- * // Infinite sequences
- * const primes = LazyList.iterate(2, n => n + 1)
- *   .filter(isPrime)
- *   .take(10)
- *   .toArray() // First 10 prime numbers
- *
- * @example
- * // Combining operations
- * const evens = LazyList.range(0, 100, 2)
- * const odds = LazyList.range(1, 100, 2)
- * const combined = evens.zip(odds)
- *   .map(([e, o]) => e + o)
- *   .take(5)
- *   .toArray() // [1, 5, 9, 13, 17]
- */
-declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>) & {
-    /**
-     * Create an empty LazyList
-     * @example
-     * const empty = LazyList.empty<number>()
-     * empty.toArray() // []
-     */
-    empty: <A extends Type>() => LazyList<A>;
-    /**
-     * Create a LazyList from a single value
-     * @example
-     * const single = LazyList.of(42)
-     *   .map(x => x * 2)
-     *   .toArray() // [84]
-     */
-    of: <A extends Type>(value: A) => LazyList<A>;
-    /**
-     * Create a LazyList from multiple values
-     */
-    from: <A extends Type>(...values: A[]) => LazyList<A>;
-    /**
-     * Create an infinite LazyList by repeatedly applying a function
-     * @example
-     * // Powers of 2
-     * const powers = LazyList.iterate(1, x => x * 2)
-     *   .take(10)
-     *   .toArray() // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
-     *
-     * @example
-     * // Fibonacci sequence
-     * const fib = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
-     *   .map(([a]) => a)
-     *   .take(8)
-     *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13]
-     */
-    iterate: <A extends Type>(initial: A, f: (a: A) => A) => LazyList<A>;
-    /**
-     * Create an infinite LazyList by repeatedly calling a function
-     */
-    generate: <A extends Type>(f: () => A) => LazyList<A>;
-    /**
-     * Create a LazyList of numbers from start to end (exclusive)
-     * @example
-     * LazyList.range(1, 6).toArray() // [1, 2, 3, 4, 5]
-     * LazyList.range(0, 10, 2).toArray() // [0, 2, 4, 6, 8]
-     * LazyList.range(10, 0, -1).toArray() // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
-     *
-     * @example
-     * // Sum of squares from 1 to 100
-     * const sum = LazyList.range(1, 101)
-     *   .map(x => x * x)
-     *   .reduce((a, b) => a + b, 0) // 338350
-     */
-    range: (start: number, end: number, step?: number) => LazyList<number>;
-    /**
-     * Create a LazyList that repeats a value n times (or infinitely if n is not provided)
-     */
-    repeat: <A extends Type>(value: A, n?: number) => LazyList<A>;
-    /**
-     * Create a LazyList that cycles through an iterable infinitely
-     */
-    cycle: <A extends Type>(iterable: Iterable<A>) => LazyList<A>;
-};
-
 /**
  * Validation rule types using template literal types
  */
@@ -1324,15 +1326,14 @@ type UniversalContainer = Option<unknown> | List<unknown> | Either<unknown, unkn
  */
 declare const HKT: {
     (): {
-        _type: string;
+        _tag: string;
         map: <F, A, B>(fa: unknown, f: (a: A) => B) => unknown;
         flatten: <F, A>(ffa: unknown) => unknown;
         flatMap: <F, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
         ap: <F, A, B>(ff: unknown, fa: unknown) => unknown;
         sequence: <F, G, A>(fga: unknown) => unknown;
         traverse: <F, G, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
-        toString(): string;
-        _tag: string;
+        _type: string;
     };
     map<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => B): unknown;
     flatten<F = unknown, A = unknown>(ffa: unknown): unknown;
@@ -1804,4 +1805,4 @@ declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
     fromBinary: <A>(binary: string) => Stack<A>;
 };
 
-export { type Async, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, Companion, Cond, ESMap, type ESMapType, Either, type EitherKind, EmailAddress, Err, type ErrorChainElement, type ErrorCode, type ErrorFormatterOptions, type ErrorMessage, type ErrorStatus, type ErrorWithTaskInfo, Extractable, FPromise, type FieldValidation, Foldable, FoldableUtils, type FormValidation, FunctypeBase, HKT, ISO8601Date, Identity, IntegerNumber, type Kind, Lazy, LazyList, Lazy as LazyType, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Ok, Option, type OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Ref, Ref as RefType, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskFailure, type TaskMetadata, type TaskOutcome, type TaskParams, type TaskResult, TaskSuccess, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, TypedError, type TypedErrorContext, UUID, type UniversalContainer, UrlString, ValidatedBrand, type ValidatedBrandCompanion, Validation, type ValidationRule, type Validator, Valuable, type ValuableParams, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };
+export { type Async, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, Companion, Cond, DO_PROTOCOL, DoResult, ESMap, type ESMapType, Either, type EitherKind, EmailAddress, Err, type ErrorChainElement, type ErrorCode, type ErrorFormatterOptions, type ErrorMessage, type ErrorStatus, type ErrorWithTaskInfo, Extractable, FPromise, type FieldValidation, Foldable, FoldableUtils, type FormValidation, FunctypeBase, HKT, ISO8601Date, Identity, IntegerNumber, type Kind, Lazy, LazyList, Lazy as LazyType, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Ok, Option, type OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Ref, Ref as RefType, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskFailure, type TaskMetadata, type TaskOutcome, type TaskParams, type TaskResult, TaskSuccess, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, TypedError, type TypedErrorContext, UUID, type UniversalContainer, UrlString, ValidatedBrand, type ValidatedBrandCompanion, Validation, type ValidationRule, type Validator, Valuable, type ValuableParams, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-export{G as Base,B as BoundedNumber,C as BoundedString,E as Cond,fa as ESMap,q as Either,x as EmailAddress,Q as Err,K as FPromise,J as FPromiseCompanion,aa as FoldableUtils,ba as HKT,A as ISO8601Date,ca as Identity,u as IntegerNumber,ea as Lazy,Z as LazyList,j as Left,h as List,ga as Map,F as Match,ha as MatchableUtils,H as NAME,w as NonEmptyString,t as NonNegativeNumber,b as None,P as Ok,d as Option,c as OptionConstructor,X as ParseError,D as PatternString,v as PositiveInteger,s as PositiveNumber,L as Ref,i as Right,e as Set,a as Some,ia as Stack,S as Task,N as TaskFailure,O as TaskSuccess,I as Throwable,da as Try,o as TypeCheckLeft,n as TypeCheckRight,f as Typeable,Y as TypedError,z as UUID,y as UrlString,r as ValidatedBrand,_ as Validation,ja as Valuable,R as createCancellationTokenSource,W as createErrorSerializer,V as formatError,U as formatStackTrace,$ as isExtractable,l as isLeft,k as isRight,M as isTaggedThrowable,g as isTypeable,T as safeStringify,m as tryCatch,p as tryCatchAsync}from'./chunk-VXULTLLY.mjs';export{a as Companion,b as Tuple}from'./chunk-BQJB6CCW.mjs';export{a as Brand,g as BrandedBoolean,f as BrandedNumber,e as BrandedString,d as createBrander,c as hasBrand,b as unbrand}from'./chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
+export{P as $,K as Base,F as BoundedNumber,G as BoundedString,I as Cond,a as DO_PROTOCOL,L as Do,M as DoAsync,pa as ESMap,u as Either,B as EmailAddress,S as EmptyListError,aa as Err,X as FPromise,W as FPromiseCompanion,T as FailureError,la as FoldableUtils,ma as HKT,E as ISO8601Date,na as Identity,y as IntegerNumber,oa as Lazy,h as LazyList,n as Left,R as LeftError,l as List,qa as Map,J as Match,ra as MatchableUtils,U as NAME,A as NonEmptyString,x as NonNegativeNumber,c as None,Q as NoneError,$ as Ok,e as Option,d as OptionConstructor,ha as ParseError,H as PatternString,z as PositiveInteger,w as PositiveNumber,g as Ref,m as Right,f as Set,b as Some,sa as Stack,ca as Task,Z as TaskFailure,_ as TaskSuccess,V as Throwable,i as Try,s as TypeCheckLeft,r as TypeCheckRight,j as Typeable,ia as TypedError,D as UUID,C as UrlString,v as ValidatedBrand,ja as Validation,ta as Valuable,ba as createCancellationTokenSource,ga as createErrorSerializer,fa as formatError,ea as formatStackTrace,N as isDoCapable,ka as isExtractable,p as isLeft,o as isRight,Y as isTaggedThrowable,k as isTypeable,da as safeStringify,q as tryCatch,t as tryCatchAsync,O as unwrap}from'./chunk-7VZBQDNM.mjs';export{a as Companion,b as Tuple}from'./chunk-BQJB6CCW.mjs';export{a as Brand,g as BrandedBoolean,f as BrandedNumber,e as BrandedString,d as createBrander,c as hasBrand,b as unbrand}from'./chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/list/index.d.ts

@@ -1,2 +1,2 @@
-export { L as List } from '../Either-DgkP4DUw.js';
-import '../Serializable-CK9upOU0.js';
+export { L as List } from '../Either-D4P39LPj.js';
+import '../Typeable-CitTP1ay.js';

package/dist/list/index.mjs

@@ -1,2 +1,2 @@
-export{h as List}from'../chunk-VXULTLLY.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
+export{l as List}from'../chunk-7VZBQDNM.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/map/index.d.ts

@@ -1,5 +1,5 @@
-import { T as Traversable, C as Collection, O as Option } from '../Either-DgkP4DUw.js';
-import { a as Typeable, S as Serializable, P as Pipe, F as Foldable, T as Type } from '../Serializable-CK9upOU0.js';
+import { c as Traversable, C as Collection, O as Option } from '../Either-D4P39LPj.js';
+import { a as Typeable, S as Serializable, P as Pipe, F as Foldable, T as Type } from '../Typeable-CitTP1ay.js';
 import { Tuple } from '../tuple/index.js';
 
 /**

package/dist/map/index.mjs

@@ -1,2 +1,2 @@
-export{ga as Map}from'../chunk-VXULTLLY.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
+export{qa as Map}from'../chunk-7VZBQDNM.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/option/index.d.ts

@@ -1,2 +1,2 @@
-export { N as None, O as Option, m as OptionConstructor, S as Some } from '../Either-DgkP4DUw.js';
-import '../Serializable-CK9upOU0.js';
+export { N as None, O as Option, p as OptionConstructor, S as Some } from '../Either-D4P39LPj.js';
+import '../Typeable-CitTP1ay.js';

package/dist/option/index.mjs

@@ -1,2 +1,2 @@
-export{b as None,d as Option,c as OptionConstructor,a as Some}from'../chunk-VXULTLLY.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
+export{c as None,e as Option,d as OptionConstructor,b as Some}from'../chunk-7VZBQDNM.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map