functype 0.45.0 → 0.46.0

package/dist/option/index.d.ts

@@ -1,2 +1,243 @@
-import { A as OptionConstructor, O as None, j as Some, k as Option } from "../index-DBg23xHh.js";
+import { mn as Doable, nn as Reshapeable, rn as Promisable, t as Functype } from "../Functype-Dc440LS5.js";
+import { l as Type } from "../Typeable-E4-aX9Gc.js";
+import { List } from "../list/index.js";
+import { Either } from "../either/index.js";
+
+//#region src/option/Option.d.ts
+/**
+ * Option type module
+ * @module Option
+ * @category Core
+ */
+/**
+ * The Option type represents a value that may or may not exist.
+ * It's used to handle potentially null or undefined values in a type-safe way.
+ * @typeParam T - The type of the value contained in the Option
+ */
+interface Option<T extends Type> extends Functype<T, "Some" | "None">, Promisable<T>, Doable<T>, Reshapeable<T> {
+  /** The contained value (undefined for None) */
+  readonly value: T | undefined;
+  /** Whether this Option contains no value */
+  isEmpty: boolean;
+  /**
+   * Returns true if this Option is a Some (contains a value)
+   * @returns true if this Option contains a value, false otherwise
+   */
+  isSome(): this is Option<T> & {
+    value: T;
+    isEmpty: false;
+  };
+  /**
+   * Returns true if this Option is a None (contains no value)
+   * @returns true if this Option is empty, false otherwise
+   */
+  isNone(): this is Option<T> & {
+    value: undefined;
+    isEmpty: true;
+  };
+  /**
+   * Returns the contained value or a default value if None
+   * @param defaultValue - The value to return if this Option is None
+   * @returns The contained value or defaultValue
+   */
+  orElse(defaultValue: T): T;
+  /**
+   * Returns the contained value or throws an error if None
+   * @param error - Optional custom error to throw. If not provided, throws a default error
+   * @returns The contained value
+   * @throws The specified error or a default error if the Option is None
+   */
+  orThrow(error?: Error): T;
+  /**
+   * Returns this Option if it contains a value, otherwise returns the alternative container
+   * @param alternative - The alternative Option to return if this is None
+   * @returns This Option or the alternative
+   */
+  or(alternative: Option<T>): Option<T>;
+  /**
+   * Returns the contained value or null if None
+   * @returns The contained value or null
+   */
+  orNull(): T | null;
+  /**
+   * Returns the contained value or undefined if None
+   * @returns The contained value or undefined
+   */
+  orUndefined(): T | undefined;
+  /**
+   * Maps the value inside the Option using the provided function
+   * @param f - The mapping function
+   * @returns A new Option containing the mapped value, or None if this Option is None
+   */
+  map<U extends Type>(f: (value: T) => U): Option<U>;
+  /**
+   * Applies a wrapped function to a wrapped value (Applicative pattern)
+   * @param ff - An Option containing a function from T to U
+   * @returns A new Option containing the result of applying the function
+   */
+  ap<U extends Type>(ff: Option<(value: T) => U>): Option<U>;
+  /**
+   * Returns this Option if it contains a value that satisfies the predicate, otherwise returns None
+   * @param predicate - The predicate function to test the value
+   * @returns This Option or None
+   */
+  filter(predicate: (value: T) => boolean): Option<T>;
+  /**
+   * Maps the value using a function that returns an Option
+   * @param f - The mapping function returning an Option
+   * @returns The result of applying f to the contained value, or None if this Option is None
+   */
+  flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
+  /**
+   * Maps the value using an async function that returns an Option
+   * @param f - The async mapping function returning an Option
+   * @returns Promise of the result of applying f to the contained value, or None if this Option is None
+   */
+  flatMapAsync<U extends Type>(f: (value: T) => Promise<Option<U>>): Promise<Option<U>>;
+  /**
+   * Applies a binary operator to a start value and the contained value
+   * @param f - The binary operator
+   * @returns The result of the reduction
+   */
+  reduce<U>(f: (acc: U, value: T) => U): U;
+  /**
+   * Applies a binary operator to the contained value and a start value
+   * @param f - The binary operator
+   * @returns The result of the reduction
+   */
+  reduceRight<U>(f: (acc: U, value: T) => U): U;
+  /**
+   * Pattern matches over the Option, applying onNone if None and onSome if Some
+   * @param onNone - Function to apply if the Option is None
+   * @param onSome - Function to apply if the Option has a value
+   * @returns The result of applying the appropriate function
+   */
+  fold<U>(onNone: () => U, onSome: (value: T) => U): U;
+  /**
+   * Left-associative fold using the provided zero value and operation
+   * @param z - Zero/identity value
+   * @returns A function that takes an operation to apply
+   */
+  foldLeft<B>(z: B): (op: (b: B, a: T) => B) => B;
+  /**
+   * Right-associative fold using the provided zero value and operation
+   * @param z - Zero/identity value
+   * @returns A function that takes an operation to apply
+   */
+  foldRight<B>(z: B): (op: (a: T, b: B) => B) => B;
+  /**
+   * Converts this Option to a List
+   * @returns A List containing the value if Some, or empty List if None
+   */
+  toList(): List<T>;
+  /**
+   * Checks if this Option contains the specified value
+   * @param value - The value to check for
+   * @returns true if this Option contains the value, false otherwise
+   */
+  contains(value: T): boolean;
+  /** The number of elements in this Option (0 or 1) */
+  size: number;
+  /**
+   * Converts this Option to an Either
+   * @param left - The value to use for Left if this Option is None
+   * @returns Either.Right with the contained value if Some, or Either.Left with left if None
+   */
+  toEither<E>(left: E): Either<E, T>;
+  /**
+   * Returns a string representation of this Option
+   * @returns A string representation
+   */
+  toString(): string;
+  /**
+   * Returns a simple object representation of this Option
+   * @returns An object with _tag and value properties
+   */
+  toValue(): {
+    _tag: "Some" | "None";
+    value: T;
+  };
+  /**
+   * Pattern matches over the Option, applying a handler function based on the variant
+   * @param patterns - Object with handler functions for Some and None variants
+   * @returns The result of applying the matching handler function
+   */
+  match<R>(patterns: {
+    Some: (value: T) => R;
+    None: () => R;
+  }): R;
+}
+/**
+ * Creates a Some variant of Option containing a value.
+ * @param value - The value to wrap in Some
+ * @returns A new Some instance containing the value
+ * @typeParam T - The type of the value
+ */
+declare const Some: <T extends Type>(value: T) => Option<T>;
+/**
+ * Creates a None variant of Option representing absence of a value.
+ * @returns A new None instance
+ * @typeParam T - The type that would be contained if this was a Some
+ */
+declare const None: <T extends Type>() => Option<T>;
+/**
+ * Safely wraps a value that might be null or undefined in an Option.
+ * Creates Some if the value is defined, None otherwise.
+ * @param value - The value to wrap (might be null/undefined)
+ * @returns Some(value) if value is defined, None otherwise
+ * @typeParam T - The type of the value
+ */
+declare const OptionConstructor: <T extends Type>(value: T | null | undefined) => Option<T>;
+declare const Option: (<T extends Type>(value: T | null | undefined) => Option<T>) & {
+  /**
+   * Creates an Option from any value. Alias for Option function.
+   * @param value - The value to wrap
+   * @returns Some(value) if value is defined, None otherwise
+   * @typeParam T - The type of the value
+   */
+  from: <T>(value: T) => Option<T>;
+  /**
+   * Returns a None instance. Alias for None function.
+   * @returns A None instance
+   * @typeParam T - The type that would be contained if this was a Some
+   */
+  none: <T>() => Option<T>;
+  /**
+   * Type guard to check if an Option is Some
+   * @param option - The Option to check
+   * @returns True if Option is Some
+   */
+  isSome: <T>(option: Option<T>) => option is Option<T> & {
+    value: T;
+    isEmpty: false;
+  };
+  /**
+   * Type guard to check if an Option is None
+   * @param option - The Option to check
+   * @returns True if Option is None
+   */
+  isNone: <T>(option: Option<T>) => option is Option<T> & {
+    value: undefined;
+    isEmpty: true;
+  };
+  /**
+   * Creates an Option from JSON string
+   * @param json - The JSON string
+   * @returns Option instance
+   */
+  fromJSON: <T>(json: string) => Option<T>;
+  /**
+   * Creates an Option from YAML string
+   * @param yaml - The YAML string
+   * @returns Option instance
+   */
+  fromYAML: <T>(yaml: string) => Option<T>;
+  /**
+   * Creates an Option from binary string
+   * @param binary - The binary string
+   * @returns Option instance
+   */
+  fromBinary: <T>(binary: string) => Option<T>;
+};
+//#endregion
 export { None, Option, OptionConstructor, Some };

