ramda-tests.ts

import * as R from './ramda';

var double = function(x: number): number {
    return x + x
};

var shout = function(x: number): string {
    return x >= 10
        ? 'big'
        : 'small'
};

class F {
    x = 'X';
    y = 'Y';
}
class F2 {
    a = 100;
    y = 1;
    x(){};
    z() {};
}

(() => {
    var x: boolean;
    x = R.isArrayLike('a');
    x = R.isArrayLike([1,2,3]);
    x = R.isArrayLike([]);
});

(() => {
    R.propIs(Number, 'x', {x: 1, y: 2});  //=> true
    R.propIs(Number, 'x')({x: 1, y: 2});  //=> true
    R.propIs(Number)('x', {x: 1, y: 2});  //=> true
    R.propIs(Number)('x')({x: 1, y: 2});  //=> true
    R.propIs(Number, 'x', {x: 'foo'});    //=> false
    R.propIs(Number, 'x', {});            //=> false
});

(() => {
    R.type({}); //=> "Object"
    R.type(1); //=> "Number"
    R.type(false); //=> "Boolean"
    R.type('s'); //=> "String"
    R.type(null); //=> "Null"
    R.type([]); //=> "Array"
    R.type(/[A-z]/); //=> "RegExp"
});

() => {
    var takesNoArg = function() { return true; };
    var takesOneArg = function(a: number) { return [a]; };
    var takesTwoArgs = function(a: number, b: number) { return [a, b]; };
    var takesThreeArgs = function(a: number, b: number, c: number) { return [a, b, c]; };

    var addFourNumbers = function(a: number, b: number, c: number, d: number): number {
      return a + b + c + d;
    };

    var x1: Function = R.curry(addFourNumbers)
    // because of the current way of currying, the following call results in a type error
    // var x2: Function = R.curry(addFourNumbers)(1,2,4)
    var x3: Function = R.curry(addFourNumbers)(1)(2)
    var x4: Function = R.curry(addFourNumbers)(1)(2)(3)
    var y1: number = R.curry(addFourNumbers)(1)(2)(3)(4)
    var y2: number = R.curry(addFourNumbers)(1,2)(3,4)
    var y3: number = R.curry(addFourNumbers)(1,2,3)(4)

    R.nAry(0, takesNoArg);
    R.nAry(0, takesOneArg);
    R.nAry(1, takesTwoArgs);
    R.nAry(1, takesThreeArgs);

    var u1: {(a: any): any} = R.unary(takesOneArg);
    var u2: {(a: any): any} = R.unary(takesTwoArgs);
    var u3: {(a: any): any} = R.unary(takesThreeArgs);

    R.binary(takesTwoArgs);
    R.binary(takesThreeArgs);

    var addTwoNumbers = function(a:number, b:number) { return a + b; }
    var addTwoNumbersCurried = R.curry(addTwoNumbers);

    var inc = addTwoNumbersCurried(1);
    var z1:number = inc(2);
    var z2:number = addTwoNumbersCurried(2,3);
}

() => {
    const addFour = (a:number) => (b:number) => (c:number) => (d:number) => a + b + c + d;
    const uncurriedAddFour = R.uncurryN<number>(4, addFour);
    const res: number = uncurriedAddFour(1, 2, 3, 4); //=> 10
}

() => {
    // coerceArray :: (a|[a]) -> [a]
    const coerceArray = R.unless(R.isArrayLike, R.of);
    const a: number[] = coerceArray([1, 2, 3]); //=> [1, 2, 3]
    const b: number[] = coerceArray(1);         //=> [1]
}

(() => {
    R.nthArg(1)('a', 'b', 'c'); //=> 'b'
    R.nthArg(-1)('a', 'b', 'c'); //=> 'c'
});

() => {
    const fn: (...args: string[])=>string = R.unapply(JSON.stringify);
    const res: string = R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'
}

() => {
    const a: number = R.until(R.flip(R.gt)(100), R.multiply(2))(1) // => 128
}

() => {
    const truncate = R.when(
        R.propSatisfies(R.flip(R.gt)(10), 'length'),
        R.pipe(R.take(10), R.append('…'), R.join(''))
    );
    const a: string = truncate('12345');         //=> '12345'
    const b: string = truncate('0123456789ABC'); //=> '0123456789…'
}

/* compose */
() => {
    var double = function(x: number): number {
        return x + x
    }
    var limit10 = function(x: number): boolean {
        return x >= 10
    }
    var func: (x: number) => boolean = R.compose(limit10, double)
    var res: boolean = R.compose(limit10, double)(10)

    const f0 = (s: string) => +s;      // string -> number
    const f1 = (n: number) => n === 1; // number -> boolean
    const f2 = R.compose(f1, f0);      // string -> boolean

    // akward example that bounces types between number and string
    const g0 = (list: number[]) => R.map(R.inc, list);
    const g1 = R.dropWhile(R.gt(10));
    const g2 = R.map((i: number) => i > 5 ? 'bigger' : 'smaller');
    const g3 = R.all((i: string) => i === 'smaller');
    const g = R.compose(g3, g2, g1, g0);
    const g_res: boolean = g([1, 2, 10, 13]);
}

/* pipe */
() => {
    var func: (x: number) => string = R.pipe(double, double, shout)
    var res: string = R.pipe(double, double, shout)(10);

    const capitalize = (str: string) => R.pipe(
        R.split(''),
        R.adjust(R.toUpper, 0),
        R.join('')
    )(str);

    var f = R.pipe(Math.pow, R.negate, R.inc);
    var fr: number = f(3, 4); // -(3^4) + 1
}

() => {
    R.invoker('charAt', String.prototype);
    R.invoker('charAt', String.prototype, 1);
}

(() => {
    const range = R.juxt([Math.min, Math.max]);
    range(3, 4, 9, -3); //=> [-3, 9]

    const chopped = R.juxt([R.head, R.last]);
    chopped('longstring'); // => ["l", "g"]
});

var square = function(x: number) { return x * x; };
var add = function(a: number, b: number) { return a + b; };
// Adds any number of arguments together
var addAll = function() {
  return 0;
};

// Basic example
R.useWith(addAll, [ double, square ]);

(() => {
  var printXPlusFive = function(x: number) { console.log(x + 5); };
  R.forEach(printXPlusFive, [1, 2, 3]);
  R.clone([{},{},{}])
  R.clone([1,2,3]);
})();

// (() => {
//   var printXPlusFive = function(x, i) { console.log(i + 5); };
//   R.forEach.idx(printXPlusFive, [{name: 1}, {name: 2}, {name: 3}]);
// })();

var i = function(x: number) {return x;};
R.times(i, 5);

(() => {
  var triple = function(x: number): number { return x * 3; };
  var square = function(x: number): number { return x * x; };
  var squareThenDoubleThenTriple = R.pipe(square, double, triple);
  squareThenDoubleThenTriple(5); //=> 150


})();

(() => {
    var multiply = function(a: number, b: number) { return a * b; };
    var double = R.partial(multiply, 2);
    double(2); //=> 4

    var greet = function(salutation: string, title: string, firstName: string, lastName: string) {
      return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';
    };
    var sayHello = R.partial(greet, 'Hello');
    var sayHelloToMs = R.partial(sayHello, 'Ms.');
    sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'

    var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');
    greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'
})();

(() => {
    var numberOfCalls = 0;
    var trackedAdd = function(a: number, b: number) {
      numberOfCalls += 1;
      return a + b;
    };
    var memoTrackedAdd = R.memoize(trackedAdd);

    memoTrackedAdd(1, 2); //=> 3
    numberOfCalls; //=> 1
    memoTrackedAdd(1, 2); //=> 3
    numberOfCalls; //=> 1
    memoTrackedAdd(2, 3); //=> 5
    numberOfCalls; //=> 2

    // Note that argument order matters
    memoTrackedAdd(2, 1); //=> 3
    numberOfCalls; //=> 3
})();

