message: refactor(timeInterval): implement in terms of scan
diff: -import { Operator } from '../Operator';
  +
  import { Observable } from '../Observable';
  -import { Subscriber } from '../Subscriber';
  import { async } from '../scheduler/async';
  -import { OperatorFunction, SchedulerLike, TimeInterval as TimeIntervalInterface } from '../types';
  +import { SchedulerLike, OperatorFunction } from '../types';
  +import { scan } from './scan';
  +import { defer } from '../observable/defer';
  +import { map } from './map';
  export function timeInterval<T>(scheduler: SchedulerLike = async): OperatorFunction<T, TimeInterval<T>> {
  - return (source: Observable<T>) => source.lift(new TimeIntervalOperator(scheduler));
  -}
  -
  -export class TimeInterval<T> implements TimeIntervalInterface<T> {
  - constructor(public value: T, public interval: number) {
  -
  - }
  -}
  -
  -class TimeIntervalOperator<T> implements Operator<T, TimeInterval<T>> {
  - constructor(private scheduler: SchedulerLike) {
  -
  - }
  -
  - call(observer: Subscriber<TimeInterval<T>>, source: any): any {
  - return source.subscribe(new TimeIntervalSubscriber(observer, this.scheduler));
  - }
  -}
  -
  -/**
  - * We need this JSDoc comment for affecting ESDoc.
  - * @ignore
  - * @extends {Ignored}
  - */
  -class TimeIntervalSubscriber<T> extends Subscriber<T> {
  - private lastTime: number = 0;
  -
  - constructor(destination: Subscriber<TimeInterval<T>>, private scheduler: SchedulerLike) {
  - super(destination);
  -
  - this.lastTime = scheduler.now();
  - }
  -
  - protected _next(value: T) {
  - let now = this.scheduler.now();
  - let span = now - this.lastTime;
  - this.lastTime = now;
  -
  - this.destination.next(new TimeInterval(value, span));
  - }
  + return (source: Observable<T>) => defer(() => {
  + return source.pipe(
  + // HACK: the typings seem off with scan
  + scan(
  + ({ current }, value) => ({ value, current: scheduler.now(), last: current }),
  + { current: scheduler.now(), value: undefined, last: undefined }
  + ) as any,
  + map<any, TimeInterval<T>>(({ current, last, value }) => new TimeInterval(value, current - last)),
  + );
  + });
  +}
  +
  +export class TimeInterval<T> {
  + constructor(public value: T, public interval: number) {}
  }
  