05_higher_order.txt

:chap_num: 5
:prev_link: 04_data
:next_link: 06_object
:load_files: ["js/code/ancestry.js", "js/00_intro.js", "js/05_higher_order.js"]

= Higher-Order Functions =

[quote, Master Yuan-Ma, The Book of Programming]
____
Tzu-li and Tzu-ssu were boasting about the size of their latest
programs. 'Two-hundred thousand lines,' said Tzu-li, 'not counting
comments!' Tzu-ssu responded, 'Psah, mine is almost a *million* lines
already.' Master Yuan-Ma said, 'My best program has five hundred
lines.' Hearing this, Tzu-li and Tzu-ssu were enlightened.
____

[quote, C.A.R. Hoare, 1980 ACM Turing Award Lecture]
____
There are two ways of constructing a software design: One way is to
make it so simple that there are obviously no deficiencies and the
other way is to make it so complicated that there are no obvious
deficiencies.
____

(((bug)))A large program is a costly program. Not necessarily because
of the time it takes to build. Size almost always involves complexity,
and complexity confuses programmers. Confused programmers have a
negative effect on a program—they tend to introduce mistakes (bugs). A
large program also provides a lot of space for these bugs to hide,
making them hard to find.

Let us briefly go back to the final two example programs in the
introduction. The first is self-contained, and six lines long.

[source,javascript]
----
var total = 0, count = 1;
while (count <= 10) {
  total += count;
  count += 1;
}
console.log(total);
----

The second relies on two external functions, and is one line long.

[source,javascript]
----
console.log(sum(range(1, 10)));
----

Which one is more likely to contain a bug?

If we count the size of the definitions of `sum` and `range`, the
second program is also big—even bigger than the first. But still, I'd
argue that it is more likely to be correct.

The reason it is more likely to be correct is that, by first building
up a language in which to express the problem, and then solving the
problem in the terms of the problem's own domain, the solution gains
clarity. Summing a range of numbers isn't about loops and counters, it
is about ranges and sums.

The definitions of the vocabulary itself (the functions `sum` and
`range`) will still have to concern themselves with loops, counters, and
other silly details. But because they are expressing simpler concepts
(the building blocks are simpler than the building), they are easier
to get right.

Of course, getting a sum over a range of numbers right is trivial with
or without vocabulary. Consider that example a miniature model of
other, actually difficult problems.

== Abstraction ==

(((abstraction)))In the context of programming, the usual term used
for these kinds vocabularies is _abstractions_. Abstractions hide
details, and give us the ability to talk on a higher (more abstract)
level.

(((recipe)))An analogy is this recipe for pea soup.

____
Put 1 cup of dried peas per person in a container. Add water until
they are well covered. Leave peas in the water for at least 12 hours.
Take the peas out of the water, and put them in a cooking pan. Add 4
cups of water per person. Cover the pan and keep the peas barely
cooking for two hours. Take half an onion per person. Cut it into
pieces with a knife. Add it to the peas. Take a stalk of celery per
person. Cut it into pieces with a knife. Add it to the peas. Take a
carrot per person. Cut it into pieces. With a knife! Add it to the
peas. Cook for 10 more minutes.
____

Compared to this one.

____

Per person: 1 cup dried split peas, half a chopped onion, a stalk of
celery, and a carrot.

Soak peas for 12 hours. Simmer them for 2 hours in 4 cups of water
(per person). Chop and add vegetables. Cook for 10 more minutes.
____

The second is shorter, and easier to interpret. It does rely on you
understanding a few more cooking-related words—“soak”, “simmer”,
“chop”, and, I guess, “vegetables”.

When programming, since we can't rely on all the words we need already
having been created by previous generations, waiting for us in the
dictionary, it is easy to fall into the pattern of the first
recipe—work out the precise steps the computer has to perform, one by
one, blind to the higher-level concepts that they express.

It has to become a second nature, when programming, to notice when a
concept is begging to be abstracted into a new word.

== Abstracting array traversal ==

Plain functions, as we've seen them so far, are a good way to build
abstractions. But sometimes they fall short.