(() => {
    var addOneOnce = R.once(function(x: number){ return x + 1; });
    addOneOnce(10); //=> 11
    addOneOnce(addOneOnce(50)); //=> 11
})();

(() => {
    var slashify = R.wrap(R.flip(R.add)('/'), function(f: Function, x: string) {
      return R.match(/\/$/, x) ? x : f(x);
    });

    slashify('a');  //=> 'a/'
    slashify('a/'); //=> 'a/'
})();

() => {
    const a0: string[] = R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']
    const a1: string[] = R.match(/a/, 'b'); //=> []
    const a2: string[] = R.match(/a/, null); //=> TypeError: null does not have a method named "match"
}

(() => {
    var numbers = [1, 2, 3];
    var add = function(a: number, b: number) {
        return a + b
    };
    R.reduce(add, 10, numbers); //=> 16;
})();

(() => {
    var plus3 = R.add(3);
})();

(() => {
    var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];
    var flattenPairs = function(acc: [string, number], pair: [string, number]) {
      return acc.concat(pair);
    };
    R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]
})();

(() => {
    var values = { x: 1, y: 2, z: 3 };
    var prependKeyAndDouble = function(num: number, key: string, obj: any) {
        return key + (num * 2);
    };
    R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }
});

(() => {
    const a: number[] = R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]
    const b: number[][] = R.of([1]); //=> [[1]]
    const c: number[] = R.of(1);

});

() => {
    const a1 = R.empty([1,2,3,4,5]); //=> []
    const a2 = R.empty([1, 2, 3]);     //=> []
    const a3 = R.empty('unicorns');    //=> ''
    const a4 = R.empty({x: 1, y: 2});  //=> {}
}

(() => {
    R.length([1, 2, 3]); //=> 3
});

(() => {
    const isEven = function(n: number) {
        return n % 2 === 0;
    };
    const filterIndexed = R.addIndex(R.filter);

    R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]

    var lastTwo = function(val: number, idx: number, list: number[]) {
      return list.length - idx <= 2;
    };
    filterIndexed(lastTwo, [8, 6, 7, 5, 3, 0, 9]); //=> [0, 9]

    var isOdd = function(n: number) {
      return n % 2 === 1;
    };
    R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]
});
(() => {
    var isNotFour = function(x: number) {
      return !(x === 4);
    };
    R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]
    R.take(2, [1, 2, 3, 4]); //=> [1, 2]
});
(() => {
    var f = function(n: number) { return n > 50 ? false : [-n, n + 10] };
    let a = R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]
    let b = R.unfold(f); //=> [-10, -20, -30, -40, -50]
    let c = b(10);
});
/*****************************************************************
 * Function category
 */


 () => {
     var mergeThree = function(a: number, b: number, c: number): number[] {
       return ([]).concat(a, b, c);
     };
     mergeThree(1, 2, 3); //=> [1, 2, 3]
     var flipped = R.flip(mergeThree);
     flipped(1, 2, 3); //=> [2, 1, 3]
 }

/*********************
 * List category
 ********************/
() => {
    var lessThan2 = R.flip(R.lt)(2);
    var lessThan3 = R.flip(R.lt)(3);
    R.all(lessThan2)([1, 2]); //=> false
    R.all(lessThan3)([1, 2]); //=> true
}

() => {
    var lessThan0 = R.flip(R.lt)(0);
    var lessThan2 = R.flip(R.lt)(2);
    R.any(lessThan0)([1, 2]); //=> false
    R.any(lessThan2)([1, 2]); //=> true
}

() => {
    R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]
    R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
    R.aperture(7, [1, 2, 3, 4, 5]); //=> []
    R.aperture(7)([1, 2, 3, 4, 5]); //=> []
}

() => {
    R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']
    R.append('tests')(['write', 'more']); //=> ['write', 'more', 'tests']
    R.append('tests', []); //=> ['tests']
    R.append<string, string[]>(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]
    R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]
    R.append<string[]>(['tests'])(['write', 'more']); //=> ['write', 'more', ['tests']]
    R.append(['tests'])(['write', 'more']); //=> ['write', 'more', ['tests']]
}

() => {
    var duplicate = function(n: number) {
        return [n, n];
    };
    R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]
    R.chain(duplicate)([1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]
}

() => {
    R.clamp(1, 10, -1) // => 1
    R.clamp(1, 10)(11) // => 10
    R.clamp(1)(10, 4)  // => 4
    R.clamp('a', 'd', 'e')  // => 'd'
}

() => {
    R.concat([], []); //=> []
    R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
    R.concat([4, 5, 6])([1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
    R.concat('ABC')('DEF'); // 'ABCDEF'
}

() => {
    R.contains(3)([1, 2, 3]); //=> true
    R.contains(3, [1, 2, 3]); //=> true
    R.contains(4)([1, 2, 3]); //=> false
    R.contains({})([{}, {}]); //=> false
    var obj = {};
    R.contains(obj)([{}, obj, {}]); //=> true
}

() => {
    R.drop(3, [1,2,3,4,5,6,7]); //=> [4,5,6,7]
    R.drop(3)([1,2,3,4,5,6,7]); //=> [4,5,6,7]
    R.drop(3, 'ramda'); //=> 'ram'
    R.drop(3)('ramda'); //=> 'ram'
}

(() => {
    R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']
    R.dropLast(2)(['foo', 'bar', 'baz']); //=> ['foo']
    R.dropLast(3, 'ramda');               //=> 'ra'
    R.dropLast(3)('ramda');               //=> 'ra'
});

(() => {
    var lteThree = (x: number) => x <= 3;
    R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]
});

() => {
    var lteTwo = function(x: number) {
        return x <= 2;
    };
    R.dropWhile(lteTwo, [1, 2, 3, 4]); //=> [3, 4]
    R.dropWhile(lteTwo)([1, 2, 3, 4]); //=> [3, 4]
}

() => {
    var isEven = function(n: number) {
        return n % 2 === 0;
    };
    R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]
    var isEvenFn = R.filter(isEven);
    isEvenFn([1, 2, 3, 4]);
}

() => {
    var lastTwo = function(val: number, idx: number, list: number[]) {
        return list.length - idx <= 2;
    };
    var filterIndexed = R.addIndex(R.filter);

    filterIndexed(lastTwo, [8, 6, 7, 5, 3, 0, 9]); //=> [0, 9]
    var lastTwoFn = filterIndexed(lastTwo);
    lastTwoFn([8, 6, 7, 5, 3, 0, 9]);
}

() => {
    var xs = [{a: 1}, {a: 2}, {a: 3}];
    R.find(R.propEq('a', 2))(xs); //=> {a: 2}
    R.find(R.propEq('a', 4))(xs); //=> undefined
}

() => {
    
    type Task = {id: number}
    let tasks: Task[] = []
    const a = R.find(task => task.id === 1, tasks) // this works

    const f: (list: Task[]) => Task = R.find<Task>(task => task.id === 1)
    const b: Task = f(tasks) // this doesn't work works`
}

() => {
    type Task = {a: number}
    let xs = [{a: 1}, {a: 2}, {a: 3}];
    const a: (list: Task[]) => number = R.findIndex(R.propEq('a', 2))
    const b: number = a(xs); //=> 1
    R.findIndex(R.propEq('a', 4))(xs); //=> -1

    R.findIndex((x: number) => x === 1, [1, 2, 3]);
}

() => {
    let xs = [{a: 1, b: 0}, {a:1, b: 1}];
    R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}
    R.findLast(R.propEq('a', 4))(xs); //=> undefined
}

() => {
    let xs = [{a: 1, b: 0}, {a:1, b: 1}];
    R.findLastIndex(R.propEq('a', 1))(xs); //=> 1
    R.findLastIndex(R.propEq('a', 4))(xs); //=> -1
    R.findLastIndex((x: number) => x === 1, [1, 2, 3]);
}

() => {
    var user1 = { address: { zipCode: 90210 } };
    var user2 = { address: { zipCode: 55555 } };
    var user3 = { name: 'Bob' };
    var users = [ user1, user2, user3 ];
    var isFamous = R.pathEq(['address', 'zipCode'], 90210);
    const a = R.filter(isFamous, users); //=> [ user1 ]
}

