Functions as First-Class Things

A number can be stored in a variable and so can a function:

  var fortytwo = function() { return 42 };

A number can be stored in an array slot and so can a function:

var fortytwos = [42, function() { return 42 }];

A number can be stored in an object field and so can a function:

var fortytwos = {number: 42, fun: function() { return 42 }};

A number can be created as needed and so can a function:

42 + (function() { return 42 })();
//=> 84

A number can be passed to a function and so can a function:

function weirdAdd(n, f) { return n + f() }
weirdAdd(42, function() { return 42 });
//=> 84

A number can be returned from a function and so can a function:

return 42;
return function() { return 42 };

_.each(['whiskey', 'tango', 'foxtrot'], function(word) {
 console.log(word.charAt(0).toUpperCase() + word.substr(1));
});
// (console) Whiskey
// (console) Tango
// (console) Foxtrot

JavaScript's Multiple Paradigms

Imperative programming Programming based around describing actions in detail Prototype-based object-oriented programming Programming based around prototypical objects and instances of them Metaprogramming Programming manipulating the basis of JavaScript's execution model

Imperative programming

var lyrics = [];
for (var bottles = 99; bottles > 0; bottles--) {
 lyrics.push(bottles + " bottles of beer on the wall");
 lyrics.push(bottles + " bottles of beer");
 lyrics.push("Take one down, pass it around");
 if (bottles > 1) {
 lyrics.push((bottles - 1) + " bottles of beer on the wall.");
 }
 else {
 lyrics.push("No more bottles of beer on the wall!");
 }
}

function lyricsSegment(n) {
  return _.chain([])
    .push(n + "bottles of beer on the wall")
    .push(n + "bottles of beer")
    .push("Take one down, pass it around")
    .tap(function(lyrics) {
      if(n > 1)
        lyrics.push((n - 1) + "bottles of beer on the wall.");
      else
        lyrics.push("No more bottles of beer on the wall!");
    })
    .value();
}

Prototype-based object-oriented programming

var a = {name: "a", fun: function () { return this; }};
a.fun();
//=> {name: "a", fun: ...};

var bFunc = function () { return this };
var b = {name: "b", fun: bFunc};
b.fun();
//=> some global object, probably Window

Metaprogramming

function Point2D(x, y) {
  this._x = x;
  this._y = y;
}

new Point2D(0, 1);
//=> {_x: 0, _y: 1}

function Point3D(x, y, z) {
  Point2D.call(this, x, y);
  this._z = z;
}

new Point3D(10, -1, 100);
//=> {_x: 10, _y: -1, _z: 100}

Applicative Programming

var nums = [1,2,3,4,5];
function doubleAll(array) {
  return _.map(array, function(n) {return n*2});
}

doubleAll(nums);
//=> [2, 4, 6, 8, 10]

function average(array) {
  var sum = _.reduce(array, function(a, b) {return a+b});
  return sum / _.size(array);
}

average(nums);
//=> 3

/* grab only even numbers in nums */
function onlyEven(array) {
 return _.filter(array, function(n) {
 return (n%2) === 0;
 });
}
onlyEven(nums);
//=> [2, 4]

_.map calls a function on every value in a collection in turn, returning a collection of the results

_.reduce collects a composite value from the incremental results of a supplied with an accumulation value and each value in a collection

_.filter calls a predicate function (one returning a true or false value) and grabs each value where said predicate returned true, returning them in a new collection

Collection-Centric Programming

_.map({a: 1, b: 2}, _.identity);
//=> [1,2]

_.map({a: 1, b: 2}, function(v, k) {
  return [k,v];
});
//=> [['a', 1], ['b', 2]]

_.map({a: 1, b: 2}, function(v,k,coll) {
 return [k, v, _.keys(coll)];
});
//=> [['a', 1, ['a', 'b']], ['b', 2, ['a', 'b']]]

Other Examples of Applicative Programming

reduceRight

var nums = [100,2,25];
function div(x,y) {return x/y};

_.reduce(nums, div);
//=> 2

_.reduceRight(nums, div);
//=> 0.125

function allOf(/* funs */) {
 return _.reduceRight(arguments, function(truth, f) {
 return truth && f();
 }, true);
}
function anyOf(/* funs */) {
 return _.reduceRight(arguments, function(truth, f) {
 return truth || f();
 }, false);
}

function T() { return true }
function F() { return false }
allOf();
//=> true
allOf(T, T);
//=> true
allOf(T, T, T , T , F);
//=> false
anyOf(T, T, F);
//=> true
anyOf(F, F, F, F);
//=> false
anyOf();
//=> false

find

_.find(['a', 'b', '3', 'd'], _.isNumber);
//=> 3

reject

_.reject(['a', 'b', 3, 'd'], _.isNumber);
//=> ['a', 'b', 'd']

all

_.all([1, 2, 3, 4], _.isNumber);
//=> true

any

_.any([1, 2, 'c', 4], _.isString);
//=> true

sortBy, groupBy, and countBy

var people = [{name: "Rick", age: 30}, {name: "Jaka", age: 24}];
_.sortBy(people, function(p) { return p.age });
//=> [{name: "Jaka", age: 24}, {name: "Rick", age: 30}]

var albums = [{title: "Sabbath Bloody Sabbath", genre: "Metal"},
 {title: "Scientist", genre: "Dub"},
 {title: "Undertow", genre: "Metal"}];
_.groupBy(albums, function(a) { return a.genre });
//=> {Metal:[{title:"Sabbath Bloody Sabbath", genre:"Metal"},
// {title:"Undertow", genre:"Metal"}],
// Dub: [{title:"Scientist", genre:"Dub"}]}


_.countBy(albums, function(a) {return a.genre});
//=> {Metal: 2, Dub: 1}

Defining a Few Applicative Functions

function cat() {
 var head = _.first(arguments);
 if (existy(head))
 return head.concat.apply(head, _.rest(arguments));
 else
 return [];
}
cat([1,2,3], [4,5], [6,7,8]);
//=> [1, 2, 3, 4, 5, 6, 7, 8]

function construct(head, tail) {
 return cat([head], _.toArray(tail));
}
construct(42, [1,2,3]);
//=> [42, 1, 2, 3]

Data Thinking

var zombie = {name: "Bub", film: "Day of the Dead"};
_.keys(zombie);
//=> ["name", "film"]
_.values(zombie);
//=> ["Bub", "Day of the Dead"]

_.pluck([{title: "Chthon", author: "Anthony"},
 {title: "Grendel", author: "Gardner"},
 {title: "After Dark"}],
 'author');
//=> ["Anthony", "Gardner", undefined]

Summary

They can be stored in a variable.

They can be stored in an array slot.

They can be stored in an object field.

They can be created as needed.

They can be passed to other functions.

They can be returned from functions.