hunk.code_window:     ).subscribe(() => { /* noop */ });
       expect(sideEffects).to.deep.equal([0, 1, 2]);
     });
   });
hunk.labels: keep keep keep add keep
hunk.after_edit:   it('should not alter the source when the number of retries is smaller than 1', () => {
       const source = cold('--1-2-3-#');
       const subs =       ['^       !'];
       const expected =    '--1-2-3-#';
       const unsub =       '         !';
       const result = source.pipe(retry(0));
       expectObservable(result, unsub).toBe(expected);
       expectSubscriptions(source.subscriptions).toBe(subs);
     })
  
hunk.file_path: spec/operators/retry-spec.ts
hunk.type: add
file: import { MonoTypeOperatorFunction } from '../types';
  import { filter } from './filter';
  
  /**
   * Returns an Observable that skips the first `count` items emitted by the source Observable.
   *
   * ![](skip.png)
   *
   * Skips the values until the sent notifications are equal or less than provided skip count. It raises
   * an error if skip count is equal or more than the actual number of emits and source raises an error.
   *
   * ## Example
   * Skip the values before the emission
   * ```ts
   * import { interval } from 'rxjs';
   * import { skip } from 'rxjs/operators';
   *
   * //emit every half second
   * const source = interval(500);
   * //skip the first 10 emitted values
   * const example = source.pipe(skip(10));
   * //output: 10...11...12...13........
   * const subscribe = example.subscribe(val => console.log(val));
   * ```
   *
   * @see {@link last}
   * @see {@link skipWhile}
   * @see {@link skipUntil}
   * @see {@link skipLast}
   *
   * @param {Number} count - The number of times, items emitted by source Observable should be skipped.
   * @return A function that returns an Observable that skips the first `count`
   * values emitted by the source Observable.
   */
  export function skip<T>(count: number): MonoTypeOperatorFunction<T> {
    return filter((_, index) => count <= index);
  }
  