() => {
    var xs: {[key:string]: string} = {a: '1', b: '0'};
    R.propEq('a', '1', xs);//=> true
    R.propEq('a', '4', xs); //=> false
}
() => {
    var xs: {[key:string]: number} = {a: 1, b: 0};
    R.propEq('a', 1, xs);//=> true
    R.propEq('a', 4, xs); //=> false
}
() => {
    var xs = {a: '1', b: '0'};
    R.propEq('a', '1', xs);//=> true
    R.propEq('a', '4', xs); //=> false
}
() => {
    var xs = {a: 1, b: 0};
    R.propEq('a', 1, xs);//=> true
    R.propEq('a', 4, xs); //=> false
}

interface Obj { a: number; b: number };
() => {
    var xs: Obj = {a: 1, b: 0};
    R.propEq('a', 1, xs);//=> true
    R.propEq('a', 4, xs); //=> false
}

() => {
    R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);
    //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
}

() => {
    var printXPlusFive = function(x: number) { console.log(x + 5); };
    R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]
    R.forEach(printXPlusFive)([1, 2, 3]); //=> [1, 2, 3]
    //-> 6
    //-> 7
    //-> 8
}

() => {
    var plusFive = function(num: number, idx: number, list: number[]) { list[idx] = num + 5 };
    R.addIndex(R.forEach)(plusFive)([1, 2, 3]); //=> [6, 7, 8]
}

() => {
    var byGrade = R.groupBy(function(student: {score: number; name: string}) {
        var score = student.score;
        return score < 65 ? 'F' :
        score < 70 ? 'D' :
        score < 80 ? 'C' :
        score < 90 ? 'B' : 'A';
    });
    var students = [{name: 'Abby', score: 84},
    {name: 'Eddy', score: 58},
    {name: 'Jack', score: 69}];
    byGrade(students);
}

() => {
    R.groupWith(R.equals, [0, 1, 1, 2, 3, 5, 8, 13, 21])
    // [[0], [1, 1], [2, 3, 5, 8, 13, 21]]

    R.groupWith((a: number, b: number) => a % 2 === b % 2, [0, 1, 1, 2, 3, 5, 8, 13, 21])
    // [[0], [1, 1], [2], [3, 5], [8], [13, 21]]

    const isVowel = (a: string) => R.contains(a, 'aeiou') ? a : '';
    R.groupWith(R.eqBy<string>(isVowel), 'aestiou')
    // ['ae', 'st', 'iou']
}

() => {
    R.head(['fi', 'fo', 'fum']); //=> 'fi'
    R.head([10, 'ten']); // => 10
    R.head(['10', 10]); // => '10'
}

(() => {
    let list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}];
    const a1 = R.indexBy(R.prop<string>('id'), list);
    const a2 = R.indexBy(R.prop<string>('id'))(list);
    const a3 = R.indexBy<{id:string}>(R.prop<string>('id'))(list);
});

() => {
    R.indexOf(3, [1,2,3,4]); //=> 2
    R.indexOf(10)([1,2,3,4]); //=> -1
}

() => {
    R.init(['fi', 'fo', 'fum']); //=> ['fi', 'fo']
}

() => {
    R.insert(2, 5, [1,2,3,4]); //=> [1,2,5,3,4]
    R.insert(2)(5, [1,2,3,4]); //=> [1,2,5,3,4]
    R.insert(2, 5)([1,2,3,4]); //=> [1,2,5,3,4]
}

() => {
    R.insertAll(2, [10,11,12], [1,2,3,4]);
    R.insertAll(2)([10,11,12], [1,2,3,4]);
    R.insertAll(2, [10,11,12])([1,2,3,4]);
}

() => {
    R.intersection([1,2,4], [1,2,3]); // => [1,2]
    R.intersection([1,2,4])([1,2,3]); // => [1,2]
}

() => {
    var buffaloSpringfield = [
        {id: 824, name: 'Richie Furay'},
        {id: 956, name: 'Dewey Martin'},
        {id: 313, name: 'Bruce Palmer'},
        {id: 456, name: 'Stephen Stills'},
        {id: 177, name: 'Neil Young'}
    ];
    var csny = [
        {id: 204, name: 'David Crosby'},
        {id: 456, name: 'Stephen Stills'},
        {id: 539, name: 'Graham Nash'},
        {id: 177, name: 'Neil Young'}
    ];
    R.intersectionWith(R.eqBy(R.prop('id')), buffaloSpringfield, csny);
        //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]
    R.intersectionWith(R.eqBy(R.prop('id')))(buffaloSpringfield, csny);
    R.intersectionWith(R.eqBy(R.prop('id')))(buffaloSpringfield)(csny);
}

() => {
    var numbers = [1, 2, 3, 4];
    var transducer = R.compose(R.map(R.add(1)), R.take(2));

    R.into([], transducer, numbers); //=> [2, 3]
    R.into([])(transducer, numbers); //=> [2, 3]
    R.into([], transducer)(numbers); //=> [2, 3]

    var intoArray = R.into([]);
    intoArray(transducer, numbers); //=> [2, 3]
    intoArray(transducer)(numbers); //=> [2, 3]
}

() => {
    var spacer = R.join(' ');
    spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'
    R.join('|', [1, 2, 3]);    //=> '1|2|3'
}

() => {
    R.last(['fi', 'fo', 'fum']); //=> 'fum'
}

() => {
    R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6
    R.lastIndexOf(10, [1,2,3,4]); //=> -1
    R.lastIndexOf(10)([1,2,3,4]); //=> -1
}

() => {
    R.length([]); //=> 0
    R.length([1, 2, 3]); //=> 3
}

() => {
    var headLens = R.lensIndex(0);
    headLens([10, 20, 30, 40]); //=> 10
    headLens.set('mu', [10, 20, 30, 40]); //=> ['mu', 20, 30, 40]
    R.view(headLens, ['a', 'b', 'c']);            //=> 'a'
    R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']
    R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']
}

() => {
    var double = function(x: number) {
        return x * 2;
    };
    R.map(double, [1, 2, 3]); //=> [2, 4, 6]

    // functor
    const stringFunctor = {
        map: (fn: (c: number) => number) => {
            var chars = "Ifmmp!Xpsme".split("");
            return chars.map((char) => String.fromCharCode(fn(char.charCodeAt(0)))).join("");
        }
    };
    R.map((x: number) => x-1, stringFunctor); // => "Hello World"
}

() => {
    var digits = ['1', '2', '3', '4'];
    var append = function(a: string, b: string): [string, string]{
        return [a + b, a + b];
    }
    R.mapAccum(append, '0', digits); //=> ['01234', ['01', '012', '0123', '01234']]
    R.mapAccum(append)('0', digits); //=> ['01234', ['01', '012', '0123', '01234']]
    R.mapAccum(append, '0')(digits); //=> ['01234', ['01', '012', '0123', '01234']]
}

() => {
    var digits = ['1', '2', '3', '4'];
    var append = function(a: string, b: string): [string, string] {
        return [a + b, a + b];
    }

    R.mapAccumRight(append, '0', digits); //=> ['04321', ['04321', '0432', '043', '04']]
    R.mapAccumRight(append)('0', digits); //=> ['04321', ['04321', '0432', '043', '04']]
    R.mapAccumRight(append, '0')(digits); //=> ['04321', ['04321', '0432', '043', '04']]
}

() => {
    var squareEnds = function(elt: number, idx: number, list: number[]) {
        if (idx === 0 || idx === list.length - 1) {
            return elt * elt;
        }
        return elt;
    };
    R.addIndex(R.map)(squareEnds, [8, 5, 3, 0, 9]); //=> [64, 5, 3, 0, 81]
    R.addIndex(R.map)(squareEnds)([8, 5, 3, 0, 9]); //=> [64, 5, 3, 0, 81]
}

