given-using-class.js

class SimpleMath {
  constructor( n ) {
    this.n = n;
  }

  static given( n ) {
    return new SimpleMath( n );
  }

  add( m ) {
    this.n += m;
    return this;
  }

  subtract( m ) {
    this.n -= m;
    return this;
  }

  multiply( m ) {
    this.n *= m;
    return this;
  }

  divide( m ) {
    this.n /= m;
    return this;
  }

  value() {
    return this.n;
  }
}

function given(n) {
  return SimpleMath.given(n);
  // or new SimpleMath(n);
}

given-using-proto.js

const proto = {
  multiply ( a ) {
    this.n *= a;
    return this;
  },
  add ( a ) {
    this.n =+ a;
    return this;
  },
  divide ( a ) {
    this.n /= a;
    return this;
  },
  subtract ( a ) {
    this.n -= a;
    return this;
  },
  value () {
    return this.n;
  }
};

function given(n) {
  let instance = Object.create( proto );
  instance.n = n;
  return instance;
}

given-with-proxy.js

/** 
 * Note this version works a little differently. Where the other
 * versions do each operation as they happen, this version
 * waits until `value` is called before evaluating the entire expression.
 * This means this version will find the correct "mathematical" answer (as a single equation). 
 **/

// map method names to related operator
const
  methodToOperator = Object.freeze({
    add: '+',
    subtract: '-',
    multiply: '*',
    divide: '/'
  });

// single get handler for known methods
const handlers = {
  get( target, prop, receiver ) {
    if ( methodToOperator.hasOwnProperty( prop )) {
      const operator = methodToOperator[ prop ];

      return function( m ) {
        target.eq += ` ${ operator } ${ m }`; // builds an equation 
        target.n = eval( `${ target.n } ${ operator } ${ m }` ); // calculate as you go

        return receiver;
      }
    }

    if ( prop === 'value' ) {
      return function() {
//         console.log( `curr n: ${ target.n }\ncurr eq: ${ target.eq }` );
        return eval( target.eq );
      };
    }
  }
};

function given( n ) {
  return new Proxy({ n, eq: `${ n }` }, handlers );
}

would be cool to save the entire stringified equation and just do a single eval on .value() so you could log the current equation if you wanted (sort of like how you can log sql text with query builders like knex)

@forrest-rival pretty sure it does that already. The equation is saved as .eq on the original target object. Then when value is requested a function is returned that runs the eval over the target .eq equation string.

The n value is the "calculate as you go" version.