(((for loop)))In the previous chapter, this type of `for` loop made
several appearances:

[source,javascript]
----
var array = [1, 2, 3];
for (var i = 0; i < array.length; i++) {
  var current = array[i];
  // do something with current
}
----

What it tries to say is “for each element in the array, do this”. But
it uses a very roundabout way that involves a counter variable, a
check against the array's length, and an extra variable declaration to
pick out the current element. Apart from being a bit of an eyesore,
this also gives us a lot of space for potential mistakes—accidentally
reuse the `i` variable, misspell `lenght`, confuse the `i` and
`current` variables, and so on.

Well then, let us try to abstract this into a function. Can you think
of a way?

The problem is that, whereas most functions just take some values,
combine them, and maybe return something, these `for` loops contain a
piece of code that they must execute. It is easy to write a function
that goes over an array and calls `console.log` on every element:

[source,javascript]
----
function logEach(array) {
  for (var i = 0; i < array.length; i++)
    console.log(array[i]);
}
----

(((array,traversal)))(((function,as value)))(((forEach method)))But
what if we want to do something else than logging the elements? Since
“doing something” can be represented as a function, and functions are
also values, we can pass our action as a function value:

[source,javascript]
----
function forEach(array, action) {
  for (var i = 0; i < array.length; i++)
    action(array[i]);
}

forEach(["Wampeter", "Foma", "Granfalloon"], console.log);
// → Wampeter
// → Foma
// → Granfalloon
----

Often, you don't pass a pre-defined function to `forEach`, but
create a function value on the spot instead.

[source,javascript]
----
var numbers = [1, 2, 3, 4, 5], sum = 0;
forEach(numbers, function(number) {
  sum += number;
});
console.log(sum);
// → 15
----

This looks quite a lot like the classical `for` loop, with its body
written as a block below it. Except that now the body is inside of the
function value, as well as inside of the parentheses of the call to
`forEach` and inside a regular statement. This is why it has to be
closed with the closing brace, closing parenthesis, _and_ semicolon.

In this pattern, we can simply specify a variable name (`number`) for
the current element as the function's argument, rather than having to
pick it out of the array manually.

We do not need to write `forEach` ourselves. It is available as a
standard method on arrays (taking the function as first argument,
since the array is already provided as the thing the method acts on).

To illustrate how helpful this is, remember this function from the
previous chapter that contains two array-traversing loops.

[source,javascript]
----
function gatherCorrelations(journal) {
  var phis = {};
  for (var entry = 0; entry < journal.length; ++entry) {
    var events = journal[entry].events;
    for (var i = 0; i < events.length; i++) {
      var event = events[i];
      if (!(event in phis))
        phis[event] = phi(tableFor(event, journal));
    }
  }
  return phis;
}
----

Working with `forEach` makes it slightly shorter and quite a bit less
noisy:

[source,javascript]
----
function gatherCorrelations(journal) {
  var phis = {};
  journal.forEach(function(entry) {
    entry.events.forEach(function(event) {
      if (!(event in phis))
        phis[event] = phi(tableFor(event, journal));
    });
  });
  return phis;
}
----

== Higher-order functions ==

(((function,higher-order)))The term for functions that operate on
functions (by taking them as arguments, or returning them) is
_higher-order functions_. For JavaScript programmers, who are used to
functions being regular values, there is actually nothing remarkable
about the fact that such functions exist. The term comes from
mathematics, where the distinction between functions and other values
is taken a little more seriously.

Higher-order functions allow us to abstract over _actions_, not just
values. They come in several forms. You can have functions that create
a new function.

[source,javascript]
----
function greaterThan(n) {
  return function(m) { return m > n; };
}
var greaterThan10 = greaterThan(10);
console.log(greaterThan10(11));
// → true
----

Or functions that change another function.

[source,javascript]
----
function noisy(f) {
  return function(arg) {
    console.log("calling with", arg);
    var val = f(arg);
    console.log("called with", arg, "- got", val);
    return val;
  };
}
noisy(Boolean)(0);
// → calling with 0
// → called with 0 - got false
----

