Lodash-like chaining using reduce for Absurdum. Why? Cuz we can..

ridiculous-chaining.js

// Law of Absurd Reduces: Everything that can be implemented with reduce() will eventually be implemented with reduce()

/**
 * @param {Object} chainableFunctions object where each key is the name of a function and it's value is the function itself
 */
const createChainables = (chainableFunctions) => ({
  chain(initialValue) {
    const operations = [];
    const evaluate = () => operations.reduce(
      (value, [func, ...args]) => func(value, ...args),
      initialValue,
    );

    const proxy = Object
      .keys(chainableFunctions)
      .reduce((acc, funcName) => ({
        ...acc,
        [funcName]: (...args) => {
          operations.push([chainableFunctions[funcName], ...args]);
          return proxy;
        },
      }), { value: evaluate });

    return proxy;
  },
});

// -- usage --
const { map } = require('@vanillaes/absurdum').arrays;
const { fromEntries } = require('@vanillaes/absurdum').objects;

const _ = createChainables({
  map,
  fromEntries,
})

const data = [
  { key: 'a', val: 1},
  { key: 'b', val: 2},
];

console.log(
  _
    .chain(data)
    .map(({ key, val }) => [key, val])
    .fromEntries()
    .value()
);