External module common

• @example ```

let vals = [ 0, null, undefined ]; vals.reduce(anyTrueR, true); // false

vals.push("hello world"); vals.reduce(anyTrueR, true); // true ```

Each iteration sets the key/val pair on the memo object, then returns the memo for the next iteration.

Each keyValueTuple should be an array with values [ key: string, value: any ]

example

var pairs = [ ["fookey", "fooval"], ["barkey", "barval"] ]

var pairsToObj = pairs.reduce((memo, pair) => applyPairs(memo, pair), {})
// pairsToObj == { fookey: "fooval", barkey: "barval" }

// Or, more simply:
var pairsToObj = pairs.reduce(applyPairs, {})
// pairsToObj == { fookey: "fooval", barkey: "barval" }

example

let foo = [ 0, 2, 4, 6 ];
let bar = [ 1, 3, 5, 7 ];
let baz = [ 10, 30, 50, 70 ];
arrayTuples(foo, bar);       // [ [0, 1], [2, 3], [4, 5], [6, 7] ]
arrayTuples(foo, bar, baz);  // [ [0, 1, 10], [2, 3, 30], [4, 5, 50], [6, 7, 70] ]

Takes functions from the 'from' object, binds those functions to the _this object, and puts the bound functions on the 'to' object.

This example creates an new class instance whose functions are prebound to the new'd object.

example

class Foo {
  constructor(data) {
    // Binds all functions from Foo.prototype to 'this',
    // then copies them to 'this'
    bindFunctions(Foo.prototype, this, this);
    this.data = data;
  }

  log() {
    console.log(this.data);
  }
}

let myFoo = new Foo([1,2,3]);
var logit = myFoo.log;
logit(); // logs [1, 2, 3] from the myFoo 'this' instance

This example creates a bound version of a service function, and copies it to another object

example

var SomeService = {
  this.data = [3, 4, 5];
  this.log = function() {
    console.log(this.data);
  }
}

// Constructor fn
function OtherThing() {
  // Binds all functions from SomeService to SomeService,
  // then copies them to 'this'
  bindFunctions(SomeService, this, SomeService);
}

let myOtherThing = new OtherThing();
myOtherThing.log(); // logs [3, 4, 5] from SomeService's 'this'

Given a function with N parameters, returns a new function that supports partial application. The new function accepts anywhere from 1 to N parameters. When that function is called with M parameters, where M is less than N, it returns a new function that accepts the remaining parameters. It continues to accept more parameters until all N parameters have been supplied.

This contrived example uses a partially applied function as an predicate, which returns true if an object is found in both arrays.

example

// returns true if an object is in both of the two arrays
function inBoth(array1, array2, object) {
  return array1.indexOf(object) !== -1 &&
         array2.indexOf(object) !== 1;
}
let obj1, obj2, obj3, obj4, obj5, obj6, obj7
let foos = [obj1, obj3]
let bars = [obj3, obj4, obj5]

// A curried "copy" of inBoth
let curriedInBoth = curry(inBoth);
// Partially apply both the array1 and array2
let inFoosAndBars = curriedInBoth(foos, bars);

// Supply the final argument; since all arguments are
// supplied, the original inBoth function is then called.
let obj1InBoth = inFoosAndBars(obj1); // false

// Use the inFoosAndBars as a predicate.
// Filter, on each iteration, supplies the final argument
let allObjs = [ obj1, obj2, obj3, obj4, obj5, obj6, obj7 ];
let foundInBoth = allObjs.filter(inFoosAndBars); // [ obj3 ]

Stolen from: http://stackoverflow.com/questions/4394747/javascript-curry-function

A value is "injectable" if it is a function, or if it is an ng1 array-notation-style array where all the elements in the array are Strings, except the last one, which is a Function

If the string is already less than the max length, return the string. Else return the string, shortened to max - 3 and append three dots ("...").

example

var foo = { a: 1, b: 2, c: 3 };
var ab = omit(foo, ['a', 'b']); // { c: 3 }

example

var foo = { a: 1, b: 2, c: 3 };
var ab = omit(foo, 'a', 'b'); // { c: 3 }

If the string is already longer than the desired length, return the string. Else returns the string, with extra spaces on the end, such that it reaches length characters.

See http://c2.com/cgi/wiki?PatternMatching

This is a conditional construct which allows a series of predicates and output functions to be checked and then applied. Each predicate receives the input. If the predicate returns truthy, then its matching output function (mapping function) is provided with the input and, then the result is returned.

Each combination (2-tuple) of predicate + output function should be placed in an array of size 2: [ predicate, mapFn ]

These 2-tuples should be put in an outer array.

example

// Here's a 2-tuple where the first element is the isString predicate
// and the second element is a function that returns a description of the input
let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];

// Second tuple: predicate "isNumber", mapfn returns a description
let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];

let third = [ (input) => input === null,  (input) => `Oh, null...` ];

let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];

let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);

console.log(descriptionOf(undefined)); // 'notdefined'
console.log(descriptionOf(55)); // '(55) That's a number!'
console.log(descriptionOf("foo")); // 'Here's your string foo'

example

var foo = { a: 1, b: 2, c: 3 };
var ab = pick(foo, ['a', 'b']); // { a: 1, b: 2 }

example

var foo = { a: 1, b: 2, c: 3 };
var ab = pick(foo, 'a', 'b'); // { a: 1, b: 2 }