Or even create functions that implement your own types of control
flow.

[source,javascript]
----
function unless(test, then) {
  if (!test) then();
}
function repeat(times, body) {
  for (var i = 0; i < times; i++) body(i);
}

repeat(3, function(n) {
  unless(n % 2, function() {
    console.log(n, "is even");
  });
});
// → 0 is even
// → 2 is even
----

(((lexical scoping)))(((closure)))The “lexical scoping” rules that we
discussed in Chapter 3 greatly work to our advantage when using
functions in this way. In the example above, the `n` variable is a
parameter to the outer function. Because the inner function lives
inside the environment of the outer one, it can use it. Thus, the
bodies of such functions can freely use the variables around them, and
play a role similar to the regular `{}` blocks used in regular loops
and conditional statements. An important difference is that variables
declared inside of them do not end up in the environment of the outer
function. And that is usually a good thing.

== Passing on arguments ==

The `noisy` function above, which wraps its argument in another
function, has a rather serious deficit.

[source,javascript]
----
function noisy(f) {
  return function(arg) {
    console.log("calling with", arg);
    var val = f(arg);
    console.log("called with", arg, "- got", val);
    return val;
  };
}
----

If `f` takes more than one parameter, only the first one is passed
through to it. We could add a bunch of arguments to the inner function
(`arg1`, `arg2`, and so on), and pass them to `f`, but it is unclear
how many would be necessary. It would also deprive `f` of the
information in `arguments.length`. Since we'd always pass the same
amount of arguments to it, it wouldn't know how many argument were
_really_ given.

For these kinds of situations, JavaScript functions have an `apply`
method. The `apply` method gets passed an array (or pseudo array) of
arguments, and will call the function with those arguments.

[source,javascript]
----
function transparentWrapping(f) {
  return function() {
    return f.apply(null, arguments);
  };
}
----

That's a particularly useless function, but it shows the pattern we
are interested in—the resulting function will pass all of the given
arguments, and only those arguments, to `f`. It does this by passing
its own `arguments` object to `apply`. The first argument to `apply`,
for which we are passing `null` here, can be used to simulate a method
call. More on that in the next chapter.

== Example data ==

(((array)))Higher-order functions that somehow apply a function to the
elements of an array are widely used in JavaScript. The `forEach`
method is the most primitive such function. There are a number of
other variants available as methods on arrays. In order to familiarize
ourselves with them, let us play around with another data set.

A few years ago, someone crawled through a lot of archives in order to
put together a book on the history of my family name
(“Haverbeke”—literally “Oatbrook”). I was hoping to find knights,
pirates, and alchemists... but the book turns out to be mostly full of
Flemish farmers. For my amusement, I extracted the information on my
direct ancestors, and put it into a computer-readable format. Let us
play with this data.

== JSON ==

(((JSON)))The file I created looks something like this:

[source,application/json]
----
[
  {"name": "Emma de Milliano", "sex": "f",
   "born": 1876, "died": 1956,
   "father": "Petrus de Milliano",
   "mother": "Sophia van Damme"},
  {"name": "Carolus Haverbeke", "sex": "m",
   "born": 1832, "died": 1905,
   "father": "Carel Haverbeke",
   "mother": "Maria van Brussel"},
  … and so on
]
----

This notation is very similar to JavaScript's way of writing arrays
and objects, with a few restrictions. All property names are
surrounded by quotes, and only simple data expressions (no function
calls, or variables, or anything that involves actual computation) are
allowed.

This format is called JSON, pronounced “Jason”, which stands for
JavaScript Object Notation. It is widely used as a data storage and
communication format on the web.

JavaScript provides two functions, `JSON.stringify` and `JSON.parse`,
that convert data from and to this format.

[source,javascript]
----
var string = JSON.stringify({name: "X", born: 1980});
console.log(string);
// → {"name":"X","born":1980}
console.log(JSON.parse(string).born);
// → 1980
----

The variable `ANCESTRY_FILE`, available in the sandbox for this
chapter as well as in
http://eloquentjavascript.net/code/ancestry.js[a downloadable file] on
the website!!tex  (`eloquentjavascript.net/code`)!!,
contains the content of my JSON file as a string. Let us decode it and
see how many people it contains:

