fpo
Version:
FP library for JavaScript. Supports named-argument style methods.
1,402 lines (1,165 loc) • 101 kB
JavaScript
"use strict";
QUnit.test( "core: API methods", function test(assert){
assert.expect( 50 );
assert.ok( _isFunction( FPO.identity ), "identity()" );
assert.ok( _isFunction( FPO.constant ), "constant()" );
assert.ok( _isFunction( FPO.pick ), "pick()" );
assert.ok( _isFunction( FPO.pickAll ), "pickAll()" );
assert.ok( _isFunction( FPO.nAry ), "nAry()" );
assert.ok( _isFunction( FPO.unary ), "unary()" );
assert.ok( _isFunction( FPO.binary ), "binary()" );
assert.ok( _isFunction( FPO.curry ), "curry()" );
assert.ok( _isFunction( FPO.curryMultiple ), "curryMultiple()" );
assert.ok( _isFunction( FPO.uncurry ), "uncurry()" );
assert.ok( _isFunction( FPO.partial ), "partial()" );
assert.ok( _isFunction( FPO.complement ), "complement()" );
assert.ok( _isFunction( FPO.apply ), "apply()" );
assert.ok( _isFunction( FPO.unapply ), "unapply()" );
assert.ok( _isFunction( FPO.compose ), "compose()" );
assert.ok( _isFunction( FPO.pipe ), "pipe()" );
assert.ok( _isFunction( FPO.prop ), "prop()" );
assert.ok( _isFunction( FPO.setProp ), "setProp()" );
assert.ok( _isFunction( FPO.reassoc ), "reassoc()" );
assert.ok( _isFunction( FPO.filterIn ), "filterIn()" );
assert.ok( _isFunction( FPO.filterInObj ), "filterInObj()" );
assert.ok( _isFunction( FPO.filterOut ), "filterOut()" );
assert.ok( _isFunction( FPO.filterOutObj ), "filterOutObj()" );
assert.ok( _isFunction( FPO.map ), "map()" );
assert.ok( _isFunction( FPO.mapObj ), "mapObj()" );
assert.ok( _isFunction( FPO.flatMap ), "flatMap()" );
assert.ok( _isFunction( FPO.flatMapObj ), "flatMapObj()" );
assert.ok( _isFunction( FPO.ap ), "ap()" );
assert.ok( _isFunction( FPO.reduce ), "reduce()" );
assert.ok( _isFunction( FPO.reduceObj ), "reduceObj()" );
assert.ok( _isFunction( FPO.reduceRight ), "reduceRight()" );
assert.ok( _isFunction( FPO.flatten ), "flatten()" );
assert.ok( _isFunction( FPO.zip ), "zip()" );
assert.ok( _isFunction( FPO.trampoline ), "trampoline()" );
assert.ok( _isObject( FPO.transducers ), "transducers" );
assert.ok( _isFunction( FPO.transducers.transduce ), "transducers.transduce()" );
assert.ok( _isFunction( FPO.transducers.into ), "transducers.into()" );
assert.ok( _isFunction( FPO.transducers.map ), "transducers.map()" );
assert.ok( _isFunction( FPO.transducers.filter ), "transducers.filter()" );
assert.ok( _isFunction( FPO.transducers.string ), "transducers.string()" );
assert.ok( _isFunction( FPO.transducers.array ), "transducers.array()" );
assert.ok( _isFunction( FPO.transducers.number ), "transducers.number()" );
assert.ok( _isFunction( FPO.transducers.booleanAnd ), "transducers.booleanAnd()" );
assert.ok( _isFunction( FPO.transducers.booleanOr ), "transducers.booleanOr()" );
assert.ok( _isFunction( FPO.transducers.default ), "transducers.default()" );
assert.ok( _isFunction( FPO.head ), "head()" );
assert.ok( _isFunction( FPO.tail ), "tail()" );
assert.ok( _isFunction( FPO.take ), "take()" );
assert.ok( _isFunction( FPO.memoize ), "memoize()" );
assert.ok( _isFunction( FPO.remap ), "remap()" );
} );
QUnit.test( "std: API methods", function test(assert){
assert.expect( 53 );
assert.ok( _isFunction( FPO.std.identity ), "identity()" );
assert.ok( _isFunction( FPO.std.constant ), "constant()" );
assert.ok( _isFunction( FPO.std.pick ), "pick()" );
assert.ok( _isFunction( FPO.std.pickAll ), "pickAll()" );
assert.ok( _isFunction( FPO.std.nAry ), "nAry()" );
assert.ok( _isFunction( FPO.std.unary ), "unary()" );
assert.ok( _isFunction( FPO.std.binary ), "binary()" );
assert.ok( _isFunction( FPO.std.curry ), "curry()" );
assert.ok( _isFunction( FPO.std.curryMultiple ), "curryMultiple()" );
assert.ok( _isFunction( FPO.std.uncurry ), "uncurry()" );
assert.ok( _isFunction( FPO.std.partial ), "partial()" );
assert.ok( _isFunction( FPO.std.partialRight ), "partialRight()" );
assert.ok( _isFunction( FPO.std.complement ), "complement()" );
assert.ok( _isFunction( FPO.std.apply ), "apply()" );
assert.ok( _isFunction( FPO.std.unapply ), "unapply()" );
assert.ok( _isFunction( FPO.std.compose ), "compose()" );
assert.ok( _isFunction( FPO.std.pipe ), "pipe()" );
assert.ok( _isFunction( FPO.std.prop ), "prop()" );
assert.ok( _isFunction( FPO.std.setProp ), "setProp()" );
assert.ok( _isFunction( FPO.std.reassoc ), "reassoc()" );
assert.ok( _isFunction( FPO.std.filterIn ), "filterIn()" );
assert.ok( _isFunction( FPO.std.filterInObj ), "filterInObj()" );
assert.ok( _isFunction( FPO.std.filterOut ), "filterOut()" );
assert.ok( _isFunction( FPO.std.filterOutObj ), "filterOutObj()" );
assert.ok( _isFunction( FPO.std.map ), "map()" );
assert.ok( _isFunction( FPO.std.mapObj ), "mapObj()" );
assert.ok( _isFunction( FPO.std.flatMap ), "flatMap()" );
assert.ok( _isFunction( FPO.std.flatMapObj ), "flatMapObj()" );
assert.ok( _isFunction( FPO.std.ap ), "ap()" );
assert.ok( _isFunction( FPO.std.reduce ), "reduce()" );
assert.ok( _isFunction( FPO.std.reduceObj ), "reduceObj()" );
assert.ok( _isFunction( FPO.std.reduceRight ), "reduceRight()" );
assert.ok( _isFunction( FPO.std.flatten ), "flatten()" );
assert.ok( _isFunction( FPO.std.zip ), "zip()" );
assert.ok( _isFunction( FPO.std.trampoline ), "trampoline()" );
assert.ok( _isObject( FPO.std.transducers ), "transducers" );
assert.ok( _isFunction( FPO.std.transducers.transduce ), "transducers.transduce()" );
assert.ok( _isFunction( FPO.std.transducers.into ), "transducers.into()" );
assert.ok( _isFunction( FPO.std.transducers.map ), "transducers.map()" );
assert.ok( _isFunction( FPO.std.transducers.filter ), "transducers.filter()" );
assert.ok( _isFunction( FPO.std.transducers.string ), "transducers.string()" );
assert.ok( _isFunction( FPO.std.transducers.array ), "transducers.array()" );
assert.ok( _isFunction( FPO.std.transducers.number ), "transducers.number()" );
assert.ok( _isFunction( FPO.std.transducers.booleanAnd ), "transducers.booleanAnd()" );
assert.ok( _isFunction( FPO.std.transducers.booleanOr ), "transducers.booleanOr()" );
assert.ok( _isFunction( FPO.std.transducers.default ), "transducers.default()" );
assert.ok( _isFunction( FPO.std.flip ), "flip()" );
assert.ok( _isFunction( FPO.std.reverseArgs ), "reverseArgs()" );
assert.ok( _isFunction( FPO.std.head ), "head()" );
assert.ok( _isFunction( FPO.std.tail ), "tail()" );
assert.ok( _isFunction( FPO.std.take ), "take()" );
assert.ok( _isFunction( FPO.std.memoize ), "memoize()" );
assert.ok( _isFunction( FPO.std.remap ), "remap()" );
} );
QUnit.test( "API method aliases", function test(assert){
assert.expect( 39 );
assert.strictEqual( FPO.always, FPO.constant, "always -> constant" );
assert.strictEqual( FPO.std.always, FPO.std.constant, "std: always -> constant" );
assert.strictEqual( FPO.partialRight, FPO.partial, "partialRight -> partial" );
assert.strictEqual( FPO.flowRight, FPO.compose, "flowRight -> compose" );
assert.strictEqual( FPO.std.flowRight, FPO.std.compose, "std: flowRight -> compose" );
assert.strictEqual( FPO.flow, FPO.pipe, "flow -> pipe" );
assert.strictEqual( FPO.std.flow, FPO.std.pipe, "std: flow -> pipe" );
assert.strictEqual( FPO.sequence, FPO.pipe, "sequence -> pipe" );
assert.strictEqual( FPO.std.sequence, FPO.std.pipe, "std: sequence -> pipe" );
assert.strictEqual( FPO.spread, FPO.apply, "spread -> apply" );
assert.strictEqual( FPO.std.spread, FPO.std.apply, "std: spread -> apply" );
assert.strictEqual( FPO.gather, FPO.unapply, "gather -> unapply" );
assert.strictEqual( FPO.std.gather, FPO.std.unapply, "std: gather -> unapply" );
assert.strictEqual( FPO.assoc, FPO.setProp, "assoc -> setProp" );
assert.strictEqual( FPO.std.assoc, FPO.std.setProp, "std: assoc -> setProp" );
assert.strictEqual( FPO.filter, FPO.filterIn, "filter -> filterIn" );
assert.strictEqual( FPO.std.filter, FPO.std.filterIn, "std: filter -> filterIn" );
assert.strictEqual( FPO.keep, FPO.filterIn, "keep -> filterIn" );
assert.strictEqual( FPO.std.keep, FPO.std.filterIn, "std: keep -> filterIn" );
assert.strictEqual( FPO.keepObj, FPO.filterInObj, "keepObj -> filterInObj" );
assert.strictEqual( FPO.std.keepObj, FPO.std.filterInObj, "std: keepObj -> filterInObj" );
assert.strictEqual( FPO.filterObj, FPO.filterInObj, "filterObj -> filterInObj" );
assert.strictEqual( FPO.std.filterObj, FPO.std.filterInObj, "std: filterObj -> filterInObj" );
assert.strictEqual( FPO.reject, FPO.filterOut, "reject -> filterOut" );
assert.strictEqual( FPO.std.reject, FPO.std.filterOut, "std: reject -> filterOut" );
assert.strictEqual( FPO.chain, FPO.flatMap, "chain -> flatMap" );
assert.strictEqual( FPO.std.chain, FPO.std.flatMap, "std: chain -> flatMap" );
assert.strictEqual( FPO.chainObj, FPO.flatMapObj, "chainObj -> flatMapObj" );
assert.strictEqual( FPO.std.chainObj, FPO.std.flatMapObj, "std: chainObj -> flatMapObj" );
assert.strictEqual( FPO.fold, FPO.reduce, "fold -> reduce" );
assert.strictEqual( FPO.std.fold, FPO.std.reduce, "std: fold -> reduce" );
assert.strictEqual( FPO.foldL, FPO.reduce, "foldL -> reduce" );
assert.strictEqual( FPO.std.foldL, FPO.std.reduce, "std: foldL -> reduce" );
assert.strictEqual( FPO.foldObj, FPO.reduceObj, "foldObj -> reduceObj" );
assert.strictEqual( FPO.std.foldObj, FPO.std.reduceObj, "std: foldObj -> reduceObj" );
assert.strictEqual( FPO.foldR, FPO.reduceRight, "foldR -> reduceRight" );
assert.strictEqual( FPO.std.foldR, FPO.std.reduceRight, "std: foldR -> reduceRight" );
assert.strictEqual( FPO.transducers.boolean, FPO.transducers.booleanAnd, "transducers.boolean -> transducers.booleanAnd" );
assert.strictEqual( FPO.std.transducers.boolean, FPO.std.transducers.booleanAnd, "std: transducers.boolean -> transducers.booleanAnd" );
} );
QUnit.test( "identity()", function test(assert){
var rExpected = 2;
var pExpected = undefined;
var qExpected = 3;
var rActual = FPO.identity( {v: 2} );
var pActual = FPO.identity()( {} )( { v: undefined } );
var qActual = FPO.identity()( {} )( {v: 3} );
assert.expect( 3 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried with undefined" );
assert.strictEqual( qActual, qExpected, "curried with value" );
} );
QUnit.test( "std.identity()", function test(assert){
var rExpected = 2;
var pExpected = undefined;
var qExpected = 3;
var rActual = FPO.std.identity( 2 );
var pActual = FPO.std.identity()( undefined );
var qActual = FPO.std.identity()( 3 );
assert.expect( 3 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried with undefined" );
assert.strictEqual( qActual, qExpected, "curried with value" );
} );
QUnit.test( "constant()", function test(assert){
var rExpected = 2;
var pExpected = undefined;
var qExpected = 3;
var rActual = FPO.constant( {v: 2} )();
var pActual = FPO.constant()( {} )( { v: undefined } )();
var qActual = FPO.constant()( {} )( {v: 3} )();
assert.expect( 3 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried with undefined" );
assert.strictEqual( qActual, qExpected, "curried with value" );
} );
QUnit.test( "std.constant()", function test(assert){
var rExpected = 2;
var pExpected = undefined;
var qExpected = 3;
var rActual = FPO.std.constant( 2 )();
var pActual = FPO.std.constant()( undefined )();
var qActual = FPO.std.constant()( 3 )();
assert.expect( 3 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried with undefined" );
assert.strictEqual( qActual, qExpected, "curried with value" );
} );
QUnit.test( "pick()", function test(assert){
var obj = { x: 1, y: 2, z: 3, w: 4 };
var rExpected = { x: 1, z: 3 };
var pExpected = { y: 2 };
var qExpected = {};
var tExpected = {};
var rActual = FPO.pick( {v: obj, props: ["x","z","x","f"]} );
var pActual = FPO.pick()( {} )( {v: obj} )( {props: ["y"]} );
var qActual = FPO.pick( {v: obj, props: []} );
var tActual = FPO.pick( {v: obj, props: undefined} );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "empty props" );
assert.deepEqual( tActual, tExpected, "undefined props" );
} );
QUnit.test( "std.pick()", function test(assert){
var obj = { x: 1, y: 2, z: 3, w: 4 };
var rExpected = { x: 1, z: 3 };
var pExpected = { y: 2 };
var qExpected = {};
var tExpected = {};
var rActual = FPO.std.pick( ["x","z","x","f"], obj );
var pActual = FPO.std.pick()( ["y"] )( obj );
var qActual = FPO.std.pick( [], obj );
var tActual = FPO.std.pick( undefined, obj );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "empty props" );
assert.deepEqual( tActual, tExpected, "undefined props" );
} );
QUnit.test( "pickAll()", function test(assert){
var obj = { x: 1, y: 2, z: 3, w: 4 };
var rExpected = { x: 1, z: 3, f: undefined };
var pExpected = { y: 2 };
var qExpected = {};
var tExpected = {};
var rActual = FPO.pickAll( {v: obj, props: ["x","z","x","f"]} );
var pActual = FPO.pickAll()( {} )( {v: obj} )( {props: ["y"]} );
var qActual = FPO.pickAll( {v: obj, props: []} );
var tActual = FPO.pickAll( {v: obj, props: undefined} );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "empty props" );
assert.deepEqual( tActual, tExpected, "undefined props" );
} );
QUnit.test( "std.pickAll()", function test(assert){
var obj = { x: 1, y: 2, z: 3, w: 4 };
var rExpected = { x: 1, z: 3, f: undefined };
var pExpected = { y: 2 };
var qExpected = {};
var tExpected = {};
var rActual = FPO.std.pickAll( ["x","z","x","f"], obj );
var pActual = FPO.std.pickAll()( ["y"] )( obj );
var qActual = FPO.std.pickAll( [], obj );
var tActual = FPO.std.pickAll( undefined, obj );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "empty props" );
assert.deepEqual( tActual, tExpected, "undefined props" );
} );
QUnit.test( "nAry()", function test(assert){
function foo(argsObj) { return argsObj; }
var obj = { x: 1, y: 2, z: 3, w: 4 };
var rExpected = { x: 1, y: 2, w: 4 };
var pExpected = { z: 3, w: 4 };
var qExpected = {};
var tExpected = {};
var sExpected = {};
var rActual = FPO.nAry( {fn: foo, props: ["x","y","w"]} )( obj );
var pActual = FPO.nAry()( {} )( {fn: foo} )( {props: ["w","z"]} )( obj );
var qActual = FPO.nAry( {fn: foo, props: []} )( obj );
var tActual = FPO.nAry( {fn: foo, props: undefined} )( obj );
var sActual = FPO.nAry( {fn: foo, props: ["x"]} )( undefined );
assert.expect( 5 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "empty props (nullary)" );
assert.deepEqual( tActual, tExpected, "undefined props (nullary)" );
assert.deepEqual( sActual, sExpected, "undefined props (nullary), no args" );
} );
QUnit.test( "std.nAry()", function test(assert){
function foo(...args) { return args; }
var args = [1,2,3,4];
var rExpected = [1,2,3];
var pExpected = [1,2];
var qExpected = [];
var tExpected = [];
var rActual = FPO.std.nAry( foo, 3 )( ...args );
var pActual = FPO.std.nAry()( foo )( 2 )( ...args );
var qActual = FPO.std.nAry()( foo )( 0 )( ...args );
var tActual = FPO.std.nAry()( foo )( undefined )( ...args );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "arity 0 (nullary)" );
assert.deepEqual( tActual, tExpected, "undefined arity (nullary)" );
} );
QUnit.test( "unary()", function test(assert){
function foo(argsObj) { return argsObj; }
var obj = { x: 1, y: 2, z: 3, w: 4 };
var rExpected = { y: 2 };
var pExpected = { w: 4 };
var qExpected = {};
var rActual = FPO.unary( {fn: foo, prop: "y"} )( obj );
var pActual = FPO.unary()( {} )( {fn: foo} )( {prop: "w"} )( obj );
var qActual = FPO.unary( {fn: foo, prop: undefined} )( obj );
assert.expect( 3 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "undefined prop" );
} );
QUnit.test( "std.unary()", function test(assert){
function foo(...args) { return args; }
var args = [1,2,3,4];
var rExpected = [1];
var pExpected = [1];
var rActual = FPO.std.unary( foo )( ...args );
var pActual = FPO.std.unary()( foo )( ...args );
assert.expect( 2 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
} );
QUnit.test( "binary()", function test(assert){
function foo(argsObj) { return argsObj; }
var obj = { x: 1, y: 2, z: 3, w: 4 };
var rExpected = { x: 1, y: 2 };
var pExpected = { z: 3, w: 4 };
var qExpected = {};
var tExpected = {};
var rActual = FPO.binary( {fn: foo, props: ["x","y"]} )( obj );
var pActual = FPO.binary()( {} )( {fn: foo} )( {props: ["w","z"]} )( obj );
var qActual = FPO.binary( {fn: foo, props: []} )( obj );
var tActual = FPO.binary( {fn: foo, props: undefined} )( obj );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "empty props" );
assert.deepEqual( tActual, tExpected, "undefined props" );
} );
QUnit.test( "std.binary()", function test(assert){
function foo(...args) { return args; }
var args = [1,2,3,4];
var rExpected = [1,2];
var pExpected = [1,2];
var rActual = FPO.std.binary( foo )( ...args );
var pActual = FPO.std.binary()( foo )( ...args );
assert.expect( 2 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
} );
QUnit.test( "curry()", function test(assert){
function foo(argsObj) { return argsObj; }
var X = { x: 1 };
var XY = { x: 1, y: 2 };
var YZ = { y: 2, z: 3 };
var W = { w: 4 };
var rExpected = { x: 1, y: 2, w: 4 };
var pExpected = { x: 1 };
var qExpected = { x: 1 };
var tExpected = { x: 1 };
var rActual = FPO.curry( {fn: foo, n: 3} )( X )( YZ )( W );
var pActual = FPO.curry()( {} )( {fn: foo} )()( {} )( XY );
var qActual = FPO.curry( {fn: foo, n: undefined} )( XY );
var tActual = FPO.curry( {fn: foo, n: 0} )( XY );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call with arity 3" );
assert.deepEqual( pActual, pExpected, "curried without arity" );
assert.deepEqual( qActual, qExpected, "undefined arity" );
assert.deepEqual( tActual, tExpected, "zero arity" );
} );
QUnit.test( "std.curry()", function test(assert){
function foo(...args) { return args; }
var a1 = [1];
var a12 = [1,2];
var a23 = [2,3];
var a4 = [4];
var rExpected = [1,2,4];
var pExpected = [1];
var qExpected = [1];
var tExpected = [1];
var rActual = FPO.std.curry( foo, 3 )( ...a1 )( ...a23 )( ...a4 );
var pActual = FPO.std.curry()( foo )()( ...a12 );
var qActual = FPO.std.curry( foo, undefined )( ...a12 );
var tActual = FPO.std.curry( foo, 0 )( ...a12 );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call with arity 3" );
assert.deepEqual( pActual, pExpected, "curried without arity" );
assert.deepEqual( qActual, qExpected, "undefined arity" );
assert.deepEqual( tActual, tExpected, "zero arity" );
} );
QUnit.test( "curryMultiple()", function test(assert){
function foo(argsObj) { return argsObj; }
var X = { x: 1 };
var XY = { x: 1, y: 2 };
var YZ = { y: 2, z: 3 };
var W = { w: 4 };
var rExpected = { x: 1, y: 2, z: 3 };
var pExpected = { x: 1, y: 2 };
var qExpected = { x: 1, y: 2 };
var tExpected = { x: 1, y: 2 };
var rActual = FPO.curryMultiple( {fn: foo, n: 3} )( X )( YZ );
var pActual = FPO.curryMultiple()( {} )( {fn: foo} )()( {} )( XY );
var qActual = FPO.curryMultiple( {fn: foo, n: undefined} )( XY );
var tActual = FPO.curryMultiple( {fn: foo, n: 0} )( XY );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call with arity 3" );
assert.deepEqual( pActual, pExpected, "curried without arity" );
assert.deepEqual( qActual, qExpected, "undefined arity" );
assert.deepEqual( tActual, tExpected, "zero arity" );
} );
QUnit.test( "std.curryMultiple()", function test(assert){
function foo(...args) { return args; }
var a1 = [1];
var a12 = [1,2];
var a23 = [2,3];
var a4 = [4];
var rExpected = [1,2,3];
var pExpected = [1,2];
var qExpected = [1,2];
var tExpected = [1,2];
var rActual = FPO.std.curryMultiple( foo, 3 )( ...a1 )( ...a23 );
var pActual = FPO.std.curryMultiple()( foo )()( ...a12 );
var qActual = FPO.std.curryMultiple( foo, undefined )( ...a12 );
var tActual = FPO.std.curryMultiple( foo, 0 )( ...a12 );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call with arity 3" );
assert.deepEqual( pActual, pExpected, "curried without arity" );
assert.deepEqual( qActual, qExpected, "undefined arity" );
assert.deepEqual( tActual, tExpected, "zero arity" );
} );
QUnit.test( "uncurry()", function test(assert){
function foo(argsObj) { return argsObj; }
var XYZ = { x: 1, y: 2, z: 3 };
var XY = { x: 1, y: 2 };
var fn1 = FPO.curry( {fn: foo, n: 3} );
var fn2 = FPO.curry( {fn: foo, n: 2} );
var rExpected = { x: 1, y: 2, z: 3 };
var pExpected = { x: 1, y: 2 };
var rActual = FPO.uncurry( {fn: fn1} )( XYZ );
var pActual = FPO.uncurry()( {} )( {fn: fn2} )( XY );
var qActual = FPO.uncurry( {fn: fn1} )( undefined );
assert.expect( 3 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.ok( typeof qActual == "function", "no args" );
} );
QUnit.test( "std.uncurry()", function test(assert){
function foo(...args) { return args; }
var a123 = [1,2,3];
var a12 = [1,2];
var fn1 = FPO.std.curry( foo, 3 );
var fn2 = FPO.std.curry( foo, 2 );
var rExpected = [1,2,3];
var pExpected = [1,2];
var rActual = FPO.std.uncurry( fn1 )( ...a123 );
var pActual = FPO.std.uncurry()( fn2 )( ...a12 );
assert.expect( 2 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
} );
QUnit.test( "partial()", function test(assert){
function foo(argsObj) { return argsObj; }
var X = { x: 1 };
var Y = { y: 2 };
var Z = { z: 3 };
var XY = { x: 1, y: 2 };
var rExpected = { x: 1, y: 2, z: 3 };
var pExpected = { x: 1, y: 2 };
var qExpected = { x: 1 };
var tExpected = { x: 1 };
var sExpected = { z: 3 };
var rActual = FPO.partial( {fn: foo, args: Z} )( XY );
var pActual = FPO.partial()( {} )( {fn: foo} )( {args: Y} )( X );
var qActual = FPO.partial( {fn: foo, args: undefined} )( X );
var tActual = FPO.partial( {fn: foo, args: {}} )( X );
var sActual = FPO.partial( {fn: foo, args: Z} )( undefined );
assert.expect( 5 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried with partial args" );
assert.deepEqual( qActual, qExpected, "undefined partial args" );
assert.deepEqual( tActual, tExpected, "empty partial args" );
assert.deepEqual( sActual, sExpected, "no args" );
} );
QUnit.test( "std.partial()", function test(assert){
function foo(...args) { return args; }
var a1 = [1];
var a12 = [1,2];
var a23 = [2,3];
var a3 = [3];
var rExpected = [1,2,3];
var pExpected = [1,2,3];
var qExpected = [3];
var tExpected = [3];
var rActual = FPO.std.partial( foo, a1 )( ...a23 );
var pActual = FPO.std.partial()( foo )()( a12 )( ...a3 );
var qActual = FPO.std.partial( foo, undefined )( ...a3 );
var tActual = FPO.std.partial( foo, [] )( ...a3 );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried with partial args" );
assert.deepEqual( qActual, qExpected, "undefined partial args" );
assert.deepEqual( tActual, tExpected, "empty partial args" );
} );
QUnit.test( "std.partialRight()", function test(assert){
function foo(...args) { return args; }
var a1 = [1];
var a12 = [1,2];
var a23 = [2,3];
var a3 = [3];
var rExpected = [2,3,1];
var pExpected = [3,1,2];
var qExpected = [3];
var tExpected = [3];
var rActual = FPO.std.partialRight( foo, a1 )( ...a23 );
var pActual = FPO.std.partialRight()( foo )()( a12 )( ...a3 );
var qActual = FPO.std.partialRight( foo, undefined )( ...a3 );
var tActual = FPO.std.partialRight( foo, [] )( ...a3 );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried with partial args" );
assert.deepEqual( qActual, qExpected, "undefined partial args" );
assert.deepEqual( tActual, tExpected, "empty partial args" );
} );
QUnit.test( "complement()", function test(assert){
function xPlusYEven(argsObj) { return (argsObj.x + argsObj.y) % 2 == 0; }
var XY12 = { x: 1, y: 2 };
var XY24 = { x: 2, y: 4 };
var rExpected = true;
var pExpected = false;
var rActual = FPO.complement( {fn: xPlusYEven} )( XY12 );
var pActual = FPO.complement()( {} )( { fn: xPlusYEven } )( XY24 );
assert.expect( 2 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried" );
} );
QUnit.test( "std.complement()", function test(assert){
function argPlusArgEven(...args) { return (args[0] + args[1]) % 2 == 0; }
var a12 = [1,2];
var a24 = [2,4];
var rExpected = true;
var pExpected = false;
var rActual = FPO.std.complement( argPlusArgEven )( ...a12 );
var pActual = FPO.std.complement()( argPlusArgEven )( ...a24 );
assert.expect( 2 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried" );
} );
QUnit.test( "apply()", function test(assert){
function foo(x,y,z) { return {x,y,z}; }
var obj = { y: 2, z: 3, x: 1 };
var rExpected = { x: 1, y: 2, z: 3 };
var pExpected = { x: 3, y: 2, z: 1 };
var qExpected = { x: 1, y: 2, z: 3 };
var tExpected = { x: undefined, y: undefined, z: undefined };
var rActual = FPO.apply( {fn: foo} )( obj );
// NOTE: intentionally reversing applied prop order
var pActual = FPO.apply()( {} )( {fn: foo, props: ["z","y","x"]} )( obj );
var qActual = FPO.apply( {fn: foo, props: undefined} )( obj );
var tActual = FPO.apply( {fn: foo, props: []} )( obj );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call without props" );
assert.deepEqual( pActual, pExpected, "curried with reversed props" );
assert.deepEqual( qActual, qExpected, "undefined props" );
assert.deepEqual( tActual, tExpected, "empty props" );
} );
QUnit.test( "std.apply(..)", function test(assert){
function foo(...args) { return args; }
var arr = [1,2,3];
var rExpected = [1,2,3];
var pExpected = [1,2,3];
var rActual = FPO.std.apply( foo )( arr );
var pActual = FPO.std.apply()( foo )( arr );
assert.expect( 2 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
} );
QUnit.test( "unapply()", function test(assert){
function foo({x,y,z}) { return {x,y,z}; }
var args = [1,2,3];
var rExpected = { x: 1, y: 2, z: 3 };
var pExpected = { x: 3, y: 2, z: 1 };
var qExpected = { x: undefined, y: undefined, z: undefined };
var tExpected = { x: undefined, y: undefined, z: undefined };
var rActual = FPO.unapply( {fn: foo, props: ["x","y","z"]} )( ...args );
// NOTE: intentionally reversing applied prop order
var pActual = FPO.unapply()( {} )( {fn: foo, props: ["z","y","x"]} )( ...args );
var qActual = FPO.unapply( {fn: foo, props: undefined} )( ...args );
var tActual = FPO.unapply( {fn: foo, props: []} )( ...args );
assert.expect( 4 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried with reversed props" );
assert.deepEqual( qActual, qExpected, "undefined props" );
assert.deepEqual( tActual, tExpected, "empty props" );
} );
QUnit.test( "std.unapply()", function test(assert){
function foo(args) { return args; }
var arr = [1,2,3];
var rExpected = [1,2,3];
var pExpected = [1,2,3];
var rActual = FPO.std.unapply( foo )( ...arr );
var pActual = FPO.std.unapply()( foo )( ...arr );
assert.expect( 2 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
} );
QUnit.test( "compose()", function test(assert){
function foo({v}) { return `foo,${v}`; }
function bar({v}) { return `bar,${v}`; }
function baz({v}) { return `baz,${v}`; }
var v = 3;
var rExpected = "foo,bar,baz,3";
var pExpected = "foo,3";
var qExpected = 3;
var tExpected = 3;
var rActual = FPO.compose( {fns: [foo,bar,baz]} )( {v} );
var pActual = FPO.compose()( {} )( {fns: [foo]} )( {v} );
var qActual = FPO.compose( {fns: undefined} )( {v} );
var tActual = FPO.compose( {fns: []} )( {v} );
assert.expect( 4 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried" );
assert.strictEqual( qActual, qExpected, "functions list undefined" );
assert.strictEqual( tActual, tExpected, "functions list empty" );
} );
QUnit.test( "std.compose()", function test(assert){
function foo(v) { return `foo,${v}`; }
function bar(v) { return `bar,${v}`; }
function baz(v) { return `baz,${v}`; }
var arr = [3,4];
var rExpected = "foo,bar,baz,3";
var pExpected = "foo,3";
var qExpected = 3;
var tExpected = 3;
var rActual = FPO.std.compose( [foo,bar,baz] )( ...arr );
var pActual = FPO.std.compose()( [foo] )( ...arr );
var qActual = FPO.std.compose( undefined )( ...arr );
var tActual = FPO.std.compose( [] )( ...arr );
assert.expect( 4 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried" );
assert.strictEqual( qActual, qExpected, "functions list undefined" );
assert.strictEqual( tActual, tExpected, "functions list empty" );
} );
QUnit.test( "pipe()", function test(assert){
function foo({v}) { return `foo,${v}`; }
function bar({v}) { return `bar,${v}`; }
function baz({v}) { return `baz,${v}`; }
var v = 3;
var rExpected = "foo,bar,baz,3";
var pExpected = "foo,3";
var qExpected = 3;
var tExpected = 3;
var rActual = FPO.pipe( {fns: [baz,bar,foo]} )( {v} );
var pActual = FPO.pipe()( {} )( {fns: [foo]} )( {v} );
var qActual = FPO.pipe( {fns: undefined} )( {v} );
var tActual = FPO.pipe( {fns: []} )( {v} );
assert.expect( 4 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried" );
assert.strictEqual( qActual, qExpected, "functions list undefined" );
assert.strictEqual( tActual, tExpected, "functions list empty" );
} );
QUnit.test( "std.pipe()", function test(assert){
function foo(v) { return `foo,${v}`; }
function bar(v) { return `bar,${v}`; }
function baz(v) { return `baz,${v}`; }
var arr = [3,4];
var rExpected = "foo,bar,baz,3";
var pExpected = "foo,3";
var qExpected = 3;
var tExpected = 3;
var rActual = FPO.std.pipe( [baz,bar,foo] )( ...arr );
var pActual = FPO.std.pipe()( [foo] )( ...arr );
var qActual = FPO.std.pipe( undefined )( ...arr );
var tActual = FPO.std.pipe( [] )( ...arr );
assert.expect( 4 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried" );
assert.strictEqual( qActual, qExpected, "functions list undefined" );
assert.strictEqual( tActual, tExpected, "functions list empty" );
} );
QUnit.test( "prop()", function test(assert){
var obj1 = { x: 1, y: 2, z: 3, w: 4 };
var obj2 = { x: 1, y: 2 };
var rExpected = 1;
var pExpected = 2;
var qExpected = 3;
var tExpected = undefined;
var sExpected = undefined;
var uExpected = undefined;
var f = FPO.prop( {prop: "z"} );
var rActual = FPO.prop( {v: obj1, prop: "x"} );
var pActual = FPO.prop()( {} )( {v: obj1} )()( {} )( {prop: "y"} );
var qActual = f( {v: obj1} )
var tActual = f( {v: obj2} );
var sActual = FPO.prop( {prop: undefined, v: undefined} );
var uActual = FPO.prop( {prop: "", v: {}} );
assert.expect( 6 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried" );
assert.strictEqual( qActual, qExpected, "with obj1" );
assert.strictEqual( tActual, tExpected, "with obj2" );
assert.strictEqual( sActual, sExpected, "prop and object undefined" );
assert.strictEqual( uActual, uExpected, "prop and object empty" );
} );
QUnit.test( "std.prop()", function test(assert){
var obj1 = { x: 1, y: 2, z: 3, w: 4 };
var obj2 = { x: 1, y: 2 };
var rExpected = 1;
var pExpected = 2;
var qExpected = undefined;
var tExpected = undefined;
var rActual = FPO.std.prop( "x", obj1 );
var pActual = FPO.std.prop()( "y" )( obj1 );
var qActual = FPO.std.prop( undefined, undefined );
var tActual = FPO.std.prop( "", {} );
assert.expect( 4 );
assert.strictEqual( rActual, rExpected, "regular call" );
assert.strictEqual( pActual, pExpected, "curried" );
assert.strictEqual( qActual, qExpected, "prop and object undefined" );
assert.strictEqual( tActual, tExpected, "prop and object empty" );
} );
QUnit.test( "setProp()", function test(assert){
var obj1 = { x: 1, y: 2, z: 3, w: 4 };
var obj2 = { x: 1, y: 2 };
var v10 = { v: 10 };
var rExpected = { x: 10, y: 2, z: 3, w: 4 };
var pExpected = { x: 1, y: 2, z: 10 };
var qExpected = { "": 10 };
var tExpected = { "": 10 };
var rActual = FPO.setProp( {o: obj1, prop: "x"} )( v10 );
var pActual = FPO.setProp()( v10 )( {} )( {prop: "z"} )( {} )( {o: obj2} );
var qActual = FPO.setProp( v10 )( {prop: undefined, o: undefined} );
var tActual = FPO.setProp( v10 )( {prop: "", o: {}} );
assert.expect( 5 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "prop and object undefined" );
assert.deepEqual( tActual, tExpected, "prop and object empty" );
assert.notStrictEqual( rActual, obj1, "object is cloned, not mutated" );
} );
QUnit.test( "std.setProp()", function test(assert){
var obj1 = { x: 1, y: 2, z: 3, w: 4 };
var obj2 = { x: 1, y: 2 };
var rExpected = { x: 10, y: 2, z: 3, w: 4 };
var pExpected = { x: 1, y: 2, z: 10 };
var qExpected = { "": 10 };
var tExpected = { "": 10 };
var rActual = FPO.std.setProp( "x", obj1 )( 10 );
var pActual = FPO.std.setProp()( "z" )()( obj2 )( 10 );
var qActual = FPO.std.setProp( undefined, undefined, 10 );
var tActual = FPO.std.setProp( "", {}, 10 );
assert.expect( 5 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "prop and object undefined" );
assert.deepEqual( tActual, tExpected, "prop and object empty" );
assert.notStrictEqual( rActual, obj1, "object is cloned, not mutated" );
} );
QUnit.test( "reassoc()", function test(assert){
var obj = { x: 1, y: 2, z: 3, w: 4 };
var props1 = { x: "a", y: "b" };
var props2 = { A: "B" };
var rExpected = { a: 1, b: 2, z: 3, w: 4 };
var pExpected = { a: 1, b: 2, z: 3, w: 4 };
var qExpected = { x: 1, y: 2, z: 3, w: 4 };
var tExpected = { x: 1, y: 2, z: 3, w: 4 };
var sExpected = { x: 1, y: 2, z: 3, w: 4 };
var rActual = FPO.reassoc( {props: props1, v: obj} );
var pActual = FPO.reassoc()( {} )( {props: props1} )()( {v: obj} );
var qActual = FPO.reassoc( {props: props2, v: obj} );
var tActual = FPO.reassoc( {props: undefined, v: obj} );
var sActual = FPO.reassoc( {props: {}, v: obj} );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "props not present on source object" );
assert.deepEqual( tActual, tExpected, "props undefined" );
assert.deepEqual( sActual, sExpected, "props empty" );
assert.notStrictEqual( tActual, tExpected, "object is cloned, not mutated" );
} );
QUnit.test( "std.reassoc()", function test(assert){
var obj = { x: 1, y: 2, z: 3, w: 4 };
var props1 = { x: "a", y: "b" };
var props2 = { A: "B" };
var rExpected = { a: 1, b: 2, z: 3, w: 4 };
var pExpected = { a: 1, b: 2, z: 3, w: 4 };
var qExpected = { x: 1, y: 2, z: 3, w: 4 };
var tExpected = { x: 1, y: 2, z: 3, w: 4 };
var sExpected = { x: 1, y: 2, z: 3, w: 4 };
var rActual = FPO.std.reassoc( props1, obj );
var pActual = FPO.std.reassoc()( props1 )()( obj );
var qActual = FPO.std.reassoc( props2, obj );
var tActual = FPO.std.reassoc( undefined, obj );
var sActual = FPO.std.reassoc( {}, obj );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "props not present on source object" );
assert.deepEqual( tActual, tExpected, "props undefined" );
assert.deepEqual( sActual, sExpected, "props empty" );
assert.notStrictEqual( tActual, tExpected, "object is cloned, not mutated" );
} );
QUnit.test( "filterIn()", function test(assert){
function checkParams({ v, i, arr }) {
if (
arr === list &&
typeof v == "number" && typeof i == "number" && _isArray( arr ) &&
v === (i + 1) && arr[i] === v
) {
return false;
}
return true;
}
function isEven({ v }) { return v % 2 == 0; }
function alwaysFalse() { return false; }
var list = [1,2,3,4,5];
var rExpected = [2,4];
var pExpected = [2,4];
var qExpected = [];
var tExpected = [];
var sExpected = [];
var uExpected = [];
var rActual = FPO.filterIn( {fn: isEven, arr: list} );
var pActual = FPO.filterIn()( {} )( {fn: isEven} )()( {arr: list} );
var qActual = FPO.filterIn( {fn: alwaysFalse, arr: list} );
var tActual = FPO.filterIn( {fn: isEven, arr: undefined} );
var sActual = FPO.filterIn( {fn: isEven, arr: []} );
var uActual = FPO.filterIn( {fn: checkParams, arr: list} );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "always false predicate" );
assert.deepEqual( tActual, tExpected, "array undefined" );
assert.deepEqual( sActual, sExpected, "array empty" );
assert.deepEqual( uActual, uExpected, "predicate params check" );
} );
QUnit.test( "std.filterIn()", function test(assert){
function checkParams(v,i,arr) {
if (
arr === list &&
typeof v == "number" && typeof i == "number" && _isArray( arr ) &&
v === (i + 1) && arr[i] === v
) {
return false;
}
return true;
}
function isEven(v) { return v % 2 == 0; }
function alwaysFalse() { return false; }
var list = [1,2,3,4,5];
var rExpected = [2,4];
var pExpected = [2,4];
var qExpected = [];
var tExpected = [];
var sExpected = [];
var uExpected = [];
var rActual = FPO.std.filterIn( isEven, list );
var pActual = FPO.std.filterIn()( isEven )()( list );
var qActual = FPO.std.filterIn( alwaysFalse, list );
var tActual = FPO.std.filterIn( isEven, undefined );
var sActual = FPO.std.filterIn( isEven, [] );
var uActual = FPO.std.filterIn( checkParams, list );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "always false predicate" );
assert.deepEqual( tActual, tExpected, "array undefined" );
assert.deepEqual( sActual, sExpected, "array empty" );
assert.deepEqual( uActual, uExpected, "predicate params check" );
} );
QUnit.test( "filterInObj()", function test(assert){
function checkParams({ v, i, o }) {
if (
o === obj &&
typeof v == "number" && typeof i == "string" && _isObject( o ) &&
o[i] === v
) {
return false;
}
return true;
}
function isEven({ v }) { return v % 2 == 0; }
function alwaysFalse() { return false; }
var obj = {a: 1, b: 2, c: 3, d: 4, e: 5};
var rExpected = {b: 2, d: 4};
var pExpected = {b: 2, d: 4};
var qExpected = {};
var tExpected = {};
var sExpected = {};
var uExpected = {};
var rActual = FPO.filterInObj( {fn: isEven, o: obj} );
var pActual = FPO.filterInObj()( {} )( {fn: isEven} )()( {o: obj} );
var qActual = FPO.filterInObj( {fn: alwaysFalse, o: obj} );
var tActual = FPO.filterInObj( {fn: isEven, o: undefined} );
var sActual = FPO.filterInObj( {fn: isEven, o: []} );
var uActual = FPO.filterInObj( {fn: checkParams, o: obj} );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "always false predicate" );
assert.deepEqual( tActual, tExpected, "array undefined" );
assert.deepEqual( sActual, sExpected, "array empty" );
assert.deepEqual( uActual, uExpected, "predicate params check" );
} );
QUnit.test( "std.filterInObj()", function test(assert){
function checkParams(v,i,o) {
if (
o === obj &&
typeof v == "number" && typeof i == "string" && _isObject( o ) &&
o[i] === v
) {
return false;
}
return true;
}
function isEven(v) { return v % 2 == 0; }
function alwaysFalse() { return false; }
var obj = {a: 1, b: 2, c: 3, d: 4, e: 5};
var rExpected = {b: 2, d: 4};
var pExpected = {b: 2, d: 4};
var qExpected = {};
var tExpected = {};
var sExpected = {};
var uExpected = {};
var rActual = FPO.std.filterInObj( isEven, obj );
var pActual = FPO.std.filterInObj()( isEven )()( obj );
var qActual = FPO.std.filterInObj( alwaysFalse, obj );
var tActual = FPO.std.filterInObj( isEven, undefined );
var sActual = FPO.std.filterInObj( isEven, {} );
var uActual = FPO.std.filterInObj( checkParams, obj );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "always false predicate" );
assert.deepEqual( tActual, tExpected, "array undefined" );
assert.deepEqual( sActual, sExpected, "array empty" );
assert.deepEqual( uActual, uExpected, "predicate params check" );
} );
QUnit.test( "filterOut()", function test(assert){
function checkParams({ v, i, arr }) {
if (
arr === list &&
typeof v == "number" && typeof i == "number" && _isArray( arr ) &&
v === (i + 1) && arr[i] === v
) {
return true;
}
return false;
}
function isEven({ v }) { return v % 2 == 0; }
function alwaysTrue() { return true; }
var list = [1,2,3,4,5];
var rExpected = [1,3,5];
var pExpected = [1,3,5];
var qExpected = [];
var tExpected = [];
var sExpected = [];
var uExpected = [];
var rActual = FPO.filterOut( {fn: isEven, arr: list} );
var pActual = FPO.filterOut()( {} )( {fn: isEven} )()( {arr: list} );
var qActual = FPO.filterOut( {fn: alwaysTrue, arr: list} );
var tActual = FPO.filterOut( {fn: isEven, arr: undefined} );
var sActual = FPO.filterOut( {fn: isEven, arr: []} );
var uActual = FPO.filterOut( {fn: checkParams, arr: list} );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "always true predicate" );
assert.deepEqual( tActual, tExpected, "array undefined" );
assert.deepEqual( sActual, sExpected, "array empty" );
assert.deepEqual( uActual, uExpected, "predicate params check" );
} );
QUnit.test( "std.filterOut()", function test(assert){
function checkParams(v,i,arr) {
if (
arr === list &&
typeof v == "number" && typeof i == "number" && _isArray( arr ) &&
v === (i + 1) && arr[i] === v
) {
return true;
}
return false;
}
function isEven(v) { return v % 2 == 0; }
function alwaysTrue() { return true; }
var list = [1,2,3,4,5];
var rExpected = [1,3,5];
var pExpected = [1,3,5];
var qExpected = [];
var tExpected = [];
var sExpected = [];
var uExpected = [];
var rActual = FPO.std.filterOut( isEven, list );
var pActual = FPO.std.filterOut()( isEven )()( list );
var qActual = FPO.std.filterOut( alwaysTrue, list );
var tActual = FPO.std.filterOut( isEven, undefined );
var sActual = FPO.std.filterOut( isEven, [] );
var uActual = FPO.std.filterOut( checkParams, list );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "always true predicate" );
assert.deepEqual( tActual, tExpected, "array undefined" );
assert.deepEqual( sActual, sExpected, "array empty" );
assert.deepEqual( uActual, uExpected, "predicate params check" );
} );
QUnit.test( "filterOutObj()", function test(assert){
function checkParams({ v, i, o }) {
if (
o === obj &&
typeof v == "number" && typeof i == "string" && _isObject( o ) &&
o[i] === v
) {
return true;
}
return false;
}
function isEven({ v }) { return v % 2 == 0; }
function alwaysTrue() { return true; }
var obj = {a: 1, b: 2, c: 3, d: 4, e: 5};
var rExpected = {a: 1, c: 3, e: 5};
var pExpected = {a: 1, c: 3, e: 5};
var qExpected = {};
var tExpected = {};
var sExpected = {};
var uExpected = {};
var rActual = FPO.filterOutObj( {fn: isEven, o: obj} );
var pActual = FPO.filterOutObj()( {} )( {fn: isEven} )()( {o: obj} );
var qActual = FPO.filterOutObj( {fn: alwaysTrue, o: obj} );
var tActual = FPO.filterOutObj( {fn: isEven, o: undefined} );
var sActual = FPO.filterOutObj( {fn: isEven, o: {}} );
var uActual = FPO.filterOutObj( {fn: checkParams, o: obj} );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "always true predicate" );
assert.deepEqual( tActual, tExpected, "array undefined" );
assert.deepEqual( sActual, sExpected, "array empty" );
assert.deepEqual( uActual, uExpected, "predicate params check" );
} );
QUnit.test( "std.filterOutObj()", function test(assert){
function checkParams(v,i,o) {
if (
o === obj &&
typeof v == "number" && typeof i == "string" && _isObject( o ) &&
o[i] === v
) {
return true;
}
return false;
}
function isEven(v) { return v % 2 == 0; }
function alwaysTrue() { return true; }
var obj = {a: 1, b: 2, c: 3, d: 4, e: 5};
var rExpected = {a: 1, c: 3, e: 5};
var pExpected = {a: 1, c: 3, e: 5};
var qExpected = {};
var tExpected = {};
var sExpected = {};
var uExpected = {};
var rActual = FPO.std.filterOutObj( isEven, obj );
var pActual = FPO.std.filterOutObj()( isEven )()( obj );
var qActual = FPO.std.filterOutObj( alwaysTrue, obj );
var tActual = FPO.std.filterOutObj( isEven, undefined );
var sActual = FPO.std.filterOutObj( isEven, {} );
var uActual = FPO.std.filterOutObj( checkParams, obj );
assert.expect( 6 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "always true predicate" );
assert.deepEqual( tActual, tExpected, "array undefined" );
assert.deepEqual( sActual, sExpected, "array empty" );
assert.deepEqual( uActual, uExpected, "predicate params check" );
} );
QUnit.test( "map()", function test(assert){
function checkParams({ v, i, arr }) {
if (
arr === list &&
typeof v == "number" && typeof i == "number" && _isArray( arr ) &&
v === (i + 1) && arr[i] === v
) {
return true;
}
return false;
}
function mul10({ v }) { return v * 10; }
var list = [1,2];
var rExpected = [10,20];
var pExpected = [10,20];
var qExpected = [];
var tExpected = [];
var sExpected = [true,true];
var rActual = FPO.map( {fn: mul10, arr: list} );
var pActual = FPO.map()( {} )( {fn: mul10} )()( {arr: list} );
var qActual = FPO.map( {fn: mul10, arr: undefined} );
var tActual = FPO.map( {fn: mul10, arr: []} );
var sActual = FPO.map( {fn: checkParams, arr: list} );
assert.expect( 5 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "array undefined" );
assert.deepEqual( tActual, tExpected, "array empty" );
assert.deepEqual( sActual, sExpected, "mapper params check" );
} );
QUnit.test( "std.map()", function test(assert){
function checkParams(v,i,arr) {
if (
arr === list &&
typeof v == "number" && typeof i == "number" && _isArray( arr ) &&
v === (i + 1) && arr[i] === v
) {
return true;
}
return false;
}
function mul10(v) { return v * 10; }
var list = [1,2];
var rExpected = [10,20];
var pExpected = [10,20];
var qExpected = [];
var tExpected = [];
var sExpected = [true,true];
var rActual = FPO.std.map( mul10, list );
var pActual = FPO.std.map()( mul10 )()( list );
var qActual = FPO.std.map( mul10, undefined );
var tActual = FPO.std.map( mul10, [] );
var sActual = FPO.std.map( checkParams, list );
assert.expect( 5 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual, pExpected, "curried" );
assert.deepEqual( qActual, qExpected, "array undefined" );
assert.deepEqual( tActual, tExpected, "array empty" );
assert.deepEqual( sActual, sExpected, "mapper params check" );
} );
QUnit.test( "mapObj()", function test(assert){
function checkParams({ v, i, o }) {
if (
o === obj &&
typeof v == "number" && typeof i == "string" && _isObject( o ) &&
v === o[i]
) {
return true;
}
return false;
}
function mul10({ v }) { return v * 10; }
var obj = {a: 1, b: 2};
var rExpected = {a: 10, b: 20};
var pExpected = {a: 10, b: 20};
var qExpected = {};
var tExpected = {};
var sExpected = {a: true, b: true};
var rActual = FPO.mapObj( {fn: mul10, o: obj} );
var pActual = FPO.mapObj()( {} )( {fn: mul10} )()( {o: obj} );
var qActual = FPO.mapObj( {fn: mul10, o: undefined} );
var tActual = FPO.mapObj( {fn: mul10, o: {}} );
var sActual = FPO.mapObj( {fn: checkParams, o: obj} );
assert.expect( 5 );
assert.deepEqual( rActual, rExpected, "regular call" );
assert.deepEqual( pActual,