GeezerVison

function emptyArray<T>(): T[] {
    return [];
}

let a1: string[] = emptyArray();  // string inferred for T
let a2: number[] = emptyArray();  // number inferred for T

function arrayFilter<T>(f: (x: T) => boolean): (a: T[]) => T[] {
    return a => a.filter(f);
}

function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[] {
    return a => a.map(f);
}

function compose<A, B, C>(f: (x: A) => B, g: (x: B) => C): (x: A) => C {
    return x => g(f(x));
}

const positives: (a: number[]) => number[] = arrayFilter(x => x >= 0);
const lengths: (a: string[]) => number[] = arrayMap(s => s.length);
const evenLengths: (a: string[]) => number[] =
    compose(arrayMap(s => s.length), arrayFilter(x => x % 2 === 0));

let a1 = positives([1, 2, -3, 4, -5]);            // [1, 2, 4]
let a2 = lengths(['a', 'bb', 'ccc', 'dddd']);     // [1, 2, 3]
let a3 = evenLengths(['a', 'bb', 'ccc', 'dddd']); // [2, 4]

function filter<T>(a: T[], f: (x: T) => boolean): T[] {
    return a.filter(f);
}

let a: Object[] = filter(['a', 'bb', 'ccc', 'dddd'], s => s.length > 2);

const wrapper = compose(x => [x], y => ({ p: y }));  // (x: {}) => { p: {}[] }