// include_code strip_log

[source,javascript]
----
var ancestry = JSON.parse(ANCESTRY_FILE);
console.log(ancestry.length);
// → 39
----

== Filtering an array ==

A function passed as an argument to a higher-order function doesn't
just represent an action that can be run. It also returns a value, and
we could use it to, for example, make a decision.

To find the people in the ancestry data set that were young in
1924, the following function might be helpful. It filters out the
elements in an array that don't pass a test.

[source,javascript]
----
function filter(array, test) {
  var passed = [];
  for (var i = 0; i < array.length; i++) {
    if (test(array[i]))
      passed.push(array[i]);
  }
  return passed;
}

console.log(filter(ancestry, function(person) {
  return person.born > 1900 && person.born < 1925;
}));
// → [{name: "Philibert Haverbeke", …}, …]
----

Three people in the file were alive and young in 1924: My grandfather,
grandmother, and great-aunt.

Like `forEach`, `filter` is also a standard method on arrays. The
example defined the function only in order to show what it does
internally. From now on, we'll use `ancestry.filter(…)` instead.

== Transforming with map ==

Say we have an array of person objects, produced by filtering the
`ancestry` array somehow. But we want an array of names, which is
easier to read through.

The `map` method transforms an array by applying a function to all of
its elements, and building a new array from the returned values. The
new array will have the same length as the input array, but its
content will have been “mapped” to a new form by the function.

// test: join

[source,javascript]
----
function map(array, transform) {
  var mapped = [];
  for (var i = 0; i < array.length; i++)
    mapped.push(transform(array[i]));
  return mapped;
}

var overNinety = ancestry.filter(function(person) {
  return person.died - person.born > 90;
});
console.log(map(overNinety, function(person) {
  return person.name;
}));
// → ["Clara Aernoudts", "Emile Haverbeke",
//    "Maria Haverbeke"]
----

Interestingly, the people that lived to over 90 years of age are the
same three people that we saw before—the people were young in the
1920s, which happens to be the youngest generation in my data set. I
guess medicine has really come a long way.

Like `forEach` and `filter`, `map` is also a standard method on
arrays.

== Summarizing with reduce ==

Another common pattern of computation on arrays is computing a single
value from them. Our recurring example, the summing of a range of
numbers, is an instance of this. If we wanted to find the person with
the earliest year of birth in the data set, that would also follow
this pattern.

The steps are to first take a start value. Then, for each element in
the array, you combine the element and the current value to create a
new value. The value that comes out after the last element in the
array has been handled is the result we want.

The higher-order operation that represents this pattern is called
_reduce_ (or sometimes _fold_). It is a little less straightforward
than the previous examples, but still not hard to follow.

[source,javascript]
----
function reduce(array, combine, start) {
  var current = start;
  for (var i = 0; i < array.length; i++)
    current = combine(current, array[i]);
  return current;
}

console.log(reduce([1, 2, 3, 4], function(a, b) {
  return a + b;
}, 0));
// → 10
----

The standard array method `reduce`, which of course corresponds to
this function, has an additional convenience. If your array contains
at least one element, you are allowed to leave off the `start`
argument, and the method will take the first element of the array as
its start value, and start reducing at the second element.

To use this to find my most ancient known ancestor, we can write
something like this:

// test: no

[source,javascript]
----
console.log(ancestry.reduce(function(min, cur) {
  if (cur.born < min.born) return cur;
  else return min;
}));
// → {name: "Pauwels van Haverbeke", born: 1535, …}
----

== Composability ==

Let us back up for a moment and consider how we would have written the
previous example (finding the person with the earliest year of birth)
without higher-order functions. The code is not that much worse:

// test: no

[source,javascript]
----
var min = ancestry[0];
for (var i = 1; i < ancestry.length; i++) {
  var cur = ancestry[i];
  if (cur.born < min.born)
    min = cur;
}
console.log(min);
// → {name: "Pauwels van Haverbeke", born: 1535, …}
----

