const task_stream =
  // Стрим из всех данных в базе
  getTasks().
    // выбираем задания только для текущего пользователя
    filter((task) => task.user_id == user_id).
    // находим те, которые еще не завершились
    filter((task) => !task.completed).
    // берем только название
    map((task) => task.name)

Observable.from(source)
    .operatorOne()
    .operatorTwo()
    .oneMoreOperator()
    .aaanddMoreOperator()
    .filter(value => value)
    .subscribe(console.log);

return Observable.fromEvent(this.elemnt.nativeElement, 'keyup')
    .map((e:any) => e.target.value)
    .debounceTime(450)
    .concat()
    .distinctUntilChanged()
    .subscribe(item => this.keywordChange.emit(item));

return Observable.fromEvent(this.elemnt.nativeElement, 'keyup')
.map((e:any) => e.target.value)
.debounceTime(450)
.concat()
.distinctUntilChanged()
.subscribe(item => this.keywordChange.emit(item));

private subscription: Subscription;

onInit(){
    this.subscription = this.listenAndSuggest();
}

listenAndSuggest(){
    return Observable
    .fromEvent(this.elemnt.nativeElement, 'keyup')
    .map((e:any) => e.target.value)
    .debounceTime(450)
    .concat()
    .distinctUntilChanged()
    .subscribe(item => this.keywordChange.emit(item));
}

interface Observer<T> {
    closed?: boolean;
    next: (value: T) => void;
    error: (err: any) => void;
    complete: () => void;
}

unsubscribe(): void {
    let hasErrors = false;
    let errors: any[];
    
    if (this.closed) {
        return;
    }

    let { _parent, _ parents, _unsubscribe, _subscriptions } = (<any> this);

    this.closed = true;
    this._parent = null;
    this._parents = null;
    this._subscriptions = null;
}

private subscription: Subscription;

onInit(){
    this.subscription = this.listenAndSuggest();
}

listenAndSuggest(){
    return Observable
    .fromEvent(this.elemnt.nativeElement, 'keyup')
    .map((e:any) => e.target.value)
    .debounceTime(450)
    .concat()
    .distinctUntilChanged()
    .subscribe(item => this.keywordChange.emit(item));
}

onDestroy(){
    this.subscription.unsubscribe();
}

export function take<T> count: number): MonoTypeOperatorFunction<T> {
  return (source: Observable<T>) => {
    if (count === 0) {
      return empty();
    } else {
      return source.lift(new TakeOperator(count));
    }
  };
}

private nextOrComplete(value: T, predicateResult: boolean): void {
  const destination = this.destination;
  if (Boolean(predicateResult)) {
    destination.next(value);
  } else {
    destination.complete();
  }
}

Observable.from([1,2,3])
    .filter(value => false)
    .take(0)
    .subscribe(console.log)

Observable.from([1,2,3])
    .filter(value => false)
    .take(1)
    .subscribe(console.log)

protected _next(value: T): void {
  const destination = this.destination;
  let result: boolean;
  try {
    result = this.predicate(value, this.index++);
  } catch (err) {
    destination.error(err);
    return;
  }
  this.nextOrComplete(value, result);
}

isDestroyed = false;

listenAndSuggest(){
    return Observable
        .fromEvent(this.element.nativeElement, 'keyup')
        .takeWhile(() => this.isDestroyed)
        .subscribe(console.log);
}

onDestroy(){
    this.isDestroyed = true;
}

protected _complete(): void {
  const destination = this.destination;
  if (!this.hasCompleted && typeof this.defaultValue !== 'undefined') {
      destination.next(this.defaultValue);
      destination.complete();
  } else if (!this.hasCompleted) {
      destination.error(new EmptyError);
  }
}

notifyNext(outerValue: T, innerValue: R,
           outerIndex: number, innerIndex: number,
           innerSub: InnerSubscriber<T, R>): void {
  this.complete();
}

export function unsubscribeManager( blackList = [] ) {

  return function ( constructor ) {
    const originalOnDestroy = constructor.prototype.ngOnDestroy;

    constructor.prototype.ngOnDestroy = function () {
      for ( let prop in this ) {
        const property = this[ prop ];
        if ( !blackList.includes(prop) ) {
          if ( property && ( typeof property.unsubscribe === "function" ) ) {
            property.unsubscribe();
          }
        }
      }
      original &&
      typeof originalOnDestroy === 'function' && 
      originalOnDestroy(this, arguments);
    };
  }

}

import { Subject } from 'rxjs/Subject';

export function TakeUntilDestroy(constructor: any) {
  const originalNgOnDestroy = constructor.prototype.ngOnDestroy;

  constructor.prototype.componentDestroy = function () {
    this._takeUntilDestroy$ = this._takeUntilDestroy$ || new Subject();
    return this._takeUntilDestroy$.asObservable();
  };

  constructor.prototype.ngOnDestroy = function () {
    if (this._takeUntilDestroy$) {
      this._takeUntilDestroy$.next(true);
      this._takeUntilDestroy$.complete();
    }
    if (originalNgOnDestroy && typeof originalNgOnDestroy === 'function') {
      originalNgOnDestroy.apply(this, arguments);
    }
  };
}