() => {
    R.none(R.isNaN, [1, 2, 3]); //=> true
    R.none(R.isNaN, [1, 2, 3, NaN]); //=> false
    R.none(R.isNaN)([1, 2, 3, NaN]); //=> false
}

() => {
    var list = ['foo', 'bar', 'baz', 'quux'];
    R.nth(1, list); //=> 'bar'
    R.nth(-1, list); //=> 'quux'
    R.nth(-99, list); //=> undefined
    R.nth(-99)(list); //=> undefined
}

() => {
    R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);
    R.partition(R.contains('s'))(['sss', 'ttt', 'foo', 'bars']);
    R.partition((x: number) => x > 2, [1, 2, 3, 4]);
    R.partition((x: number) => x > 2)([1, 2, 3, 4]);
}

() => {
    const a = R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]
    const b = R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]
}

() => {
    R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']
    R.prepend('fee')(['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']
}

() => {
    R.range(1, 5);    //=> [1, 2, 3, 4]
    R.range(50)(53);  //=> [50, 51, 52]
}

() => {
    var numbers = [1, 2, 3];
    var add = function(a: number, b: number) {
        return a + b;
    };
    R.reduce(add, 10, numbers); //=> 16
    R.reduce(add)(10, numbers); //=> 16
    R.reduce(add, 10)(numbers); //=> 16
}

interface Student {
    name: string;
    score: number;
}
() => {
    const reduceToNamesBy = R.reduceBy((acc: string[], student: Student) => acc.concat(student.name), []);
    const namesByGrade = reduceToNamesBy(function(student) {
          let score = student.score;
          return score < 65 ? 'F' :
                 score < 70 ? 'D' :
                 score < 80 ? 'C' :
                 score < 90 ? 'B' : 'A';
    });
    let students = [{name: 'Lucy', score: 92},
                    {name: 'Drew', score: 85},
                    {name: 'Bart', score: 62}];
    const names = namesByGrade(students);
    // {
    //   'A': ['Lucy'],
    //   'B': ['Drew']
    //   'F': ['Bart']
    // }
}

() => {
    var reduceIndexed = R.addIndex(R.reduce);
    var letters = ['a', 'b', 'c'];
    var objectify = function(accObject: {[elem:string]: number}, elem: string, idx: number, list: string[]) {
        accObject[elem] = idx;
        return accObject;
    };
    reduceIndexed(objectify, {}, letters); //=> { 'a': 0, 'b': 1, 'c': 2 }
    reduceIndexed(objectify)({}, letters); //=> { 'a': 0, 'b': 1, 'c': 2 }
    reduceIndexed(objectify, {})(letters); //=> { 'a': 0, 'b': 1, 'c': 2 }
}

interface KeyValuePair<K, V> extends Array<K | V> { 0 : K; 1 : V; }
type Pair = KeyValuePair<string, number>
() => {
    var pairs: Pair[] = [ ['a', 1], ['b', 2], ['c', 3] ];
    var flattenPairs = function(acc: Pair[], pair: Pair): Pair[] {
        return acc.concat(pair);
    };
    R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]
    R.reduceRight(flattenPairs, [])(pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]
    R.reduceRight(flattenPairs)([], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]
}

() => {
    var isOdd = function(n: number) {
        return n % 2 === 1;
    };
    R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]
    R.reject(isOdd)([1, 2, 3, 4]); //=> [2, 4]
}

() => {
    const lastTwo = function(val: number, idx: number, list: number[]) {
        return list.length - idx <= 2;
    };
    const rejectIndexed = R.addIndex(R.reject);
    rejectIndexed(lastTwo, [8, 6, 7, 5, 3, 0, 9]); //=> [8, 6, 7, 5, 3]
    rejectIndexed(lastTwo)([8, 6, 7, 5, 3, 0, 9]); //=> [8, 6, 7, 5, 3]
}

() => {
    R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]
    R.remove(2, 3)([1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]
    R.remove(2)(3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]
}

() => {
    R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']
    var obj = {};
    var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]
    repeatedObjs[0] === repeatedObjs[1]; //=> true
}

() => {
    R.reverse([1, 2, 3]);  //=> [3, 2, 1]
    R.reverse([1, 2]);     //=> [2, 1]
    R.reverse([1]);        //=> [1]
    R.reverse([]);         //=> []
}

() => {
    var numbers = [1, 2, 3, 4];
    R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]
    R.scan(R.multiply, 1)(numbers); //=> [1, 1, 2, 6, 24]
    R.scan(R.multiply)(1, numbers); //=> [1, 1, 2, 6, 24]
}

() => {
    var xs = R.range(0, 10);
    R.slice(2, 5, xs); //=> [2, 3, 4]
    R.slice(2, 5)(xs); //=> [2, 3, 4]
    R.slice(2)(5, xs); //=> [2, 3, 4]

    var str = 'Hello World';
    R.slice(2, 5, str); //=> 'llo'
    R.slice(2, 5)(str); //=> 'llo'
    R.slice(2)(5, str); //=> 'llo'
}

() => {
    var diff = function(a: number, b: number) { return a - b; };
    R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]
    R.sort(diff)([4,2,7,5]); //=> [2, 4, 5, 7]
}

() => {
    const fn = R.cond([
        [R.equals(0),   R.always('water freezes at 0°C')],
        [R.equals(100), R.always('water boils at 100°C')],
        [R.T,           (temp: number) => 'nothing special happens at ' + temp + '°C']
    ]);
    const a: string = fn(0); //=> 'water freezes at 0°C'
    const b: string = fn(50); //=> 'nothing special happens at 50°C'
    const c: string = fn(100); //=> 'water boils at 100°C'
}

() => {
    R.tail(['fi', 'fo', 'fum']); //=> ['fo', 'fum']
    R.tail([1, 2, 3]); //=> [2, 3]
}

() => {
    R.take(3,[1,2,3,4,5]); //=> [1,2,3]

    var members= [ "Paul Desmond","Bob Bates","Joe Dodge","Ron Crotty","Lloyd Davis","Joe Morello","Norman Bates",
    "Eugene Wright","Gerry Mulligan","Jack Six","Alan Dawson","Darius Brubeck","Chris Brubeck",
    "Dan Brubeck","Bobby Militello","Michael Moore","Randy Jones"];
    var takeFive = R.take(5);
    takeFive(members); //=> ["Paul Desmond","Bob Bates","Joe Dodge","Ron Crotty","Lloyd Davis"]
}
() => {
    R.take(3,"Example"); //=> "Exa"

    var takeThree = R.take(3);
    takeThree("Example"); //=> "Exa"
}



() => {
	const a: string[] = R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']
    const b: string[] = R.takeLast(2)(['foo', 'bar', 'baz']); //=> ['bar', 'baz']
    const c: string = R.takeLast(3, 'ramda');               //=> 'mda'
    const d: string = R.takeLast(3)('ramda');               //=> 'mda'
}

() => {
	const isNotOne = (x: number) => x !== 1;
	const a: number[] = R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]
	const b: number[] = R.takeLastWhile(isNotOne)([1, 2, 3, 4]); //=> [2, 3, 4]
}

() => {
    var isNotFour = function(x: number) {
        return !(x === 4);
    };

    R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]
    R.takeWhile(isNotFour)([1, 2, 3, 4]); //=> [1, 2, 3]
}

() => {
	const sayX = (x: number) => console.log('x is ' + x);
    const a: number = R.tap(sayX, 100); //=> 100
}

() => {
	const a: boolean = R.test(/^x/, 'xyz'); //=> true
    const b: boolean = R.test(/^y/)('xyz'); //=> false
}

() => {
    const a1 = R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]
    const a2 = R.times(R.identity)(5); //=> [0, 1, 2, 3, 4]
}

() => {
	class Point {
		constructor(public x: number, public y: number) {
    		this.x = x;
        	this.y = y;
		}
		toStringn() {
        	return 'new Point(' + this.x + ', ' + this.y + ')';
		}
    };
    R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'

    R.toString(42); //=> '42'
    R.toString('abc'); //=> '"abc"'
    R.toString([1, 2, 3]); //=> '[1, 2, 3]'
    R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}'
    R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")'
}