package/dist/option/index.js

@@ -1 +1,2 @@
-import{Ct as e,St as t,Tt as n,wt as r}from"../src-Bl2PmAVK.js";export{t as None,e as Option,r as OptionConstructor,n as Some};
+import{rt as e}from"../Valuable-B8h0iKI_.js";import{t}from"../Companion-VlxcFhzb.js";import{Try as n}from"../try/index.js";import{List as r}from"../list/index.js";import{Left as i,Right as a}from"../either/index.js";import o from"safe-stable-stringify";const s=t=>({_tag:`Some`,value:t,isEmpty:!1,isSome(){return!0},isNone(){return!1},orElse:()=>t,orThrow:()=>t,or:e=>s(t),orNull:()=>t,orUndefined:()=>t,map:e=>s(e(t)),ap:e=>e._tag===`Some`&&e.value?s(e.value(t)):c,filter(e){return e(t)?s(t):c},count:e=>e(t)?1:0,find:e=>e(t)?s(t):c,exists:e=>e(t),forEach:e=>e(t),fold:(e,n)=>n(t),match:e=>e.Some(t),flatMap:e=>e(t),flatMapAsync:async e=>await e(t),reduce:e=>e(void 0,t),reduceRight:e=>e(void 0,t),foldLeft:e=>n=>n(e,t),foldRight:e=>n=>n(t,e),toList:()=>r([t]),contains:e=>e===t,size:1,toOption:()=>s(t),toEither:e=>a(t),toTry:()=>n(()=>t),toPromise:()=>Promise.resolve(t),toString:()=>`Some(${o(t)})`,toValue:()=>({_tag:`Some`,value:t}),pipe:e=>e(t),serialize:()=>e(`Some`,t),doUnwrap(){return{ok:!0,value:t}}}),c={_tag:`None`,value:void 0,isEmpty:!0,isSome(){return!1},isNone(){return!0},orElse:e=>e,orThrow(e){throw e??Error(`Cannot extract value from None`)},or:e=>e,orNull:()=>null,orUndefined:()=>void 0,map:e=>c,ap:e=>c,filter(e){return c},count:e=>0,find:e=>c,exists:e=>!1,forEach:e=>{},flatMap:e=>c,flatMapAsync:e=>Promise.resolve(c),reduce:()=>void 0,reduceRight:()=>void 0,fold:(e,t)=>e(),match:e=>e.None(),foldLeft:e=>()=>e,foldRight:e=>()=>e,toList:()=>r([]),contains:()=>!1,size:0,toOption:()=>c,toEither:e=>i(e),toTry:()=>n(()=>{throw Error(`None`)}),toPromise:()=>Promise.reject(Error(`Cannot convert None to Promise`)),toString:()=>`None`,toValue:()=>({_tag:`None`,value:void 0}),pipe:e=>e(void 0),serialize:()=>e(`None`,null),doUnwrap(){return{ok:!1,empty:!0}}},l=()=>c,u=e=>e==null?l():s(e),d={from:e=>f(e),none:()=>l(),isSome:e=>e.isSome(),isNone:e=>e.isNone(),fromJSON:e=>{let t=JSON.parse(e);return t._tag===`Some`?s(t.value):l()},fromYAML:e=>{let t=e.split(`
+`),n=t[0]?.split(`: `)[1],r=t[1]?.split(`: `)[1];if(!n||!r)return l();let i=r===`null`?null:JSON.parse(r);return n===`Some`?s(i):l()},fromBinary:e=>{let t=Buffer.from(e,`base64`).toString();return d.fromJSON(t)}},f=t(u,d);export{l as None,f as Option,u as OptionConstructor,s as Some};

