functype 0.8.60 → 0.8.62

package/README.md

@@ -43,6 +43,8 @@ Functype is a lightweight functional programming library for TypeScript, drawing
 - [ ] Implement immutable data structures with structural sharing
 - [ ] Add performance benchmarks
 - [x] Optimize TreeShaking with sideEffects flag in package.json
+- [x] Support selective module imports for smaller bundles
+- [x] Add bundle size monitoring to CI/CD
 
 ### API Consistency
 
@@ -50,9 +52,9 @@ Functype is a lightweight functional programming library for TypeScript, drawing
   - Constructor functions that return objects with methods
   - Object methods for common operations
   - Companion functions for additional utilities
-- [ ] Align Task API with other monadic structures
+- [x] Align Task API with other monadic structures
 - [ ] Standardize import patterns (@ imports vs relative paths)
-- [ ] Implement consistent error handling strategy for async operations
+- [x] Implement consistent error handling strategy for async operations
 
 ### Testing and Documentation
 
@@ -88,6 +90,21 @@ pnpm add functype
 bun add functype
 ```
 
+### Bundle Size Optimization
+
+Functype is optimized for tree-shaking and offers multiple import strategies to minimize bundle size:
+
+```typescript
+// Selective module imports (recommended for production)
+import { Option } from "functype/option"
+import { Either } from "functype/either"
+
+// Direct constructor imports (smallest bundle)
+import { some, none } from "functype/option"
+```
+
+For detailed optimization strategies, see the [Bundle Optimization Guide](docs/BUNDLE_OPTIMIZATION.md).
+
 ## Usage Examples
 
 ### Option
@@ -189,7 +206,7 @@ const either = result.toEither()
 import { Task } from "functype"
 
 // Synchronous operations with error handling
-const syncResult = Task().Task(
+const syncResult = Task().Sync(
   () => "success",
   (error) => new Error(`Failed: ${error}`),
 )
@@ -202,6 +219,21 @@ const asyncTask = async () => {
   )
   return result
 }
+
+// Converting promise-based functions to Task
+const fetchUserAPI = (userId: string): Promise<User> => fetch(`/api/users/${userId}`).then((r) => r.json())
+
+// Use the adapter pattern for seamless integration
+const fetchUser = Task({ name: "UserFetch" }).fromPromise(fetchUserAPI)
+
+// Later use it with standard promise patterns
+fetchUser("user123")
+  .then((user) => console.log(user))
+  .catch((error) => console.error(error))
+
+// Or convert Task results back to promises
+const taskResult = Task().Sync(() => "hello world")
+const promise = Task().toPromise(taskResult) // Promise<string>
 ```
 
 ## Type Safety

package/dist/Map-BNxKlujn.mjs

@@ -0,0 +1,46 @@
+import { f as h, e as n, O as c } from "./index-CgMYHgdG.mjs";
+import { Tuple as w } from "./tuple/index.mjs";
+const l = Map, r = (a) => {
+  const i = "Map", s = {
+    values: new l(a)
+  }, o = () => Array.from(s.values.entries()).map(([t, e]) => w([t, e])), u = (t) => r(new l(s.values).set(t.toArray()[0], t.toArray()[1]).entries()), p = (t) => {
+    const e = new l(s.values);
+    return e.delete(t) ? r(e.entries()) : r(s.values.entries());
+  }, g = (t) => {
+    const e = t.toArray();
+    return s.values.get(e[0]) === e[1];
+  }, v = () => s.values.size, f = (t) => r(Array.from(s.values.entries()).map(([e, O]) => [e, t(O)])), d = (t) => {
+    const e = r(s.values.entries()).toList();
+    return r(e.flatMap(t).toArray());
+  }, m = (t) => n(o()).reduce(t), M = (t) => n(o()).reduceRight(t), E = (t) => (e) => n(o()).foldLeft(t)(e), y = (t) => (e) => n(o()).foldRight(t)(e), S = (t) => c(s.values.get(t)), A = (t, e) => c(s.values.get(t)).getOrElse(e), L = () => s.values.size === 0;
+  return {
+    _tag: i,
+    add: u,
+    remove: p,
+    contains: g,
+    get size() {
+      return v();
+    },
+    map: f,
+    flatMap: d,
+    reduce: m,
+    reduceRight: M,
+    foldLeft: E,
+    foldRight: y,
+    get: S,
+    getOrElse: A,
+    get isEmpty() {
+      return L();
+    },
+    orElse: (t, e) => c(s.values.get(t)).orElse(e),
+    toList: () => n(o()),
+    toSet: () => h(o()),
+    toString: () => `Map(${o().toString()})`,
+    toValue: () => ({ _tag: "Map", value: s.values })
+  };
+}, x = (a) => r(a);
+export {
+  l as E,
+  x as M
+};
+//# sourceMappingURL=Map-BNxKlujn.mjs.map