() => {
    var numbers = [1, 2, 3, 4];
    var transducer = R.compose(R.map(R.add(1)), R.take(2));
    var fn = R.flip<number, number[], number[]>(R.append);
    R.transduce(transducer, fn, [], numbers); //=> [2, 3]
    R.transduce(transducer, fn, [])(numbers); //=> [2, 3]
    R.transduce(transducer, fn)([], numbers); //=> [2, 3]
    R.transduce(transducer)(fn, [], numbers); //=> [2, 3]
}

() => {
    const a: any[][] = R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) //=> [[1, 2, 3], ['a', 'b', 'c']]
    const b: any[][] = R.transpose([[1, 2, 3], ['a', 'b', 'c']]) //=> [[1, 'a'], [2, 'b'], [3, 'c']]
    const c: any[][] = R.transpose([[10, 11], [20], [], [30, 31, 32]]) //=> [[10, 20, 30], [11, 31], [32]]
}

() => {
    const x = R.prop('x');
    const a: boolean = R.tryCatch<boolean>(R.prop('x'), R.F, {x: true}); //=> true
    const b: boolean = R.tryCatch<boolean>(R.prop('x'), R.F, null);      //=> false
}

() => {
    R.uniq([1, 1, 2, 1]); //=> [1, 2]
    R.uniq([{}, {}]);     //=> [{}, {}]
    R.uniq([1, '1']);     //=> [1, '1']
}

() => {
    var strEq = function(a: any, b: any) { return String(a) === String(b); };
    R.uniqWith(strEq, [1, '1', 2, 1]); //=> [1, 2]
    R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]
    R.uniqWith(strEq)([{}, {}]);       //=> [{}]
    R.uniqWith(strEq)([1, '1', 1]);    //=> [1]
    R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']
}

() => {
    R.equals(R.unnest([1, [2], [[3]]]), [1,2,[3]]); //=> true
    R.equals(R.unnest([[1, 2], [3, 4], [5, 6]]),[1,2,3,4,5,6]); //=> true
}

() => {
    R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
    R.xprod([1, 2])(['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
}

() => {
    R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]
    R.zip([1, 2, 3])(['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]
}

() => {
    R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}
    R.zipObj(['a', 'b', 'c'])([1, 2, 3]); //=> {a: 1, b: 2, c: 3}
}

() => {
    var f = function(x:number, y:string) {
        // ...
    };
    R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']); //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]
    R.zipWith(f)([1, 2, 3], ['a', 'b', 'c']); //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]
    R.zipWith(f, [1, 2, 3])(['a', 'b', 'c']); //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]
}

/*****************************************************************
 * Object category
 */
() => {
    const a = R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}
    const b = R.assoc('c')(3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}
    const c = R.assoc('c', 3)({a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}
}

() => {
    const a1 = R.dissoc<{a:number, c:number}>('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}
    const a2 = R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}
    const a4 = R.dissoc('b')<{a:number, c:number}>({a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}
}

() => {
    const a = R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}
    const b = R.assocPath(['a', 'b', 'c'])(42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}
    const c = R.assocPath(['a', 'b', 'c'], 42)({a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}
}

() => {
    const a1 = R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}
    // optionally specify return type
    const a2 = R.dissocPath<{a :{ b: number}}>(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}
    const a3 = R.dissocPath(['a', 'b', 'c'])({a: {b: {c: 42}}}); //=> {a: {b: {}}}
}

() => {
    var obj1 = [{}, {}, {}];
    var obj2 = [{a:1}, {a:2}, {a:3}];
    const a1: any[] = R.clone(obj1);
    const a2: {a: number}[] = R.clone(obj2);
    const a3: any = R.clone({});
    const a4: number = R.clone(10);
    const a5: string = R.clone('foo');
    const a6: number = R.clone(Date.now());
}

() => {
    var o1 = { a: 1, b: 2, c: 3, d: 4 };
    var o2 = { a: 10, b: 20, c: 3, d: 40 };
    const a1 = R.eqProps('a', o1, o2); //=> false
    const a2 = R.eqProps('c', o1, o2); //=> true
    const a3: {<T,U>(obj1: T, obj2: U): boolean} = R.eqProps('c');
    const a4: {<U>(obj2: U): boolean} = R.eqProps('c', o1);
}

() => {
    const a1 = R.evolve({ elapsed: R.add(1), remaining: R.add(-1) }, { name: 'Tomato', elapsed: 100, remaining: 1400 });
    const a2 = R.evolve({ elapsed: R.add(1), remaining: R.add(-1) })({ name: 'Tomato', elapsed: 100, remaining: 1400 });
}

() => {
    // var tomato = {firstName: 'Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};
    // var transformations = {
    //     firstName: R.trim,
    //     lastName: R.trim, // Will not get invoked.
    //     data: {elapsed: R.add(1), remaining: R.add(-1)}
    // };
    // const a = R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}
    // const b = R.evolve(transformations)(tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}
}

() => {
    const hasName = R.has('name');
    const a1: boolean = hasName({name: 'alice'});   //=> true
    const a2: boolean = hasName({name: 'bob'});     //=> true
    const a3: boolean = hasName({});                //=> false

    const point = {x: 0, y: 0};
    const pointHas = R.flip(R.has)(point);
    const b1: boolean = pointHas('x');  //=> true
    const b2: boolean = pointHas('y');  //=> true
    const b3: boolean = pointHas('z');  //=> false
}

class Rectangle {
    constructor(public width: number, public height: number) {
        this.width = width;
        this.height = height;
    }
    area():number {
        return this.width * this.height;
    }
};
() => {

    var square = new Rectangle(2, 2);
    R.hasIn('width', square);  //=> true
    R.hasIn('area', square);  //=> true
    R.flip(R.hasIn)(square)('area');  //=> true
}

() => {
    var raceResultsByFirstName = {
      first: 'alice',
      second: 'jake',
      third: 'alice',
    };
    R.invert(raceResultsByFirstName);
    //=> { 'alice': ['first', 'third'], 'jake':['second'] }
}

() => {
    let raceResults0 = {
      first: 'alice',
      second: 'jake'
    };
    R.invertObj(raceResults0);
    //=> { 'alice': 'first', 'jake':'second' }

    // Alternatively:
    let raceResults1 = ['alice', 'jake'];
    R.invertObj(raceResults1);
    //=> { 'alice': '0', 'jake':'1' }
}

() => {
    R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']
}

() => {
    var f = new F();
    R.keysIn(f); //=> ['x', 'y']
}

() => {
    var xLens = R.lens(R.prop('x'), R.assoc('x'));
    R.view(xLens, {x: 1, y: 2});            //=> 1
    R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}
    R.set(xLens)(4, {x: 1, y: 2});          //=> {x: 4, y: 2}
    R.set(xLens, 4)({x: 1, y: 2});          //=> {x: 4, y: 2}
    R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}
    R.over(xLens, R.negate)({x: 1, y: 2});  //=> {x: -1, y: 2}
    R.over(xLens)(R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}
}
() => {
    var headLens = R.lensIndex(0);
    R.view(headLens, ['a', 'b', 'c']);            //=> 'a'
    R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']
    R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']
}
() => {
    var xLens = R.lensProp('x');
    R.view(xLens, {x: 1, y: 2});            //=> 1
    R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}
    R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}
}

() => {
  const xyLens = R.lensPath(['x', 'y']);

  R.view(xyLens, {x: {y: 2, z: 3}});            //=> 2
  R.set(xyLens, 4, {x: {y: 2, z: 3}});          //=> {x: {y: 4, z: 3}}
  R.over(xyLens, R.negate, {x: {y: 2, z: 3}});  //=> {x: {y: -2, z: 3}}
}

() => {
    R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']
}

() => {
    var f = new F();
    R.keysIn(f); //=> ['x', 'y']
}