package/dist/set/index.d.ts

@@ -1,2 +1,54 @@
-import { F as Set } from "../index-DBg23xHh.js";
+import { i as Collection, r as FunctypeCollection } from "../Functype-Dc440LS5.js";
+import { l as Type } from "../Typeable-E4-aX9Gc.js";
+import { List } from "../list/index.js";
+
+//#region src/set/Set.d.ts
+interface Set<A> extends FunctypeCollection<A, "Set">, Collection<A> {
+  add: (value: A) => Set<A>;
+  remove: (value: A) => Set<A>;
+  contains: (value: A) => boolean;
+  has: (value: A) => boolean;
+  map: <B>(f: (a: A) => B) => Set<B>;
+  flatMap: <B>(f: (a: A) => Iterable<B>) => Set<B>;
+  filter: (p: (a: A) => boolean) => Set<A>;
+  filterNot: (p: (a: A) => boolean) => Set<A>;
+  fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U) => U;
+  toList: () => List<A>;
+  toSet: () => Set<A>;
+  toArray: <B = A>() => B[];
+  toString: () => string;
+}
+declare const Set: (<A>(iterable?: Iterable<A>) => Set<A>) & {
+  /**
+   * Creates an empty Set
+   * Returns a singleton instance for efficiency
+   * @returns An empty Set instance
+   */
+  empty: <A extends Type>() => Set<A>;
+  /**
+   * Creates a Set from variadic arguments
+   * @param values - Values to create set from
+   * @returns A Set containing the unique values
+   */
+  of: <A extends Type>(...values: A[]) => Set<A>;
+  /**
+   * Creates a Set from JSON string
+   * @param json - The JSON string
+   * @returns Set instance
+   */
+  fromJSON: <A>(json: string) => Set<A>;
+  /**
+   * Creates a Set from YAML string
+   * @param yaml - The YAML string
+   * @returns Set instance
+   */
+  fromYAML: <A>(yaml: string) => Set<A>;
+  /**
+   * Creates a Set from binary string
+   * @param binary - The binary string
+   * @returns Set instance
+   */
+  fromBinary: <A>(binary: string) => Set<A>;
+};
+//#endregion
 export { Set };