package/dist/Map-BNxKlujn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Map-BNxKlujn.mjs","sources":["../src/map/shim.ts","../src/map/Map.ts"],"sourcesContent":["export type IESMap<K, V> = Map<K, V>\nexport const ESMap = Map\n","import type { Collection } from \"@/collections\"\nimport { type Traversable, Typeable } from \"@/index\"\nimport type { IterableType } from \"@/iterable\"\nimport { List } from \"@/list/List\"\nimport { Option } from \"@/option/Option\"\nimport { Set } from \"@/set/Set\"\nimport { Tuple } from \"@/tuple/Tuple\"\nimport { Valuable } from \"@/valuable/Valuable\"\n\nimport { ESMap, type IESMap } from \"./shim\"\n\ntype SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, \"map\" | \"flatMap\">\n\nexport type Map<K, V> = {\n  add(item: Tuple<[K, V]>): Map<K, V>\n  remove(value: K): Map<K, V>\n  map<U>(f: (value: V) => U): Map<K, U>\n  flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => IterableType<[K2, V2]>): Map<K2, V2>\n  get(key: K): Option<V>\n  getOrElse(key: K, defaultValue: V): V\n  orElse(key: K, alternative: Option<V>): Option<V>\n} & SafeTraversable<K, V> &\n  Collection<Tuple<[K, V]>> &\n  Typeable<\"Map\"> &\n  Valuable<\"Map\", IESMap<K, V>>\n\ntype MapState<K, V> = {\n  values: IESMap<K, V>\n}\n\nconst MapObject = <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null): Map<K, V> => {\n  const _tag = \"Map\"\n  const state: MapState<K, V> = {\n    values: new ESMap<K, V>(entries),\n  }\n\n  const getEntries = () => Array.from(state.values.entries()).map(([key, value]) => Tuple<[K, V]>([key, value]))\n\n  const add = (item: Tuple<[K, V]>): Map<K, V> =>\n    MapObject(new ESMap(state.values).set(item.toArray()[0], item.toArray()[1]).entries())\n\n  const remove = (value: K): Map<K, V> => {\n    const newMap = new ESMap(state.values)\n    return newMap.delete(value) ? MapObject(newMap.entries()) : MapObject(state.values.entries())\n  }\n\n  const contains = (value: Tuple<[K, V]>): boolean => {\n    const tuple = value.toArray()\n    return state.values.get(tuple[0]) === tuple[1]\n  }\n\n  const size = (): number => state.values.size\n\n  const map = <U>(f: (value: V) => U): Map<K, U> =>\n    MapObject(Array.from(state.values.entries()).map(([k, v]) => [k, f(v)]))\n\n  const flatMap = <K2, V2>(f: (entry: Tuple<[K, V]>) => IterableType<[K2, V2]>): Map<K2, V2> => {\n    const list = MapObject(state.values.entries()).toList()\n    return MapObject(list.flatMap(f).toArray())\n  }\n\n  const reduce = (f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]> =>\n    List(getEntries()).reduce(f)\n\n  const reduceRight = (f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]> =>\n    List(getEntries()).reduceRight(f)\n\n  const foldLeft =\n    <B>(z: B) =>\n    (op: (b: B, a: Tuple<[K, V]>) => B): B =>\n      List(getEntries()).foldLeft(z)(op)\n\n  const foldRight =\n    <B>(z: B) =>\n    (op: (a: Tuple<[K, V]>, b: B) => B): B =>\n      List(getEntries()).foldRight(z)(op)\n\n  const get = (key: K): Option<V> => Option(state.values.get(key))\n\n  const getOrElse = (key: K, defaultValue: V): V => Option(state.values.get(key)).getOrElse(defaultValue)\n\n  const isEmpty = (): boolean => state.values.size === 0\n\n  const orElse = (key: K, alternative: Option<V>): Option<V> => Option(state.values.get(key)).orElse(alternative)\n\n  const toList = (): List<Tuple<[K, V]>> => List(getEntries())\n\n  const toSet = (): Set<Tuple<[K, V]>> => Set(getEntries())\n\n  const toString = (): string => `Map(${getEntries().toString()})`\n\n  return {\n    _tag,\n    add,\n    remove,\n    contains,\n    get size() {\n      return size()\n    },\n    map,\n    flatMap,\n    reduce,\n    reduceRight,\n    foldLeft,\n    foldRight,\n    get,\n    getOrElse,\n    get isEmpty() {\n      return isEmpty()\n    },\n    orElse,\n    toList,\n    toSet,\n    toString,\n    toValue: () => ({ _tag: \"Map\", value: state.values }),\n  }\n}\n\nexport const Map = <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null): Map<K, V> =>\n  MapObject(entries)\n\n// Example usage\n// const myMap = createMap<string, unknown>([\n//   [\"a\", 1],\n//   [\"b\", 2],\n//   [\"c\", 3],\n// ])\n"],"names":["ESMap","MapObject","entries","_tag","state","getEntries","key","value","Tuple","add","item","remove","newMap","contains","tuple","size","map","f","k","v","flatMap","list","reduce","List","reduceRight","foldLeft","z","op","foldRight","get","Option","getOrElse","defaultValue","isEmpty","alternative","Set","Map"],"mappings":";;AACO,MAAMA,IAAQ,KC6BfC,IAAY,CAAOC,MAAwF;AAC/G,QAAMC,IAAO,OACPC,IAAwB;AAAA,IAC5B,QAAQ,IAAIJ,EAAYE,CAAO;AAAA,EACjC,GAEMG,IAAa,MAAM,MAAM,KAAKD,EAAM,OAAO,SAAS,EAAE,IAAI,CAAC,CAACE,GAAKC,CAAK,MAAMC,EAAc,CAACF,GAAKC,CAAK,CAAC,CAAC,GAEvGE,IAAM,CAACC,MACXT,EAAU,IAAID,EAAMI,EAAM,MAAM,EAAE,IAAIM,EAAK,QAAU,EAAA,CAAC,GAAGA,EAAK,QAAA,EAAU,CAAC,CAAC,EAAE,SAAS,GAEjFC,IAAS,CAACJ,MAAwB;AACtC,UAAMK,IAAS,IAAIZ,EAAMI,EAAM,MAAM;AACrC,WAAOQ,EAAO,OAAOL,CAAK,IAAIN,EAAUW,EAAO,QAAS,CAAA,IAAIX,EAAUG,EAAM,OAAO,SAAS;AAAA,EAC9F,GAEMS,IAAW,CAACN,MAAkC;AAC5C,UAAAO,IAAQP,EAAM,QAAQ;AACrB,WAAAH,EAAM,OAAO,IAAIU,EAAM,CAAC,CAAC,MAAMA,EAAM,CAAC;AAAA,EAC/C,GAEMC,IAAO,MAAcX,EAAM,OAAO,MAElCY,IAAM,CAAIC,MACdhB,EAAU,MAAM,KAAKG,EAAM,OAAO,QAAS,CAAA,EAAE,IAAI,CAAC,CAACc,GAAGC,CAAC,MAAM,CAACD,GAAGD,EAAEE,CAAC,CAAC,CAAC,CAAC,GAEnEC,IAAU,CAASH,MAAqE;AAC5F,UAAMI,IAAOpB,EAAUG,EAAM,OAAO,QAAQ,CAAC,EAAE,OAAO;AACtD,WAAOH,EAAUoB,EAAK,QAAQJ,CAAC,EAAE,SAAS;AAAA,EAC5C,GAEMK,IAAS,CAACL,MACdM,EAAKlB,GAAY,EAAE,OAAOY,CAAC,GAEvBO,IAAc,CAACP,MACnBM,EAAKlB,GAAY,EAAE,YAAYY,CAAC,GAE5BQ,IACJ,CAAIC,MACJ,CAACC,MACCJ,EAAKlB,EAAW,CAAC,EAAE,SAASqB,CAAC,EAAEC,CAAE,GAE/BC,IACJ,CAAIF,MACJ,CAACC,MACCJ,EAAKlB,EAAW,CAAC,EAAE,UAAUqB,CAAC,EAAEC,CAAE,GAEhCE,IAAM,CAACvB,MAAsBwB,EAAO1B,EAAM,OAAO,IAAIE,CAAG,CAAC,GAEzDyB,IAAY,CAACzB,GAAQ0B,MAAuBF,EAAO1B,EAAM,OAAO,IAAIE,CAAG,CAAC,EAAE,UAAU0B,CAAY,GAEhGC,IAAU,MAAe7B,EAAM,OAAO,SAAS;AAU9C,SAAA;AAAA,IACL,MAAAD;AAAA,IACA,KAAAM;AAAA,IACA,QAAAE;AAAA,IACA,UAAAE;AAAA,IACA,IAAI,OAAO;AACT,aAAOE,EAAK;AAAA,IACd;AAAA,IACA,KAAAC;AAAA,IACA,SAAAI;AAAA,IACA,QAAAE;AAAA,IACA,aAAAE;AAAA,IACA,UAAAC;AAAA,IACA,WAAAG;AAAA,IACA,KAAAC;AAAA,IACA,WAAAE;AAAA,IACA,IAAI,UAAU;AACZ,aAAOE,EAAQ;AAAA,IACjB;AAAA,IACA,QA3Ba,CAAC3B,GAAQ4B,MAAsCJ,EAAO1B,EAAM,OAAO,IAAIE,CAAG,CAAC,EAAE,OAAO4B,CAAW;AAAA,IA4B5G,QA1Ba,MAA2BX,EAAKlB,GAAY;AAAA,IA2BzD,OAzBY,MAA0B8B,EAAI9B,GAAY;AAAA,IA0BtD,UAxBe,MAAc,OAAOA,EAAW,EAAE,SAAU,CAAA;AAAA,IAyB3D,SAAS,OAAO,EAAE,MAAM,OAAO,OAAOD,EAAM,OAAO;AAAA,EACrD;AACF,GAEagC,IAAM,CAAOlC,MACxBD,EAAUC,CAAO;"}