() => {
    var headLens = R.lens(
      function get(arr: number[]) { return arr[0]; },
      function set(val: number, arr: number[]) { return [val].concat(arr.slice(1)); }
    );
    headLens([10, 20, 30, 40]); //=> 10
    headLens.set('mu', [10, 20, 30, 40]); //=> ['mu', 20, 30, 40]

    var phraseLens = R.lens(
      function get(obj: any) { return obj.phrase; },
      function set(val: string, obj: any) {
        var out = R.clone(obj);
        out.phrase = val;
        return out;
      }
    );
    var obj1 = { phrase: 'Absolute filth . . . and I LOVED it!'};
    var obj2 = { phrase: "What's all this, then?"};
    phraseLens(obj1); // => 'Absolute filth . . . and I LOVED it!'
    phraseLens(obj2); // => "What's all this, then?"
    phraseLens.set('Ooh Betty', obj1); //=> { phrase: 'Ooh Betty'}
}


() => {
    var phraseLens = R.lensProp('phrase');
    var obj1 = { phrase: 'Absolute filth . . . and I LOVED it!'};
    var obj2 = { phrase: "What's all this, then?"};
    phraseLens(obj1); // => 'Absolute filth . . . and I LOVED it!'
    phraseLens(obj2); // => "What's all this, then?"
    phraseLens.set('Ooh Betty', obj1); //=> { phrase: 'Ooh Betty'}
}

() => {
    R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });
    //=> { 'name': 'fred', 'age': 40 }

    var resetToDefault = R.flip(R.merge)({x: 0});
    resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}
}

() => {
    const a = R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}
    const b = R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}
}

() => {
    const a = R.mergeWith(R.concat,
        { a: true, values: [10, 20] },
        { b: true, values: [15, 35] });
        //=> { a: true, b: true, values: [10, 20, 15, 35] }
}

() => {
    let concatValues = (k:string, l: string, r: string) => k == 'values' ? R.concat(l, r) : r;
    R.mergeWithKey(concatValues,
        { a: true, thing: 'foo', values: [10, 20] },
        { b: true, thing: 'bar', values: [15, 35] });
    const merge = R.mergeWithKey(concatValues);
    merge({ a: true, thing: 'foo', values: [10, 20] }, { b: true, thing: 'bar', values: [15, 35] });
}

() => {
    const a1 = R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2
    const a2 = R.pathOr('N/A', ['a', 'b'])({a: {b: 2}}); //=> 2
    const a3 = R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A"
    const a4 = R.pathOr({c:2})(['a', 'b'], {c: {b: 2}}); //=> "N/A"
}

() => {
    var isPositive = function(n: number) {
        return n > 0;
    };
    const a1 = R.pickBy(isPositive, {a: 1, b: 2, c: -1, d: 0, e: 5}); //=> {a: 1, b: 2, e: 5}
    var containsBackground = function(val: any) {
        return val.bgcolor;
    };
    var colors = {1: {color: 'read'}, 2: {color: 'black', bgcolor: 'yellow'}};
    R.pickBy(containsBackground, colors); //=> {2: {color: 'black', bgcolor: 'yellow'}}

    var isUpperCase = function(val: number, key: string) { return key.toUpperCase() === key; }
    R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}
}


() => {
    const a1 = R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
    const a2 = R.pick<any, {a: number}>(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}
    const a3 = R.pick(['a', 'e', 'f'])({a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}
    const a4 = R.pick(['a', 'e', 'f'], [1, 2, 3, 4]); //=> {a: 1}
}

() => {
    var matchPhrases = R.compose(
    R.objOf('must'),
    R.map(R.objOf('match_phrase'))
)

matchPhrases(['foo', 'bar', 'baz']);
}
() => {
    R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}
    R.omit(['a', 'd'])({a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}
}


() => {
    R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}
}

() => {
    R.pair('foo', 'bar'); //=> ['foo', 'bar']
    let p = R.pair('foo', 1); //=> ['foo', 'bar']
    let x: string = p[0];
    let y: number = p[1];
}

() => {
    var headLens = R.lensIndex(0);
    R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']
}

() => {
    R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
    R.pickAll(['a', 'd'])({a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
    R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}
    R.pickAll(['a', 'e', 'f'])({a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}
}

() => {
    var isUpperCase = function(val: number, key: string) { return key.toUpperCase() === key; }
    R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}
}

() => {
    var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};
    var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};
    var kids = [abby, fred];
    R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]
}

() => {
    var x: number = <number>R.prop('x', {x: 100}); //=> 100
    const a = R.prop('x', {}); //=> undefined
}

() => {
    var alice = {
      name: 'ALICE',
      age: 101
    };
    var favorite = R.prop('favoriteLibrary');
    var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');

    const s1 = favorite(alice);  //=> undefined
    const s2 = favoriteWithDefault(alice);  //=> 'Ramda'
}

() => {
    const a: boolean = R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true
    const b: boolean = R.propSatisfies(x => x > 0, 'x')({x: 1, y: 2}); //=> true
    const c: boolean = R.propSatisfies(x => x > 0)('x')({x: 1, y: 2}); //=> true
}

() => {
    R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]
    R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]

    var fullName = R.compose(R.join(' '), R.props(['first', 'last']));
    fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'
}

() => {
    const a = R.toPairs<string,number>({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]
}

() => {
    var f = new F();
    const a1 = R.toPairsIn(f); //=> [['x','X'], ['y','Y']]
    const a2 = R.toPairsIn<string,string>(f); //=> [['x','X'], ['y','Y']]
}

() => {
    const a = R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]
}
() => {
    var f = new F();
    const a = R.valuesIn(f); //=> ['X', 'Y']
}

() => {
    var spec = {x: 2};
    var x1: boolean = R.where(spec, {w: 10, x: 2, y: 300}); //=> true
    var x2: boolean = R.where(spec, {x: 1, y: 'moo', z: true}); //=> false
    var x3: boolean = R.where(spec)({w: 10, x: 2, y: 300}); //=> true
    var x4: boolean = R.where(spec)({x: 1, y: 'moo', z: true}); //=> false

    // There's no way to represent the below functionality in typescript
    // per http://stackoverflow.com/a/29803848/632495
    // will need a work around.

    var spec2 = {x: function(val: number, obj: any) { return  val + obj.y > 10; }};
    R.where(spec2, {x: 2, y: 7}); //=> false
    R.where(spec2, {x: 3, y: 8}); //=> true

    var xs = [{x: 2, y: 1}, {x: 10, y: 2}, {x: 8, y: 3}, {x: 10, y: 4}];
    R.filter(R.where({x: 10}), xs); // ==> [{x: 10, y: 2}, {x: 10, y: 4}]
    R.filter(R.where({x: 10}))(xs); // ==> [{x: 10, y: 2}, {x: 10, y: 4}]
}

() => {
    // pred :: Object -> Boolean
    var pred = R.whereEq({a: 1, b: 2});
    pred({a: 1});              //=> false
    pred({a: 1, b: 2});        //=> true
    pred({a: 1, b: 2, c: 3});  //=> true
    pred({a: 1, b: 1});        //=> false
    R.whereEq({a: 'one'}, {a: 'one'}); // => true
}

() => {
    const a: number[] = R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]
}

() => {
    var mapIndexed = R.addIndex(R.map);
    mapIndexed(function(val: string, idx: number) {return idx + '-' + val;})(['f', 'o', 'o', 'b', 'a', 'r']);
      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']
    mapIndexed((rectangle: Rectangle, idx: number):number => rectangle.area()*idx, [new Rectangle(1,2), new Rectangle(4,7)]);
      //=> [2, 56]
}

() => {
    var reduceIndexed = R.addIndex(R.reduce);
    reduceIndexed(function(acc: string, val: string, idx: number) {
        return acc + ',' + idx + '-' + val;
        }
        ,''
        ,['f', 'o', 'o', 'b', 'a', 'r']);
      //=> ['0-f,1-o,2-o,3-b,4-a,5-r']
}



() => {
    var t = R.always('Tee');
    const x: string = t(); //=> 'Tee'
}

