functype 0.1.1 → 0.2.1

package/dist/index-5f972212.d.ts

@@ -0,0 +1,227 @@
+import { Type, IFunctor } from './functor/index.mjs';
+import { ITuple, Tuple } from './tuple/Tuple.mjs';
+
+interface Option<T extends Type> extends IFunctor<T>, ITraversable<T> {
+    get(): T;
+    getOrElse(defaultValue: T): T;
+    orElse(alternative: Option<T>): Option<T>;
+    map<U extends Type>(f: (value: T) => U): Option<U>;
+    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
+    toList(): IIterable<T>;
+}
+declare class Some<A extends Type> implements Option<A> {
+    private value;
+    constructor(value: A);
+    get isEmpty(): boolean;
+    get(): A;
+    getOrElse(defaultValue: A): A;
+    orElse(alternative: Option<A>): Option<A>;
+    map<U extends Type>(f: (value: A) => U): Option<U>;
+    flatMap<U extends Type>(f: (value: A) => Option<U>): Option<U>;
+    reduce<U>(f: (acc: U, value: A) => U): U;
+    reduceRight<U>(f: (acc: U, value: A) => U): U;
+    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
+    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
+    toList(): IIterable<A>;
+    contains(value: A): boolean;
+    get size(): number;
+}
+declare class None<A extends Type> implements Option<A> {
+    get isEmpty(): boolean;
+    get(): A;
+    getOrElse(defaultValue: A): A;
+    orElse(alternative: Option<A>): Option<A>;
+    map<U extends Type>(f: (value: A) => U): Option<U>;
+    flatMap<U extends Type>(f: (value: A) => Option<U>): Option<U>;
+    reduce(f: (acc: A, value: A) => A): A;
+    reduceRight(f: (b: A, a: A) => A): A;
+    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
+    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
+    toList(): IIterable<A>;
+    contains(value: A): boolean;
+    get size(): number;
+}
+
+declare const option: <T extends unknown>(value?: T | undefined) => Option<T>;
+declare const some: <T extends unknown>(value: T) => Option<T>;
+declare const none: <T extends unknown>() => Option<T>;
+
+declare class Seq<A> implements IIterable<A> {
+    protected readonly values: Iterable<A>;
+    constructor(values?: Iterable<A> | IIterable<A>);
+    readonly [n: number]: A;
+    get length(): number;
+    map<B>(f: (a: A) => B): IIterable<B>;
+    flatMap<B>(f: (a: A) => IIterable<B>): IIterable<B>;
+    forEach(f: (a: A) => void): void;
+    count(p: (x: A) => boolean): number;
+    exists(p: (a: A) => boolean): Boolean;
+    filter(p: (a: A) => boolean): IIterable<A>;
+    filterNot(p: (a: A) => boolean): IIterable<A>;
+    find(p: (a: A) => boolean): Option<A>;
+    get head(): A;
+    get headOption(): Option<A>;
+    get isEmpty(): boolean;
+    get size(): number;
+    toArray(): A[];
+    reduce(f: (prev: A, curr: A) => A): A;
+    reduceRight(f: (prev: A, curr: A) => A): A;
+    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
+    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
+}
+
+interface IIterable<A extends Type> extends IFunctor<A> {
+    count(p: (x: A) => boolean): number;
+    find(p: (a: A) => boolean): Option<A>;
+    forEach(f: (a: A) => void): void;
+    exists(p: (a: A) => boolean): Boolean;
+    filter(p: (a: A) => boolean): IIterable<A>;
+    filterNot(p: (a: A) => boolean): IIterable<A>;
+    reduce(f: (b: A, a: A) => A): A;
+    reduceRight(f: (b: A, a: A) => A): A;
+    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
+    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
+    get head(): A;
+    get headOption(): Option<A>;
+    get isEmpty(): boolean;
+    map<B extends Type>(f: (a: A) => B): IIterable<B>;
+    flatMap<B extends Type>(f: (a: A) => IIterable<B>): IIterable<B>;
+    get size(): number;
+    toArray(): readonly A[];
+}
+
+interface ISet<T> extends IIterable<T>, ICollection<T> {
+    has(value: T): boolean;
+}
+declare class Set<A> extends Seq<A> implements ISet<A> {
+    constructor(iterable?: Iterable<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) => IIterable<B>): Set<B>;
+    toList(): IList<A>;
+    toSet(): ISet<A>;
+}
+
+interface IConverters<A> {
+    toList(): IList<A>;
+    toSet(): ISet<A>;
+}
+interface ICollection<A> extends IConverters<A> {
+}
+
+interface IList<T> extends IIterable<T>, ArrayLike<T> {
+    add(item: T): IList<T>;
+}
+declare class List<A> extends Seq<A> implements IList<A>, ICollection<A> {
+    constructor(values?: Iterable<A> | IIterable<A>);
+    readonly [n: number]: A;
+    map<B>(f: (a: A) => B): List<B>;
+    flatMap<B>(f: (a: A) => IIterable<B>): List<B>;
+    remove(value: A): List<A>;
+    contains(value: A): boolean;
+    add(item: A): List<A>;
+    removeAt(index: number): List<A>;
+    get(index: number): Option<A>;
+    concat(other: List<A>): List<A>;
+    toList(): IList<A>;
+    toSet(): Set<A>;
+    toString(): string;
+}
+
+declare const list: <T extends unknown>(items: T[] | undefined) => List<T>;
+
+interface IMap<K, V> extends ITraversable<ITuple<[K, V]>>, ICollection<ITuple<[K, V]>> {
+    map<U>(f: (value: any) => U): IMap<K, U>;
+    flatMap<U>(f: (value: any) => IMap<K, U>): IMap<K, U>;
+    get(key: K): Option<V>;
+    getOrElse(key: K, defaultValue: V): V;
+    orElse(key: K, alternative: Option<V>): Option<V>;
+}
+declare class Map<K, V> implements IMap<K, V> {
+    private values;
+    private get entries();
+    constructor(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null);
+    add(item: ITuple<[K, V]>): Map<K, V>;
+    remove(value: ITuple<[K, V]>): Map<K, V>;
+    contains(value: ITuple<[K, V]>): boolean;
+    get size(): number;
+    map<U>(f: (value: V) => U): IMap<K, U>;
+    flatMap<U>(f: (value: V) => IMap<K, U>): IMap<K, U>;
+    reduce(f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]>;
+    reduceRight(f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]>;
+    foldLeft<B>(z: B): (op: (b: B, a: ITuple<[K, V]>) => B) => B;
+    foldRight<B>(z: B): (op: (a: ITuple<[K, V]>, b: B) => B) => B;
+    get(key: K): Option<V>;
+    getOrElse(key: K, defaultValue: V): V;
+    get isEmpty(): boolean;
+    orElse(key: K, alternative: Option<V>): Option<V>;
+    toList(): IList<Tuple<[K, V]>>;
+    toSet(): ISet<Tuple<[K, V]>>;
+}
+
+interface Either<L, R> extends IFunctor<R> {
+    value: L | R;
+    isLeft(): this is Left<L, R>;
+    isRight(): this is Right<L, R>;
+    map<U>(f: (value: R) => U): Either<L, U>;
+    flatMap<U>(f: (value: R) => Either<L, U>): Either<L, U>;
+    toOption(): Option<R>;
+    toList(): List<R>;
+}
+declare class Right<L, R> implements Either<L, R> {
+    value: R;
+    constructor(value: R);
+    isLeft(): this is Left<L, R>;
+    isRight(): this is Right<L, R>;
+    map<U>(f: (value: R) => U): Either<L, U>;
+    flatMap<U>(f: (value: R) => Either<L, U>): Either<L, U>;
+    toOption(): Option<R>;
+    toList(): List<R>;
+}
+declare class Left<L, R> implements Either<L, R> {
+    value: L;
+    constructor(value: L);
+    isLeft(): this is Left<L, R>;
+    isRight(): this is Right<L, R>;
+    map<U>(_f: (value: R) => U): Either<L, U>;
+    flatMap<U>(_f: (value: R) => Either<L, U>): Either<L, U>;
+    toOption(): Option<R>;
+    toList(): List<R>;
+}
+
+declare const left: <L, R>(value: L) => Either<L, R>;
+declare const right: <L, R>(value: R) => Either<L, R>;
+
+interface ITry<T> {
+    isSuccess(): boolean;
+    isFailure(): boolean;
+    getOrElse(defaultValue: T): T;
+    orElse(alternative: ITry<T>): ITry<T>;
+    toEither(): Either<Error, T>;
+}
+declare class Try<T> implements ITry<T> {
+    private readonly value;
+    private readonly error;
+    private constructor();
+    static of<T>(f: () => T): Try<T>;
+    isSuccess(): boolean;
+    isFailure(): boolean;
+    getOrElse(defaultValue: T): T;
+    orElse(alternative: ITry<T>): ITry<T>;
+    toEither(): Either<Error, T>;
+}
+
+interface ITraversable<A extends Type> extends IFunctor<A> {
+    get size(): number;
+    get isEmpty(): boolean;
+    contains(value: A): boolean;
+    reduce(f: (b: A, a: A) => A): A;
+    reduceRight(f: (b: A, a: A) => A): A;
+    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
+    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
+}
+
+export { Either as E, IIterable as I, List as L, Map as M, None as N, Option as O, Right as R, Some as S, Try as T, Seq as a, ISet as b, Set as c, IConverters as d, ICollection as e, IList as f, IMap as g, Left as h, left as i, ITry as j, ITraversable as k, list as l, none as n, option as o, right as r, some as s };

