functype 0.8.70 → 0.8.80

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-DlOLCe3b.js';
-import '../Valuable-D4BtNlTV.js';
+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-CfG7OVB-.js';
+import '../Valuable-BI2O7E9Q.js';

package/dist/either/index.mjs

@@ -1,2 +1,2 @@
-export{p as Either,i as Left,h as Right,n as TypeCheckLeft,m as TypeCheckRight,k as isLeft,j as isRight,l as tryCatch,o as tryCatchAsync}from'../chunk-5ABR3A24.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{p as Either,i as Left,h as Right,n as TypeCheckLeft,m as TypeCheckRight,k as isLeft,j as isRight,l as tryCatch,o as tryCatchAsync}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.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-DlOLCe3b.js';
-import { T as Type } from '../Valuable-D4BtNlTV.js';
+import { E as Either } from '../Either-CfG7OVB-.js';
+import { T as Type } from '../Valuable-BI2O7E9Q.js';
 
 /**
  * Error context information that provides additional metadata about errors.

package/dist/fpromise/index.mjs

@@ -1,2 +1,2 @@
-export{J as FPromise,I as FPromiseCompanion}from'../chunk-5ABR3A24.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{J as FPromise,I as FPromiseCompanion}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/index.d.ts

@@ -1,14 +1,14 @@
 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, F as Foldable, L as List, T as Traversable, S as Serializable, P as Pipe, M as Matchable } from './Either-DlOLCe3b.js';
-export { a as Collection, C as Converters, I as IterableType, c as Left, h as MatchableUtils, N as None, k as OptionConstructor, R as Right, l as SerializationMethods, m as Set, j as Some, b as TestEither, f as TypeCheckLeft, e as TypeCheckRight, d as isLeft, i as isRight, t as tryCatch, g as tryCatchAsync } from './Either-DlOLCe3b.js';
-import { T as Type, a as Typeable, F as Functor, V as Valuable } from './Valuable-D4BtNlTV.js';
-export { A as AbstractFunctor, c as ArrayFunctor, b as AsyncFunctor, E as ExtractTag, d as TypeableParams, e as ValuableParams, i as isTypeable } from './Valuable-D4BtNlTV.js';
+import { O as Option, E as Either, F as Foldable, L as List, P as Pipe, S as Serializable, M as Matchable, T as Traversable } from './Either-CfG7OVB-.js';
+export { a as Collection, C as Converters, I as IterableType, c as Left, h as MatchableUtils, N as None, k as OptionConstructor, R as Right, l as SerializationMethods, m as Set, j as Some, b as TestEither, f as TypeCheckLeft, e as TypeCheckRight, d as isLeft, i as isRight, t as tryCatch, g as tryCatchAsync } from './Either-CfG7OVB-.js';
+import { T as Type, a as Typeable, F as Functor, A as AsyncFunctor, V as Valuable } from './Valuable-BI2O7E9Q.js';
+export { b as AbstractFunctor, c as ArrayFunctor, E as ExtractTag, d as TypeableParams, e as ValuableParams, i as isTypeable } from './Valuable-BI2O7E9Q.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 { a as ESMap, E as ESMapType, M as Map, S as SafeTraversable } from './Map-R4vpSnzG.js';
+export { a as ESMap, E as ESMapType, M as Map, S as SafeTraversable } from './Map-wkGSJvYa.js';
 export { Tuple } from './tuple/index.js';
 
 /**
@@ -645,205 +645,6 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
 };
 type Task = ReturnType<typeof Task>;
 
-/**
- * Code context for LLM-based self-healing and analysis
- */
-type CodeContext = {
-    /** The source code being executed */
-    source: string;
-    /** File path or identifier */
-    filePath?: string;
-    /** Function/method name */
-    functionName?: string;
-    /** Line number where error occurred */
-    lineNumber?: number;
-    /** Input parameters that caused the issue */
-    inputParams?: Record<string, unknown>;
-    /** Expected output type/shape */
-    expectedOutput?: unknown;
-    /** Stack trace at time of error */
-    stackTrace?: string;
-    /** Previous execution attempts */
-    attempts?: Array<{
-        timestamp: Date;
-        error: string;
-        modifications?: string;
-    }>;
-    /** Additional context for LLM */
-    llmContext?: {
-        /** Description of what the code should do */
-        intent: string;
-        /** Known constraints or requirements */
-        constraints?: string[];
-        /** Related code/dependencies */
-        dependencies?: string[];
-        /** Business rules or domain knowledge */
-        domain?: string;
-    };
-};
-/**
- * Fitness function result for code quality assessment
- */
-type FitnessResult = {
-    /** Overall fitness score (0-100) */
-    score: number;
-    /** Individual metric scores */
-    metrics: {
-        /** Correctness score (0-100) */
-        correctness: number;
-        /** Performance score (0-100) */
-        performance: number;
-        /** Maintainability score (0-100) */
-        maintainability: number;
-        /** Security score (0-100) */
-        security: number;
-        /** Type safety score (0-100) */
-        typeSafety: number;
-    };
-    /** Detailed feedback for improvement */
-    feedback: string[];
-    /** Suggestions for self-healing */
-    suggestions: string[];
-};
-/**
- * Partial fitness result from individual functions
- */
-type PartialFitnessResult = {
-    /** Partial metric scores */
-    metrics?: Partial<FitnessResult["metrics"]>;
-    /** Detailed feedback for improvement */
-    feedback?: string[];
-    /** Suggestions for self-healing */
-    suggestions?: string[];
-};
-/**
- * Configuration for self-healing behavior
- */
-type SelfHealingConfig = {
-    /** Maximum number of self-healing attempts */
-    maxAttempts: number;
-    /** Whether to use LLM for code generation */
-    enableLLMHealing: boolean;
-    /** Minimum fitness score to accept */
-    minFitnessScore: number;
-    /** Custom fitness functions */
-    customFitnessFunctions?: Array<(context: CodeContext, result?: unknown) => Promise<PartialFitnessResult>>;
-    /** LLM provider configuration */
-    llmConfig?: {
-        provider: "openai" | "anthropic" | "custom";
-        apiKey?: string;
-        model?: string;
-        temperature?: number;
-        customEndpoint?: string;
-    };
-};
-/**
- * Self-healing attempt result
- */
-type HealingAttempt = {
-    /** Attempt number */
-    attempt: number;
-    /** Timestamp of attempt */
-    timestamp: Date;
-    /** Error that triggered healing */
-    error: string;
-    /** Generated/modified code */
-    healedCode?: string;
-    /** Fitness score of healed code */
-    fitnessScore?: number;
-    /** Whether healing was successful */
-    success: boolean;
-    /** Reasoning for the healing approach */
-    reasoning?: string;
-};
-/**
- * Code-aware task that can self-heal using LLM context
- */
-type CodeAwareTask<T extends Type> = {
-    /** Execute with code context and self-healing */
-    executeWithHealing: (codeContext: CodeContext, config: SelfHealingConfig, cancellationToken?: CancellationToken) => Promise<{
-        result: Option<unknown>;
-        fitness: FitnessResult;
-        healingAttempts: HealingAttempt[];
-        finalCode: string;
-    }>;
-    /** Evaluate fitness of code without execution */
-    evaluateFitness: (codeContext: CodeContext, result?: unknown, customFunctions?: Array<(context: CodeContext, result?: unknown) => Promise<PartialFitnessResult>>) => Promise<FitnessResult>;
-    /** Generate healing suggestions using LLM */
-    generateHealingSuggestions: (codeContext: CodeContext, error: string, config: SelfHealingConfig) => Promise<{
-        suggestions: string[];
-        healedCode?: string;
-        reasoning: string;
-    }>;
-    /** Validate healed code before execution */
-    validateHealedCode: (original: CodeContext, healed: string, config: SelfHealingConfig) => Promise<{
-        isValid: boolean;
-        issues: string[];
-        riskLevel: "low" | "medium" | "high";
-    }>;
-};
-/**
- * Code-aware task that provides LLM context for self-healing and fitness evaluation
- * @example
- * // Basic usage with self-healing
- * const codeTask = CodeAwareTask<string>({ name: "DataProcessor" })
- * const context = CodeAwareTask.createCodeContext(
- *   "function processData(data) { return data.map(x => x.value) }",
- *   "Process array of objects to extract values"
- * )
- *
- * const result = await codeTask.executeWithHealing(
- *   context,
- *   CodeAwareTask.defaultConfig()
- * )
- *
- * @example
- * // Custom fitness evaluation
- * const customFitness = CodeAwareTask.createCustomFitnessFunction(
- *   "businessLogic",
- *   async (context, result) => ({
- *     score: 85,
- *     feedback: ["Follows business rules correctly"],
- *     suggestions: ["Consider adding validation"]
- *   })
- * )
- *
- * const fitness = await codeTask.evaluateFitness(context, result, [customFitness])
- *
- * @example
- * // High-fitness configuration
- * const strictConfig = CodeAwareTask.fitnessConfig(90)
- * const result = await codeTask.executeWithHealing(context, strictConfig)
- */
-declare const CodeAwareTask: (<T extends Type>(params?: TaskParams) => CodeAwareTask<T>) & {
-    /**
-     * Create a default self-healing configuration
-     */
-    defaultConfig: () => SelfHealingConfig;
-    /**
-     * Create a fitness-focused configuration
-     */
-    fitnessConfig: (minScore: number) => SelfHealingConfig;
-    /**
-     * Create a custom fitness function for domain-specific evaluation
-     */
-    createCustomFitnessFunction: (name: string, evaluator: (context: CodeContext, result?: unknown) => Promise<{
-        score: number;
-        feedback: string[];
-        suggestions?: string[];
-    }>) => (context: CodeContext, result?: unknown) => Promise<PartialFitnessResult>;
-    /**
-     * Utility to create code context from function
-     */
-    createCodeContext: (source: string, intent: string, options?: {
-        filePath?: string;
-        functionName?: string;
-        expectedOutput?: unknown;
-        constraints?: string[];
-        dependencies?: string[];
-    }) => CodeContext;
-};
-
 /**
  * Type definition for task information that may be attached to errors
  */
