foop/typings/FantasyLand.d.ts

interfaces that describe their intentions.

// Fantasyland export interfaces

// TODO: incorporate generalized inheritance e.g.: `<U extends
// Applicative, V extends FantasyTraversable>`; possibly needs [rank 2
// polymorphism](https://github.com/Microsoft/TypeScript/issues/1213).

import {Primitive} from './generic'

export interface Setoid<T> {
    equals(b: Setoid<T>): boolean;
}

export interface Semigroup<T> {
    concat(b: Semigroup<T>): Semigroup<T>;
}

export interface Monoid<T> extends Semigroup<T> {
    /* static */ empty<T>(): Monoid<T>;
}

export interface Functor<T> {
    map<U>(fn: (t: T) => U): Functor<U>;
}

export interface Apply<T> extends Functor<T> {
    apply<U>(fn: Apply<(t: T) => U>): Apply<U>;
}

export interface Applicative<T> extends Apply<T> {
    /* static */ of<U>(a: U): Applicative<U>;
}

export interface Alt<T> extends Functor<T> {
    alt(b: T): Alt<T>;
}

export interface Plus<T> extends Alt<T> {
    /* static */ zero<T>(): Plus<T>;
}

export interface Alternative<T> extends Plus<T>, Applicative<T> {
}

/**
 * Generate a function that accepts a number of arguments.
 */
export function nary <U> (length: 0, fn: () => U): () => U
export function nary <T, U> (length: 1, fn: (arg: T) => U): (arg: T) => U
export function nary <T1, T2, U> (length: 2, fn: (arg1: T1, arg2: T2) => U): (arg1: T1, arg2: T2) => U
export function nary <T1, T2, T3, U> (length: 3, fn: (arg1: T1, arg2: T2, arg3: T3) => U): (arg1: T1, arg2: T2, arg3: T3) => U
export function nary <T1, T2, T3, T4, U> (length: 4, fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => U): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => U
export function nary <T1, T2, T3, T4, T5, U> (length: 5, fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => U): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => U
export function nary <T1, T2, T3, T4, T5, T6, U> (length: 6, fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => U): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => U
export function nary <TAll, U> (length: number, fn: (args: TAll[]) => U): (args: TAll[]) => U
export function nary (length: number, fn: (...args: any[]) => any): (...args: any[]) => any {
}

export interface Foldable<T> {
    reduce<U>(fn: (u: U, t: T) => U, u: U): U;
}

export interface FantasyTraversable<T> extends Functor<T>, Foldable<T> {
    traverse<U, V>(fn: (t: T) => Applicative<U>, of: (v: V) => Applicative<V>): Applicative<FantasyTraversable<U>>;
}

export interface FantasyChain<T> extends Apply<T> {
    chain<U>(fn: (t: T) => FantasyChain<U>): FantasyChain<U>;
}

export interface FantasyChainRec<T> extends FantasyChain<T> {
    /* static */ chainRec<A,B,C>(f: (next: (a: A) => C, done: (b: B) => C, value: A) => FantasyChainRec<C>, i: A): FantasyChainRec<B>;
}

export interface Monad<T> extends Applicative<T>, FantasyChain<T> {
}

export interface Extend<T> {
    extend<U>(f: (v: Extend<T>) => U): Extend<U>;
}

export interface Comonad<T> extends Functor<T>, Extend<T> {
    extract<U>(): U; // 'same U as in extend's f -- how to bind?
}

export interface Bifunctor<T,U> extends Functor<T> /*, Functor<U>*/ {
    bimap<B,D>(f: (v: T) => B, g: (v: U) => D): Bifunctor<B,D>;
}

export interface Profunctor<T,U> extends Functor<T> /*, Functor<U>*/ {
    promap<B,D>(f: (v: T) => B, g: (v: U) => D): Profunctor<B,D>;
}

// simple types

type Index = string | number;
// type Primitive = string | number | boolean;
type Ord = string | number | boolean | Date;

export interface Dictionary<T> {
    [index: string]: T;
}

type ObjF<T> = Dictionary<T>;
type List<T> = T[] | ArrayLike<T>;
type StringLike = string | StringRepresentable<string>;
type Prop = Index | StringRepresentable<Index>;
type Path = List<Prop>;
type Struct<T> = ObjF<T> | List<T>;
type AccOpts<T,U> = List<any>|ObjF<any>|Transformer<T, U, U>;
type Pred<T> = (v: T) => boolean;
type ObjFPred<T> = (value: T, key: string) => boolean;

// Ramda export interfaces

export interface Type<T> extends Function {
    new (...args: any[]): T;
}

export interface Variadic<T> {
    (...args: any[]): T;
}

export interface KeyValuePair<K, V> extends Array<K | V> { 0 : K; 1 : V; }

export interface Transformer<T, Acc, Res> {
    step: (acc: Acc, v: T) => Acc;
    init: () => Acc;
    result: (acc: Acc) => Res; // = R.identity
}

export interface NumericDictionary<T> {
    [index: number]: T;
}

export interface StringRepresentable<T> {
    toString(): T;
}

export interface NestedObj<T> {
    [index: string]: T|NestedObj<T>;
}

// export interface RecursiveArray<T> extends Array<T|RecursiveArray<T>> {}
// export interface ListOfRecursiveArraysOrValues<T> extends List<T|RecursiveArray<T>> {}
export interface NestedArray <T> {
  [index: number]: T | NestedArray<T>;
  length: number;
}