Skip to content
Switch branches/tags
Go to file
Cannot retrieve contributors at this time

Maybe {#maybe}

A common problem in programming is checking for null or undefined (hereafter called "nothing," while all other values including 0, [] and false will be called "something"). Languages like JavaScript do not strongly enforce the notion that a particular variable or particular property be something, so programs are often written to account for values that may be nothing.

This recipe concerns a pattern that is very common: A function fn takes a value as a parameter, and its behaviour by design is to do nothing if the parameter is nothing:

function isSomething (value) {
  return value !== null && value !== void 0;

function checksForSomething (value) {
  if (isSomething(value)) {
    // function's true logic

Alternately, the function may be intended to work with any value, but the code calling the function wishes to emulate the behaviour of doing nothing by design when given nothing:

var something = isSomething(value) ? 
  doesntCheckForSomething(value) : value;

Naturally, there's a recipe for that, borrowed from Haskell's maybe monad, Ruby's andand, and CoffeeScript's existential method invocation:

function maybe (fn) {
  return function () {
    var i;
    if (arguments.length === 0) {
    else {
      for (i = 0; i < arguments.length; ++i) {
        if (arguments[i] == null) return
      return fn.apply(this, arguments)

maybe reduces the logic of checking for nothing to a function call, either:

var checksForSomething = maybe(function (value) {
  // function's true logic


var something = maybe(doesntCheckForSomething)(value);

As a bonus, maybe plays very nicely with instance methods, we'll discuss those later:

function Model () {};

Model.prototype.setSomething = maybe(function (value) {
  this.something = value;

If some code ever tries to call model.setSomething with nothing, the operation will be skipped.