functype 0.2.1 → 0.4.0

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

@@ -1,227 +0,0 @@
-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 };