js-dispatcher

Flexible Conditional Logic

Usage

The Basics

Here's an example of a programmatically constructed if... else if... else statement:

const {
  Dispatcher,
  IF, RETURN,
} = require('js-dispatcher');


const d = Dispatcher();

// Setup our Dispatcher rules:
d.use(IF((x, y)=> x < y, (x, y)=> x + y));
d.use(IF((x, y)=> x > y, (x, y)=> x * y));
d.otherwise((x, y)=> 0);


// Alright, let's put it to the test:
console.log(d(3, 4));   // Output: 7
console.log(d(4, 3));   // Output: 12
console.log(d(3, 3));   // Output: 0

Notice that d.otherwise((x, y)=> 0) always just returns the value 0. Since this is a common pattern, you can also write the statement as:

d.otherwise(RETURN(0));

Advanced Stuff

The IF(condition, handler) function is just a factory for producing a very common type of RULE_FUNCTION. Specifically, the RULE_FUNCTION has the form:

function _if(...args) {
  if(condition(...args)) {
    return handler;
  }
}

As you can see, it evaluates the condition(..). If this condition returns something truthy, then it returns the associated handler(..) function. Otherwise, it returns undefined. This protocol informs the Dispatcher about whether or not the RULE_FUNCTION is able to handle the input.

Most of the time, you don't need to worry about this level of detail, and you can just rely upon the IF(..) factory. But, on rare occassions, both the RULE_FUNCTION and the handler(..) function rely upon the same computationally-expensive operation. In these cases, you can write your own RULE_FUNCTION by hand to minimize computational costs. For example:

function customRule(...args) {
  const expensive = someExpensiveCalculation(...args);

  if(someCondition(expensive)) {
    function handler() {
      return doSomethingWith(expensive);
    }

    return handler;
  }
}


d.use(customRule);