There are a few more variables being created and assigned to, and the
program is two lines longer, but still quite easy to understand.

The higher-order function approach really starts to shine when you
need to compose several concepts. As an example, let us write code
that finds the average age for men and for women in the data set.

// test: clip

[source,javascript]
----
function average(array) {
  function plus(a, b) { return a + b; }
  return array.reduce(plus) / array.length;
}
function age(p) { return p.died - p.born; }
function male(p) { return p.sex == "m"; }
function female(p) { return p.sex == "f"; }

console.log(average(ancestry.filter(male).map(age)));
// → 61.67
console.log(average(ancestry.filter(female).map(age)));
// → 54.56
----

(It is a bit silly that we have to define `plus` as a function.
Operators in JavaScript, unlike functions, are not values, so we can't
pass them as arguments.)

Instead of tangling all of the logic required into a big loop, we can
neatly decompose it into the concepts we are interested in (deciding
on sex, computing age, averaging numbers), and apply those one by one
to get the result we were looking for.

This is _fabulous_ for writing clear code. But there is a cloud on the
horizon.

== The cost ==

In the happy land of elegant code and pretty rainbows, there lives a
mean spoil-sport monster called “__inefficiency__”.

Reducing the processing of an array into a sequence of cleanly
separated steps that each do something with the array and produce a
new array is easy to think about. But building up all those
intermediate arrays is somewhat expensive.

Passing a function to `forEach` and letting that method handle the
array iteration for us is convenient and elegant. But function calls
in JavaScript are costly, compared to simple loop bodies.

And so it goes with a lot of techniques that help improve the clarity
of a program. They add additional layers between the raw things the
computer is doing and the concepts we are working with, and thus cause
the machine to perform more work. This is not an inescapable, iron
law—there are programming languages that have better support for
building abstractions without adding inefficiencies, and even in
JavaScript, an experienced programmer can find ways to write
relatively abstract code that is still fast—but it is a problem that
comes up a lot.

Fortunately, most computers are insanely fast, and if you are
processing a modest set of data, or doing something that only has to
happen on a human time scale (say, only once, or once every time the
user clicks a button), then it _does not matter_ whether you wrote the
pretty solution that takes half a millisecond, or the super-optimized
solution that takes a tenth of a millisecond.

It is helpful to roughly keep track of how often a piece of your
program is going to run. If you have a loop inside a loop (directly,
or through the outer loop calling a function that ends up performing
the inner loop), the code inside the inner loop will end up running
N×M times, where N is the number of times the outer loop repeats, and
M the number of times the inner loop repeats. If that inner loop
contains another loop that makes P rounds, its body will run M×N×P
times, and so on. This adds up.

== Great-great-great-great-... ==

My grandfather, Philibert Haverbeke, is included in the data file. As
a final example problem, I want to know whether the most ancient
person in the data (Pauwels van Haverbeke) is my direct ancestor, and
if so, how much DNA I theoretically share with him.

First, I build up an object that makes it possible to easily find
people by name.

// include_code strip_log

[source,javascript]
----
var byName = {};
ancestry.forEach(function(person) {
  byName[person.name] = person;
});

console.log(byName["Philibert Haverbeke"]);
// → {name: "Philibert Haverbeke", …}
----

Now, the problem is not entirely as simple as following the `parent`
properties and counting how many we need to reach Pauwels. There are
several cases in the family tree where people married their second
cousins (tiny villages and all that). This causes the branches of the
family tree to re-join in a few places, which means I share more than
1/2^G^ with this person (using G for the number of generations, each generation
splitting the gene pool in two).

A reasonable way to think about this problem is to put it in similar
terms as the `reduce` algorithm. A family tree has a more interesting
structure than a flat array—a structure that in fact already suggests
a way of computing values from it.

Given a person, a function to combine values from the two parents of a
given person, and a zero value that is to be used for unknown persons,
the `reduceAncestors` function computes a value from a family tree.

// include_code

