message: refactor(mergeMap): slight efficiency improvement. Adds comments
diff: @@ -116,10 +116,18 @@ export function mergeMap<T, R, O extends ObservableInput<any>>(
  * so long as we don't have more active inner subscriptions than
  * the concurrency limit allows.
  */
  - const doInnerSub = () => {
  + const tryInnerSub = () => {
  while (active < concurrent && buffer.length > 0) {
  - const value = buffer.shift()!;
  + doInnerSub(buffer.shift()!);
  + }
  + };
  + /**
  + * Creates an inner observable and subscribes to it with the
  + * given outer value.
  + * @param value the value to process
  + */
  + const doInnerSub = (value: T) => {
  // Subscribe to the inner source
  active++;
  subscriber.add(
  @@ -129,6 +137,7 @@ export function mergeMap<T, R, O extends ObservableInput<any>>(
  // INNER SOURCE NEXT
  // We got a value from the inner source, emit it from the result.
  (innerValue) => subscriber.next(innerValue),
  + // Errors are sent to the consumer.
  undefined,
  () => {
  // INNER SOURCE COMPLETE
  @@ -139,28 +148,24 @@ export function mergeMap<T, R, O extends ObservableInput<any>>(
  // Note that this call will increment `active` ahead of the
  // next conditional, if there were any more inner subscriptions
  // to start.
  - buffer.length && doInnerSub();
  + buffer.length && tryInnerSub();
  // Check to see if we can complete, and complete if so.
  checkComplete();
  }
  )
  )
  );
  - }
  };
  let outerSubs: Subscription;
  outerSubs = source.subscribe(
  new OperatorSubscriber(
  subscriber,
  - (value) => {
  // OUTER SOURCE NEXT
  - // Push the value onto the buffer. We have no idea what the concurrency limit
  - // is and we don't care. Just buffer it and then call `doInnerSub()` to try to
  - // process what is in the buffer.
  - buffer.push(value);
  - doInnerSub();
  - },
  + // If we are under our concurrency limit, start the inner subscription with the value
  + // right away. Otherwise, push it onto the buffer and wait.
  + (value) => (active < concurrent ? doInnerSub(value) : buffer.push(value)),
  + // Let errors pass through.
  undefined,
  () => {
  // OUTER SOURCE COMPLETE
  