package/dist/index.d.mts

@@ -1,212 +1,3 @@
-import { ParseError } from './error/ParseError.mjs';
-
-declare class Left<L, R> implements Either<L, R> {
-    value: L;
-    constructor(value: L);
-    isLeft(): this is Left<L, R>;
-    isRight(): this is Right<L, R>;
-    map<U>(_f: (value: R) => U): Either<L, U>;
-    flatMap<U>(_f: (value: R) => Either<L, U>): Either<L, U>;
-    toOption(): Option<R>;
-    toList(): List<R>;
-}
-
-declare class Right<L, R> implements Either<L, R> {
-    value: R;
-    constructor(value: R);
-    isLeft(): this is Left<L, R>;
-    isRight(): this is Right<L, R>;
-    map<U>(f: (value: R) => U): Either<L, U>;
-    flatMap<U>(f: (value: R) => Either<L, U>): Either<L, U>;
-    toOption(): Option<R>;
-    toList(): List<R>;
-}
-
-interface Either<L, R> extends IFunctor<R> {
-    value: L | R;
-    isLeft(): this is Left<L, R>;
-    isRight(): this is Right<L, R>;
-    map<U>(f: (value: R) => U): Either<L, U>;
-    flatMap<U>(f: (value: R) => Either<L, U>): Either<L, U>;
-    toOption(): Option<R>;
-    toList(): List<R>;
-}
-declare const left: <L, R>(value: L) => Either<L, R>;
-declare const right: <L, R>(value: R) => Either<L, R>;
-declare const parseNumber: (input: string) => Either<ParseError, number>;
-
-declare class Some<T extends Type> implements Option<T> {
-    private value;
-    constructor(value: T);
-    get isEmpty(): boolean;
-    get(): T;
-    getOrElse(defaultValue: T): T;
-    orElse(alternative: Option<T>): Option<T>;
-    map<U extends Type>(f: (value: T) => U): Option<U>;
-    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    toList(): List<T>;
-    contains(value: T): boolean;
-    get size(): number;
-}
-
-declare class None<T extends Type> implements Option<T> {
-    get isEmpty(): boolean;
-    get(): T;
-    getOrElse(defaultValue: T): T;
-    orElse(alternative: Option<T>): Option<T>;
-    map<U extends Type>(f: (value: T) => U): Option<U>;
-    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    toList(): List<T>;
-    contains(value: T): boolean;
-    get size(): number;
-}
-
-interface Option<T extends Type> extends IFunctor<T>, ITraversable<T> {
-    get(): T;
-    getOrElse(defaultValue: T): T;
-    orElse(alternative: Option<T>): Option<T>;
-    map<U extends Type>(f: (value: T) => U): Option<U>;
-    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
-    toList(): List<T>;
-}
-declare const option: <T extends unknown>(value?: T | undefined) => Option<T>;
-declare const some: <T extends unknown>(value: T) => Option<T>;
-declare const none: <T extends unknown>() => Option<T>;
-
-declare class List<T> implements IList<T> {
-    private readonly items;
-    constructor(iterable?: Iterable<T>);
-    readonly [n: number]: T;
-    remove(value: T): List<T>;
-    contains(value: T): boolean;
-    get size(): number;
-    get isEmpty(): boolean;
-    get length(): number;
-    add(item: T): List<T>;
-    removeAt(index: number): List<T>;
-    get(index: number): Option<T>;
-    toArray(): readonly T[];
-    map<U>(f: (value: T) => U): List<U>;
-    flatMap<U>(f: (value: T) => List<U>): List<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    concat(other: List<T>): List<T>;
-    toString(): string;
-}
-
-interface IList<T extends Type> extends IFunctor<T>, ICollection<T>, ArrayLike<T> {
-    map<U extends Type>(f: (value: T) => U): IList<U>;
-    flatMap<U extends Type>(f: (value: T) => IList<U>): IList<U>;
-    reduce<U extends Type>(f: (acc: U, value: T) => U): U;
-    foldLeft<U extends Type>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U extends Type>(initialValue: U, f: (value: T, acc: U) => U): U;
-}
-declare const list: <T extends unknown>(items: T[] | undefined) => List<T>;
-
-declare class Tuple<T extends ArrayType> implements ITuple<T> {
-    private readonly values;
-    constructor(values: T);
-    map<U extends ArrayType>(f: (value: T) => U): Tuple<U>;
-    flatMap<U extends ArrayType>(f: (value: T) => Tuple<U>): Tuple<U>;
-    get(index: number): T[number];
-    getAs<U>(index: number, f?: (item: T) => boolean): U;
-    toArray(): T;
-}
-
-interface ITuple<T extends ArrayType> extends IArrayFunctor<T> {
-    get(index: number): T[number];
-    getAs<U>(index: number, f?: (item: T) => boolean): U;
-    map<U extends any[]>(f: (value: T) => U): ITuple<U>;
-    flatMap<U extends any[]>(f: (value: T) => ITuple<U>): ITuple<U>;
-}
-
-declare class Map<K, V> implements IMap<K, V> {
-    private internalMap;
-    constructor(entries?: [K, V][]);
-    add(item: K): Map<K, V>;
-    remove(value: ITuple<[K, V]>): Map<K, V>;
-    contains(value: ITuple<[K, V]>): boolean;
-    get size(): number;
-    map<U extends Type>(f: (value: V) => U): IMap<K, U>;
-    flatMap<U extends Type>(f: (value: V) => IMap<K, U>): IMap<K, U>;
-    reduce<U extends ITuple<[K, V]>>(f: (acc: U, value: ITuple<[K, V]>) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: ITuple<[K, V]>) => U): U;
-    foldRight<U>(initialValue: U, f: (value: ITuple<[K, V]>, acc: U) => U): U;
-    get(key: K): Option<V>;
-    getOrElse(key: K, defaultValue: V): V;
-    get isEmpty(): boolean;
-    orElse(key: K, alternative: Option<V>): Option<V>;
-}
-
-interface IMap<K, V> extends IFunctor<ITuple<[K, V]>>, ITraversable<ITuple<[K, V]>> {
-    map<U>(f: (value: any) => U): IMap<K, U>;
-    flatMap<U>(f: (value: any) => IMap<K, U>): IMap<K, U>;
-    reduce<U extends ITuple<[K, V]>>(f: (acc: U, value: ITuple<[K, V]>) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: ITuple<[K, V]>) => U): U;
-    foldRight<U>(initialValue: U, f: (value: ITuple<[K, V]>, acc: U) => U): U;
-    get(key: K): Option<V>;
-    getOrElse(key: K, defaultValue: V): V;
-    orElse(key: K, alternative: Option<V>): Option<V>;
-}
-
-declare class Set<T> implements ISet<T>, ICollection<T> {
-    private readonly internalSet;
-    constructor(iterable?: Iterable<T>);
-    add(value: T): Set<T>;
-    remove(value: T): Set<T>;
-    contains(value: T): boolean;
-    get size(): number;
-    get isEmpty(): boolean;
-    map<U>(f: (value: T) => U): ISet<U>;
-    flatMap<U>(f: (value: T) => ISet<U>): ISet<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    has(value: T): boolean;
-}
-
-interface ISet<T> extends IFunctor<T> {
-    map<U>(f: (value: T) => U): ISet<U>;
-    flatMap<U>(f: (value: T) => ISet<U>): ISet<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    has(value: T): boolean;
-}
-
-type SingleType = any;
-type ArrayType = SingleType[];
-type Type = SingleType | ArrayType;
-interface AbstractFunctor<T extends Type> {
-    map(f: (value: T) => Type): AbstractFunctor<Type>;
-    flatMap(f: (value: T) => AbstractFunctor<Type>): AbstractFunctor<Type>;
-}
-interface IFunctor<T extends Type> extends AbstractFunctor<T> {
-    map<U extends Type>(f: (value: T) => U): IFunctor<U>;
-    flatMap<U extends Type>(f: (value: T) => IFunctor<U>): IFunctor<U>;
-}
-interface IArrayFunctor<T extends ArrayType> extends AbstractFunctor<T> {
-    map<U extends ArrayType>(f: (value: T) => U): IArrayFunctor<U>;
-    flatMap<U extends ArrayType>(f: (value: T) => IArrayFunctor<U>): IArrayFunctor<U>;
-}
-interface ITraversable<T extends Type> extends IFunctor<T> {
-    get size(): number;
-    get isEmpty(): boolean;
-    contains(value: T): boolean;
-    reduce<U extends T>(f: (acc: U, value: T) => U): U;
-    foldLeft<U extends Type>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U extends Type>(initialValue: U, f: (value: T, acc: U) => U): U;
-}
-interface ICollection<T extends Type> extends ITraversable<T> {
-    add(value: T): ITraversable<T>;
-    remove(value: T): ITraversable<T>;
-}
-
-export { AbstractFunctor, ArrayType, Either, IArrayFunctor, ICollection, IFunctor, IList, IMap, ISet, ITraversable, ITuple, Left, List, Map, None, Option, Right, Set, SingleType, Some, Tuple, Type, left, list, none, option, parseNumber, right, some };
+export { ArrayType, IAbstractFunctor, IArrayFunctor, IFunctor, SingleType, Type } from './functor/index.mjs';
+export { E as Either, I as IIterable, f as IList, g as IMap, b as ISet, k as ITraversable, j as ITry, h as Left, L as List, M as Map, N as None, O as Option, R as Right, a as Seq, c as Set, S as Some, T as Try, i as left, l as list, n as none, o as option, r as right, s as some } from './index-5f972212.js';
+export { ITuple, Tuple } from './tuple/Tuple.mjs';