package/dist/set/index.js

@@ -1 +1,2 @@
-import{xt as e}from"../src-Bl2PmAVK.js";export{e as Set};
+import{et as e,rt as t}from"../Valuable-B8h0iKI_.js";import{t as n}from"../Companion-VlxcFhzb.js";import{Option as r}from"../option/index.js";import{List as i}from"../list/index.js";const a=n=>{let o=new e(n),s={_tag:`Set`,[Symbol.iterator]:()=>o[Symbol.iterator](),add:e=>a([...o,e]),remove:t=>{let n=new e(o);return n.delete(t),a(n)},contains:e=>o.has(e),has:e=>o.has(e),map:e=>a(Array.from(o).map(e)),ap:t=>{let n=new e;for(let e of o)for(let r of t)n.add(r(e));return a(n)},flatMap:t=>{let n=new e;for(let e of o)for(let r of t(e))n.add(r);return a(n)},flatMapAsync:async t=>{let n=new e;for(let e of o){let r=await t(e);for(let e of r)n.add(e)}return a(n)},fold:(e,t)=>{if(o.size===0)return e();let n=Array.from(o);if(n.length===0)return e();let r=n[0];return r===void 0?e():t(r)},foldLeft:e=>t=>{let n=e;for(let e of o)n=t(n,e);return n},foldRight:e=>t=>Array.from(o).reduceRight((e,n)=>t(n,e),e),get size(){return o.size},get isEmpty(){return o.size===0},reduce:e=>{let t=Array.from(o);if(t.length===0)throw Error(`Cannot reduce empty Set`);return t.reduce(e)},reduceRight:e=>{let t=Array.from(o);if(t.length===0)throw Error(`Cannot reduceRight empty Set`);return t.reduceRight(e)},count:e=>{let t=0;for(let n of o)e(n)&&t++;return t},find:e=>{for(let t of o)if(e(t))return r(t);return r(null)},exists:e=>{for(let t of o)if(e(t))return!0;return!1},forEach:e=>{o.forEach(e)},filter:t=>{let n=new e;for(let e of o)t(e)&&n.add(e);return a(n)},filterNot:t=>{let n=new e;for(let e of o)t(e)||n.add(e);return a(n)},drop:e=>a(Array.from(o).slice(e)),dropRight:e=>a(Array.from(o).slice(0,-e)),dropWhile:e=>{let t=Array.from(o),n=t.findIndex(t=>!e(t));return a(n===-1?[]:t.slice(n))},flatten:()=>{let t=new e;for(let e of o)if(Array.isArray(e))for(let n of e)t.add(n);else if(e&&typeof e==`object`&&Symbol.iterator in e)for(let n of e)t.add(n);else t.add(e);return a(t)},get head(){return Array.from(o)[0]},get headOption(){let e=Array.from(o)[0];return r(e)},take:e=>a(Array.from(o).slice(0,Math.max(0,e))),takeWhile:e=>{let t=Array.from(o),n=[];for(let r of t){if(!e(r))break;n.push(r)}return a(n)},takeRight:e=>{let t=Array.from(o);return a(e<=0?[]:t.slice(-e))},get last(){let e=Array.from(o);return e[e.length-1]},get lastOption(){let e=Array.from(o);return r(e[e.length-1])},get tail(){return a(Array.from(o).slice(1))},get init(){let e=Array.from(o);return a(e.length===0?[]:e.slice(0,-1))},toList:()=>i(Array.from(o)),toSet:()=>s,toArray:()=>Array.from(o),toString:()=>`Set(${Array.from(o).toString()})`,toValue:()=>({_tag:`Set`,value:Array.from(o)}),pipe:e=>e(Array.from(o)),serialize:()=>t(`Set`,Array.from(o))};return s},o=e=>a(e),s=a([]),c={empty:()=>s,of:(...e)=>a(e),fromJSON:e=>l(JSON.parse(e).value),fromYAML:e=>{let t=e.split(`
+`)[1]?.split(`: `)[1];return l(t?JSON.parse(t):[])},fromBinary:e=>{let t=Buffer.from(e,`base64`).toString();return c.fromJSON(t)}},l=n(o,c);export{l as Set};