[source,javascript]
----
function reduceAncestors(person, f, zero) {
  function reduce(person) {
    if (person == null) return zero;
    var father = byName[person.father];
    var mother = byName[person.mother];
    return f(person, reduce(father), reduce(mother));
  }
  return reduce(person);
}
----

The inner function (`reduce`) handles a single person. Through the
magic of recursion, it can simply call itself to handle the father and
the mother of this person. The results, along with the person object
itself, are passed to `f`.

Some people's father and mother are not in the data set (obviously, or
it would include an awful lot of people). So when looking up a parent
doesn't yield a value, `reduce` simply returns the `zero` value that
was passed to `reduceAncestors`.

We can then use this to compute the amount of DNA my grandfather
shared with Pauwels van Haverbeke, and divide that by four.

// test: clip

[source,javascript]
----
function sharedDNA(person, fromFather, fromMother) {
  if (person.name == "Pauwels van Haverbeke")
    return 1;
  else
    return (fromFather + fromMother) / 2;
}
var ph = byName["Philibert Haverbeke"];
console.log(reduceAncestors(ph, sharedDNA, 0) / 4);
// → 0.00049
----

The person with the name Pauwels van Haverbeke obviously shared 100%
of his DNA with Pauwels van Haverbeke (there are no people who share
names in the data set). All other people share the average of the
amount that their parents share.

So, statistically speaking, I share about 0.05% of my DNA with this
16th-century person. The chances of one of my 44 non-XY chromosomes
coming from him are thus rather small. However, assuming no extramarital
children in the family history, I do have his Y chromosome.

Data structures (such as this family tree) can often be made easier to
use (as well as easier to think about) by finding analogues to
`forEach` (iterate), `map` (transform), and `reduce` that apply to
them. A `forEachAncestor` function would simply call a function for
each ancestor. A mapping function probably isn't of much use for this
data structure, but would, for example, be useful for the list type
that was introduced in the exercises to the last chapter.

== Binding ==

(((bind method)))(((partial application)))Often, you'll find yourself
writing function expressions that just call through to another
function, adding a fixed argument.

The code below uses an array of strings as a set of names, and defines
a function `isInSet` that tells us whether a person is in a given set.
To call `filter` in order to collect those person objects whose name
is in a specific set, we can either write a function expression that
makes a call to `isInSet` with our set as its first argument, or
_partially apply_ the `isInSet` function.

[source,javascript]
----
var theSet = ["Carel Haverbeke", "Maria van Brussel",
              "Donald Duck"];
function isInSet(set, person) {
  return set.indexOf(person.name) > -1;
}

console.log(ancestry.filter(function(person) {
  return isInSet(theSet, person);
}));
// → [{name: "Maria van Brussel", …},
//    {name: "Carel Haverbeke", …}]
console.log(ancestry.filter(isInSet.bind(null, theSet)));
// → … same result
----

The `bind` method, which all functions have, creates a new function
that will call the original function, but with some of the arguments
already fixed. Calling the result of the above `bind` call will call
`isInSet` with `theSet` as first argument, followed by any remaining
arguments given to the bound function.

The first argument, where the example passes `null`, is used for
method calls, similar to the first argument to `apply`. We could bind
an array's `push` method to get a function that adds an argument to
that specific array:

[source,javascript]
----
var array = [];
var addElement = array.push.bind(array);
addElement(1);
console.log(array);
// → [1]
----

== Summary ==

Being able to pass function values to other functions is not a random
gimmick, but a deeply useful aspect of JavaScript. It allows us to
describe computations with “gaps” in them as functions, and allow the
code that calls these functions to fill in the gaps by providing
function values that describe the missing computations.

Arrays provide a number of very useful higher-order methods—`forEach`
to do something with each element in an array, `map` to build a new
array where each element has been put through a function, and `reduce`
to combine all the elements in the array into a single value.

Functions have an `apply` method that can be used to call them with an
array specifying their arguments. They also have a `bind` method,
which is used to create a partially applied version of the function.

== Exercises ==

=== Flattening ===

Use the `reduce` method in combination with the `concat` method to
“flatten” an array of arrays into a single array that has all the
elements of the input arrays.

ifdef::html_target[]