@@ -1024,6 +825,254 @@ type Identity<T> = {
 };
 declare function Identity<T>(value: T): Identity<T>;
 
+/**
+ * Lazy type module
+ * @module Lazy
+ * @category Core
+ */
+/**
+ * The Lazy type represents a computation that is deferred until needed.
+ * It provides memoization and safe evaluation with integration to Option, Either, and Try.
+ * @typeParam T - The type of the value to be computed
+ */
+type Lazy<T extends Type> = {
+    /** Tag identifying this as a Lazy type */
+    readonly _tag: "Lazy";
+    /** Whether the computation has been evaluated */
+    readonly isEvaluated: boolean;
+    /**
+     * Forces evaluation of the lazy value and returns the result.
+     * The result is memoized after first evaluation.
+     * @returns The computed value
+     * @throws Any error thrown by the computation
+     */
+    get(): T;
+    /**
+     * Returns the computed value or a default value if computation fails
+     * @param defaultValue - The value to return if computation fails
+     * @returns The computed value or defaultValue
+     */
+    getOrElse(defaultValue: T): T;
+    /**
+     * Returns the computed value or null if computation fails
+     * @returns The computed value or null
+     */
+    getOrNull(): T | null;
+    /**
+     * Returns the computed value or throws a specified error if computation fails
+     * @param error - The error to throw if computation fails
+     * @returns The computed value
+     * @throws The specified error if computation fails
+     */
+    getOrThrow(error: Error): T;
+    /**
+     * Maps the value inside the Lazy using the provided function
+     * @param f - The mapping function
+     * @returns A new Lazy containing the mapped value
+     */
+    map<U extends Type>(f: (value: T) => U): Lazy<U>;
+    /**
+     * Maps the value inside the Lazy using an async function
+     * @param f - The async mapping function
+     * @returns A Promise of a new Lazy containing the mapped value
+     */
+    mapAsync<U extends Type>(f: (value: T) => Promise<U>): Promise<Lazy<U>>;
+    /**
+     * Maps the value using a function that returns a Lazy
+     * @param f - The mapping function returning a Lazy
+     * @returns A new Lazy containing the flattened result
+     */
+    flatMap<U extends Type>(f: (value: T) => Lazy<U>): Lazy<U>;
+    /**
+     * Maps the value using an async function that returns a Lazy
+     * @param f - The async mapping function returning a Lazy
+     * @returns A Promise of a new Lazy containing the flattened result
+     */
+    flatMapAsync<U extends Type>(f: (value: T) => Promise<Lazy<U>>): Promise<Lazy<U>>;
+    /**
+     * Returns a Lazy that filters the value based on a predicate
+     * @param predicate - The predicate function
+     * @returns A Lazy containing an Option of the value
+     */
+    filter(predicate: (value: T) => boolean): Lazy<Option<T>>;
+    /**
+     * Recovers from a failed computation by providing an alternative value
+     * @param f - Function that takes the error and returns a recovery value
+     * @returns A new Lazy that will use the recovery function if computation fails
+     */
+    recover(f: (error: unknown) => T): Lazy<T>;
+    /**
+     * Recovers from a failed computation by providing an alternative Lazy
+     * @param f - Function that takes the error and returns a recovery Lazy
+     * @returns A new Lazy that will use the recovery Lazy if computation fails
+     */
+    recoverWith(f: (error: unknown) => Lazy<T>): Lazy<T>;
+    /**
+     * Evaluates the computation and returns it as an Option
+     * @returns Some containing the value if successful, None if computation fails
+     */
+    toOption(): Option<T>;
+    /**
+     * Evaluates the computation and returns it as an Either
+     * @returns Right containing the value if successful, Left containing the error if computation fails
+     */
+    toEither(): Either<unknown, T>;
+    /**
+     * Evaluates the computation and returns it as an Either with a mapped error
+     * @param mapError - Function to map the error
+     * @returns Right containing the value if successful, Left containing the mapped error if computation fails
+     */
+    toEitherWith<E>(mapError: (error: unknown) => E): Either<E, T>;
+    /**
+     * Evaluates the computation and returns it as a Try
+     * @returns Try containing the result of the computation
+     */
+    toTry(): Try<T>;
+    /**
+     * Applies an effect function to the value if computation succeeds
+     * @param f - The effect function
+     * @returns This Lazy for chaining
+     */
+    tap(f: (value: T) => void): Lazy<T>;
+    /**
+     * Applies an effect function to the error if computation fails
+     * @param f - The effect function for errors
+     * @returns This Lazy for chaining
+     */
+    tapError(f: (error: unknown) => void): Lazy<T>;
+    /**
+     * Pattern matching on the Lazy value
+     * @param f - Function to apply to the computed value
+     * @returns The result of applying f to the computed value
+     */
+    fold<U>(f: (value: T) => U): U;
+    /**
+     * Pattern matching with success and failure handlers
+     * @param onFailure - Function to handle computation failure
+     * @param onSuccess - Function to handle successful computation
+     * @returns The result of the appropriate handler
+     */
+    foldWith<U>(onFailure: (error: unknown) => U, onSuccess: (value: T) => U): U;
+    /**
+     * Left fold operation
+     * @param z - Initial value
+     * @returns Function that takes an operator and applies it
+     */
+    foldLeft: <B>(z: B) => (op: (b: B, a: T) => B) => B;
+    /**
+     * Right fold operation
+     * @param z - Initial value
+     * @returns Function that takes an operator and applies it
+     */
+    foldRight: <B>(z: B) => (op: (a: T, b: B) => B) => B;
+    /**
+     * Pattern matching for the Lazy type
+     * @param patterns - Object with handler for Lazy pattern
+     * @returns The result of the matched handler
+     */
+    match<R>(patterns: {
+        Lazy: (value: T) => R;
+    }): R;
+    /**
+     * Creates a string representation of the Lazy
+     * @returns String representation showing evaluation status
+     */
+    toString(): string;
+    /**
+     * Converts the Lazy to a value object
+     * @returns Object representation of the Lazy
+     */
+    toValue(): {
+        _tag: "Lazy";
+        evaluated: boolean;
+        value?: T;
+    };
+} & Functor<T> & AsyncFunctor<T> & Pipe<T> & Serializable<T> & Typeable<"Lazy"> & Foldable<T> & Matchable<T, "Lazy">;
+/**
+ * Creates a Lazy computation that defers evaluation until needed.
+ * Results are memoized after first evaluation.
+ *
+ * @example
+ * // Basic lazy evaluation
+ * const expensive = Lazy(() => {
+ *   console.log("Computing...")
+ *   return 42
+ * })
+ * // Nothing printed yet
+ * const result = expensive.get() // Prints "Computing..." and returns 42
+ * const cached = expensive.get() // Returns 42 without printing
+ *
+ * @example
+ * // Error handling
+ * const risky = Lazy(() => {
+ *   if (Math.random() > 0.5) throw new Error("Failed")
+ *   return "Success"
+ * })
+ * const safe = risky.getOrElse("Default") // Returns "Success" or "Default"
+ * const option = risky.toOption() // Some("Success") or None
+ * const either = risky.toEither() // Right("Success") or Left(Error)
+ *
+ * @example
+ * // Chaining computations
+ * const result = Lazy(() => 10)
+ *   .map(x => x * 2)
+ *   .flatMap(x => Lazy(() => x + 5))
+ *   .recover(err => 0)
+ *   .get() // 25
+ *
+ * @example
+ * // Integration with functype
+ * const userOption = Option({ id: 1, name: "Alice" })
+ * const userName = Lazy.fromOption(userOption, () => ({ id: 0, name: "Anonymous" }))
+ *   .map(user => user.name)
+ *   .get() // "Alice"
+ */
+declare const Lazy: (<T extends Type>(thunk: () => T) => Lazy<T>) & {
+    /**
+     * Creates a Lazy from a thunk (deferred computation)
+     * @param thunk - Function that computes the value
+     * @returns A new Lazy instance
+     */
+    of: <T extends Type>(thunk: () => T) => Lazy<T>;
+    /**
+     * Creates a Lazy from an immediate value
+     * @param value - The value to wrap
+     * @returns A new Lazy instance that returns the value
+     */
+    fromValue: <T extends Type>(value: T) => Lazy<T>;
+    /**
+     * Creates a Lazy from an Option
+     * @param option - The Option to convert
+     * @param defaultThunk - Thunk to compute default value if Option is None
+     * @returns A new Lazy instance
+     */
+    fromOption: <T extends Type>(option: Option<T>, defaultThunk: () => T) => Lazy<T>;
+    /**
+     * Creates a Lazy from a Try
+     * @param tryValue - The Try to convert
+     * @returns A new Lazy instance
+     */
+    fromTry: <T extends Type>(tryValue: Try<T>) => Lazy<T>;
+    /**
+     * Creates a Lazy from an Either
+     * @param either - The Either to convert
+     * @returns A new Lazy instance
+     */
+    fromEither: <E, T extends Type>(either: Either<E, T>) => Lazy<T>;
+    /**
+     * Creates a Lazy that will throw an error since promises need to be awaited first
+     * @param promise - The Promise to convert
+     * @returns A new Lazy instance that throws an error
+     */
+    fromPromise: <T extends Type>(promise: Promise<T>) => Lazy<T>;
+    /**
+     * Creates a failed Lazy that will throw when evaluated
+     * @param error - The error to throw
+     * @returns A new Lazy instance that throws the error
+     */
+    fail: <T extends Type>(error: unknown) => Lazy<T>;
+};
+
 /**
  * LazyList provides lazy evaluation for list operations.
  * Operations are deferred until the list is materialized.
@@ -1244,4 +1293,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, CodeAwareTask, type CodeContext, Companion, Cond, Either, type EitherKind, EmailAddress, type ErrorChainElement, type ErrorFormatterOptions, type ErrorWithTaskInfo, FPromise, type FitnessResult, Foldable, FoldableUtils, Functor, HKT, type HealingAttempt, ISO8601Date, Identity, IntegerNumber, type Kind, LazyList, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Option, type OptionKind, ParseError, type PartialFitnessResult, PatternString, Pipe, PositiveInteger, PositiveNumber, type SelfHealingConfig, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, UUID, type UniversalContainer, UrlString, ValidatedBrand, Valuable, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };
+export { type Async, AsyncFunctor, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, Companion, Cond, Either, type EitherKind, EmailAddress, type ErrorChainElement, type ErrorFormatterOptions, type ErrorWithTaskInfo, FPromise, Foldable, FoldableUtils, Functor, 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, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, UUID, type UniversalContainer, UrlString, ValidatedBrand, Valuable, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-export{F as Base,A as BoundedNumber,B as BoundedString,P as CodeAwareTask,a as Companion,D as Cond,_ as ESMap,p as Either,w as EmailAddress,J as FPromise,I as FPromiseCompanion,V as FoldableUtils,X as HKT,z as ISO8601Date,Y as Identity,t as IntegerNumber,Z as LazyList,i as Left,g as List,$ as Map,E as Match,aa as MatchableUtils,G as NAME,v as NonEmptyString,s as NonNegativeNumber,c as None,e as Option,d as OptionConstructor,U as ParseError,C as PatternString,u as PositiveInteger,r as PositiveNumber,h as Right,f as Set,b as Some,ba as Stack,O as Task,L as TaskException,M as TaskResult,H as Throwable,W as Try,n as TypeCheckLeft,m as TypeCheckRight,y as UUID,x as UrlString,q as ValidatedBrand,N as createCancellationTokenSource,T as createErrorSerializer,S as formatError,R as formatStackTrace,k as isLeft,j as isRight,K as isTaggedThrowable,Q as safeStringify,l as tryCatch,o as tryCatchAsync}from'./chunk-5ABR3A24.mjs';export{d as Tuple,a as Typeable,c as Valuable,b as isTypeable}from'./chunk-7PQA3W7W.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-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{F as Base,A as BoundedNumber,B as BoundedString,a as Companion,D as Cond,_ as ESMap,p as Either,w as EmailAddress,J as FPromise,I as FPromiseCompanion,U as FoldableUtils,W as HKT,z as ISO8601Date,X as Identity,t as IntegerNumber,Y as Lazy,Z as LazyList,i as Left,g as List,$ as Map,E as Match,aa as MatchableUtils,G as NAME,v as NonEmptyString,s as NonNegativeNumber,c as None,e as Option,d as OptionConstructor,T as ParseError,C as PatternString,u as PositiveInteger,r as PositiveNumber,h as Right,f as Set,b as Some,ba as Stack,O as Task,L as TaskException,M as TaskResult,H as Throwable,V as Try,n as TypeCheckLeft,m as TypeCheckRight,y as UUID,x as UrlString,q as ValidatedBrand,N as createCancellationTokenSource,S as createErrorSerializer,R as formatError,Q as formatStackTrace,k as isLeft,j as isRight,K as isTaggedThrowable,P as safeStringify,l as tryCatch,o as tryCatchAsync}from'./chunk-JIVKCD74.mjs';export{d as Tuple,a as Typeable,c as Valuable,b as isTypeable}from'./chunk-7PQA3W7W.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-TQJDL6YW.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-DlOLCe3b.js';
-import '../Valuable-D4BtNlTV.js';
+export { L as List } from '../Either-CfG7OVB-.js';
+import '../Valuable-BI2O7E9Q.js';

package/dist/list/index.mjs

@@ -1,2 +1,2 @@
-export{g as List}from'../chunk-5ABR3A24.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{g as List}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/map/index.d.ts

@@ -1,4 +1,4 @@
-import '../Either-DlOLCe3b.js';
-import '../Valuable-D4BtNlTV.js';
-export { M as Map, S as SafeTraversable } from '../Map-R4vpSnzG.js';
+import '../Either-CfG7OVB-.js';
+import '../Valuable-BI2O7E9Q.js';
+export { M as Map, S as SafeTraversable } from '../Map-wkGSJvYa.js';
 import '../tuple/index.js';

package/dist/map/index.mjs

@@ -1,2 +1,2 @@
-export{$ as Map}from'../chunk-5ABR3A24.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{$ as Map}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.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, k as OptionConstructor, j as Some } from '../Either-DlOLCe3b.js';
-import '../Valuable-D4BtNlTV.js';
+export { N as None, O as Option, k as OptionConstructor, j as Some } from '../Either-CfG7OVB-.js';
+import '../Valuable-BI2O7E9Q.js';

package/dist/option/index.mjs

@@ -1,2 +1,2 @@
-export{c as None,e as Option,d as OptionConstructor,b as Some}from'../chunk-5ABR3A24.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{c as None,e as Option,d as OptionConstructor,b as Some}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/set/index.d.ts

@@ -1,2 +1,2 @@
-export { m as Set } from '../Either-DlOLCe3b.js';
-import '../Valuable-D4BtNlTV.js';
+export { m as Set } from '../Either-CfG7OVB-.js';
+import '../Valuable-BI2O7E9Q.js';

package/dist/set/index.mjs

@@ -1,2 +1,2 @@
-export{f as Set}from'../chunk-5ABR3A24.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{f as Set}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/try/index.d.ts

@@ -1,5 +1,5 @@
-import { E as Either, S as Serializable, P as Pipe, F as Foldable, M as Matchable } from '../Either-DlOLCe3b.js';
-import { T as Type, a as Typeable, V as Valuable } from '../Valuable-D4BtNlTV.js';
+import { E as Either, S as Serializable, P as Pipe, F as Foldable, M as Matchable } from '../Either-CfG7OVB-.js';
+import { T as Type, a as Typeable, V as Valuable } from '../Valuable-BI2O7E9Q.js';
 
 /**
  * Possible types of Try instances

package/dist/try/index.mjs

@@ -1,2 +1,2 @@
-export{W as Try}from'../chunk-5ABR3A24.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{V as Try}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/tuple/index.d.ts

@@ -1,4 +1,4 @@
-import { T as Type, c as ArrayFunctor, a as Typeable, V as Valuable } from '../Valuable-D4BtNlTV.js';
+import { T as Type, c as ArrayFunctor, a as Typeable, V as Valuable } from '../Valuable-BI2O7E9Q.js';
 
 type Tuple<T extends Type[]> = {
     get<K extends number>(index: K): T[K];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functype",
-  "version": "0.8.70",
+  "version": "0.8.80",
   "type": "module",
   "description": "A smallish functional library for TypeScript",
   "author": "jordan.burke@gmail.com",
@@ -12,12 +12,12 @@
   "homepage": "https://github.com/jordanburke/functype#readme",
   "url": "https://github.com/jordanburke/functype",
   "devDependencies": {
-    "@eslint/compat": "^1.3.0",
+    "@eslint/compat": "^1.3.1",
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
-    "@types/node": "^22.15.32",
-    "@typescript-eslint/eslint-plugin": "^8.34.1",
-    "@typescript-eslint/parser": "^8.34.1",
+    "@types/node": "^22.15.33",
+    "@typescript-eslint/eslint-plugin": "^8.35.0",
+    "@typescript-eslint/parser": "^8.35.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "cross-env": "^7.0.3",
@@ -25,11 +25,11 @@
     "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-functional": "^9.0.2",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.0",
+    "eslint-plugin-prettier": "^5.5.1",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "fast-check": "^4.1.1",
     "globals": "^16.2.0",
-    "prettier": "^3.5.3",
+    "prettier": "^3.6.1",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
     "tsup": "^8.5.0",
@@ -76,6 +76,12 @@
         "default": "./dist/conditional/index.mjs"
       }
     },
+    "./lazy": {
+      "import": {
+        "types": "./dist/lazy/index.d.ts",
+        "default": "./dist/lazy/index.mjs"
+      }
+    },
     "./task": {
       "import": {
         "types": "./dist/core/task/index.d.ts",
@@ -88,6 +94,18 @@
         "default": "./dist/fpromise/index.mjs"
       }
     },
+    "./functype": {
+      "import": {
+        "types": "./dist/functype/index.d.ts",
+        "default": "./dist/functype/index.mjs"
+      }
+    },
+    "./typeclass": {
+      "import": {
+        "types": "./dist/typeclass/index.d.ts",
+        "default": "./dist/typeclass/index.mjs"
+      }
+    },
     "./map": {
       "import": {
         "types": "./dist/map/index.d.ts",