package/dist/try/index.d.ts

@@ -1,2 +1,97 @@
-import { Mn as Try, Nn as TypeNames } from "../index-DBg23xHh.js";
+import { dn as Extractable, mn as Doable, n as FunctypeBase, nn as Reshapeable, rn as Promisable } from "../Functype-Dc440LS5.js";
+import { l as Type, s as Pipe } from "../Typeable-E4-aX9Gc.js";
+import { Option } from "../option/index.js";
+import { List } from "../list/index.js";
+import { Either } from "../either/index.js";
+
+//#region src/try/Try.d.ts
+/**
+ * Possible types of Try instances
+ */
+type TypeNames = "Success" | "Failure";
+interface Try<T> extends FunctypeBase<T, TypeNames>, Extractable<T>, Pipe<T>, Promisable<T>, Doable<T>, Reshapeable<T> {
+  readonly _tag: TypeNames;
+  readonly error: Error | undefined;
+  isSuccess(): this is Try<T> & {
+    readonly _tag: "Success";
+    error: undefined;
+  };
+  isFailure(): this is Try<T> & {
+    readonly _tag: "Failure";
+    error: Error;
+  };
+  orElse: (defaultValue: T) => T;
+  orThrow: (error?: Error) => T;
+  or: (alternative: Try<T>) => Try<T>;
+  orNull: () => T | null;
+  orUndefined: () => T | undefined;
+  toOption: () => Option<T>;
+  toEither: <E extends Type>(leftValue: E) => Either<E, T>;
+  toList: () => List<T>;
+  toTry: () => Try<T>;
+  map: <U>(f: (value: T) => U) => Try<U>;
+  ap: <U>(ff: Try<(value: T) => U>) => Try<U>;
+  flatMap: <U>(f: (value: T) => Try<U>) => Try<U>;
+  flatMapAsync: <U>(f: (value: T) => Promise<Try<U>>) => Promise<Try<U>>;
+  /**
+   * Pattern matches over the Try, applying onFailure if Failure and onSuccess if Success
+   * @param onFailure - Function to apply if the Try is Failure
+   * @param onSuccess - Function to apply if the Try is Success
+   * @returns The result of applying the appropriate function
+   */
+  fold: <U extends Type>(onFailure: (error: Error) => U, onSuccess: (value: T) => U) => U;
+  toString: () => string;
+  /**
+   * Pattern matches over the Try, applying a handler function based on the variant
+   * @param patterns - Object with handler functions for Success and Failure variants
+   * @returns The result of applying the matching handler function
+   */
+  match<R>(patterns: {
+    Success: (value: T) => R;
+    Failure: (error: Error) => R;
+  }): R;
+  toValue(): {
+    _tag: TypeNames;
+    value: T | Error;
+  };
+}
+declare const Try: (<T>(f: () => T) => Try<T>) & {
+  /**
+   * Type guard to check if a Try is Success
+   * @param tryValue - The Try to check
+   * @returns True if Try is Success
+   */
+  isSuccess: <T>(tryValue: Try<T>) => tryValue is Try<T> & {
+    readonly _tag: "Success";
+    error: undefined;
+  };
+  /**
+   * Type guard to check if a Try is Failure
+   * @param tryValue - The Try to check
+   * @returns True if Try is Failure
+   */
+  isFailure: <T>(tryValue: Try<T>) => tryValue is Try<T> & {
+    readonly _tag: "Failure";
+    error: Error;
+  };
+  /**
+   * Creates a Try from JSON string
+   * @param json - The JSON string
+   * @returns Try instance
+   */
+  fromJSON: <T>(json: string) => Try<T>;
+  /**
+   * Creates a Try from YAML string
+   * @param yaml - The YAML string
+   * @returns Try instance
+   */
+  fromYAML: <T>(yaml: string) => Try<T>;
+  /**
+   * Creates a Try from binary string
+   * @param binary - The binary string
+   * @returns Try instance
+   */
+  fromBinary: <T>(binary: string) => Try<T>;
+};
+//#endregion
 export { Try, TypeNames };

package/dist/try/index.js

