hunk.code_window:     const expected =  '----------(w|)';
       const predicate = function (x, y) {
         return x < y ? x : y;
       };
  
hunk.labels: keep keep keep replace keep keep
hunk.after_edit:       return x > y ? -1 : 1;
  
hunk.file_path: spec/operators/min-spec.ts
hunk.type: replace
file: import { Scheduler } from '../Scheduler';
  import { Observable } from '../Observable';
  import { ScalarObservable } from './ScalarObservable';
  import { EmptyObservable } from './EmptyObservable';
  import { Subscriber } from '../Subscriber';
  import { TeardownLogic } from '../Subscription';
  
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */
  export class ArrayLikeObservable<T> extends Observable<T> {
  
    static create<T>(arrayLike: ArrayLike<T>, scheduler?: Scheduler): Observable<T> {
      const length = arrayLike.length;
      if (length === 0) {
        return new EmptyObservable<T>();
      } else if (length === 1) {
        return new ScalarObservable<T>(<any>arrayLike[0], scheduler);
      } else {
        return new ArrayLikeObservable(arrayLike, scheduler);
      }
    }
  
    static dispatch(state: any) {
      const { arrayLike, index, length, subscriber } = state;
  
      if (subscriber.closed) {
        return;
      }
  
      if (index >= length) {
        subscriber.complete();
        return;
      }
  
      subscriber.next(arrayLike[index]);
  
      state.index = index + 1;
  
      (<any> this).schedule(state);
    }
  
    // value used if Array has one value and _isScalar
    private value: any;
  
    constructor(private arrayLike: ArrayLike<T>, private scheduler?: Scheduler) {
      super();
      if (!scheduler && arrayLike.length === 1) {
        this._isScalar = true;
        this.value = arrayLike[0];
      }
    }
  
    protected _subscribe(subscriber: Subscriber<T>): TeardownLogic {
      let index = 0;
      const { arrayLike, scheduler } = this;
      const length = arrayLike.length;
  
      if (scheduler) {
        return scheduler.schedule(ArrayLikeObservable.dispatch, 0, {
          arrayLike, index, length, subscriber
        });
      } else {
        for (let i = 0; i < length && !subscriber.closed; i++) {
          subscriber.next(arrayLike[i]);
        }
        subscriber.complete();
      }
    }
  }
  