refactor: Don't return subscriber or subscription in operate unnece…

…ssarily.

src/internal/operators/count.ts

@@ -67,7 +67,7 @@ export function count<T>(predicate?: (value: T, index: number, source: Observabl
     let index = 0;
     let count = 0;
 
-    return source.subscribe(
+    source.subscribe(
       new OperatorSubscriber(
         subscriber,
         (value) => (!predicate || predicate(value, index++, source)) && count++,

src/internal/operators/dematerialize.ts

@@ -52,7 +52,7 @@ import { OperatorSubscriber } from './OperatorSubscriber';
  * embedded in Notification objects emitted by the source Observable.
  */
 export function dematerialize<N extends ObservableNotification<any>>(): OperatorFunction<N, ValueFromNotification<N>> {
-  return operate((source, subscriber) =>
-    source.subscribe(new OperatorSubscriber(subscriber, (notification) => observeNotification(notification, subscriber)))
-  );
+  return operate((source, subscriber) => {
+    source.subscribe(new OperatorSubscriber(subscriber, (notification) => observeNotification(notification, subscriber)));
+  });
 }

src/internal/operators/filter.ts

@@ -58,15 +58,11 @@ export function filter<T>(predicate: (value: T, index: number) => boolean, thisA
 
     // Subscribe to the source, all errors and completions are
     // forwarded to the consumer.
-    return source.subscribe(
-      new OperatorSubscriber(subscriber, (value) => {
-        // Call the predicate with the appropriate `this` context,
-        // if the predicate returns `true`, then send the value
-        // to the consumer.
-        if (predicate.call(thisArg, value, index++)) {
-          subscriber.next(value);
-        }
-      })
+    source.subscribe(
+      // Call the predicate with the appropriate `this` context,
+      // if the predicate returns `true`, then send the value
+      // to the consumer.
+      new OperatorSubscriber(subscriber, (value) => predicate.call(thisArg, value, index++) && subscriber.next(value))
     );
   });
 }

src/internal/operators/refCount.ts

@@ -106,12 +106,10 @@ export function refCount<T>(): MonoTypeOperatorFunction<T> {
       subscriber.unsubscribe();
     });
 
-    const subscription = source.subscribe(refCounter);
+    source.subscribe(refCounter);
 
     if (!refCounter.closed) {
       connection = (source as ConnectableObservable<T>).connect();
     }
-
-    return subscription;
   });
 }

src/internal/operators/skip.ts

@@ -15,10 +15,6 @@ import { OperatorSubscriber } from './OperatorSubscriber';
 export function skip<T>(count: number): MonoTypeOperatorFunction<T> {
   return operate((source, subscriber) => {
     let seen = 0;
-    return source.subscribe(
-      new OperatorSubscriber(subscriber, (value) => {
-        count === seen ? subscriber.next(value) : seen++;
-      })
-    );
+    source.subscribe(new OperatorSubscriber(subscriber, (value) => (count === seen ? subscriber.next(value) : seen++)));
   });
 }

src/internal/operators/take.ts

@@ -53,7 +53,7 @@ export function take<T>(count: number): MonoTypeOperatorFunction<T> {
     ? () => EMPTY
     : operate((source, subscriber) => {
         let seen = 0;
-        return source.subscribe(
+        source.subscribe(
           new OperatorSubscriber(subscriber, (value) => {
             if (++seen <= count) {
               subscriber.next(value);

src/internal/operators/takeWhile.ts

@@ -53,7 +53,7 @@ export function takeWhile<T>(predicate: (value: T, index: number) => boolean, in
 export function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive = false): MonoTypeOperatorFunction<T> {
   return operate((source, subscriber) => {
     let index = 0;
-    return source.subscribe(
+    source.subscribe(
       new OperatorSubscriber(subscriber, (value) => {
         const result = predicate(value, index++);
         (result || inclusive) && subscriber.next(value);

src/internal/operators/tap.ts

@@ -149,7 +149,8 @@ export function tap<T>(
       onError = error ? wrap(error.bind(nextOrObserver)) : noop;
       onComplete = complete ? wrap(complete.bind(nextOrObserver)) : noop;
     }
-    return source.subscribe(new TapSubscriber(subscriber, onNext, onError, onComplete));
+
+    source.subscribe(new TapSubscriber(subscriber, onNext, onError, onComplete));
   });
 }
 

src/internal/operators/zipWith.ts

@@ -78,7 +78,9 @@ export function zip<T, TOther, R>(
  * @deprecated Deprecated. Use {@link zipWith}.
  */
 export function zip<T, R>(...sources: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, any> {
-  return operate((source, subscriber) => zipStatic(source, ...sources).subscribe(subscriber));
+  return operate((source, subscriber) => {
+    zipStatic(source, ...sources).subscribe(subscriber);
+  });
 }
 
 /**