package/dist/index.d.ts

@@ -1,212 +1,3 @@
-import { ParseError } from './error/ParseError.js';
-
-declare class Left<L, R> implements Either<L, R> {
-    value: L;
-    constructor(value: L);
-    isLeft(): this is Left<L, R>;
-    isRight(): this is Right<L, R>;
-    map<U>(_f: (value: R) => U): Either<L, U>;
-    flatMap<U>(_f: (value: R) => Either<L, U>): Either<L, U>;
-    toOption(): Option<R>;
-    toList(): List<R>;
-}
-
-declare class Right<L, R> implements Either<L, R> {
-    value: R;
-    constructor(value: R);
-    isLeft(): this is Left<L, R>;
-    isRight(): this is Right<L, R>;
-    map<U>(f: (value: R) => U): Either<L, U>;
-    flatMap<U>(f: (value: R) => Either<L, U>): Either<L, U>;
-    toOption(): Option<R>;
-    toList(): List<R>;
-}
-
-interface Either<L, R> extends IFunctor<R> {
-    value: L | R;
-    isLeft(): this is Left<L, R>;
-    isRight(): this is Right<L, R>;
-    map<U>(f: (value: R) => U): Either<L, U>;
-    flatMap<U>(f: (value: R) => Either<L, U>): Either<L, U>;
-    toOption(): Option<R>;
-    toList(): List<R>;
-}
-declare const left: <L, R>(value: L) => Either<L, R>;
-declare const right: <L, R>(value: R) => Either<L, R>;
-declare const parseNumber: (input: string) => Either<ParseError, number>;
-
-declare class Some<T extends Type> implements Option<T> {
-    private value;
-    constructor(value: T);
-    get isEmpty(): boolean;
-    get(): T;
-    getOrElse(defaultValue: T): T;
-    orElse(alternative: Option<T>): Option<T>;
-    map<U extends Type>(f: (value: T) => U): Option<U>;
-    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    toList(): List<T>;
-    contains(value: T): boolean;
-    get size(): number;
-}
-
-declare class None<T extends Type> implements Option<T> {
-    get isEmpty(): boolean;
-    get(): T;
-    getOrElse(defaultValue: T): T;
-    orElse(alternative: Option<T>): Option<T>;
-    map<U extends Type>(f: (value: T) => U): Option<U>;
-    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    toList(): List<T>;
-    contains(value: T): boolean;
-    get size(): number;
-}
-
-interface Option<T extends Type> extends IFunctor<T>, ITraversable<T> {
-    get(): T;
-    getOrElse(defaultValue: T): T;
-    orElse(alternative: Option<T>): Option<T>;
-    map<U extends Type>(f: (value: T) => U): Option<U>;
-    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
-    toList(): List<T>;
-}
-declare const option: <T extends unknown>(value?: T | undefined) => Option<T>;
-declare const some: <T extends unknown>(value: T) => Option<T>;
-declare const none: <T extends unknown>() => Option<T>;
-
-declare class List<T> implements IList<T> {
-    private readonly items;
-    constructor(iterable?: Iterable<T>);
-    readonly [n: number]: T;
-    remove(value: T): List<T>;
-    contains(value: T): boolean;
-    get size(): number;
-    get isEmpty(): boolean;
-    get length(): number;
-    add(item: T): List<T>;
-    removeAt(index: number): List<T>;
-    get(index: number): Option<T>;
-    toArray(): readonly T[];
-    map<U>(f: (value: T) => U): List<U>;
-    flatMap<U>(f: (value: T) => List<U>): List<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    concat(other: List<T>): List<T>;
-    toString(): string;
-}
-
-interface IList<T extends Type> extends IFunctor<T>, ICollection<T>, ArrayLike<T> {
-    map<U extends Type>(f: (value: T) => U): IList<U>;
-    flatMap<U extends Type>(f: (value: T) => IList<U>): IList<U>;
-    reduce<U extends Type>(f: (acc: U, value: T) => U): U;
-    foldLeft<U extends Type>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U extends Type>(initialValue: U, f: (value: T, acc: U) => U): U;
-}
-declare const list: <T extends unknown>(items: T[] | undefined) => List<T>;
-
-declare class Tuple<T extends ArrayType> implements ITuple<T> {
-    private readonly values;
-    constructor(values: T);
-    map<U extends ArrayType>(f: (value: T) => U): Tuple<U>;
-    flatMap<U extends ArrayType>(f: (value: T) => Tuple<U>): Tuple<U>;
-    get(index: number): T[number];
-    getAs<U>(index: number, f?: (item: T) => boolean): U;
-    toArray(): T;
-}
-
-interface ITuple<T extends ArrayType> extends IArrayFunctor<T> {
-    get(index: number): T[number];
-    getAs<U>(index: number, f?: (item: T) => boolean): U;
-    map<U extends any[]>(f: (value: T) => U): ITuple<U>;
-    flatMap<U extends any[]>(f: (value: T) => ITuple<U>): ITuple<U>;
-}
-
-declare class Map<K, V> implements IMap<K, V> {
-    private internalMap;
-    constructor(entries?: [K, V][]);
-    add(item: K): Map<K, V>;
-    remove(value: ITuple<[K, V]>): Map<K, V>;
-    contains(value: ITuple<[K, V]>): boolean;
-    get size(): number;
-    map<U extends Type>(f: (value: V) => U): IMap<K, U>;
-    flatMap<U extends Type>(f: (value: V) => IMap<K, U>): IMap<K, U>;
-    reduce<U extends ITuple<[K, V]>>(f: (acc: U, value: ITuple<[K, V]>) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: ITuple<[K, V]>) => U): U;
-    foldRight<U>(initialValue: U, f: (value: ITuple<[K, V]>, acc: U) => U): U;
-    get(key: K): Option<V>;
-    getOrElse(key: K, defaultValue: V): V;
-    get isEmpty(): boolean;
-    orElse(key: K, alternative: Option<V>): Option<V>;
-}
-
-interface IMap<K, V> extends IFunctor<ITuple<[K, V]>>, ITraversable<ITuple<[K, V]>> {
-    map<U>(f: (value: any) => U): IMap<K, U>;
-    flatMap<U>(f: (value: any) => IMap<K, U>): IMap<K, U>;
-    reduce<U extends ITuple<[K, V]>>(f: (acc: U, value: ITuple<[K, V]>) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: ITuple<[K, V]>) => U): U;
-    foldRight<U>(initialValue: U, f: (value: ITuple<[K, V]>, acc: U) => U): U;
-    get(key: K): Option<V>;
-    getOrElse(key: K, defaultValue: V): V;
-    orElse(key: K, alternative: Option<V>): Option<V>;
-}
-
-declare class Set<T> implements ISet<T>, ICollection<T> {
-    private readonly internalSet;
-    constructor(iterable?: Iterable<T>);
-    add(value: T): Set<T>;
-    remove(value: T): Set<T>;
-    contains(value: T): boolean;
-    get size(): number;
-    get isEmpty(): boolean;
-    map<U>(f: (value: T) => U): ISet<U>;
-    flatMap<U>(f: (value: T) => ISet<U>): ISet<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    has(value: T): boolean;
-}
-
-interface ISet<T> extends IFunctor<T> {
-    map<U>(f: (value: T) => U): ISet<U>;
-    flatMap<U>(f: (value: T) => ISet<U>): ISet<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<U>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U>(initialValue: U, f: (value: T, acc: U) => U): U;
-    has(value: T): boolean;
-}
-
-type SingleType = any;
-type ArrayType = SingleType[];
-type Type = SingleType | ArrayType;
-interface AbstractFunctor<T extends Type> {
-    map(f: (value: T) => Type): AbstractFunctor<Type>;
-    flatMap(f: (value: T) => AbstractFunctor<Type>): AbstractFunctor<Type>;
-}
-interface IFunctor<T extends Type> extends AbstractFunctor<T> {
-    map<U extends Type>(f: (value: T) => U): IFunctor<U>;
-    flatMap<U extends Type>(f: (value: T) => IFunctor<U>): IFunctor<U>;
-}
-interface IArrayFunctor<T extends ArrayType> extends AbstractFunctor<T> {
-    map<U extends ArrayType>(f: (value: T) => U): IArrayFunctor<U>;
-    flatMap<U extends ArrayType>(f: (value: T) => IArrayFunctor<U>): IArrayFunctor<U>;
-}
-interface ITraversable<T extends Type> extends IFunctor<T> {
-    get size(): number;
-    get isEmpty(): boolean;
-    contains(value: T): boolean;
-    reduce<U extends T>(f: (acc: U, value: T) => U): U;
-    foldLeft<U extends Type>(initialValue: U, f: (acc: U, value: T) => U): U;
-    foldRight<U extends Type>(initialValue: U, f: (value: T, acc: U) => U): U;
-}
-interface ICollection<T extends Type> extends ITraversable<T> {
-    add(value: T): ITraversable<T>;
-    remove(value: T): ITraversable<T>;
-}
-
-export { AbstractFunctor, ArrayType, Either, IArrayFunctor, ICollection, IFunctor, IList, IMap, ISet, ITraversable, ITuple, Left, List, Map, None, Option, Right, Set, SingleType, Some, Tuple, Type, left, list, none, option, parseNumber, right, some };
+export { ArrayType, IAbstractFunctor, IArrayFunctor, IFunctor, SingleType, Type } from './functor/index.js';
+export { E as Either, I as IIterable, f as IList, g as IMap, b as ISet, k as ITraversable, j as ITry, h as Left, L as List, M as Map, N as None, O as Option, R as Right, a as Seq, c as Set, S as Some, T as Try, i as left, l as list, n as none, o as option, r as right, s as some } from './index-3866f956.js';
+export { ITuple, Tuple } from './tuple/Tuple.js';