// test: no

[source,javascript]
----
var arrays = [[1, 2, 3], [4, 5], [6]];
// Your code here.
// → [1, 2, 3, 4, 5, 6];
----
endif::html_target[]

=== Mother-child age difference ===

Using the example data set from this chapter, compute the average age
difference between mothers and children. You can use the `average`
function defined above.

Note that not all the mothers mentioned in the data are themselves
present in the array. The `byName` object, which makes it easy to find
a person's object from their name, might be useful here.

ifdef::html_target[]

// test: no
// include_code

[source,javascript]
----
function average(array) {
  function plus(a, b) { return a + b; }
  return array.reduce(plus) / array.length;
}

var byName = {};
ancestry.forEach(function(person) {
  byName[person.name] = person;
});

// Your code here.

// → 31.2
----
endif::html_target[]

!!solution!!

Because not all elements in the `ancestry` array produce useful data
(we can't compute the age difference unless we know the birth date of
the mother), we will have to apply `filter` in some manner before
calling `average`. You could do it as a first pass, by defining a
`hasKnownMother` function and filtering on that first. Alternatively,
you could start by calling `map`, and in your mapping function return
either the age difference, or `null` if no mother is known. Then, you
can call `filter` to remove the `null` elements before passing the
array to `average`.

!!solution!!

=== Historical life expectancy ===

When we looked up all the people in our data set that lived more than
ninety years, only the very latest generation in the data came out.
Let us take a closer look at that phenomenon.

Compute and output the average age of the people in the ancestry data
set per century. A person is assigned to a century by taking their
year of death, dividing it by a hundred, and rounding it up, as in
`Math.ceil(person.died / 100)`.

ifdef::html_target[]

// test: no

[source,javascript]
----
function average(array) {
  function plus(a, b) { return a + b; }
  return array.reduce(plus) / array.length;
}

// Your code here.

// → 16: 43.5
//   17: 51.2
//   18: 52.8
//   19: 54.8
//   20: 84.7
//   21: 94
----
endif::html_target[]

!!solution!!

The essence of this example lies in grouping the elements of a
collection by some aspect of theirs—splitting the array of ancestors
into smaller arrays with the ancestors for each century.

During the grouping process, keep an object that associates century
names (numbers) with arrays of either person objects or ages. Since we
do not know in advance what categories we will find, we'll have to
create them on the fly. For each person, after computing their
century, we test whether that century was already known. If not, add
an array for it. Then add the person (or age) to the array for the
proper century.

Finally, a `for`/`in` loop can be used to print the average ages for
the individual centuries.

!!solution!!

For bonus points, write a function `groupBy` that abstracts the
grouping algorithm. It accepts as arguments an array and a function
that computes the group for an element in the array, and returns the
object containing the groups.

=== Every and then some ===

Arrays also come with the standard methods `every` and `some`, which
are analogous to the `&&` and `||` operators.

Both take a predicate function that, when called with an array element
as argument, returns true or false. Just like `&&` only returns a true
value when the expressions on both sides are true, `every` only
returns true when the predicate returned true for _all_ elements
of the array. Similarly, `some` returns true as soon as the predicate
returned true for _any_ of the elements. They do not process more
elements than necessary—for example, if `some` finds that the
predicate holds for the first element of the array, it will not look
at the values after that.

Write two functions, `every` and `some`, that behave like these
methods, except that they take the array as their first argument,
rather than being a method.

ifdef::html_target[]

// test: no

[source,javascript]
----
// Your code here.

console.log(every([NaN, NaN, NaN], isNaN));
// → true
console.log(every([NaN, NaN, 4], isNaN));
// → false
console.log(some([NaN, 3, 4], isNaN));
// → true
console.log(some([2, 3, 4], isNaN));
// → false
----
endif::html_target[]

!!solution!!

The functions can follow a similar pattern to the definition of
`forEach` at the start of the chapter, except that they must return
immediately (with the right value) when the predicate function returns
false—or true. Don't forget to put another `return` statement after
the loop, so that the function also returns the correct value when it
reaches the end of the array.

!!solution!!