typecat/lib/index.d.ts

A tiny functional programming library for TypeScript that provides Option (Some/None) and Either(Left/Right) with functor map, applicative map and monad flatmap

export declare const id: (a: any) => any;
export interface Functor<T> {
    fmap<S>(f: (a: T) => S): Functor<S>;
}
export interface Applicative<T> extends Functor<T> {
    applyMap(a: Applicative<T>): Applicative<any>;
}
export interface Monad<T> extends Applicative<T> {
    flatMap<S>(f: (a: T) => Monad<S>): Monad<S>;
}
export declare abstract class Option<T> implements Monad<T> {
    abstract _value?: T;
    abstract fmap<S>(f: (a: T) => S): Option<S>;
    abstract applyMap(a: Option<T>): Option<any>;
    abstract flatMap<S>(f: (a: T) => Option<S>): Option<S>;
    abstract [Symbol.iterator](): IterableIterator<T>;
    abstract get(): T;
    abstract getOrElse(defaultValue: T): T;
}
export declare class Some<T> extends Option<T> {
    _value?: T;
    constructor(a: T);
    fmap<S>(f: (a: T) => S): Some<S>;
    applyMap(a: Option<any>): Option<any>;
    flatMap<S>(f: (a: T) => Option<S>): Option<S>;
    get(): T;
    getOrElse(defaultValue: T): T;
    [Symbol.iterator](): IterableIterator<T>;
}
export declare class None<T = any> extends Option<T> {
    _value?: T;
    constructor();
    fmap<S>(f: any): Some<S>;
    applyMap(a: any): Option<any>;
    flatMap(f: any): Option<any>;
    get(): T;
    getOrElse(defaultValue: T): T;
    [Symbol.iterator](): IterableIterator<T>;
}
export declare abstract class Either<T, S> implements Monad<S> {
    abstract _left?: T;
    abstract _right?: S;
    abstract fmap<U>(f: (a: S) => U): Either<T, U>;
    abstract applyMap(a: Either<T, any>): Either<T, any>;
    abstract flatMap<U>(f: (a: S) => Either<T, U>): Either<T, U>;
    abstract [Symbol.iterator](): IterableIterator<S>;
    abstract get(): S;
    abstract getOrElse(defaultValue: S): S;
    abstract getLeft(): T;
    abstract getLeftOrElse(defaultValue: T): T;
}
export declare class Left<T, S = any> extends Either<T, S> {
    _left?: T;
    _right?: S;
    constructor(a: T);
    fmap<U>(f: any): Either<T, any>;
    applyMap(f: any): Either<T, any>;
    flatMap<U>(f: any): Either<T, U>;
    get(): S;
    getOrElse(defaultValue: S): S;
    getLeft(): T;
    getLeftOrElse(defaultValue: T): T;
    [Symbol.iterator](): IterableIterator<any>;
}
export declare class Right<S> extends Either<any, S> {
    _left?: any;
    _right?: S;
    constructor(a: S);
    fmap<U>(f: (a: S) => U): Either<any, U>;
    applyMap(a: Either<any, any>): Either<any, any>;
    flatMap<U>(f: (a: S) => Either<any, U>): Either<any, U>;
    get(): S;
    getOrElse(defaultValue: S): S;
    getLeft(): any;
    getLeftOrElse(defaultValue: any): any;
    [Symbol.iterator](): IterableIterator<S>;
}