package/dist/index.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk7XCWDOMWjs = require('./chunk-7XCWDOMW.js');require('./chunk-DOG6HMTN.js');var _chunkXNAZ5QU3js = require('./chunk-XNAZ5QU3.js');require('./chunk-3VJERXBP.js');require('./chunk-ZTL76QDL.js');require('./chunk-ZOH672YH.js');var _chunk7VFL33KHjs = require('./chunk-7VFL33KH.js');require('./chunk-5VTXJIR3.js');require('./chunk-TVZBBVEV.js');var _chunkSSP26X5Yjs = require('./chunk-SSP26X5Y.js');var _chunkWY62QD3Cjs = require('./chunk-WY62QD3C.js');require('./chunk-VTKL7OQI.js');exports.Left = _chunk7XCWDOMWjs.a; exports.List = _chunkWY62QD3Cjs.f; exports.Map = _chunk7VFL33KHjs.a; exports.None = _chunkWY62QD3Cjs.b; exports.Right = _chunk7XCWDOMWjs.b; exports.Set = _chunkXNAZ5QU3js.a; exports.Some = _chunkWY62QD3Cjs.a; exports.Tuple = _chunkSSP26X5Yjs.a; exports.left = _chunk7XCWDOMWjs.c; exports.list = _chunkWY62QD3Cjs.g; exports.none = _chunkWY62QD3Cjs.e; exports.option = _chunkWY62QD3Cjs.c; exports.parseNumber = _chunk7XCWDOMWjs.e; exports.right = _chunk7XCWDOMWjs.d; exports.some = _chunkWY62QD3Cjs.d;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-6BEXQNLZ.js');var _chunk3RJPXVXEjs = require('./chunk-3RJPXVXE.js');require('./chunk-ZOH672YH.js');var _chunk5DQWEDA3js = require('./chunk-5DQWEDA3.js');require('./chunk-TVZBBVEV.js');var _chunkFQY6BMNGjs = require('./chunk-FQY6BMNG.js');require('./chunk-5VTXJIR3.js');var _chunkBYPZZZTGjs = require('./chunk-BYPZZZTG.js');var _chunkBFK2RZ2Zjs = require('./chunk-BFK2RZ2Z.js');var _chunkSDHW57XQjs = require('./chunk-SDHW57XQ.js');require('./chunk-3VJERXBP.js');require('./chunk-XORABVON.js');require('./chunk-XVHCBGUW.js');var _chunkZTTAUZK3js = require('./chunk-ZTTAUZK3.js');require('./chunk-BNNK42JC.js');require('./chunk-VTKL7OQI.js');exports.Left = _chunkBFK2RZ2Zjs.b; exports.List = _chunkSDHW57XQjs.b; exports.Map = _chunk5DQWEDA3js.a; exports.None = _chunkZTTAUZK3js.b; exports.Right = _chunkBFK2RZ2Zjs.a; exports.Seq = _chunkZTTAUZK3js.f; exports.Set = _chunkSDHW57XQjs.a; exports.Some = _chunkZTTAUZK3js.a; exports.Try = _chunk3RJPXVXEjs.a; exports.Tuple = _chunkFQY6BMNGjs.a; exports.left = _chunkBYPZZZTGjs.a; exports.list = _chunkSDHW57XQjs.c; exports.none = _chunkZTTAUZK3js.e; exports.option = _chunkZTTAUZK3js.c; exports.right = _chunkBYPZZZTGjs.b; exports.some = _chunkZTTAUZK3js.d;

