De Morgan's laws are a pair of boolean algebra rules, if written in javascript-style boolean expressions, they look like this:

!(A && B) is equivalent to !A || !B
!(A || B) is equivalent to !A && !B

This is not only useful for boolean simplification, but also for general problem solving. For example, in underscore.js there is a function called .every that returns true if every value in a collection passes a truth test. There is also a function called .some that returns true if any value in the collection passes the truth test. Normally, the logic of _.some can be written similar to this:

var _.some = function(collection, test) {
  var anyPass = false;

  for (var i = 0; i < collection.length; i++) {
    anyPass = anyPass || (test(collection[i]));
  }

  return anyPass;
};

This straightforward implementation can be simplified slightly with .reduce. However, there is also a clever way to reimplement the same function with .every. Can you think of a way? (Hint: It has to do with the title of this blog post.)


The trick depends on the overlap between the two functions. The relationship may not be apparent at first, but using De Morgan's laws, it can be shown rather easily:

    A || B || C
->  !!(A || B || C)
->  !(!A && !B && !C)

Using a double negation, we yield a logical equivalency between two boolean expressions that can be summarized as this:

Some elements pass the truth test is equivalent to Not all elements fail the truth test.

With this knowledge in hand, we can reimplement _.some with some cleverness, as shown here:

var _.some = function(collection, test) {
  return !_.every(collection, function(element) {
    return !test(element);
  });
};