functype 0.11.2 → 0.14.0

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;
 };
 
@@ -639,6 +771,21 @@ interface TaskSuccess<T> extends TaskOutcome<T> {
  */
 declare const TaskSuccess: <T>(data: T, params?: TaskParams) => TaskSuccess<T>;
 type TaskResult<T> = Promise<TaskOutcome<T>>;
+/**
+ * Ok constructor - Creates a successful TaskOutcome
+ * Alias for TaskSuccess for cleaner, more concise code
+ * @param value - The successful value
+ * @param params - Optional task parameters
+ */
+declare const Ok: <T>(value: T, params?: TaskParams) => TaskSuccess<T>;
+/**
+ * Err constructor - Creates a failed TaskOutcome
+ * Alias for TaskFailure for cleaner, more concise code
+ * @param error - The error value
+ * @param data - Optional additional error data
+ * @param params - Optional task parameters
+ */
+declare const Err: <T>(error: unknown, data?: unknown, params?: TaskParams) => TaskFailure<T>;
 /**
  * The CancellationToken is a control structure that allows long-running tasks to be cancelled
  * Cancellation is cooperative, meaning the task must check the token and respond to cancellation requests
@@ -679,7 +826,7 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
      * @param f - Optional finally handler function
      * @param cancellationToken - Optional token for cancellation support
      */
-    Async: <U = T>(t: () => U | Promise<U>, e?: (error: unknown) => unknown, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<U>;
+    Async: <U = T>(t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
     /**
      * Run a synchronous operation with explicit try/catch/finally semantics
      * Returns a TaskOutcome for functional error handling
@@ -699,8 +846,9 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
      * @param f - Optional finally handler function
      * @param cancellationToken - Optional token for cancellation support
      */
-    AsyncWithProgress: <U = T>(t: (updateProgress: (percent: number) => void) => U | Promise<U>, onProgress: (percent: number) => void, e?: (error: unknown) => unknown, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<U>;
+    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;
 }) & {
     /**
@@ -711,6 +859,16 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
      * Create a failed Task result
      */
     fail: <T>(error: unknown, data?: unknown, params?: TaskParams) => TaskFailure<T>;
+    /**
+     * Create a successful Task result (alias for success)
+     * Preferred for new code
+     */
+    ok: <T>(data: T, params?: TaskParams) => TaskSuccess<T>;
+    /**
+     * Create a failed Task result (alias for fail)
+     * Preferred for new code
+     */
+    err: <T>(error: unknown, data?: unknown, params?: TaskParams) => TaskFailure<T>;
     /**
      * Extract the error chain from a Throwable error
      * Returns an array of errors from outermost to innermost
@@ -734,7 +892,7 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
     /**
      * Convert a Promise-returning function to a Task-compatible function
      */
-    fromPromise: <U, Args extends unknown[]>(promiseFn: (...args: Args) => Promise<U>, params?: TaskParams) => ((...args: Args) => FPromise<U>);
+    fromPromise: <U, Args extends unknown[]>(promiseFn: (...args: Args) => Promise<U>, params?: TaskParams) => ((...args: Args) => FPromise<TaskOutcome<U>>);
     /**
      * Convert a Task result to a Promise
      */
@@ -748,7 +906,7 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
      * @param params - Task parameters for the race operation
      * @returns A promise that resolves with the first task to complete or rejects if all tasks fail
      */
-    race: <T>(tasks: Array<FPromise<T>>, timeoutMs?: number, params?: TaskParams) => FPromise<T>;
+    race: <T>(tasks: Array<FPromise<T> | FPromise<TaskOutcome<T>>>, timeoutMs?: number, params?: TaskParams) => FPromise<TaskOutcome<T>>;
     /**
      * Convert a Node.js style callback function to a Task-compatible function
      * Node.js callbacks typically have the signature (error, result) => void
@@ -757,7 +915,7 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
      * @param params - Task parameters
      * @returns A function that returns an FPromise
      */
-    fromNodeCallback: <T, Args extends unknown[]>(nodeFn: (...args: [...Args, (error: unknown, result: T) => void]) => void, params?: TaskParams) => ((...args: Args) => FPromise<T>);
+    fromNodeCallback: <T, Args extends unknown[]>(nodeFn: (...args: [...Args, (error: unknown, result: T) => void]) => void, params?: TaskParams) => ((...args: Args) => FPromise<TaskOutcome<T>>);
     /**
      * Create a cancellation token source
      * @returns A cancellation token source that can be used to control task cancellation
@@ -770,8 +928,8 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
      * @param params - Task parameters
      * @returns An object with the task and a function to cancel it
      */
-    cancellable: <T>(task: (token: CancellationToken) => Promise<T>, params?: TaskParams) => {
-        task: FPromise<T>;
+    cancellable: <T>(task: (token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>, params?: TaskParams) => {
+        task: FPromise<TaskOutcome<T>>;
         cancel: () => void;
     };
     /**
@@ -782,8 +940,8 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
      * @param params - Task parameters
      * @returns An object with the task, cancel function, and current progress
      */
-    withProgress: <T>(task: (updateProgress: (percent: number) => void, token: CancellationToken) => Promise<T>, onProgress?: (percent: number) => void, params?: TaskParams) => {
-        task: FPromise<T>;
+    withProgress: <T>(task: (updateProgress: (percent: number) => void, token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>, onProgress?: (percent: number) => void, params?: TaskParams) => {
+        task: FPromise<TaskOutcome<T>>;
         cancel: () => void;
         currentProgress: () => number;
     };
@@ -1011,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
  */
@@ -1299,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;
@@ -1779,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, 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, 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,da as ESMap,q as Either,x as EmailAddress,K as FPromise,J as FPromiseCompanion,_ as FoldableUtils,$ as HKT,A as ISO8601Date,aa as Identity,u as IntegerNumber,ca as Lazy,X as LazyList,j as Left,h as List,ea as Map,F as Match,fa as MatchableUtils,H as NAME,w as NonEmptyString,t as NonNegativeNumber,b as None,d as Option,c as OptionConstructor,V as ParseError,D as PatternString,v as PositiveInteger,s as PositiveNumber,L as Ref,i as Right,e as Set,a as Some,ga as Stack,Q as Task,N as TaskFailure,O as TaskSuccess,I as Throwable,ba as Try,o as TypeCheckLeft,n as TypeCheckRight,f as Typeable,W as TypedError,z as UUID,y as UrlString,r as ValidatedBrand,Y as Validation,ha as Valuable,P as createCancellationTokenSource,U as createErrorSerializer,T as formatError,S as formatStackTrace,Z as isExtractable,l as isLeft,k as isRight,M as isTaggedThrowable,g as isTypeable,R as safeStringify,m as tryCatch,p as tryCatchAsync}from'./chunk-PPFDDUSD.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-PPFDDUSD.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{ea as Map}from'../chunk-PPFDDUSD.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-PPFDDUSD.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

package/dist/set/index.d.ts

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

package/dist/set/index.mjs

@@ -1,2 +1,2 @@
-export{e as Set}from'../chunk-PPFDDUSD.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
+export{f as Set}from'../chunk-7VZBQDNM.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/try/index.d.ts

@@ -1,74 +1,2 @@
-import { F as FunctypeBase, a as Extractable, P as Promisable, E as Either } from '../Either-DgkP4DUw.js';
-import { P as Pipe, T as Type } from '../Serializable-CK9upOU0.js';
-
-/**
- * Possible types of Try instances
- */
-type TypeNames = "Success" | "Failure";
-interface Try<T> extends FunctypeBase<T, TypeNames>, Extractable<T>, Pipe<T>, Promisable<T> {
-    readonly _tag: TypeNames;
-    readonly error: Error | undefined;
-    isSuccess(): this is Try<T> & {
-        readonly _tag: "Success";
-        error: undefined;
-    };
-    isFailure(): this is Try<T> & {
-        readonly _tag: "Failure";
-        error: Error;
-    };
-    get: () => T;
-    getOrElse: (defaultValue: T) => T;
-    getOrThrow: (error?: Error) => T;
-    orElse: (alternative: Try<T>) => Try<T>;
-    orNull: () => T | null;
-    orUndefined: () => T | undefined;
-    orThrow: (error: Error) => T;
-    toEither: () => Either<Error, T>;
-    map: <U>(f: (value: T) => U) => Try<U>;
-    ap: <U>(ff: Try<(value: T) => U>) => Try<U>;
-    flatMap: <U>(f: (value: T) => Try<U>) => Try<U>;
-    flatMapAsync: <U>(f: (value: T) => Promise<Try<U>>) => Promise<Try<U>>;
-    /**
-     * Pattern matches over the Try, applying onFailure if Failure and onSuccess if Success
-     * @param onFailure - Function to apply if the Try is Failure
-     * @param onSuccess - Function to apply if the Try is Success
-     * @returns The result of applying the appropriate function
-     */
-    fold: <U extends Type>(onFailure: (error: Error) => U, onSuccess: (value: T) => U) => U;
-    toString: () => string;
-    /**
-     * Pattern matches over the Try, applying a handler function based on the variant
-     * @param patterns - Object with handler functions for Success and Failure variants
-     * @returns The result of applying the matching handler function
-     */
-    match<R>(patterns: {
-        Success: (value: T) => R;
-        Failure: (error: Error) => R;
-    }): R;
-    toValue(): {
-        _tag: TypeNames;
-        value: T | Error;
-    };
-}
-declare const Try: (<T>(f: () => T) => Try<T>) & {
-    /**
-     * Creates a Try from JSON string
-     * @param json - The JSON string
-     * @returns Try instance
-     */
-    fromJSON: <T>(json: string) => Try<T>;
-    /**
-     * Creates a Try from YAML string
-     * @param yaml - The YAML string
-     * @returns Try instance
-     */
-    fromYAML: <T>(yaml: string) => Try<T>;
-    /**
-     * Creates a Try from binary string
-     * @param binary - The binary string
-     * @returns Try instance
-     */
-    fromBinary: <T>(binary: string) => Try<T>;
-};
-
-export { Try, type TypeNames };
+export { T as Try, r as TypeNames } from '../Either-D4P39LPj.js';
+import '../Typeable-CitTP1ay.js';

package/dist/try/index.mjs

@@ -1,2 +1,2 @@
-export{ba as Try}from'../chunk-PPFDDUSD.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
+export{i as Try}from'../chunk-7VZBQDNM.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-YBBRJTHY.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/tuple/index.d.ts

@@ -1,4 +1,4 @@
-import { T as Type, F as Foldable, P as Pipe, S as Serializable, a as Typeable } from '../Serializable-CK9upOU0.js';
+import { T as Type, F as Foldable, P as Pipe, S as Serializable, a as Typeable } from '../Typeable-CitTP1ay.js';
 
 interface Tuple<T extends Type[]> extends Foldable<T[number]>, Pipe<Tuple<T>>, Serializable<Tuple<T>>, Typeable<"Tuple"> {
     get<K extends number>(index: K): T[K];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functype",
-  "version": "0.11.2",
+  "version": "0.14.0",
   "type": "module",
   "description": "A smallish functional library for TypeScript",
   "author": "jordan.burke@gmail.com",
@@ -14,18 +14,18 @@
   "devDependencies": {
     "@eslint/compat": "^1.3.2",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.33.0",
+    "@eslint/js": "^9.34.0",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/github": "^11.0.4",
     "@semantic-release/npm": "^12.0.2",
     "@semantic-release/release-notes-generator": "^14.0.3",
-    "@types/node": "^22.17.2",
-    "@typescript-eslint/eslint-plugin": "^8.40.0",
-    "@typescript-eslint/parser": "^8.40.0",
+    "@types/node": "^22.18.0",
+    "@typescript-eslint/eslint-plugin": "^8.41.0",
+    "@typescript-eslint/parser": "^8.41.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "cross-env": "^10.0.0",
-    "eslint": "^9.33.0",
+    "eslint": "^9.34.0",
     "eslint-config-functype": "1.3.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-functional": "^9.0.2",
@@ -38,7 +38,7 @@
     "semantic-release": "^24.2.7",
     "ts-node": "^10.9.2",
     "tsup": "^8.5.0",
-    "typedoc": "^0.28.10",
+    "typedoc": "^0.28.11",
     "typescript": "5.9.2",
     "vitest": "^3.2.4"
   },
@@ -81,6 +81,12 @@
         "default": "./dist/conditional/index.mjs"
       }
     },
+    "./do": {
+      "import": {
+        "types": "./dist/do/index.d.ts",
+        "default": "./dist/do/index.mjs"
+      }
+    },
     "./lazy": {
       "import": {
         "types": "./dist/lazy/index.d.ts",