package/dist/branded/Brand.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Brand is a utility for creating nominal typing in TypeScript
+ * It allows for creating distinct types that are structurally identical
+ * but considered different by TypeScript's type system
+ */
+export type Brand<K extends string, T> = T & {
+    readonly __brand: K;
+};
+export type Unbrand<T> = T extends Brand<string, infer U> ? U : never;
+export type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never;
+/**
+ * Helper to create a branded type
+ * @param value - The value to brand
+ * @returns The branded value
+ */
+export declare function Brand<K extends string, T>(brand: K, value: T): Brand<K, T>;
+/**
+ * Helper to remove a brand from a value
+ * @param branded - The branded value
+ * @returns The original value without the brand
+ */
+export declare function unbrand<T>(branded: Brand<string, T>): T;
+/**
+ * Type guard for checking if a value has a specific brand
+ * @param value - The value to check
+ * @param brand - The brand to check for
+ * @returns True if the value has the specified brand
+ *
+ * Note: Since brands are phantom types that exist only at compile time,
+ * this function can only provide a runtime approximation. It always returns true
+ * for non-null values, as we have no way to actually check the brand at runtime.
+ * This function is primarily for API consistency and documentation purposes.
+ */
+export declare function hasBrand<K extends string, T>(value: unknown, brand: K): value is Brand<K, T>;
+/**
+ * Create a branded type constructor for a specific brand
+ * @param brand - The brand name
+ * @returns A function that brands values with the specified brand
+ */
+export declare function createBrander<K extends string, T>(brand: K): (value: T) => Brand<K, T>;
+export type BrandedString<K extends string> = Brand<K, string>;
+export type BrandedNumber<K extends string> = Brand<K, number>;
+export type BrandedBoolean<K extends string> = Brand<K, boolean>;
+export declare const BrandedString: <K extends string>(brand: K) => (value: string) => BrandedString<K>;
+export declare const BrandedNumber: <K extends string>(brand: K) => (value: number) => BrandedNumber<K>;
+export declare const BrandedBoolean: <K extends string>(brand: K) => (value: boolean) => BrandedBoolean<K>;