@@ -1 +1,2 @@
-import{vt as e}from"../src-Bl2PmAVK.js";export{e as Try};
+import{rt as e,tt as t}from"../Valuable-B8h0iKI_.js";import{t as n}from"../Companion-VlxcFhzb.js";import{None as r,Option as i,Some as a}from"../option/index.js";import{List as o}from"../list/index.js";import{Left as s,Right as c}from"../either/index.js";import l from"safe-stable-stringify";const u=t=>({_tag:`Success`,error:void 0,isSuccess(){return!0},isFailure(){return!1},orElse:e=>t,orThrow:e=>t,or:e=>u(t),orNull:()=>t,orUndefined:()=>t,toEither:e=>c(t),map:e=>m(()=>e(t)),ap:e=>e.map(e=>e(t)),flatMap:e=>e(t),flatMapAsync:async e=>e(t),fold:(e,n)=>n(t),match:e=>e.Success(t),foldLeft:e=>n=>n(e,t),foldRight:e=>n=>n(t,e),toString:()=>`Success(${l(t)})`,toPromise:()=>Promise.resolve(t),toValue:()=>({_tag:`Success`,value:t}),toOption:()=>a(t),toList:()=>o([t]),toTry:()=>u(t),pipe:e=>e(t),serialize:()=>e(`Success`,t),get size(){return 1},get isEmpty(){return!1},contains:e=>t===e,reduce:e=>t,reduceRight:e=>t,count:e=>e(t)?1:0,find:e=>e(t)?i(t):i(void 0),exists:e=>e(t),forEach:e=>e(t),doUnwrap(){return{ok:!0,value:t}}}),d=e=>({_tag:`Failure`,error:e,isSuccess(){return!1},isFailure(){return!0},orElse:e=>e,orThrow:t=>{throw t??e},or:e=>e,orNull:()=>null,orUndefined:()=>void 0,toEither:t=>s(e),map:t=>d(e),ap:t=>d(e),flatMap:t=>d(e),flatMapAsync:t=>Promise.resolve(d(e)),fold:(t,n)=>t(e),match:t=>t.Failure(e),foldLeft:e=>t=>e,foldRight:e=>t=>e,toString:()=>`Failure(${l(e)}))`,toPromise:()=>Promise.reject(e),toValue:()=>({_tag:`Failure`,value:e}),toOption:()=>r(),toList:()=>o([]),toTry:()=>d(e),pipe:t=>{throw e},serialize:()=>t({_tag:`Failure`,error:e.message,stack:e.stack}),get size(){return 0},get isEmpty(){return!0},contains:e=>!1,reduce:e=>{throw Error(`Cannot reduce a Failure`)},reduceRight:e=>{throw Error(`Cannot reduceRight a Failure`)},count:e=>0,find:e=>i(null),exists:e=>!1,forEach:e=>{},doUnwrap(){return{ok:!1,empty:!1,error:e}}}),f=e=>{try{return u(e())}catch(e){return d(e instanceof Error?e:Error(String(e)))}},p={isSuccess:e=>e.isSuccess(),isFailure:e=>e.isFailure(),fromJSON:e=>{let t=JSON.parse(e);if(t._tag===`Success`)return u(t.value);{let e=Error(t.error);return t.stack&&(e.stack=t.stack),d(e)}},fromYAML:e=>{let t=e.split(`
+`),n=t[0]?.split(`: `)[1];if(!n)return d(Error(`Invalid YAML format for Try`));if(n===`Success`){let e=t[1]?.split(`: `)[1];return e?u(JSON.parse(e)):d(Error(`Invalid YAML format for Try Success`))}else{let e=t[1]?.split(`: `)[1];if(!e)return d(Error(`Invalid YAML format for Try Failure`));let n=t[2]?.split(`: `),r=n&&n.length>1?n.slice(1).join(`: `):void 0,i=Error(e);return r&&(i.stack=r),d(i)}},fromBinary:e=>{let t=Buffer.from(e,`base64`).toString();return p.fromJSON(t)}},m=n(f,p);export{m as Try};

package/dist/tuple/index.d.ts

