hunk.code_window:  */
   export function concat<O extends ObservableInput<any>, R>(...observables: Array<O | SchedulerLike>): Observable<ObservedValueOf<O> | R> {
     return concatAll<R>()(of(...observables) as Observable<ObservedValueOf<O>>);
   }
hunk.labels: keep replace replace keep
hunk.after_edit: export function concat<O extends ObservableInput<any>>(...observables: Array<O | SchedulerLike>): Observable<ObservedValueOf<O>> {
     // The cast with `as` below is due to the SchedulerLike, once this is removed, it will no longer be a problem.
     return concatAll<ObservedValueOf<O>>()(of(...observables) as Observable<ObservedValueOf<O>>);
  
hunk.file_path: src/internal/observable/concat.ts
hunk.type: replace
file: import { expect } from 'chai';
  import * as sinon from 'sinon';
  import { hot, cold, expectObservable, expectSubscriptions } from '../helpers/marble-testing';
  import { EMPTY, NEVER, of, race as staticRace, timer, defer, Observable, throwError } from 'rxjs';
  import { race, mergeMap, map, finalize, startWith } from 'rxjs/operators';
  
  /** @test {race} */
  describe('race operator', () => {
    it('should race cold and cold', () => {
      const e1 =  cold('---a-----b-----c----|');
      const e1subs =   '^                   !';
      const e2 =  cold('------x-----y-----z----|');
      const e2subs =   '^  !';
      const expected = '---a-----b-----c----|';
  
      const result = e1.pipe(race(e2));
  
      expectObservable(result).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should race cold and cold and accept an Array of Observable argument', () => {
      const e1 =  cold('---a-----b-----c----|');
      const e1subs =   '^                   !';
      const e2 =  cold('------x-----y-----z----|');
      const e2subs =   '^  !';
      const expected = '---a-----b-----c----|';
  
      const result = e1.pipe(race([e2]));
  
      expectObservable(result).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should race hot and hot', () => {
      const e1 =   hot('---a-----b-----c----|');
      const e1subs =   '^                   !';
      const e2 =   hot('------x-----y-----z----|');
      const e2subs =   '^  !';
      const expected = '---a-----b-----c----|';
  
      const result = e1.pipe(race(e2));
  
      expectObservable(result).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should race hot and cold', () => {
      const e1 =  cold('---a-----b-----c----|');
      const e1subs =   '^                   !';
      const e2 =   hot('------x-----y-----z----|');
      const e2subs =   '^  !';
      const expected = '---a-----b-----c----|';
  
      const result = e1.pipe(race(e2));
  
      expectObservable(result).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should race 2nd and 1st', () => {
      const e1 =  cold('------x-----y-----z----|');
      const e1subs =   '^  !';
      const e2 =  cold('---a-----b-----c----|');
      const e2subs =   '^                   !';
      const expected = '---a-----b-----c----|';
  
      const result = e1.pipe(race(e2));
  
      expectObservable(result).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should race emit and complete', () => {
      const e1 =  cold('-----|');
      const e1subs =   '^    !';
      const e2 =   hot('------x-----y-----z----|');
      const e2subs =   '^    !';
      const expected = '-----|';
  
      const result = e1.pipe(race(e2));
  
      expectObservable(result).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should allow unsubscribing early and explicitly', () => {
      const e1 =  cold('---a-----b-----c----|');
      const e1subs =   '^           !';
      const e2 =   hot('------x-----y-----z----|');
      const e2subs =   '^  !';
      const expected = '---a-----b---';
      const unsub =    '            !';
  
      const result = e1.pipe(race(e2));
  
      expectObservable(result, unsub).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should not break unsubscription chains when unsubscribed explicitly', () => {
      const e1 =   hot('--a--^--b--c---d-| ');
      const e1subs =        '^        !    ';
      const e2 =   hot('---e-^---f--g---h-|');
      const e2subs =        '^  !    ';
      const expected =      '---b--c---    ';
      const unsub =         '         !    ';
  
      const result = e1.pipe(
        mergeMap((x: string) => of(x)),
        race(e2),
        mergeMap((x: string) => of(x))
      );
  
      expectObservable(result, unsub).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should never emit when given non emitting sources', () => {
      const e1 =  cold('---|');
      const e2 =  cold('---|');
      const e1subs =   '^  !';
      const expected = '---|';
  
      const source = e1.pipe(race(e2));
  
      expectObservable(source).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
    });
  
    it('should throw when error occurs mid stream', () => {
      const e1 =  cold('---a-----#');
      const e1subs =   '^        !';
      const e2 =  cold('------x-----y-----z----|');
      const e2subs =   '^  !';
      const expected = '---a-----#';
  
      const result = e1.pipe(race(e2));
  
      expectObservable(result).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should throw when error occurs before a winner is found', () => {
      const e1 =  cold('---#');
      const e1subs =   '^  !';
      const e2 =  cold('------x-----y-----z----|');
      const e2subs =   '^  !';
      const expected = '---#';
  
      const result = e1.pipe(race(e2));
  
      expectObservable(result).toBe(expected);
      expectSubscriptions(e1.subscriptions).toBe(e1subs);
      expectSubscriptions(e2.subscriptions).toBe(e2subs);
    });
  
    it('should allow observable emits immediately', (done: MochaDone) => {
      const e1 = of(true);
      const e2 = timer(200).pipe(map(_ => false));
  
      staticRace(e1, e2).subscribe(x => {
        expect(x).to.be.true;
      }, done, done);
    });
  
    it('should ignore latter observables if a former one emits immediately', () => {
      const onNext = sinon.spy();
      const onSubscribe = sinon.spy();
      const e1 = of('a'); // Wins the race
      const e2 = defer(onSubscribe); // Should be ignored
  
      e1.pipe(race(e2)).subscribe(onNext);
      expect(onNext.calledWithExactly('a')).to.be.true;
      expect(onSubscribe.called).to.be.false;
    });
  
    it('should ignore latter observables if a former one completes immediately', () => {
      const onComplete = sinon.spy();
      const onSubscribe = sinon.spy();
      const e1 = EMPTY; // Wins the race
      const e2 = defer(onSubscribe); // Should be ignored
  
      e1.pipe(race(e2)).subscribe({ complete: onComplete });
      expect(onComplete.calledWithExactly()).to.be.true;
      expect(onSubscribe.called).to.be.false;
    });
  
    it('should ignore latter observables if a former one errors immediately', () => {
      const onError = sinon.spy();
      const onSubscribe = sinon.spy();
      const e1 = throwError('kaboom'); // Wins the race
      const e2 = defer(onSubscribe); // Should be ignored
  
      e1.pipe(race(e2)).subscribe({ error: onError });
      expect(onError.calledWithExactly('kaboom')).to.be.true;
      expect(onSubscribe.called).to.be.false;
    });
  
    it('should unsubscribe former observables if a latter one emits immediately', () => {
      const onNext = sinon.spy();
      const onUnsubscribe = sinon.spy();
      const e1 = NEVER.pipe(finalize(onUnsubscribe)); // Should be unsubscribed
      const e2 = of('b'); // Wins the race
  
      e1.pipe(race(e2)).subscribe(onNext);
      expect(onNext.calledWithExactly('b')).to.be.true;
      expect(onUnsubscribe.calledOnce).to.be.true;
    });
  
    it('should unsubscribe from immediately emitting observable on unsubscription', () => {
      const onNext = sinon.spy();
      const onUnsubscribe = sinon.spy();
      const e1 = <Observable<never>>NEVER.pipe(startWith('a'), finalize(onUnsubscribe)); // Wins the race
      const e2 = NEVER; // Loses the race
  
      const subscription = e1.pipe(race(e2)).subscribe(onNext);
      expect(onNext.calledWithExactly('a')).to.be.true;
      expect(onUnsubscribe.called).to.be.false;
      subscription.unsubscribe();
      expect(onUnsubscribe.calledOnce).to.be.true;
    });
  });
  