hunk.code_window:  * @param {Function} optional comparer function that it will use instead of its default to compare the value of two items.
    * @return {Observable<R>} an Observable that emits item with the smallest number.
    * @method min
    * @owner Observable
    */
   export function min<T>(comparer?: (x: T, y: T) => T): Observable<T> {
     const min: typeof comparer = (typeof comparer === 'function')
       ? comparer
       : (x, y) => x < y ? x : y;
     return this.lift(new ReduceOperator(min));
   }
  
hunk.labels: keep keep keep keep keep replace replace replace keep keep keep
hunk.after_edit: export function min<T>(comparer?: (x: T, y: T) => number): Observable<T> {
     const min: (x: T, y: T) => T = (typeof comparer === 'function')
       ? (x, y) => comparer(x, y) < 0 ? x : y
  
hunk.file_path: src/operator/min.ts
hunk.type: replace
file: var RxOld = require('rx');
  var RxNew = require('../../../../index');
  
  module.exports = function (suite) {
    var oldTakeWithImmediateScheduler = RxOld.Observable.just(50, RxOld.Scheduler.immediate).take(5);
    var newTakeWithImmediateScheduler = RxNew.Observable.of(50).take(5);
  
    function _next(x) { }
    function _error(e) { }
    function _complete() { }
    return suite
        .add('old take with immediate scheduler', function () {
          oldTakeWithImmediateScheduler.subscribe(_next, _error, _complete);
        })
        .add('new take with immediate scheduler', function () {
          newTakeWithImmediateScheduler.subscribe(_next, _error, _complete);
        });
  };