@@ -1,2 +1,76 @@
-import { t as Tuple } from "../Tuple-35L0I92q.js";
+import { a as Serializable, c as Foldable, l as Type, n as Typeable, s as Pipe } from "../Typeable-E4-aX9Gc.js";
+
+//#region src/tuple/Tuple.d.ts
+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];
+  map<U extends Type[]>(f: (value: T) => U): Tuple<U>;
+  flatMap<U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U>;
+  toArray(): T;
+  length: number;
+  [Symbol.iterator](): Iterator<T[number]>;
+  toString(): string;
+  toValue(): {
+    _tag: "Tuple";
+    value: T;
+  };
+}
+/**
+ * Tuple provides a type-safe, fixed-length array with functional operations.
+ *
+ * @example
+ * // Creating tuples
+ * const t1 = Tuple([1, "hello", true])
+ * const t2 = Tuple.of(1, "hello", true)
+ * const pair = Tuple.pair("key", 42)
+ *
+ * @example
+ * // Type-safe access
+ * const triple = Tuple.triple("x", 10, true)
+ * const first = triple.get(0)  // string
+ * const second = triple.get(1) // number
+ * const third = triple.get(2)  // boolean
+ *
+ * @example
+ * // Functional operations
+ * const doubled = Tuple([1, 2, 3])
+ *   .map(arr => arr.map(x => x * 2))
+ *   .toArray() // [2, 4, 6]
+ */
+declare const Tuple: (<T extends Type[]>(values: T) => Tuple<T>) & {
+  /**
+   * Create a Tuple from multiple arguments
+   * @example
+   * const t = Tuple.of(1, "hello", true)
+   * // TypeScript infers: Tuple<[number, string, boolean]>
+   */
+  of: <T extends Type[]>(...values: T) => Tuple<T>;
+  /**
+   * Create a Tuple of size 2 (pair)
+   * @example
+   * const pair = Tuple.pair("key", 42)
+   * // TypeScript infers: Tuple<[string, number]>
+   */
+  pair: <A extends Type, B extends Type>(first: A, second: B) => Tuple<[A, B]>;
+  /**
+   * Create a Tuple of size 3 (triple)
+   * @example
+   * const triple = Tuple.triple("x", 10, true)
+   * // TypeScript infers: Tuple<[string, number, boolean]>
+   */
+  triple: <A extends Type, B extends Type, C extends Type>(first: A, second: B, third: C) => Tuple<[A, B, C]>;
+  /**
+   * Create an empty Tuple
+   * @example
+   * const empty = Tuple.empty()
+   * // TypeScript infers: Tuple<[]>
+   */
+  empty: () => Tuple<[]>;
+  /**
+   * Create a Tuple from an array (alias for constructor)
+   * @example
+   * const t = Tuple.from([1, 2, 3])
+   */
+  from: <T extends Type[]>(values: T) => Tuple<T>;
+};
+//#endregion
 export { Tuple };

package/dist/tuple/index.js

@@ -1 +1 @@
-import{t as e}from"../Tuple-BQLc_Ion.js";export{e as Tuple};
+import{t as e}from"../Companion-VlxcFhzb.js";import t from"safe-stable-stringify";const n=e=>{let n={_tag:`Tuple`,map:t=>r(t(e)),flatMap:t=>t(e),get:t=>e[t],toArray:()=>e,length:e.length,[Symbol.iterator](){let t=0;return{next:()=>t<e.length?{value:e[t++],done:!1}:{value:void 0,done:!0}}},fold:(t,n)=>e.length===0?t():n(e[0]),foldLeft:t=>n=>e.reduce(n,t),foldRight:t=>n=>e.reduceRight((e,t)=>n(t,e),t),pipe:e=>e(n),serialize:()=>({toJSON:()=>JSON.stringify({_tag:`Tuple`,value:e}),toYAML:()=>`_tag: Tuple\nvalue: ${t(e)}`,toBinary:()=>Buffer.from(JSON.stringify({_tag:`Tuple`,value:e})).toString(`base64`)}),toValue:()=>({_tag:`Tuple`,value:e}),toString:()=>`Tuple(${e.map(e=>String(e)).join(`, `)})`};return n},r=e(e=>n(e),{of:(...e)=>n(e),pair:(e,t)=>n([e,t]),triple:(e,t,r)=>n([e,t,r]),empty:()=>n([]),from:e=>n(e)});export{r as Tuple};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functype",
-  "version": "0.45.0",
+  "version": "0.46.0",
   "type": "module",
   "description": "A functional programming library for TypeScript, using immutable data structures and type classes",
   "author": "jordan.burke@gmail.com",
@@ -44,14 +44,14 @@
     "cli-example": "npx . Option"
   },
   "devDependencies": {
-    "@eslint/compat": "^2.0.1",
-    "@types/node": "~24.10.9",
+    "@eslint/compat": "^2.0.2",
+    "@types/node": "~24.10.11",
     "eslint-config-functype": "1.3.0",
     "eslint-plugin-functional": "^9.0.2",
     "fast-check": "^4.5.3",
-    "globals": "^17.0.0",
-    "ts-builds": "^2.2.1",
-    "tsdown": "^0.19.0",
+    "globals": "^17.3.0",
+    "ts-builds": "^2.3.2",
+    "tsdown": "^0.20.3",
     "tsx": "^4.21.0",
     "typedoc": "^0.28.16"
   },
