​

/*======================================

=            IMPLEMENTATION            =

======================================*/

const lazy = target => {

  // Stack will hold all the code to evaluate it later.

  const stack = [];

  // Proxy object allows intercept get and apply.

  //

  // Instead of invoke a function we add that call

  // to the stack and we return the proxy to hook

  // the next call.

  //

  // We transform the original object into a callable object

  // to intercept apply.

  return new Proxy(Object.assign(() => {}, target), {

    get: (target, property, receiver) => (

      (...args) => {

        stack.push({ fn: property, args: args });

        return receiver;

      }        

    ),

    apply: (target, thisArg, args) => {

      // Because target is a callable object any intent

      // to invoke the object will trigger this trap.

      // So we can perform computations at this point.

      return stack.reduce((accum, current, index) => {

        const fn = target[current.fn]; 

        return fn.apply(fn, [accum, ...current.args]);

      }, args[0]);

    }

  });

};

​

// Let's define a bunch of functions to use as example.

const custom = {

  add: (accum, value) => accum + value,

  sub: (accum, value) => accum - value ,

  mul: (accum, value) => accum * value,

};

​

​

/*=============================

=            USAGE            =

=============================*/

// Lazy evaluation using a custom library.

const add4 = lazy(custom)

  .add(3)

  .add(3)

  .sub(2);

​

const add6 = add4.add(2);

​

console.log(add6(1)); // Output: 7

​

​

// Using lodash

const drop2AndSum = lazy(_)

    .fill(2, 0, 3)

    .dropRight(1)

    .sum();

​

console.log(drop2AndSum([1, 2, 3, 4]));  // Output: 6