Skip to content
master
Switch branches/tags
Code

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
 
 
 
 
 
 
 
 
 
 
 
 

Functional chain

forthebadge forthebadge forthebadge

A micro engine to create a chainable function APIs

Installation

npm install --save functional-chain

Basic example

Two arguments must be passed to the Chainable method in order to generate the function chain

  1. An object of function builders. Each representing one method of the api
  2. A "resolve" method, that will receive an array of all the functions, that have been chained. Its role is to call the functions and return the final output
const { Chainable } = require('functional-chain');

const API = Chainable({
  add: (val) => {
    return num => num + val
  },

  subtract(val) {
    return num => num - val
  },

  multiplyBy(val) {
    return num => num * val
  },

  divideBy(val) {
    return num => num / val
  }
}, (chain, num) => {
  return chain.reduce((mem, fn) => fn(mem), num);
})

const { multiplyBy } = API;

const operation = multiplyBy(2)
  .and.subtract(6)
  .and.divideBy(2);

  // 33 * 2 => 66
  // 66 - 6 => 60
  // 60 / 2 => 30
  const res = operation(33);
  console.log(res) // -> 30

Analysing the chain

An analyse( chain ) method is provided which allows reflection and serialization of operation chains

// ...

const operation = multiplyBy(2)
  .and.subtract(6)
  .and.divideBy(2);

analyse(operation);

// output =>
[
  { multiplyBy:  [2] },
  { subtract: [6]},
  { divideBy: [2] }
]

Usage case example: Redux reducer

Let's write an example of a Redux store, which uses our chainable methods to apply transformations to the store.

First version, a standard reducer:

const initialState = {
  requestCount: 0,
  loading:      false,

  // ...
};

createStore((state = initialState, action) => {
  switch (action.type) {
    case: 'START_REQUEST':
      const count = state.requestCount + 1;
      return { ...state, requestCount: count, loading: count > 0 }
    case: 'END_REQUEST':
      const count = state.requestCount - 1;
      return { ...state, requestCount: count, loading: count > 0 }

    // ...
  }
  return state;
});

Now, we take this a we try to add it some fun function chaining.

Let's build a little helper API to combine changes together

const API = Chainable({
  increment(key) {
    return state => ({ [key]: state[key] + 1 });
  },

  decrement(key) {
    return state => ({ [key]: state[key] - 1 });
  },

  updateLoading() {
    return (state) => ({'loading': state.requestCount > 0 });
  }
}, (chain, state) => {
  // resolve method
  return chain.reduce((changes, fn) => {
    return { ...changes, ...fn(state )}
  }, {});
});

Now we use that in our store to define state transformations

const { increment, decrement } = require('./stateHelpers');

const transformations = {
  "START_REQUEST": increment('requestCount')
    .and.updateLoading();

  "END_REQUEST": decrement('requestCount')
    .and.updateLoading();
};

createStore((state = initialState, action) => {
  const mut = transformations[action.type];
  if (!mut) {
    return state;
  }
  return { ...state, ...mut(state, action) };
})

About

Mini engine to create a chainable function API

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published