@@ -164,5 +164,5 @@
     "safe-stable-stringify": "^2.5.0"
   },
   "sideEffects": false,
-  "packageManager": "pnpm@10.28.1+sha512.7d7dbbca9e99447b7c3bf7a73286afaaf6be99251eb9498baefa7d406892f67b879adb3a1d7e687fc4ccc1a388c7175fbaae567a26ab44d1067b54fcb0d6a316"
+  "packageManager": "pnpm@10.28.2+sha512.41872f037ad22f7348e3b1debbaf7e867cfd448f2726d9cf74c08f19507c31d2c8e7a11525b983febc2df640b5438dee6023ebb1f84ed43cc2d654d2bc326264"
 }

package/dist/Brand-B_uQBKwR.d.ts

@@ -1,54 +0,0 @@
-//#region src/branded/Brand.d.ts
-type Brand<K extends string, T> = T & {
-  readonly __brand: K;
-};
-type Unwrap<T> = T extends Brand<string, infer U> ? U : T;
-type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never;
-/**
- * Brand is a utility for creating nominal typing in TypeScript.
- * It creates phantom types that exist only at compile time.
- * At runtime, the branded value IS the primitive value.
- *
- * @param _brand
- * @param value - The value to brand
- * @returns The value with phantom type brand
- */
-declare function Brand<K extends string, T>(_brand: K, value: T): Brand<K, T>;
-/**
- * Helper to unwrap a branded value to its underlying type
- * Works with both Brand and ValidatedBrand
- * @param branded - The branded value (can be null or undefined)
- * @returns The original value without the brand
- *
- * Note: Also exported as 'unwrap' from 'functype/branded' for convenience
- */
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T>): T;
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null): T | null;
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | undefined): T | undefined;
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null | undefined): T | null | undefined;
-/**
- * Type guard for checking if a value has a specific brand
- * @param value - The value to check
- * @param _brand - The brand to check for (unused at runtime)
- * @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.
- */
-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
- */
-declare function createBrander<K extends string, T>(brand: K): (value: T) => Brand<K, T>;
-type BrandedString<K extends string> = Brand<K, string>;
-type BrandedNumber<K extends string> = Brand<K, number>;
-type BrandedBoolean<K extends string> = Brand<K, boolean>;
-declare const BrandedString: <K extends string>(brand: K) => (value: string) => BrandedString<K>;
-declare const BrandedNumber: <K extends string>(brand: K) => (value: number) => BrandedNumber<K>;
-declare const BrandedBoolean: <K extends string>(brand: K) => (value: boolean) => BrandedBoolean<K>;
-//#endregion
-export { ExtractBrand as a, hasBrand as c, BrandedString as i, unwrapBrand as l, BrandedBoolean as n, Unwrap as o, BrandedNumber as r, createBrander as s, Brand as t };

package/dist/Brand-DxglW-qB.js

@@ -1 +0,0 @@
-function e(e,t){return t}function t(e){return e??e}function n(e,t){return e!=null}function r(t){return n=>e(t,n)}const i=t=>n=>e(t,n),a=t=>n=>e(t,n),o=t=>n=>e(t,n);export{r as a,i,o as n,n as o,a as r,t as s,e as t};

package/dist/Tuple-BQLc_Ion.js

@@ -1 +0,0 @@
-import e from"safe-stable-stringify";function t(e,t){return Object.assign(e,t)}function n(e,n){return t(e,n)}const r=t=>{let n={_tag:`Tuple`,map:e=>i(e(t)),flatMap:e=>e(t),get:e=>t[e],toArray:()=>t,length:t.length,[Symbol.iterator](){let e=0;return{next:()=>e<t.length?{value:t[e++],done:!1}:{value:void 0,done:!0}}},fold:(e,n)=>t.length===0?e():n(t[0]),foldLeft:e=>n=>t.reduce(n,e),foldRight:e=>n=>t.reduceRight((e,t)=>n(t,e),e),pipe:e=>e(n),serialize:()=>({toJSON:()=>JSON.stringify({_tag:`Tuple`,value:t}),toYAML:()=>`_tag: Tuple\nvalue: ${e(t)}`,toBinary:()=>Buffer.from(JSON.stringify({_tag:`Tuple`,value:t})).toString(`base64`)}),toValue:()=>({_tag:`Tuple`,value:t}),toString:()=>`Tuple(${t.map(e=>String(e)).join(`, `)})`};return n},i=n(e=>r(e),{of:(...e)=>r(e),pair:(e,t)=>r([e,t]),triple:(e,t,n)=>r([e,t,n]),empty:()=>r([]),from:e=>r(e)});export{n,t as r,i as t};