/**
 * Sets a subset of the state. Always use this to mutate
 * state. You should treat `this.state` as immutable.
 *
 * There is no guarantee that `this.state` will be immediately updated, so
 * accessing `this.state` after calling this method may return the old value.
 *
 * There is no guarantee that calls to `setState` will run synchronously,
 * as they may eventually be batched together.  You can provide an optional
 * callback that will be executed when the call to setState is actually
 * completed.
 *
 * When a function is provided to setState, it will be called at some point in
 * the future (not synchronously). It will be called with the up to date
 * component arguments (state, props, context). These values can be different
 * from this.* because your function may be called after receiveProps but before
 * shouldComponentUpdate, and this new state, props, and context will not yet be
 * assigned to this.
 *
 * @param {object|function} partialState Next partial state or function to
 * produce next partial state to be merged with current state.
 * @param {?function} callback Called after state is updated.
 * @final
 * @protected
 */
Component.prototype.setState = function(partialState, callback) {
  !(typeof partialState === "object" || typeof partialState === "function" || partialState == null)
    ? invariant(
        false,
        "setState(...): takes an object of state variables to update or a function which returns an object of state variables."
      )
    : void 0;
  this.updater.enqueueSetState(this, partialState, callback, "setState");
};

this.state={price:5000, count:0, subTotal:0};

setSubTotal(){
  setState({count:this.state.count+1}, ()=>{
    setState({subTotal:this.state.price * this.state.count})
  });
};

setSubTotal(){
  setState((previousState)=>{
    return {
      count:previousState.count+1
    }
  });
  setState((previousState)=>{
    return {
      sutTotal:previousState.price * previousState.count
    }
  });
};