package/dist/branded/index.d.ts

@@ -0,0 +1 @@
+export * from './Brand';

package/dist/branded/index.mjs

@@ -0,0 +1,23 @@
+function t(n, r) {
+  return r;
+}
+function d(n) {
+  return n;
+}
+function e(n, r) {
+  return n != null;
+}
+function a(n) {
+  return (r) => t(n, r);
+}
+const o = (n) => (r) => t(n, r), u = (n) => (r) => t(n, r), c = (n) => (r) => t(n, r);
+export {
+  t as Brand,
+  c as BrandedBoolean,
+  u as BrandedNumber,
+  o as BrandedString,
+  a as createBrander,
+  e as hasBrand,
+  d as unbrand
+};
+//# sourceMappingURL=index.mjs.map

package/dist/branded/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../src/branded/Brand.ts"],"sourcesContent":["/**\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\n// The brand symbol type\nexport type Brand<K extends string, T> = T & { readonly __brand: K }\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 * Helper to create a branded type\n * @param value - The value to brand\n * @returns The branded value\n */\nexport function Brand<K extends string, T>(brand: K, value: T): Brand<K, T> {\n  return value as Brand<K, T>\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 as T\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"],"names":["Brand","brand","value","unbrand","branded","hasBrand","createBrander","BrandedString","BrandedNumber","BrandedBoolean"],"mappings":"AAoBgB,SAAAA,EAA2BC,GAAUC,GAAuB;AACnE,SAAAA;AACT;AAOO,SAASC,EAAWC,GAA8B;AAChD,SAAAA;AACT;AAagB,SAAAC,EAA8BH,GAAgBD,GAAgC;AAGrF,SAAAC,KAAU;AACnB;AAOO,SAASI,EAAmCL,GAAU;AAC3D,SAAO,CAACC,MAA0BF,EAAMC,GAAOC,CAAK;AACtD;AAQO,MAAMK,IACX,CAAmBN,MACnB,CAACC,MACCF,EAAMC,GAAOC,CAAK,GAETM,IACX,CAAmBP,MACnB,CAACC,MACCF,EAAMC,GAAOC,CAAK,GAETO,IACX,CAAmBR,MACnB,CAACC,MACCF,EAAMC,GAAOC,CAAK;"}

package/dist/collections/index.d.ts

@@ -0,0 +1,8 @@
+import { List } from '../list/List';
+import { Set } from '../set/Set';
+export type Converters<A> = {
+    toList(): List<A>;
+    toSet(): Set<A>;
+    toString(): string;
+};
+export type Collection<A> = Converters<A>;

package/dist/companion/Companion.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Creates a function-object hybrid similar to Scala's companion objects.
+ * This utility allows creating TypeScript function objects with attached methods,
+ * mimicking Scala's class + companion object pattern without using classes.
+ *
+ * @param object The main function that will be invoked when the object is called
+ * @param companion Additional static methods to attach to the function
+ * @returns A function with the attached methods
+ *
+ * @example
+ * const greet = (name: string) => `Hello, ${name}!`;
+ * const methods = {
+ *   formal: (name: string) => `Good day, ${name}.`,
+ *   casual: (name: string) => `Hey ${name}!`
+ * };
+ * const Greeter = createCompanionObject(greet, methods);
+ *
+ * // Usage:
+ * Greeter("World"); // Hello, World!
+ * Greeter.formal("Sir"); // Good day, Sir.
+ * Greeter.casual("Friend"); // Hey Friend!
+ */
+export declare function Companion<ObjectF extends object, CompanionF extends object>(object: ObjectF, companion: CompanionF): ObjectF & CompanionF;

package/dist/companion/index.d.ts

@@ -0,0 +1 @@
+export * from './Companion';

package/dist/core/base/Base.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Base Object from which most other objects inherit
+ * @param type
+ * @param body
+ * @constructor
+ */
+export declare function Base<T>(type: string, body: T): T & {
+    toString(): string;
+    _tag: string;
+};

package/dist/core/base/index.d.ts

@@ -0,0 +1 @@
+export * from './Base';

package/dist/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base';
+export * from './info';
+export * from './task';
+export * from './throwable';

package/dist/core/info/Info.d.ts

@@ -0,0 +1,26 @@
+import { Identity } from '../../identity/Identity';
+type Params = {
+    id: string;
+    description: string;
+    location: string;
+    reason: string;
+    means: string;
+} & Identity<string>;
+/**
+ * Base Object from which most other objects inherit
+ * @param type
+ * @param body
+ * @param params
+ * @constructor
+ */
+export declare function Info<T>(type: string, body: T, params: Params): T & {
+    toString(): string;
+    _tag: string;
+} & {
+    id: string;
+    description: string;
+    location: string;
+    reason: string;
+    means: string;
+} & Identity<string>;
+export {};

package/dist/core/info/index.d.ts

@@ -0,0 +1 @@
+export * from './Info';

package/dist/core/task/Task.d.ts

@@ -0,0 +1,57 @@
+import { Throwable } from '../throwable/Throwable';
+import { Either } from '../../either/Either';
+import { FPromise } from '../../fpromise/FPromise';
+export type TaskParams = {
+    name?: string;
+    description?: string;
+};
+export type TaskInfo = {
+    _task: TaskParams;
+};
+export type TaskException<T> = Either<Throwable, T> & TaskInfo;
+/**
+ * TaskException factory function
+ * @param error
+ * @param _task
+ * @param data
+ * @constructor
+ */
+export declare const TaskException: <T>(error: unknown, data?: unknown, _task?: TaskParams) => TaskException<T>;
+export type TaskResult<T> = Either<Throwable, T> & TaskInfo;
+export declare const TaskResult: <T>(data: T, _task?: TaskParams) => TaskResult<T>;
+export type Sync<T> = Either<Throwable, T>;
+export type Async<T> = FPromise<Sync<T>>;
+/**
+ * Task adapter for bridging promise-based code with functional error handling patterns
+ */
+export declare const Task: <T = unknown>(params?: TaskParams) => {
+    _type: string;
+    /**
+     * Run an async operation with explicit try/catch/finally semantics
+     * Returns a raw Promise that can interact with traditional Promise-based code
+     */
+    Async: <U = T>(t: () => U | Promise<U>, e?: (error: unknown) => unknown, f?: () => Promise<void> | void) => FPromise<U>;
+    /**
+     * Run a synchronous operation with explicit try/catch/finally semantics
+     * Returns an Either for functional error handling
+     */
+    Sync: <U = T>(t: () => U, e?: (error: unknown) => unknown, f?: () => void) => Sync<U>;
+    /**
+     * Create a successful Task result
+     */
+    success: (data: T) => TaskResult<T>;
+    /**
+     * Create a failed Task result
+     */
+    fail: (error: unknown) => TaskException<T>;
+    /**
+     * Convert a Promise-returning function to a Task-compatible function
+     */
+    fromPromise: <U, Args extends unknown[]>(promiseFn: (...args: Args) => Promise<U>) => ((...args: Args) => FPromise<U>);
+    /**
+     * Convert a Task result to a Promise
+     */
+    toPromise: <U>(taskResult: TaskResult<U> | TaskException<U>) => Promise<U>;
+    toString(): string;
+    _tag: string;
+};

package/dist/core/task/index.d.ts

@@ -0,0 +1 @@
+export * from './Task';

package/dist/core/throwable/Throwable.d.ts

@@ -0,0 +1,18 @@
+import { Typeable } from '../../typeable/Typeable';
+declare const NAME: "Throwable";
+export type ThrowableType = Error & Typeable<typeof NAME> & {
+    readonly data?: unknown;
+    readonly cause?: Error;
+};
+export declare class Throwable extends Error implements ThrowableType {
+    readonly _tag: typeof NAME;
+    readonly data?: unknown;
+    readonly cause?: Error;
+    protected constructor(message: string, options?: {
+        data?: unknown | undefined;
+        cause?: Error | undefined;
+        stack?: string | undefined;
+    });
+    static apply(srcError: unknown, data?: unknown): ThrowableType;
+}
+export {};

package/dist/core/throwable/index.d.ts

@@ -0,0 +1 @@
+export * from './Throwable';

package/dist/either/Either.d.ts

@@ -0,0 +1,57 @@
+import { AsyncFunctor, Functor, Type } from '../functor';
+import { List } from '../list/List';
+import { Option } from '../option/Option';
+import { Typeable } from '../typeable/Typeable';
+import { Valuable } from '../valuable/Valuable';
+/**
+ * Either type module
+ * @module Either
+ * @category Core
+ */
+export type Either<L extends Type, R extends Type> = {
+    readonly _tag: "Left" | "Right";
+    value: L | R;
+    isLeft: () => boolean;
+    isRight: () => boolean;
+    getOrElse: (defaultValue: R) => R;
+    getOrThrow: () => R;
+    map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
+    merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R, R1]>;
+    mapAsync: <U extends Type>(f: (value: R) => Promise<U>) => Promise<Either<L, U>>;
+    flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>;
+    flatMapAsync: <U extends Type>(f: (value: R) => Promise<Either<L, U>>) => Promise<Either<L, U>>;
+    toOption: () => Option<R>;
+    toList: () => List<R>;
+    toString: () => string;
+    [Symbol.iterator]: () => Iterator<R>;
+    yield: () => Generator<R, void, unknown>;
+    traverse: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U[]>;
+    lazyMap: <U extends Type>(f: (value: R) => U) => Generator<Either<L, U>, void, unknown>;
+    tap: (f: (value: R) => void) => Either<L, R>;
+    tapLeft: (f: (value: L) => void) => Either<L, R>;
+    mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R>;
+    bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R) => R2) => Either<L2, R2>;
+    fold: <T extends Type>(onLeft: (value: L) => T, onRight: (value: R) => T) => T;
+    swap: () => Either<R, L>;
+} & Typeable<"Left" | "Right"> & Valuable<"Left" | "Right", L | R> & PromiseLike<R> & AsyncFunctor<R>;
+export type TestEither<L extends Type, R extends Type> = Either<L, R> & Functor<R> & AsyncFunctor<R>;
+export declare const Right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
+export declare const Left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
+export declare const isRight: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
+    value: R;
+};
+export declare const isLeft: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
+    value: L;
+};
+export declare const tryCatch: <L extends Type, R extends Type>(f: () => R, onError: (error: unknown) => L) => Either<L, R>;
+export declare const TypeCheckRight: <L extends Type, R extends Type>(value: R) => TestEither<L, R>;
+export declare const TypeCheckLeft: <L extends Type, R extends Type>(value: L) => TestEither<L, R>;
+export declare const tryCatchAsync: <L extends Type, R extends Type>(f: () => Promise<R>, onError: (error: unknown) => L) => Promise<Either<L, R>>;
+export declare const Either: {
+    sequence: <L extends Type, R extends Type>(eithers: Either<L, R>[]) => Either<L, R[]>;
+    traverse: <L extends Type, R extends Type, U extends Type>(arr: R[], f: (value: R) => Either<L, U>) => Either<L, U[]>;
+    fromNullable: <L extends Type, R extends Type>(value: R | null | undefined, leftValue: L) => Either<L, R>;
+    fromPredicate: <L extends Type, R extends Type>(value: R, predicate: (value: R) => boolean, leftValue: L) => Either<L, R>;
+    ap: <L extends Type, R extends Type, U extends Type>(eitherF: Either<L, (value: R) => U>, eitherV: Either<L, R>) => Either<L, U>;
+    fromPromise: <L, R>(promise: Promise<R>, onRejected: (reason: unknown) => L) => Promise<Either<L, R>>;
+};

package/dist/either/index.d.ts

@@ -0,0 +1 @@
+export * from './Either';

package/dist/either/index.mjs

@@ -0,0 +1,13 @@
+import { E as s, L as e, R as h, b as i, T as c, a as r, i as y, t as f, c as C } from "../index-CgMYHgdG.mjs";
+export {
+  s as Either,
+  e as Left,
+  h as Right,
+  i as TypeCheckLeft,
+  c as TypeCheckRight,
+  r as isLeft,
+  y as isRight,
+  f as tryCatch,
+  C as tryCatchAsync
+};
+//# sourceMappingURL=index.mjs.map

package/dist/either/index.mjs.map

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

package/dist/error/ParseError.d.ts

@@ -0,0 +1,6 @@
+export declare const ParseError: (message?: string) => Error & {
+    name: "ParseError";
+};
+export type ParseError = Error & {
+    name: "ParseError";
+};

package/dist/error/index.d.ts

@@ -0,0 +1 @@
+export * from './ParseError';