message: docs(if): create documentation for the operator
  Describe what if operator accepts and returns. Emphasize
  when condition function will be called. Describe
  two basic use cases for that operator and show examples
  with that use cases. Compare to defer operator.
diff: @@ -11,6 +11,87 @@ import { OuterSubscriber } from '../OuterSubscriber';
  */
  export class IfObservable<T, R> extends Observable<T> {
  + /**
  + * Decides at subscription time which Observable will actually be subscribed.
  + *
  + * <span class="informal">`If` statement for Observables.</span>
  + *
  + * `if` accepts a condition function and two Observables. When
  + * an Observable returned by the operator is subscribed, condition function will be called.
  + * Based on what boolean it returns at that moment, consumer will subscribe either to
  + * the first Observable (if condition was true) or to the second (if condition was false). Condition
  + * function may also not return anything - in that case condition will be evaluated as false and
  + * second Observable will be subscribed.
  + *
  + * Note that Observables for both cases (true and false) are optional. If condition points to an Observable that
  + * was left undefined, resulting stream will simply complete immediately. That allows you to, rather
  + * then controlling which Observable will be subscribed, decide at runtime if consumer should have access
  + * to given Observable or not.
  + *
  + * If you have more complex logic that requires decision between more than two Observables, {@link defer}
  + * will probably be a better choice. Actually `if` can be easily implemented with {@link defer}
  + * and exists only for convenience and readability reasons.
  + *
  + *
  + * @example <caption>Change at runtime which Observable will be subscribed</caption>
  + * let subscribeToFirst;
  + * const firstOrSecond = Rx.Observable.if(
  + * () => subscribeToFirst,
  + * Rx.Observable.of('first'),
  + * Rx.Observable.of('second')
  + * );
  + *
  + * subscribeToFirst = true;
  + * firstOrSecond.subscribe(value => console.log(value));
  + *
  + * // Logs:
  + * // "first"
  + *
  + * subscribeToFirst = false;
  + * firstOrSecond.subscribe(value => console.log(value));
  + *
  + * // Logs:
  + * // "second"
  + *
  + *
  + * @example <caption>Control an access to an Observable</caption>
  + * let accessGranted;
  + * const observableIfYouHaveAccess = Rx.Observable.if(
  + * () => accessGranted,
  + * Rx.Observable.of('It seems you have an access...') // Note that only one Observable is passed to the operator.
  + * );
  + *
  + * accessGranted = true;
  + * observableIfYouHaveAccess.subscribe(
  + * value => console.log(value),
  + * err => {},
  + * () => console.log('The end')
  + * );
  + *
  + * // Logs:
  + * // "It seems you have an access..."
  + * // "The end"
  + *
  + * accessGranted = false;
  + * observableIfYouHaveAccess.subscribe(
  + * value => console.log(value),
  + * err => {},
  + * () => console.log('The end')
  + * );
  + *
  + * // Logs:
  + * // "The end"
  + *
  + * @see {@link defer}
  + *
  + * @param {function(): boolean} condition Condition which Observable should be chosen.
  + * @param {Observable} [trueObservable] An Observable that will be subscribed if condition is true.
  + * @param {Observable} [falseObservable] An Observable that will be subscribed if condition is false.
  + * @return {Observable} Either first or second Observable, depending on condition.
  + * @static true
  + * @name if
  + * @owner Observable
  + */
  static create<T, R>(condition: () => boolean | void,
  thenSource?: SubscribableOrPromise<T> | void,
  elseSource?: SubscribableOrPromise<R> | void): Observable<T|R> {
  