package/dist/index.mjs

@@ -1 +1 @@
-import{a,b,c,d,e}from"./chunk-VWFTFPZB.mjs";import"./chunk-72IAI5F4.mjs";import{a as o}from"./chunk-U237FVPP.mjs";import"./chunk-HA5XD5KC.mjs";import"./chunk-CFYIJKWF.mjs";import"./chunk-3OHJLCSR.mjs";import{a as n}from"./chunk-PKWOSOD7.mjs";import"./chunk-377WQNCB.mjs";import"./chunk-LBQXRIXP.mjs";import{a as m}from"./chunk-VM6KG6UB.mjs";import{a as f,b as g,c as h,d as i,e as j,f as k,g as l}from"./chunk-CZKHN2SM.mjs";import"./chunk-U5EUM74A.mjs";export{a as Left,k as List,n as Map,g as None,b as Right,o as Set,f as Some,m as Tuple,c as left,l as list,j as none,h as option,e as parseNumber,d as right,i as some};
+import"./chunk-Q4H3PCBH.mjs";import{a as d}from"./chunk-TAJ6OYCN.mjs";import"./chunk-3OHJLCSR.mjs";import{a as n}from"./chunk-DP5G2LT6.mjs";import"./chunk-LBQXRIXP.mjs";import{a}from"./chunk-RMQF6I4T.mjs";import"./chunk-377WQNCB.mjs";import{a as i,b as c}from"./chunk-DFWZ7ANA.mjs";import{a as B,b}from"./chunk-LGUIG2RX.mjs";import{a as m,b as A,c as x}from"./chunk-6RUUD24R.mjs";import"./chunk-HA5XD5KC.mjs";import"./chunk-V2J3R5IU.mjs";import"./chunk-74TKYQJS.mjs";import{a as e,b as o,c as r,d as t,e as f,f as p}from"./chunk-X52Z6M5P.mjs";import"./chunk-RRAIFS3D.mjs";import"./chunk-U5EUM74A.mjs";export{b as Left,A as List,n as Map,o as None,B as Right,p as Seq,m as Set,e as Some,d as Try,a as Tuple,i as left,x as list,f as none,r as option,c as right,t as some};