() => {
    const x: number[] = R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]
    const y: number[] = R.ap([R.multiply(2), R.add(3)])([1,2,3]); //=> [2, 4, 6, 4, 5, 6]
}

() => {
    var nums = [1, 2, 3, -99, 42, 6, 7];
    R.apply(Math.max, nums); //=> 42
    R.apply(Math.max)(nums); //=> 42
}

() => {
    type T = {sum: number, nested: {mul: number}};
    const getMetrics = R.applySpec<T>({
        sum: R.add, nested: { mul: R.multiply }
    });
    const result = getMetrics(2, 4); // => { sum: 6, nested: { mul: 8 } }
}

() => {
    var takesThreeArgs = function(a: number, b: number, c: number) {
        return [a, b, c];
    };
    takesThreeArgs.length; //=> 3
    takesThreeArgs(1, 2, 3); //=> [1, 2, 3]

    var takesTwoArgs = R.binary(takesThreeArgs);
    takesTwoArgs.length; //=> 2
    // Only 2 arguments are passed to the wrapped function
    takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]
}

() => {
    var indentN = R.pipe(R.times(R.always(' ')),
         R.join(''),
         R.replace(/^(?!$)/gm)
    );

    var format = R.converge(
        R.call, [
            R.pipe(R.prop('indent'), indentN),
            R.prop('value')
        ]
    );

    format({indent: 2, value: 'foo\nbar\nbaz\n'}); //=> '  foo\n  bar\n  baz\n'
}

() => {
    type T = {age: number};
    var cmp = R.comparator(function(a: T, b: T) {
      return a.age < b.age;
    });
    var people = [
      {name: 'Agy', age:33}, {name: 'Bib', age: 15}, {name: 'Cari', age: 16}
    ];
    R.sort(cmp, people);
}

() => {
    var add = function(a: number, b: number) { return a + b; };
    var multiply = function(a: number, b: number) { return a * b; };
    var subtract = function(a: number, b: number) { return a - b; };

    //≅ multiply( add(1, 2), subtract(1, 2) );
    const x: number = R.converge(multiply, [ add, subtract ])(1, 2); //=> -3

    var add3 = function(a: number, b: number, c: number) { return a + b + c; };
    const y: number = R.converge(add3, [ multiply, add, subtract ])(1, 2); //=> 4
}

() => {
    const f0 = R.compose(Math.pow);
    const f1 = R.compose(R.negate, Math.pow);
    const f2 = R.compose(R.inc, R.negate, Math.pow);
    const f3 = R.compose(R.inc, R.inc, R.negate, Math.pow);
    const f4 = R.compose(R.inc, R.inc, R.inc, R.negate, Math.pow);
    const f5 = R.compose(R.inc, R.inc, R.inc, R.inc, R.negate, Math.pow);
    const x0: number = f0(3, 4); // -(3^4) + 1
    const x1: number = f1(3, 4); // -(3^4) + 1
    const x2: number = f2(3, 4); // -(3^4) + 1
    const x3: number = f3(3, 4); // -(3^4) + 1
    const x4: number = f4(3, 4); // -(3^4) + 1
    const x5: number = f5(3, 4); // -(3^4) + 1
}

() => {
    const fn = function(a: string, b: number, c: string) {
        return [a,b,c];
    }
    const gn = R.compose(R.length, fn);
    const x: number = gn('Hello', 4, "world");
}

(() => {
    var Circle = function(r: number) {
        this.r = r;
        this.colors = Array.prototype.slice.call(arguments, 1);
    };
    Circle.prototype.area = function() {return Math.PI * Math.pow(this.r, 2);};
    var circleN = R.constructN(2, Circle);
    var c1 = circleN(1, 'red');
    var circle = R.construct(Circle);
    var c1 = circle(1, 'red');
})();

/*****************************************************************
 * Relation category
 */

() => {
    var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
    var letters = R.split('', 'abcABCaaaBBc');
    R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}
    R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}
}

() => {
    R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]
    R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]
}

() => {
    function cmp(x: any, y: any) { return x.a === y.a; }
    var l1 = [{a: 1}, {a: 2}, {a: 3}];
    var l2 = [{a: 3}, {a: 4}];
    R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]
}

() => {
    R.equals(1, 1); //=> true
    R.equals('2', '1'); //=> false
    R.equals([1, 2, 3], [1, 2, 3]); //=> true

    var a: any = {}; a.v = a;
    var b: any = {}; b.v = b;
    R.equals(a, b); //=> true
}

() => {
    const a1 = R.identity(1); //=> 1
    let obj = {};
    const a2 = R.identity([1,2,3]);
    const a3 = R.identity(['a','b','c']);
    const a4 = R.identity(obj) === obj; //=> true
}

() => {
    var o = {};
    R.identical(o, o); //=> true
    R.identical(1, 1); //=> true
    R.identical('2', '1'); //=> false
    R.identical([], []); //=> false
    R.identical(0, -0); //=> false
    R.identical(NaN, NaN); //=> true
}

() => {
    R.path(['a', 'b'], {a: {b: 2}}); //=> 2
    R.path(['a', 'b'])({a: {b: 2}}); //=> 2
}

() => {
    var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));
    var alice = {
      name: 'ALICE',
      age: 101
    };
    var bob = {
      name: 'Bob',
      age: -10
    };
    var clara = {
      name: 'clara',
      age: 314.159
    };
    var people = [clara, bob, alice];
    sortByNameCaseInsensitive(people); //=> [alice, bob, clara]
}

() => {
	const a: number[][] = R.splitAt(1, [1, 2, 3]);        //=> [[1], [2, 3]]
	const b: number[][] = R.splitAt(1)([1, 2, 3]);        //=> [[1], [2, 3]]
    const c: string[] = R.splitAt(5, 'hello world');      //=> ['hello', ' world']
    const d: string[] = R.splitAt(-1, 'foobar');          //=> ['fooba', 'r']
}

() => {
	const a: number[][] = R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]);   //=> [[1], [2, 3, 1, 2, 3]]
	const b: number[][] = R.splitWhen(R.equals(2))([1, 2, 3, 1, 2, 3]);   //=> [[1], [2, 3, 1, 2, 3]]
}

() => {
    R.add(2, 3);       //=>  5
    R.add(7)(10);      //=> 17
}

() => {
    R.dec(42); //=> 41
}

() => {
    R.divide(71, 100); //=> 0.71

    var half = R.flip(R.divide)(2);
    half(42); //=> 21

    var reciprocal = R.divide(1);
    reciprocal(4);   //=> 0.25
}

() => {
    R.gt(2, 6); //=> false
    R.gt(2, 0); //=> true
    R.gt(2, 2); //=> false
    R.flip(R.gt)(2)(10); //=> true
    R.gt(2)(10); //=> false
}

() => {
    R.gte(2, 6); //=> false
    R.gte(2, 0); //=> true
    R.gte(2, 2); //=> false
    R.flip(R.gte)(2)(10); //=> true
    R.gte(2)(10); //=> false
}

() => {
    R.isNaN(NaN);        //=> true
    R.isNaN(undefined);  //=> false
    R.isNaN({});         //=> false
}

() => {
    R.lt(2, 6); //=> true
    R.lt(2, 0); //=> false
    R.lt(2, 2); //=> false
    R.lt(5)(10); //=> true
    R.flip(R.lt)(5)(10); //=> false // right-sectioned currying
}

() => {
    R.lte(2, 6); //=> true
    R.lte(2, 0); //=> false
    R.lte(2, 2); //=> true
    R.flip(R.lte)(2)(1); //=> true
    R.lte(2)(10); //=> true
}

() => {
    R.mathMod(-17, 5);  //=> 3
    R.mathMod(17, 5);   //=> 2
    R.mathMod(17, -5);  //=> NaN
    R.mathMod(17, 0);   //=> NaN
    R.mathMod(17.2, 5); //=> NaN
    R.mathMod(17, 5.3); //=> NaN

    var clock = R.flip(R.mathMod)(12);
    clock(15); //=> 3
    clock(24); //=> 0

    var seventeenMod = R.mathMod(17);
    seventeenMod(3);  //=> 2
}

