title: Operator that skips the next emission from the source whenever another Observable emits
body: <p>I have a use case where I need an Observable to skip its next emission whenever another notifier Observable emits.</p>
  
  <pre><code>source:    |---X---X---X---X---X---X---X---X---X---X--|&gt;
  notifier:  |-------------X---------X----------X-------|&gt;
  result:    |---X---X---X-------X---X-------X-------X--|&gt;
  </code></pre>
  
  <p>Basically, I want an operator called <code>skipNextWhen</code> that takes in the notifier observable and skips the next emission from the source.</p>
  
  <p>I tried using an implementation that uses the <code>pausable</code> operator (re-implemented using <code>switchMap</code>), but couldn't get it to work.</p>
  
  <p><strong>pausable.ts</strong></p>
  
  <pre><code>import { Observable } from 'rxjs/Observable';
  import { Subject } from 'rxjs/Subject';
  import 'rxjs/add/observable/never';
  import 'rxjs/add/operator/startWith';
  
  declare module 'rxjs/Observable' {
      interface Observable&lt;T&gt; {
          pausable: typeof pausable;
      }
  }
  
  function pausable&lt;T&gt;(notifier: Observable&lt;boolean&gt;): Observable&lt;T&gt; {
      return notifier.startWith(false).switchMap((paused) =&gt; {
          if (paused) {
              return Observable.never();
          } else {
              const source = new Subject();
              this.subscribe(source);
              return source;
          }
      });
  }
  
  Observable.prototype.pausable = pausable;
  </code></pre>
  
  <p><strong>skipNextWhen.ts</strong></p>
  
  <pre><code>import { Observable } from 'rxjs/Observable';
  import './pausable';
  
  declare module 'rxjs/Observable' {
      interface Observable&lt;T&gt; {
          skipNextWhen: typeof skipNextWhen;
      }
  }
  
  function skipNextWhen&lt;T, R&gt;(other: Observable&lt;T&gt;): Observable&lt;R&gt; {
      const notifier = Observable.merge(this.map(() =&gt; false), 
                                        other.map(() =&gt; true));
      return this.pausable(notifier);
  }
  
  Observable.prototype.skipNextWhen = skipNextWhen;
  </code></pre>
  
  <p>Is there a more suitable operator that I should consider using instead? The behavior I'm seeing with my current implementation is that the result Observable emits once, and then never again - even if the notifier Observable never emits.</p>