functype 0.9.0 → 0.9.1

package/dist/chunk-R2TQJN3P.mjs

@@ -0,0 +1,2 @@
+function e(r,n){let d=n,t={unbrand(){return n},unwrap(){return n},toString(){return String(n)}};return typeof n=="number"&&Object.assign(t,{valueOf(){return n}}),Object.assign(d,t)}function a(r){return r.unbrand()}function s(r,n){return r!=null}function o(r){return n=>e(r,n)}var i=r=>n=>e(r,n),K=r=>n=>e(r,n),B=r=>n=>e(r,n);export{e as a,a as b,s as c,o as d,i as e,K as f,B as g};//# sourceMappingURL=chunk-R2TQJN3P.mjs.map
+//# sourceMappingURL=chunk-R2TQJN3P.mjs.map

package/dist/chunk-R2TQJN3P.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/branded/Brand.ts"],"names":["Brand","brand","value","branded","methods","unbrand","hasBrand","createBrander","BrandedString","BrandedNumber","BrandedBoolean"],"mappings":"AAsBO,SAASA,CAAAA,CAA2BC,EAAUC,CAAAA,CAAuB,CAC1E,IAAMC,CAAAA,CAAUD,CAAAA,CACVE,EAAU,CACd,OAAA,EAAa,CACX,OAAOF,CACT,EACA,MAAA,EAAY,CACV,OAAOA,CACT,CAAA,CACA,QAAA,EAAmB,CACjB,OAAO,MAAA,CAAOA,CAAK,CACrB,CACF,EAGA,OAAI,OAAOA,GAAU,QAAA,EACnB,MAAA,CAAO,OAAOE,CAAAA,CAAS,CACrB,SAAkB,CAChB,OAAOF,CACT,CACF,CAAC,EAGI,MAAA,CAAO,MAAA,CAAOC,CAAAA,CAASC,CAAO,CACvC,CAOO,SAASC,CAAAA,CAAWF,CAAAA,CAA8B,CACvD,OAAOA,CAAAA,CAAQ,SACjB,CAaO,SAASG,CAAAA,CAA8BJ,CAAAA,CAAgBD,EAAgC,CAG5F,OAAOC,GAAU,IACnB,CAOO,SAASK,CAAAA,CAAmCN,CAAAA,CAAU,CAC3D,OAAQC,CAAAA,EAA0BF,CAAAA,CAAMC,EAAOC,CAAK,CACtD,CAQO,IAAMM,CAAAA,CACQP,GAClBC,CAAAA,EACCF,CAAAA,CAAMC,CAAAA,CAAOC,CAAK,CAAA,CAETO,CAAAA,CACQR,GAClBC,CAAAA,EACCF,CAAAA,CAAMC,EAAOC,CAAK,CAAA,CAETQ,EACQT,CAAAA,EAClBC,CAAAA,EACCF,CAAAA,CAAMC,CAAAA,CAAOC,CAAK","file":"chunk-R2TQJN3P.mjs","sourcesContent":["// The brand symbol type with instance methods\nexport type Brand<K extends string, T> = T & {\n  readonly __brand: K\n  readonly unbrand: () => T\n  readonly unwrap: () => T\n}\n\n// Utility type to extract the underlying type from a branded type\nexport type Unbrand<T> = T extends Brand<string, infer U> ? U : never\n\n// Utility type to extract the brand from a branded type\nexport type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never\n\n/**\n * Brand is a utility for creating nominal typing in TypeScript.\n * It allows for creating distinct types that are structurally identical\n * but considered different by TypeScript's type system.\n *\n * @param brand - The brand name\n * @param value - The value to brand\n * @returns The branded value with unbrand/unwrap methods\n */\nexport function Brand<K extends string, T>(brand: K, value: T): Brand<K, T> {\n  const branded = value as Brand<K, T>\n  const methods = {\n    unbrand(): T {\n      return value\n    },\n    unwrap(): T {\n      return value\n    },\n    toString(): string {\n      return String(value)\n    },\n  }\n\n  // Add valueOf for numeric types to support numeric operations\n  if (typeof value === \"number\") {\n    Object.assign(methods, {\n      valueOf(): number {\n        return value as number\n      },\n    })\n  }\n\n  return Object.assign(branded, methods)\n}\n\n/**\n * Helper to remove a brand from a value\n * @param branded - The branded value\n * @returns The original value without the brand\n */\nexport function unbrand<T>(branded: Brand<string, T>): T {\n  return branded.unbrand()\n}\n\n/**\n * Type guard for checking if a value has a specific brand\n * @param value - The value to check\n * @param brand - The brand to check for\n * @returns True if the value has the specified brand\n *\n * Note: Since brands are phantom types that exist only at compile time,\n * this function can only provide a runtime approximation. It always returns true\n * for non-null values, as we have no way to actually check the brand at runtime.\n * This function is primarily for API consistency and documentation purposes.\n */\nexport function hasBrand<K extends string, T>(value: unknown, brand: K): value is Brand<K, T> {\n  // In a phantom type system, we can't actually check the brand at runtime\n  // We can only verify the value exists\n  return value !== null && value !== undefined\n}\n\n/**\n * Create a branded type constructor for a specific brand\n * @param brand - The brand name\n * @returns A function that brands values with the specified brand\n */\nexport function createBrander<K extends string, T>(brand: K) {\n  return (value: T): Brand<K, T> => Brand(brand, value)\n}\n\n// Common branded primitive types\nexport type BrandedString<K extends string> = Brand<K, string>\nexport type BrandedNumber<K extends string> = Brand<K, number>\nexport type BrandedBoolean<K extends string> = Brand<K, boolean>\n\n// Factory for common primitive branded types\nexport const BrandedString =\n  <K extends string>(brand: K) =>\n  (value: string): BrandedString<K> =>\n    Brand(brand, value)\n\nexport const BrandedNumber =\n  <K extends string>(brand: K) =>\n  (value: number): BrandedNumber<K> =>\n    Brand(brand, value)\n\nexport const BrandedBoolean =\n  <K extends string>(brand: K) =>\n  (value: boolean): BrandedBoolean<K> =>\n    Brand(brand, value)\n"]}

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-C-PDWX2U.js';
-import '../Serializable-D9GKEo30.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-BHep7I0d.js';
+import '../Serializable-BbKuhDDL.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-4EYCKDDF.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-V6LFV5LW.mjs';//# sourceMappingURL=index.mjs.map
+export{o as Either,h as Left,g as Right,m as TypeCheckLeft,l as TypeCheckRight,j as isLeft,i as isRight,k as tryCatch,n as tryCatchAsync}from'../chunk-GHBOC52G.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-R2TQJN3P.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-C-PDWX2U.js';
-import { T as Type } from '../Serializable-D9GKEo30.js';
+import { E as Either } from '../Either-BHep7I0d.js';
+import { T as Type } from '../Serializable-BbKuhDDL.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-4EYCKDDF.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-V6LFV5LW.mjs';//# sourceMappingURL=index.mjs.map
+export{I as FPromise,H as FPromiseCompanion}from'../chunk-GHBOC52G.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-R2TQJN3P.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 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-C-PDWX2U.js';
-export { A as Applicative, p as AsyncMonad, C as Collection, n as CollectionOps, o as ContainerOps, q as Functor, h as Functype, j as FunctypeCollection, c as Left, k as MatchableUtils, r as Monad, N as None, l as OptionConstructor, R as Right, m as Set, S 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-C-PDWX2U.js';
-import { T as Type, a as Typeable, F as Foldable, P as Pipe, S as Serializable } from './Serializable-D9GKEo30.js';
-export { E as ExtractTag, b as SerializationMethods, c as TypeableParams, i as isTypeable } from './Serializable-D9GKEo30.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-BHep7I0d.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, 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-BHep7I0d.js';
+import { T as Type, a as Typeable, F as Foldable, P as Pipe, S as Serializable } from './Serializable-BbKuhDDL.js';
+export { b as SerializationMethods } from './Serializable-BbKuhDDL.js';
 import { FPromise } from './fpromise/index.js';
 export { ErrorContext, FPromiseCompanion } from './fpromise/index.js';
 import { Try } from './try/index.js';
@@ -11,13 +11,6 @@ export { TypeNames } from './try/index.js';
 export { Map, SafeTraversable } from './map/index.js';
 export { Tuple } from './tuple/index.js';
 
-/**
- * A brand with runtime validation
- * @example
- * const Age = ValidatedBrand("Age", (n: number) => n >= 0 && n <= 150)
- * const myAge = Age.of(25) // Option<Brand<"Age", number>>
- * const invalid = Age.of(-5) // None
- */
 type ValidatedBrand<K extends string, T> = {
     readonly brand: K;
     readonly validate: (value: T) => boolean;
@@ -144,6 +137,7 @@ declare function PatternString(brand: string, pattern: RegExp): ValidatedBrand<s
  */
 declare function Companion<ObjectF extends object, CompanionF extends object>(object: ObjectF, companion: CompanionF): ObjectF & CompanionF;
 
+/** @internal */
 type LazyCondChain<T> = {
     when: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
     elseWhen: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
@@ -277,12 +271,16 @@ declare const Cond: (<T extends Type>() => Cond<T>) & {
 
 /**
  * Type-level utilities for exhaustiveness checking
+ * @internal
  */
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/** @internal */
 type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+/** @internal */
 type RequireExhaustive<T, Cases> = IsUnion<T> extends true ? (keyof Cases extends T ? (T extends keyof Cases ? Cases : never) : never) : Cases;
 /**
  * Pattern types for nested matching
+ * @internal
  */
 type Pattern<T> = T | {
     [K in keyof T]?: Pattern<T[K]>;
@@ -291,6 +289,7 @@ type Pattern<T> = T | {
 };
 /**
  * Extract result from pattern
+ * @internal
  */
 type PatternResult<T, R> = R | ((matched: T) => R);
 /**
@@ -529,6 +528,9 @@ declare function Base<T>(type: string, body: T): T & {
  * The identifier name for Throwable type
  */
 declare const NAME: "Throwable";
+/**
+ * @internal
+ */
 type ThrowableType = Error & Typeable<typeof NAME> & {
     readonly data?: unknown;
     readonly cause?: Error;
@@ -1222,13 +1224,20 @@ type EitherKind<E> = <A>(a: A) => Either<E, A>;
 type TryKind = <A>(a: A) => Try<A>;
 /**
  * Generic container types for type-safe operations
+ * @internal
  */
 type Mappable<T> = {
     map<U>(f: (value: T) => U): unknown;
 };
+/**
+ * @internal
+ */
 type Flattenable = {
     flatten(): unknown;
 };
+/**
+ * @internal
+ */
 type FlatMappable<T> = {
     flatMap<U>(f: (value: T) => unknown): unknown;
 };
@@ -1603,7 +1612,7 @@ type ValuableParams<Tag extends string, T, V> = {
     value: V;
 };
 /**
- * Creates a Valuable wrapper that adds value extraction capabilities
+ * Represents a type that can extract its inner value. Creates a Valuable wrapper that adds value extraction capabilities.
  * @param params - Configuration parameters
  * @module Valuable
  * @category Utilities
@@ -1615,13 +1624,12 @@ declare function Valuable<Tag extends string, V, T = object>(params: ValuablePar
     };
     _tag: Tag;
 };
-/**
- * Represents a type that can extract its inner value
- * @interface
- * @module Valuable
- * @category Utilities
- */
-type Valuable<Tag extends string, V, T = object> = ReturnType<typeof Valuable<Tag, V, T>>;
+type Valuable<Tag extends string, V, T = object> = Typeable<Tag, T> & {
+    toValue: () => {
+        _tag: Tag;
+        value: V;
+    };
+};
 
 /**
  * Stack data structure - Last In, First Out (LIFO)
@@ -1725,4 +1733,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, 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, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, TypedError, type TypedErrorContext, UUID, type UniversalContainer, UrlString, ValidatedBrand, 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, 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, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, TypedError, type TypedErrorContext, UUID, type UniversalContainer, UrlString, ValidatedBrand, 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,ba as ESMap,q as Either,x as EmailAddress,K as FPromise,J as FPromiseCompanion,Y as FoldableUtils,_ as HKT,A as ISO8601Date,$ as Identity,u as IntegerNumber,aa as Lazy,W as LazyList,j as Left,h as List,ca as Map,F as Match,da as MatchableUtils,H as NAME,w as NonEmptyString,t as NonNegativeNumber,b as None,d as Option,c as OptionConstructor,U as ParseError,D as PatternString,v as PositiveInteger,s as PositiveNumber,ea as Ref,i as Right,e as Set,a as Some,ga as Stack,P as Task,M as TaskException,N as TaskResult,I as Throwable,Z as Try,o as TypeCheckLeft,n as TypeCheckRight,f as Typeable,V as TypedError,z as UUID,y as UrlString,r as ValidatedBrand,X as Validation,fa as Valuable,O as createCancellationTokenSource,T as createErrorSerializer,S as formatError,R as formatStackTrace,l as isLeft,k as isRight,L as isTaggedThrowable,g as isTypeable,Q as safeStringify,m as tryCatch,p as tryCatchAsync}from'./chunk-4EYCKDDF.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-V6LFV5LW.mjs';//# sourceMappingURL=index.mjs.map
+export{E as Base,z as BoundedNumber,A as BoundedString,C as Cond,aa as ESMap,o as Either,v as EmailAddress,I as FPromise,H as FPromiseCompanion,X as FoldableUtils,Z as HKT,y as ISO8601Date,_ as Identity,s as IntegerNumber,$ as Lazy,U as LazyList,h as Left,f as List,ba as Map,D as Match,ca as MatchableUtils,F as NAME,u as NonEmptyString,r as NonNegativeNumber,b as None,d as Option,c as OptionConstructor,S as ParseError,B as PatternString,t as PositiveInteger,q as PositiveNumber,da as Ref,g as Right,e as Set,a as Some,fa as Stack,N as Task,K as TaskException,L as TaskResult,G as Throwable,Y as Try,m as TypeCheckLeft,l as TypeCheckRight,T as TypedError,x as UUID,w as UrlString,p as ValidatedBrand,V as Validation,ea as Valuable,M as createCancellationTokenSource,R as createErrorSerializer,Q as formatError,P as formatStackTrace,W as isExtractable,j as isLeft,i as isRight,J as isTaggedThrowable,O as safeStringify,k as tryCatch,n as tryCatchAsync}from'./chunk-GHBOC52G.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-R2TQJN3P.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-C-PDWX2U.js';
-import '../Serializable-D9GKEo30.js';
+export { L as List } from '../Either-BHep7I0d.js';
+import '../Serializable-BbKuhDDL.js';

package/dist/list/index.mjs

@@ -1,2 +1,2 @@
-export{h as List}from'../chunk-4EYCKDDF.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-V6LFV5LW.mjs';//# sourceMappingURL=index.mjs.map
+export{f as List}from'../chunk-GHBOC52G.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-R2TQJN3P.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-C-PDWX2U.js';
-import { a as Typeable, S as Serializable, P as Pipe, F as Foldable, T as Type } from '../Serializable-D9GKEo30.js';
+import { T as Traversable, C as Collection, O as Option } from '../Either-BHep7I0d.js';
+import { a as Typeable, S as Serializable, P as Pipe, F as Foldable, T as Type } from '../Serializable-BbKuhDDL.js';
 import { Tuple } from '../tuple/index.js';
 
 /**

package/dist/map/index.mjs

@@ -1,2 +1,2 @@
-export{ca as Map}from'../chunk-4EYCKDDF.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-V6LFV5LW.mjs';//# sourceMappingURL=index.mjs.map
+export{ba as Map}from'../chunk-GHBOC52G.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-R2TQJN3P.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, l as OptionConstructor, S as Some } from '../Either-C-PDWX2U.js';
-import '../Serializable-D9GKEo30.js';
+export { N as None, O as Option, m as OptionConstructor, S as Some } from '../Either-BHep7I0d.js';
+import '../Serializable-BbKuhDDL.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-4EYCKDDF.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-V6LFV5LW.mjs';//# sourceMappingURL=index.mjs.map
+export{b as None,d as Option,c as OptionConstructor,a as Some}from'../chunk-GHBOC52G.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-R2TQJN3P.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-C-PDWX2U.js';
-import '../Serializable-D9GKEo30.js';
+export { n as Set } from '../Either-BHep7I0d.js';
+import '../Serializable-BbKuhDDL.js';

package/dist/set/index.mjs

@@ -1,2 +1,2 @@
-export{e as Set}from'../chunk-4EYCKDDF.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-V6LFV5LW.mjs';//# sourceMappingURL=index.mjs.map
+export{e as Set}from'../chunk-GHBOC52G.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-R2TQJN3P.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/try/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FunctypeBase, a as Extractable, E as Either } from '../Either-C-PDWX2U.js';
-import { P as Pipe, T as Type } from '../Serializable-D9GKEo30.js';
+import { F as FunctypeBase, a as Extractable, E as Either } from '../Either-BHep7I0d.js';
+import { P as Pipe, T as Type } from '../Serializable-BbKuhDDL.js';
 
 /**
  * Possible types of Try instances

package/dist/try/index.mjs

@@ -1,2 +1,2 @@
-export{Z as Try}from'../chunk-4EYCKDDF.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-V6LFV5LW.mjs';//# sourceMappingURL=index.mjs.map
+export{Y as Try}from'../chunk-GHBOC52G.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-R2TQJN3P.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-D9GKEo30.js';
+import { T as Type, F as Foldable, P as Pipe, S as Serializable, a as Typeable } from '../Serializable-BbKuhDDL.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.9.0",
+  "version": "0.9.1",
   "type": "module",
   "description": "A smallish functional library for TypeScript",
   "author": "jordan.burke@gmail.com",
@@ -20,7 +20,7 @@
     "@typescript-eslint/parser": "^8.38.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
-    "cross-env": "^7.0.3",
+    "cross-env": "^10.0.0",
     "eslint": "^9.32.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-functional": "^9.0.2",
@@ -33,7 +33,7 @@
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
     "tsup": "^8.5.0",
-    "typedoc": "^0.28.7",
+    "typedoc": "^0.28.8",
     "typescript": "5.8.3",
     "vitest": "^3.2.4"
   },

package/readme/BUNDLE_OPTIMIZATION.md

@@ -0,0 +1,74 @@
+# Bundle Size Optimization Guide
+
+## Overview
+
+Functype is designed with tree-shaking in mind, allowing you to optimize your application's bundle size by only including the specific modules you need.
+
+## Import Strategies
+
+### Strategy 1: Selective Module Imports (Recommended)
+
+Import only the specific modules you need to reduce bundle size significantly.
+
+```typescript
+import { Option } from "functype/option"
+import { Either } from "functype/either"
+
+// Usage
+const option = Option.some(42)
+const either = Either.right("value")
+```
+
+### Strategy 2: Direct Constructor Imports (Smallest Bundle)
+
+For the most aggressive tree-shaking, import only the specific constructors and functions you need.
+
+```typescript
+import { some, none } from "functype/option"
+import { right } from "functype/either"
+
+// Usage
+const option = some(42)
+const none_value = none()
+const either = right("value")
+```
+
+## Bundle Size Comparison
+
+| Import Strategy | Approximate Bundle Size  | Best For                   |
+| --------------- | ------------------------ | -------------------------- |
+| Selective       | 200-500 bytes per module | Most applications          |
+| Direct          | <200 bytes per feature   | Size-critical applications |
+
+## Common Module Sizes
+
+| Module   | Approximate Size (minified) | Gzipped Size |
+| -------- | --------------------------- | ------------ |
+| Option   | ~200 bytes                  | ~140 bytes   |
+| Either   | ~290 bytes                  | ~190 bytes   |
+| List     | ~170 bytes                  | ~125 bytes   |
+| Try      | ~170 bytes                  | ~125 bytes   |
+| Tuple    | ~120 bytes                  | ~100 bytes   |
+| FPromise | ~200 bytes                  | ~140 bytes   |
+
+## Additional Tips
+
+1. **Import Analysis**: Use tools like [webpack-bundle-analyzer](https://github.com/webpack-contrib/webpack-bundle-analyzer) or [rollup-plugin-visualizer](https://github.com/btd/rollup-plugin-visualizer) to analyze your bundle and identify opportunities for optimization.
+
+2. **Dynamic Imports**: Consider using dynamic imports for rarely used functionality:
+
+   ```typescript
+   // Only load when needed
+   const useRareFeature = async () => {
+     const { someLargeUtility } = await import("functype/some-large-module")
+     return someLargeUtility()
+   }
+   ```
+
+3. **Development vs Production**: During development, you might prefer the convenience of importing everything. In production builds, switch to selective imports.
+
+4. **Peer Dependencies**: Functype has minimal dependencies, and the only external dependency (`safe-stable-stringify`) is quite small.
+
+## Need Help?
+
+If you need assistance with optimizing your bundle size further, please open an issue on our GitHub repository.

package/readme/FPromise-Assessment.md

@@ -0,0 +1,43 @@
+# FPromise Implementation Assessment
+
+## Overview
+
+This document provides an assessment of whether the FPromise implementation is ready to replace the old main branch version, with particular focus on potential impacts to implementing libraries outside this one.
+
+## Strengths of the FPromise Implementation
+
+1. **Comprehensive Error Handling**: FPromise provides rich error handling capabilities including `mapError`, `tapError`, `recover`, `recoverWith`, `recoverWithF`, `filterError`, and `logError`.
+
+2. **Either Integration**: FPromise has built-in conversion to/from Either with `toEither()` and `fromEither()`, which aligns well with the functional programming approach used in the Task implementation.
+
+3. **Promise Compatibility**: FPromise implements the PromiseLike interface, ensuring compatibility with async/await and standard Promise chains.
+
+4. **Extensive Test Coverage**: The test suite is comprehensive, covering basic functionality, error handling, recovery mechanisms, and real-world scenarios.
+
+5. **Retry Mechanisms**: The implementation includes multiple retry strategies (basic retry, retry with backoff, and retry with options).
+
+## Potential Compatibility Issues
+
+1. **Import Path Differences**: The Task.ts file imports from `"'core/throwable/Throwable"'` and `"'either/Either"'` with unusual quotes, while the actual imports should use `@/` prefix. This might cause issues if external libraries rely on these specific import paths.
+
+2. **Type Compatibility**: The Task implementation uses `Either<Throwable, T>` for error handling, while FPromise uses a more generic approach. Libraries expecting specific Either structures might need adjustments.
+
+3. **API Surface Changes**: External libraries that directly interact with the Promise implementation might need to adapt to the new methods and patterns provided by FPromise.
+
+## Recommendation
+
+The FPromise implementation is technically sound and provides significant improvements, but to avoid breaking implementing libraries outside this one:
+
+1. **Gradual Migration**: Consider a phased approach where both implementations coexist temporarily.
+
+2. **Version Bumping**: This change warrants a major version bump to signal potential breaking changes.
+
+3. **Documentation**: Provide clear migration guides for dependent libraries.
+
+4. **Import Path Fixes**: Ensure import paths are consistent and follow the project's conventions.
+
+5. **Compatibility Layer**: Consider providing a thin compatibility layer for libraries that can't immediately migrate to the new API.
+
+## Conclusion
+
+The FPromise implementation appears ready to replace the old main branch version from a technical perspective, but careful migration planning is necessary to minimize disruption to implementing libraries.

package/readme/HKT.md

@@ -0,0 +1,110 @@
+# Higher-Kinded Types (HKT)
+
+Higher-kinded types allow for writing generic code that works across different container types like `Option`, `List`, `Either`, and `Try`. This is a powerful abstraction that lets you create algorithms that work with any type that supports certain operations, without having to rewrite them for each specific type.
+
+## Introduction
+
+In functional programming, many operations like `map`, `flatMap`, or `sequence` follow similar patterns across different data structures. The HKT module provides a unified way to work with these operations for any supporting container type.
+
+## Key Concepts
+
+1. **Kind**: A type-level function representing a higher-kinded type relationship
+2. **Container Types**: Data structures that contain values (Option, List, Either, etc.)
+3. **Type Constructor**: A function that takes a type and returns a new type
+
+## Basic Operations
+
+### Map
+
+Apply a function to a value inside a container:
+
+```typescript
+import { Option, HKT } from "functype"
+
+const option = Option(42)
+const doubled = HKT.map(option, (x) => x * 2) // Option(84)
+```
+
+### FlatMap
+
+Apply a function that returns a container to a value inside a container, then flatten the result:
+
+```typescript
+const option = Option(42)
+const result = HKT.flatMap(option, (x) => Option(x * 2)) // Option(84)
+```
+
+### Flatten
+
+Flatten a nested container:
+
+```typescript
+const nestedOption = Option(Option(42))
+const flattened = HKT.flatten(nestedOption) // Option(42)
+```
+
+## Advanced Operations
+
+### Sequence
+
+Transform a container of containers into a container of container (e.g., `Option<List<A>>` to `List<Option<A>>`):
+
+```typescript
+const optionOfList = Option(List([1, 2, 3]))
+const listOfOptions = HKT.sequence(optionOfList)
+// List([Option(1), Option(2), Option(3)])
+```
+
+### Traverse
+
+Transform each element in a container using a function that returns another container type, then sequence the results:
+
+```typescript
+const list = List([1, 2, 3])
+const result = HKT.traverse(list, (x) => Option(x * 2))
+// Option(List([2, 4, 6]))
+```
+
+### Applicative (ap)
+
+Apply a function inside a container to a value inside another container:
+
+```typescript
+const optionFn = Option((x: number) => x * 2)
+const optionValue = Option(21)
+const result = HKT.ap(optionFn, optionValue) // Option(42)
+```
+
+## Supported Container Types
+
+The HKT module currently supports the following container types:
+
+- `Option<A>`
+- `List<A>`
+- `Either<E, A>`
+- `Try<A>`
+
+## Creating Generic Algorithms
+
+The power of HKT is in creating algorithms that work with any container type:
+
+```typescript
+// A function that works with any container implementing map
+function increment<F extends (a: number) => any>(container: Kind<F, number>): Kind<F, number> {
+  return HKT.map(container, (x) => x + 1)
+}
+
+// Works with any container
+increment(Option(41)) // Option(42)
+increment(List([1, 2, 3])) // List([2, 3, 4])
+increment(Right<string, number>(41)) // Right(42)
+```
+
+## Implementing Your Own Container Types
+
+To make your custom container types work with HKT, you need to:
+
+1. Implement the appropriate methods (`map`, `flatMap`, etc.)
+2. Add type checking in the HKT functions
+
+This allows seamless integration with the rest of the functional programming ecosystem.

package/readme/ROADMAP.md

@@ -0,0 +1,113 @@
+# Functype Roadmap (2025-2026)
+
+This roadmap outlines the planned development path for the Functype library, focusing on expanding functionality, improving performance, ensuring API consistency, and enhancing TypeScript integration.
+
+## Q2 2025: Core Functional Data Types
+
+### Lazy Evaluation
+
+- [ ] Implement `LazyList` / `Stream` for efficient processing of potentially infinite sequences
+- [ ] Add common operations: `map`, `filter`, `take`, `drop`, etc.
+- [ ] Implement memoization for evaluated values
+
+### Validation Type
+
+- [ ] Create `Validation` data type for applicative validation
+- [ ] Support collecting multiple errors (unlike Either which short-circuits)
+- [ ] Add utilities for combining validation results
+
+### Performance Foundation
+
+- [ ] Add memoization utilities for expensive function calls
+- [ ] Implement a basic benchmarking suite for measuring performance
+- [ ] Standardize performance metrics across data structures
+
+## Q3 2025: Advanced Functional Patterns & Optimizations
+
+### Type Classes
+
+- [x] Implement `Foldable` typeclass with fold, foldLeft, and foldRight methods
+- [x] Implement `Matchable` typeclass for pattern matching
+- [ ] Implement proper `Functor` and `Monad` typeclasses
+- [ ] Add `Applicative` typeclass
+- [ ] Support `Traversable` with comprehensive HKT
+
+### Monad Implementations
+
+- [ ] Implement `Reader` monad for dependency injection
+- [ ] Add `State` monad for managing state transformations
+- [ ] Create `IO` monad for pure handling of side effects
+- [ ] Add comprehensive documentation and examples
+
+### Performance Improvements
+
+- [ ] Implement structural sharing for immutable collections
+- [ ] Optimize recursive operations for large data structures
+- [ ] Add performance comparison against other FP libraries
+
+### Lenses & Optics
+
+- [ ] Implement lens abstraction for immutable updates
+- [ ] Add prism implementation for optional data
+- [ ] Create utilities for composing lenses and prisms
+
+## Q4 2025: TypeScript Enhancements & API Consistency
+
+### TypeScript Integration
+
+- [x] Add support for higher-kinded types
+- [ ] Remove `any` from HKT
+- [x] Implement branded/nominal types for stronger type safety
+- [ ] Add type-level utilities using newer TypeScript features
+- [ ] Leverage const type parameters and tuple manipulation
+
+### API Normalization
+
+- [ ] Review and standardize API across all modules
+- [ ] Ensure consistent implementation of the Scala-inspired pattern
+- [ ] Standardize import patterns (@imports throughout)
+- [ ] Create migration guides for API changes
+
+## Q1 2026: Testing, Documentation & Community Support
+
+### Testing Expansion
+
+- [ ] Add test coverage metrics and set coverage goals
+- [ ] Expand property-based testing across all modules
+- [ ] Create interoperability tests with popular libraries
+- [ ] Add more specialized test cases for error handling
+
+### Documentation & Examples
+
+- [ ] Add comprehensive documentation for all modules
+- [ ] Create step-by-step migration guides from imperative to functional
+- [ ] Add real-world examples showcasing practical applications
+- [ ] Create tutorial sections for beginners
+
+### Community Engagement
+
+- [ ] Create contribution guidelines and templates
+- [ ] Set up automated issue/PR handling
+- [ ] Establish regular release schedule
+- [ ] Add community forum/discussion platform
+
+## Ongoing Priorities
+
+### Compatibility
+
+- [ ] Ensure compatibility with Node.js LTS versions
+- [ ] Maintain browser compatibility
+- [ ] Support for Deno and other runtimes
+- [ ] Test with various bundlers (webpack, esbuild, etc.)
+
+### Bundle Size
+
+- [x] Optimize tree-shaking
+- [x] Provide guidance on importing only needed modules
+- [x] Add bundle size monitoring to CI/CD
+
+### Community Feedback
+
+- [ ] Regular review of GitHub issues and feature requests
+- [ ] Prioritization based on community needs
+- [ ] Transparent development process