() => {
    var hasName = R.has('name');
    hasName({name: 'alice'});   //=> true
    hasName({name: 'bob'});     //=> true
    hasName({});                //=> false

    var point = {x: 0, y: 0};
    var pointHas = R.flip(R.has)(point);
    pointHas('x');  //=> true
    pointHas('y');  //=> true
    pointHas('z');  //=> false
}

() => {
    let x: R.Ord = R.max(7, 3); //=> 7
    let y: R.Ord = R.max('a', 'z'); //=> 'z'
}

() => {
    function cmp(obj: { x: R.Ord }) { return obj.x; }
    var a = {x: 1}, b = {x: 2}, c = {x: 3}, d = {x: "a"}, e = {x:"z"};
    R.maxBy(cmp, a, c); //=> {x: 3}
    R.maxBy(cmp)(a, c); //=> {x: 3}
    R.maxBy(cmp)(a)(b);
    R.maxBy(cmp)(d)(e);
}

() => {
    const a: number = R.mean([2, 7, 9]); //=> 6
    const b: number = R.mean([]); //=> NaN
}

() => {
    const a: number = R.median([7, 2, 10, 9]); //=> 8
    const b: number = R.median([]); //=> NaN
}

() => {
    let x: R.Ord = R.min(9, 3); //=> 3
    let y: R.Ord = R.min('a', 'z'); //=> 'a'
}

() => {
    function cmp(obj: {x: R.Ord}) { return obj.x; }
    var a = {x: 1}, b = {x: 2}, c = {x: 3}, d = {x: "a"}, e = {x: "z"};
    R.minBy(cmp, a, b); //=> {x: 1}
    R.minBy(cmp)(a, b); //=> {x: 1}
    R.minBy(cmp)(a)(c);
    R.minBy(cmp, d, e);
}

() => {
    R.modulo(17, 3); //=> 2
    // JS behavior:
    R.modulo(-17, 3); //=> -2
    R.modulo(17, -3); //=> 2

    var isOdd = R.flip(R.modulo)(2);
    isOdd(42); //=> 0
    isOdd(21); //=> 1
}

() => {
    var double = R.multiply(2);
    var triple = R.multiply(3);
    double(3);       //=>  6
    triple(4);       //=> 12
    R.multiply(2, 5);  //=> 10
}

() => {
    R.negate(42); //=> -42
}

() => {
    R.product([2,4,6,8,100,1]); //=> 38400
}

() => {
    R.subtract(10, 8); //=> 2

    var minus5 = R.flip(R.subtract)(5);
    minus5(17); //=> 12

    var complementaryAngle = R.subtract(90);
    complementaryAngle(30); //=> 60
    complementaryAngle(72); //=> 18
}

() => {
    R.sum([2,4,6,8,100,1]); //=> 121
}

() => {
	const a: number[] = R.symmetricDifference([1,2,3,4], [7,6,5,4,3]); //=> [1,2,7,6,5]
	const b: number[] = R.symmetricDifference([7,6,5,4,3])([1,2,3,4]); //=> [7,6,5,1,2]
}

() => {
	const eqA = R.eqBy(R.prop('a'));
	const l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];
	const l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];
	R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]
	R.symmetricDifferenceWith(eqA)(l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]
	const c: (a: any[]) => any[] = R.symmetricDifferenceWith(eqA)(l1); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]
}

/*****************************************************************
 * String category
 */

() => {
    R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'
    R.replace('foo', 'bar')('foo foo foo'); //=> 'bar foo foo'
    R.replace('foo')('bar')('foo foo foo'); //=> 'bar foo foo'
    R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'

    // Use the "g" (global) flag to replace all occurrences:
    R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'
    R.replace(/foo/g, 'bar')('foo foo foo'); //=> 'bar bar bar'
    R.replace(/foo/g)('bar')('foo foo foo'); //=> 'bar bar bar'
}

/*****************************************************************
 * Is category
 */

() => {
    R.is(Object, {}); //=> true
    R.is(Object)({}); //=> true
    R.is(Number, 1); //=> true
    R.is(Number)(1); //=> true
    R.is(Object, 1); //=> false
    R.is(Object)(1); //=> false
    R.is(String, 's'); //=> true
    R.is(String)('s'); //=> true
    R.is(String, new String('')); //=> true
    R.is(String)(new String('')); //=> true
    R.is(Object, new String('')); //=> true
    R.is(Object)(new String('')); //=> true
    R.is(Object, 's'); //=> false
    R.is(Object)('s'); //=> false
    R.is(Number, {}); //=> false
    R.is(Number)({}); //=> false
}

/*****************************************************************
 * Logic category
 */
() => {
    var gt10 = function(x: number) { return x > 10; };
    var even = function(x: number) { return x % 2 === 0};
    var f = R.allPass([gt10, even]);
    f(11); //=> false
    f(12); //=> true
}

() => {
    R.and(false, true); //=> false
    R.and(0, []); //=> 0
    R.and(0)([]); //=> 0
    R.and(null, ''); //=> null
    var Why: any = (function(val: boolean) {
        var why: any;
        why.val = val;
        why.and = function(x: boolean) {
            return this.val && x;
        }
        return Why;
    })(true);
    var why = new Why(true);
    R.and(why, false); // false
}
() => {
    var gt10 = function(x: number) { return x > 10; };
    var even = function(x: number) { return x % 2 === 0};
    var f = R.anyPass([gt10, even]);
    f(11); //=> true
    f(8); //=> true
    f(9); //=> false
}

() => {
    var gt10 = function(x: number) { return x > 10; };
    var even = function(x: number) { return x % 2 === 0 };
    var f = R.both(gt10, even);
    var g = R.both(gt10)(even);
    f(100); //=> true
    f(101); //=> false
}
() => {
    var isEven = function(n: number) { return n % 2 === 0; };
    var isOdd = R.complement(isEven);
    isOdd(21); //=> true
    isOdd(42); //=> false
}

(() => {
    R.eqBy(Math.abs, 5, -5); //=> true
    R.eqBy(Math.abs)(5, -5); //=> true
    R.eqBy(Math.abs, 5)(-5); //=> true
});

() => {
    var defaultTo42 = R.defaultTo(42);
    defaultTo42(null);  //=> 42
    defaultTo42(undefined);  //=> 42
    defaultTo42('Ramda');  //=> 'Ramda'
}
() => {
    var gt10 = function(x: number) { return x > 10; };
    var even = function(x: number) { return x % 2 === 0 };
    var f = R.either(gt10, even);
    var g = R.either(gt10)(even);
    f(101); //=> true
    f(8); //=> true
}
() => {
    // Flatten all arrays in the list but leave other values alone.
    var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));

    flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]
    flattenArrays([[[10], 123], [8, [10]], "hello"]); //=> [[10, 123], [8, 10], "hello"]
}
() => {
    R.isEmpty([1, 2, 3]); //=> false
    R.isEmpty([]); //=> true
    R.isEmpty(''); //=> true
    R.isEmpty(null); //=> false
    R.isEmpty({}); //=>true
    R.isEmpty({a:1}); //=> false
}

() => {
    R.not(true); //=> false
    R.not(false); //=> true
    R.not(0); // => true
    R.not(1); // => false
}

class Why {
    val: boolean;
    constructor(val: boolean) {
        this.val = val;
    }
    or(x: boolean) {
        return this.val && x;
    }
}
() => {
    const x0: boolean = R.or(false, true); //=> false
    const x1: number|any[] = R.or(0, []); //=> []
    const x2: number|any[] = R.or(0)([]); //=> []
    const x3: string = R.or(null, ''); //=> ''

    var why = new Why(true);
    why.or(true)
    const x4: Why|boolean = R.or(why, false); // false
}

() => {
    R.intersperse(',', ['foo', 'bar']); //=> ['foo', ',', 'bar']
    R.intersperse(0, [1, 2]); //=> [1, 0, 2]
    R.intersperse(0, [1]); //=> [1]
}