@fncts/observable 0.0.9 → 0.0.11

package/_src/Observable/api.ts

@@ -29,8 +29,8 @@ export function halt(defect: unknown): Observable<never, never, never> {
  * @tsplus static fncts.observable.ObservableOps defer
  */
 export function defer<R, E, A>(observable: Lazy<ObservableInput<R, E, A>>): Observable<R, E, A> {
-  return new Observable((s) => {
-    from(observable()).subscribe(s);
+  return new Observable((s, environment) => {
+    from(observable()).provideEnvironment(environment).subscribe(s);
   });
 }
 
@@ -184,13 +184,11 @@ export interface IterateOptions<S> {
 
 export function iterate<S>(options: IterateOptions<S>): Observable<never, never, S> {
   const { initialState, cont, iterate, scheduler } = options;
-
   function* gen() {
     for (let state = initialState; !cont || cont(state); state = iterate(state)) {
       yield state;
     }
   }
-
   return defer(scheduler ? () => scheduleIterable(gen(), scheduler!) : gen);
 }
 
@@ -212,7 +210,6 @@ export function interval(period = 0, scheduler: SchedulerLike = asyncScheduler):
     // eslint-disable-next-line no-param-reassign
     period = 0;
   }
-
   return timer(period, period, scheduler);
 }
 
@@ -233,7 +230,7 @@ export function merge<O extends ReadonlyArray<ObservableInput<any, any>>>(
     ? empty()
     : sources.length === 1
     ? from(sources[0] as ObservableInput<any, any>)
-    : mergeAll_(fromArrayLike(sources as ReadonlyArray<ObservableInput<any, any>>), concurrency);
+    : fromArrayLike(sources as ReadonlyArray<ObservableInput<any, any>>).mergeAll(concurrency);
 }
 
 /**
@@ -254,26 +251,28 @@ export function single<A>(a: A): Observable<never, never, A> {
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable scheduled
+ * @tsplus pipeable fncts.observable.Observable scheduled
  * @tsplus static fncts.observable.ObservableOps scheduled
  */
-export function scheduled<R, E, A>(input: ObservableInput<R, E, A>, scheduler: SchedulerLike): Observable<R, E, A> {
-  if (isArrayLike(input)) {
-    return scheduleArray(input, scheduler);
-  }
-  if (isPromiseLike(input)) {
-    return schedulePromise(input, scheduler);
-  }
-  if (isIterable(input)) {
-    return scheduleIterable(input, scheduler);
-  }
-  if (isAsyncIterable(input)) {
-    return scheduleAsyncIterable(input, scheduler);
-  }
-  if (isReadableStream(input)) {
-    return scheduleReadableStreamLike(input, scheduler);
-  }
-  return scheduleObservable(from(input), scheduler);
+export function scheduled(scheduler: SchedulerLike) {
+  return <R, E, A>(input: ObservableInput<R, E, A>): Observable<R, E, A> => {
+    if (isArrayLike(input)) {
+      return scheduleArray(input, scheduler);
+    }
+    if (isPromiseLike(input)) {
+      return schedulePromise(input, scheduler);
+    }
+    if (isIterable(input)) {
+      return scheduleIterable(input, scheduler);
+    }
+    if (isAsyncIterable(input)) {
+      return scheduleAsyncIterable(input, scheduler);
+    }
+    if (isReadableStream(input)) {
+      return scheduleReadableStreamLike(input, scheduler);
+    }
+    return scheduleObservable(from(input), scheduler);
+  };
 }
 
 export function scheduleArray<A>(input: ArrayLike<A>, scheduler: SchedulerLike): Observable<never, never, A> {
@@ -336,18 +335,17 @@ export function scheduleIterable<A>(input: Iterable<A>, scheduler: SchedulerLike
         });
       }),
     );
-
     return () => isFunction(iterator?.return) && iterator.return();
   });
 }
 
 export function scheduleObservable<R, E, A>(input: Observable<R, E, A>, scheduler: SchedulerLike): Observable<R, E, A> {
-  return new Observable((subscriber) => {
+  return new Observable((subscriber, environment) => {
     const sub = new Subscription();
     sub.add(
       scheduler.schedule(() => {
         sub.add(
-          input.subscribe({
+          input.provideEnvironment(environment).subscribe({
             next: (value) => {
               sub.add(scheduler.schedule(() => subscriber.next(value)));
             },
@@ -441,34 +439,38 @@ export function makeZip<O extends ReadonlyArray<ObservableInput<any, any>>>(
 ): Observable<
   Observable.EnvironmentOf<O[number]>,
   Observable.ErrorOf<O[number]>,
-  { [K in keyof O]: Observable.TypeOf<O[K]> }
+  {
+    [K in keyof O]: Observable.TypeOf<O[K]>;
+  }
 > {
   return sources.length
-    ? new Observable((subscriber) => {
+    ? new Observable((subscriber, environment) => {
         let buffers: unknown[][] = sources.map(() => []);
         let completed            = sources.map(() => false);
         subscriber.add(() => {
           buffers = completed = null!;
         });
         for (let sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
-          from(sources[sourceIndex]!).subscribe(
-            operatorSubscriber(subscriber, {
-              next: (value) => {
-                buffers[sourceIndex]!.push(value);
-                if (buffers.every((buffer) => buffer.length)) {
-                  const result: any = buffers.map((buffer) => buffer.shift()!);
-                  subscriber.next(result);
-                  if (buffers.some((buffer, i) => !buffer.length && completed[i])) {
-                    subscriber.complete();
+          from(sources[sourceIndex]!)
+            .provideEnvironment(environment)
+            .subscribe(
+              operatorSubscriber(subscriber, {
+                next: (value) => {
+                  buffers[sourceIndex]!.push(value);
+                  if (buffers.every((buffer) => buffer.length)) {
+                    const result: any = buffers.map((buffer) => buffer.shift()!);
+                    subscriber.next(result);
+                    if (buffers.some((buffer, i) => !buffer.length && completed[i])) {
+                      subscriber.complete();
+                    }
                   }
-                }
-              },
-              complete: () => {
-                completed[sourceIndex] = true;
-                !buffers[sourceIndex]!.length && subscriber.complete();
-              },
-            }),
-          );
+                },
+                complete: () => {
+                  completed[sourceIndex] = true;
+                  !buffers[sourceIndex]!.length && subscriber.complete();
+                },
+              }),
+            );
         }
         return () => {
           buffers = completed = null!;
@@ -482,12 +484,12 @@ export function makeZip<O extends ReadonlyArray<ObservableInput<any, any>>>(
  */
 export function fromIO<R, E, A>(io: IO<R, E, A>, scheduler: SchedulerLike = asyncScheduler): Observable<R, E, A> {
   return new Observable((s, env) => {
-    let fiber: FiberContext<E, A>;
+    let fiber: FiberRuntime<E, A>;
     const scheduled = scheduler.schedule(() => {
       fiber = io.provideEnvironment(env).unsafeRunFiber();
-      fiber.unsafeOnDone((exit) => {
+      fiber.addObserver((exit) => {
         if (!s.closed) {
-          exit.flatten.match(
+          exit.match(
             (cause) => s.error(cause),
             (a) => s.next(a),
           );
@@ -508,87 +510,91 @@ export function fromIO<R, E, A>(io: IO<R, E, A>, scheduler: SchedulerLike = asyn
 export const unit: Observable<never, never, void> = Observable.single(undefined);
 
 /**
- * @tsplus fluent fncts.observable.Observable zipWith
+ * @tsplus pipeable fncts.observable.Observable zipWith
  */
-export function zipWith<R, E, A, R1, E1, B, C>(
-  fa: Observable<R, E, A>,
-  fb: Observable<R1, E1, B>,
-  f: (a: A, b: B) => C,
-): Observable<R | R1, E | E1, C> {
-  return fa.mergeMap((a) => fb.map((b) => f(a, b)));
+export function zipWith<A, R1, E1, B, C>(fb: Observable<R1, E1, B>, f: (a: A, b: B) => C) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, C> => {
+    return fa.mergeMap((a) => fb.map((b) => f(a, b)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable zip
+ * @tsplus pipeable fncts.observable.Observable zip
  */
-export function zip<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
-  fb: Observable<R1, E1, B>,
-): Observable<R | R1, E | E1, readonly [A, B]> {
-  return zipWith(fa, fb, Function.tuple);
+export function zip<R1, E1, B>(fb: Observable<R1, E1, B>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, readonly [A, B]> => {
+    return fa.zipWith(fb, Function.tuple);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable ap
+ * @tsplus pipeable fncts.observable.Observable ap
  */
-export function ap<R, E, A, R1, E1, B>(
-  fab: Observable<R, E, (a: A) => B>,
-  fa: Observable<R1, E1, A>,
-): Observable<R | R1, E | E1, B> {
-  return zipWith(fab, fa, (f, a) => f(a));
+export function ap<A, R1, E1>(fa: Observable<R1, E1, A>) {
+  return <R, E, B>(fab: Observable<R, E, (a: A) => B>): Observable<R | R1, E | E1, B> => {
+    return fab.zipWith(fa, (f, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable mapWithIndex
+ * @tsplus pipeable fncts.observable.Observable mapWithIndex
  */
-export function mapWithIndex<R, E, A, B>(fa: Observable<R, E, A>, f: (i: number, a: A) => B): Observable<R, E, B> {
-  return fa.operate((source, subscriber) => {
-    let i = 0;
-    source.subscribe(
-      new OperatorSubscriber(subscriber, {
-        next: (value) => {
-          subscriber.next(f(i++, value));
-        },
-      }),
-    );
-  });
+export function mapWithIndex<A, B>(f: (i: number, a: A) => B) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, B> => {
+    return fa.operate((source, subscriber, environment) => {
+      let i = 0;
+      source.provideEnvironment(environment).subscribe(
+        new OperatorSubscriber(subscriber, {
+          next: (value) => {
+            subscriber.next(f(i++, value));
+          },
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable map
+ * @tsplus pipeable fncts.observable.Observable map
  */
-export function map_<R, E, A, B>(fa: Observable<R, E, A>, f: (a: A) => B): Observable<R, E, B> {
-  return fa.mapWithIndex((_, a) => f(a));
+export function map_<A, B>(f: (a: A) => B) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, B> => {
+    return fa.mapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable as
+ * @tsplus pipeable fncts.observable.Observable as
  */
-export function as_<R, E, A, B>(fa: Observable<R, E, A>, b: Lazy<B>): Observable<R, E, B> {
-  return map_(fa, b);
+export function as<B>(b: Lazy<B>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, B> => {
+    return fa.map(b);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable mapError
+ * @tsplus pipeable fncts.observable.Observable mapError
  */
-export function mapError_<R, E, A, E1>(fa: Observable<R, E, A>, f: (e: E) => E1): Observable<R, E1, A> {
-  return fa.operate((source, subscriber) => {
-    source.subscribe(
-      new OperatorSubscriber(subscriber, {
-        error: (err) => {
-          subscriber.error(err.map(f));
-        },
-      }),
-    );
-  });
+export function mapError<E, E1>(f: (e: E) => E1) {
+  return <R, A>(fa: Observable<R, E, A>): Observable<R, E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      source.provideEnvironment(environment).subscribe(
+        new OperatorSubscriber(subscriber, {
+          error: (err) => {
+            subscriber.error(err.map(f));
+          },
+        }),
+      );
+    });
+  };
 }
 
 /**
  * @tsplus getter fncts.observable.Observable swap
  */
 export function swap<R, E, A>(fa: Observable<R, E, A>): Observable<R, A, E> {
-  return operate_(fa, (source, subscriber) => {
-    source.subscribe(
+  return fa.operate((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(
       new OperatorSubscriber(subscriber, {
         next: (value) => {
           subscriber.error(Cause.fail(value));
@@ -609,216 +615,193 @@ export function swap<R, E, A>(fa: Observable<R, E, A>): Observable<R, A, E> {
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable filterWithIndex
+ * @tsplus pipeable fncts.observable.Observable filterWithIndex
  */
-export function filterWithIndex_<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function filterWithIndex<A, B extends A>(
   refinement: RefinementWithIndex<number, A, B>,
-): Observable<R, E, B>;
-export function filterWithIndex_<R, E, A>(
-  fa: Observable<R, E, A>,
-  predicate: PredicateWithIndex<number, A>,
-): Observable<R, E, A>;
-export function filterWithIndex_<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
+export function filterWithIndex<A>(
   predicate: PredicateWithIndex<number, A>,
-): Observable<R, E, A> {
-  return operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(
-      operatorSubscriber(subscriber, { next: (value) => predicate(index++, value) && subscriber.next(value) }),
-    );
-  });
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function filterWithIndex<A>(predicate: PredicateWithIndex<number, A>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let index = 0;
+      source
+        .provideEnvironment(environment)
+        .subscribe(
+          operatorSubscriber(subscriber, { next: (value) => predicate(index++, value) && subscriber.next(value) }),
+        );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable filter
+ * @tsplus pipeable fncts.observable.Observable filter
  */
-export function filter_<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function filter<A, B extends A>(
   refinement: Refinement<A, B>,
-): Observable<R, E, B>;
-export function filter_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, A>;
-export function filter_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, A> {
-  return fa.filterWithIndex((_, a) => predicate(a));
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
+export function filter<A>(predicate: Predicate<A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function filter<A>(predicate: Predicate<A>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.filterWithIndex((_, a) => predicate(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable filterMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable filterMapWithIndex
  */
-export function filterMapWithIndex<R, E, A, B>(
-  fa: Observable<R, E, A>,
-  f: (i: number, a: A) => Maybe<B>,
-): Observable<R, E, B> {
-  return operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) =>
-          f(index++, value).match(
-            () => noop,
-            (b) => subscriber.next(b),
-          ),
-      }),
-    );
-  });
+export function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, B> => {
+    return fa.operate((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) =>
+            f(index++, value).match(
+              () => noop,
+              (b) => subscriber.next(b),
+            ),
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable filterMap
+ * @tsplus pipeable fncts.observable.Observable filterMap
  */
-export function filterMap_<R, E, A, B>(fa: Observable<R, E, A>, f: (a: A) => Maybe<B>): Observable<R, E, B> {
-  return fa.filterMapWithIndex((_, a) => f(a));
+export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, B> => {
+    return fa.filterMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable partitionWithIndex
+ * @tsplus pipeable fncts.observable.Observable partitionWithIndex
  */
-export function partitionWithIndex<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function partitionWithIndex<A, B extends A>(
   refinement: RefinementWithIndex<number, A, B>,
-): readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
-export function partitionWithIndex<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
+export function partitionWithIndex<A>(
   predicate: PredicateWithIndex<number, A>,
-): readonly [Observable<R, E, A>, Observable<R, E, A>];
-export function partitionWithIndex<R, E, A>(
-  fa: Observable<R, E, A>,
-  predicate: PredicateWithIndex<number, A>,
-): readonly [Observable<R, E, A>, Observable<R, E, A>] {
-  return [fa.filterWithIndex((i, a) => !predicate(i, a)), fa.filterWithIndex(predicate)];
+): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, A>, Observable<R, E, A>];
+export function partitionWithIndex<A>(predicate: PredicateWithIndex<number, A>) {
+  return <R, E>(fa: Observable<R, E, A>): readonly [Observable<R, E, A>, Observable<R, E, A>] => {
+    return [fa.filterWithIndex((i, a) => !predicate(i, a)), fa.filterWithIndex(predicate)];
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable partition
+ * @tsplus pipeable fncts.observable.Observable partition
  */
-export function partition_<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function partition<A, B extends A>(
   refinement: Refinement<A, B>,
-): readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
-export function partition_<R, E, A>(
-  fa: Observable<R, E, A>,
-  predicate: Predicate<A>,
-): readonly [Observable<R, E, A>, Observable<R, E, A>];
-export function partition_<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
+export function partition<A>(
   predicate: Predicate<A>,
-): readonly [Observable<R, E, A>, Observable<R, E, A>] {
-  return fa.partitionWithIndex((_, a) => predicate(a));
-}
-
-/**
- * @tsplus fluent fncts.observable.Observable partitionMapWithIndex
- */
-export function partitionMapWithIndex_<R, E, A, B, C>(
-  fa: Observable<R, E, A>,
-  f: (i: number, a: A) => Either<B, C>,
-): readonly [Observable<R, E, B>, Observable<R, E, C>] {
-  return [
-    operate_(fa, (source, subscriber) => {
-      let index = 0;
-      source.subscribe(
-        operatorSubscriber(subscriber, {
-          next: (value) => {
-            f(index++, value).match((b) => subscriber.next(b), noop);
-          },
-        }),
-      );
-    }),
-    operate_(fa, (source, subscriber) => {
-      let index = 0;
-      source.subscribe(
-        operatorSubscriber(subscriber, {
-          next: (value) => {
-            f(index++, value).match(noop, (c) => subscriber.next(c));
-          },
-        }),
-      );
-    }),
-  ];
+): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, A>, Observable<R, E, A>];
+export function partition<A>(predicate: Predicate<A>) {
+  return <R, E>(fa: Observable<R, E, A>): readonly [Observable<R, E, A>, Observable<R, E, A>] => {
+    return fa.partitionWithIndex((_, a) => predicate(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable partitionMap
+ * @tsplus pipeable fncts.observable.Observable partitionMapWithIndex
  */
-export function partitionMap_<R, E, A, B, C>(
-  fa: Observable<R, E, A>,
-  f: (a: A) => Either<B, C>,
-): readonly [Observable<R, E, B>, Observable<R, E, C>] {
-  return fa.partitionMapWithIndex((_, a) => f(a));
+export function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>) {
+  return <R, E>(fa: Observable<R, E, A>): readonly [Observable<R, E, B>, Observable<R, E, C>] => {
+    return [
+      fa.operate((source, subscriber, environment) => {
+        let index = 0;
+        source.provideEnvironment(environment).subscribe(
+          operatorSubscriber(subscriber, {
+            next: (value) => {
+              f(index++, value).match((b) => subscriber.next(b), noop);
+            },
+          }),
+        );
+      }),
+      fa.operate((source, subscriber, environment) => {
+        let index = 0;
+        source.provideEnvironment(environment).subscribe(
+          operatorSubscriber(subscriber, {
+            next: (value) => {
+              f(index++, value).match(noop, (c) => subscriber.next(c));
+            },
+          }),
+        );
+      }),
+    ];
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable provideEnvironment
+ * @tsplus pipeable fncts.observable.Observable partitionMap
  */
-export function provideEnvironment<R, E, A>(
-  self: Observable<R, E, A>,
-  environment: Environment<R>,
-): Observable<never, E, A> {
-  return self.provide(environment);
+export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
+  return <R, E>(fa: Observable<R, E, A>): readonly [Observable<R, E, B>, Observable<R, E, C>] => {
+    return fa.partitionMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable provideService
+ * @tsplus pipeable fncts.observable.Observable provideService
  */
-export function provideService<R, E, A, S>(
-  self: Observable<R, E, A>,
-  service: S,
-  /** @tsplus auto */ tag: Tag<S>,
-): Observable<Exclude<R, S>, E, A> {
-  return self.contramapEnvironment((environment) => environment.add(service, tag) as Environment<R>);
+export function provideService<S>(service: S, /** @tsplus auto */ tag: Tag<S>) {
+  return <R, E, A>(self: Observable<R, E, A>): Observable<Exclude<R, S>, E, A> => {
+    return self.contramapEnvironment((environment) => environment.add(service, tag) as Environment<R>);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable mergeMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable mergeMapWithIndex
  */
-export function mergeMapWithIndex<R, E, A, R1, E1, B>(
-  ma: Observable<R, E, A>,
+export function mergeMapWithIndex<A, R1, E1, B>(
   f: (i: number, a: A) => ObservableInput<R1, E1, B>,
   concurrent = Infinity,
-): Observable<R | R1, E | E1, B> {
-  return operate_(ma, (source, sub) => mergeInternal(source, sub, f, concurrent));
+) {
+  return <R, E>(ma: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return ma.operate((source, sub, environment) => mergeInternal(source, sub, environment, f, concurrent));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable mergeMap
+ * @tsplus pipeable fncts.observable.Observable mergeMap
  */
-export function mergeMap_<R, E, A, R1, E1, B>(
-  ma: Observable<R, E, A>,
-  f: (a: A) => ObservableInput<R1, E1, B>,
-  concurrent = Infinity,
-): Observable<R | R1, E | E1, B> {
-  return ma.mergeMapWithIndex((_, a) => f(a), concurrent);
+export function mergeMap<A, R1, E1, B>(f: (a: A) => ObservableInput<R1, E1, B>, concurrent = Infinity) {
+  return <R, E>(ma: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return ma.mergeMapWithIndex((_, a) => f(a), concurrent);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable concatMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable concatMapWithIndex
  */
-export function concatMapWithIndex<R, E, A, R1, E1, B>(
-  ma: Observable<R, E, A>,
-  f: (i: number, a: A) => ObservableInput<R1, E1, B>,
-): Observable<R | R1, E | E1, B> {
-  return ma.mergeMapWithIndex(f, 1);
+export function concatMapWithIndex<A, R1, E1, B>(f: (i: number, a: A) => ObservableInput<R1, E1, B>) {
+  return <R, E>(ma: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return ma.mergeMapWithIndex(f, 1);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable concatMap
+ * @tsplus pipeable fncts.observable.Observable concatMap
  */
-export function concatMap_<R, E, A, R1, E1, B>(
-  ma: Observable<R, E, A>,
-  f: (a: A) => ObservableInput<R1, E1, B>,
-): Observable<R | R1, E | E1, B> {
-  return ma.mergeMapWithIndex((_, a) => f(a), 1);
+export function concatMap<A, R1, E1, B>(f: (a: A) => ObservableInput<R1, E1, B>) {
+  return <R, E>(ma: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return ma.mergeMapWithIndex((_, a) => f(a), 1);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable contramapEnvironment
+ * @tsplus pipeable fncts.observable.Observable contramapEnvironment
  */
-export function contramapEnvironment<R, E, A, R0>(
-  self: Observable<R, E, A>,
-  f: (r0: Environment<R0>) => Environment<R>,
-): Observable<R0, E, A> {
-  return Observable.environmentWithObservable((environment) => self.provide(f(environment)));
+export function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) => Environment<R>) {
+  return <E, A>(self: Observable<R, E, A>): Observable<R0, E, A> => {
+    return Observable.environmentWithObservable((environment) => self.provideEnvironment(f(environment)));
+  };
 }
 
 /**
@@ -829,178 +812,173 @@ export function flatten<R, E, R1, E1, A>(mma: Observable<R, E, Observable<R1, E1
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable foldLeftWithIndex
+ * @tsplus pipeable fncts.observable.Observable foldLeftWithIndex
  */
-export function foldLeftWithIndex<R, E, A, B>(
-  fa: Observable<R, E, A>,
-  initial: B,
-  f: (index: number, acc: B, value: A) => B,
-): Observable<R, E, B> {
-  return fa.operate(scanInternal(f, initial, true, false, true));
+export function foldLeftWithIndex<A, B>(initial: B, f: (index: number, acc: B, value: A) => B) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, B> => {
+    return fa.operate(scanInternal(f, initial, true, false, true));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable foldLeft
+ * @tsplus pipeable fncts.observable.Observable foldLeft
  */
-export function foldLeft<R, E, A, B>(
-  fa: Observable<R, E, A>,
-  initial: B,
-  f: (acc: B, value: A) => B,
-): Observable<R, E, B> {
-  return fa.foldLeftWithIndex(initial, (_, b, a) => f(b, a));
+export function foldLeft<A, B>(initial: B, f: (acc: B, value: A) => B) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, B> => {
+    return fa.foldLeftWithIndex(initial, (_, b, a) => f(b, a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable at
+ * @tsplus pipeable fncts.observable.Observable at
  */
-export function at_<R, E, A>(fa: Observable<R, E, A>, index: number): Observable<R, E, Maybe<A>> {
-  return fa
-    .filterWithIndex((i) => i === index)
-    .take(1)
-    .map(Maybe.just)
-    .onEmpty(() => Nothing());
+export function at(index: number) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, Maybe<A>> => {
+    return fa
+      .filterWithIndex((i) => i === index)
+      .take(1)
+      .map(Maybe.just)
+      .onEmpty(() => Nothing());
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable audit
+ * @tsplus pipeable fncts.observable.Observable audit
  */
-export function audit_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
-  durationSelector: (value: A) => ObservableInput<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return fa.operate((source, subscriber) => {
-    let lastValue: Maybe<A> = Nothing();
-    let durationSubscriber: Subscriber<any, any> | null = null;
-    let isComplete    = false;
-    const endDuration = () => {
-      durationSubscriber?.unsubscribe();
-      durationSubscriber = null;
-      if (lastValue.isJust()) {
-        const { value } = lastValue;
-        lastValue       = Nothing();
-        subscriber.next(value);
-      }
-      isComplete && subscriber.complete();
-    };
-
-    const cleanupDuration = () => {
-      durationSubscriber = null;
-      isComplete && subscriber.complete();
-    };
-
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          lastValue = Just(value);
-          if (!durationSubscriber) {
-            from(durationSelector(value)).subscribe(
-              (durationSubscriber = operatorSubscriber(subscriber, { next: endDuration, complete: cleanupDuration })),
-            );
-          }
-        },
-        complete: () => {
-          isComplete = true;
-          (lastValue.isNothing() || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
-        },
-      }),
-    );
-  });
+export function audit<A, R1, E1>(durationSelector: (value: A) => ObservableInput<R1, E1, any>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let lastValue: Maybe<A> = Nothing();
+      let durationSubscriber: Subscriber<any, any> | null = null;
+      let isComplete    = false;
+      const endDuration = () => {
+        durationSubscriber?.unsubscribe();
+        durationSubscriber = null;
+        if (lastValue.isJust()) {
+          const { value } = lastValue;
+          lastValue       = Nothing();
+          subscriber.next(value);
+        }
+        isComplete && subscriber.complete();
+      };
+      const cleanupDuration = () => {
+        durationSubscriber = null;
+        isComplete && subscriber.complete();
+      };
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            lastValue = Just(value);
+            if (!durationSubscriber) {
+              from(durationSelector(value))
+                .provideEnvironment(environment)
+                .subscribe(
+                  (durationSubscriber = operatorSubscriber(subscriber, {
+                    next: endDuration,
+                    complete: cleanupDuration,
+                  })),
+                );
+            }
+          },
+          complete: () => {
+            isComplete = true;
+            (lastValue.isNothing() || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
+          },
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable auditTime
+ * @tsplus pipeable fncts.observable.Observable auditTime
  */
-export function auditTime_<R, E, A>(
-  fa: Observable<R, E, A>,
-  duration: number,
-  scheduler: SchedulerLike = asyncScheduler,
-): Observable<R, E, A> {
-  return fa.audit(() => timer(duration, scheduler));
+export function auditTime(duration: number, scheduler: SchedulerLike = asyncScheduler) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.audit(() => timer(duration, scheduler));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable buffer
+ * @tsplus pipeable fncts.observable.Observable buffer
  */
-export function buffer_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
-  closingNotifier: Observable<R1, E1, any>,
-): Observable<R | R1, E | E1, ReadonlyArray<A>> {
-  return fa.operate((source, subscriber) => {
-    let buffer: A[] = [];
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => buffer.push(value),
-        complete: () => {
-          subscriber.next(buffer);
-          subscriber.complete();
-        },
-      }),
-    );
-    closingNotifier.subscribe(
-      operatorSubscriber(subscriber, {
-        next: () => {
-          const b = buffer;
-          buffer  = [];
-          subscriber.next(b);
-        },
-        complete: noop,
-      }),
-    );
-    return () => {
-      buffer = null!;
-    };
-  });
+export function buffer<R1, E1>(closingNotifier: Observable<R1, E1, any>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, ReadonlyArray<A>> => {
+    return fa.operate((source, subscriber, environment) => {
+      let buffer: A[] = [];
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => buffer.push(value),
+          complete: () => {
+            subscriber.next(buffer);
+            subscriber.complete();
+          },
+        }),
+      );
+      closingNotifier.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: () => {
+            const b = buffer;
+            buffer  = [];
+            subscriber.next(b);
+          },
+          complete: noop,
+        }),
+      );
+      return () => {
+        buffer = null!;
+      };
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable bufferCount
+ * @tsplus pipeable fncts.observable.Observable bufferCount
  */
-export function bufferCount_<R, E, A>(
-  fa: Observable<R, E, A>,
-  bufferSize: number,
-  startBufferEvery?: number,
-): Observable<R, E, ReadonlyArray<A>> {
-  // eslint-disable-next-line no-param-reassign
-  startBufferEvery = startBufferEvery ?? bufferSize;
-  return fa.operate((source, subscriber) => {
-    let buffers: A[][] = [];
-    let count          = 0;
-    source.subscribe(
-      operatorSubscriber(
-        subscriber,
-        {
-          next: (value) => {
-            let toEmit: A[][] | null = null;
-            if (count++ % startBufferEvery! === 0) {
-              buffers.push([]);
-            }
-            for (const buffer of buffers) {
-              buffer.push(value);
-              if (bufferSize <= buffer.length) {
-                toEmit = toEmit ?? [];
-                toEmit.push(buffer);
+export function bufferCount(bufferSize: number, startBufferEvery?: number) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, ReadonlyArray<A>> => {
+    // eslint-disable-next-line no-param-reassign
+    startBufferEvery = startBufferEvery ?? bufferSize;
+    return fa.operate((source, subscriber, environment) => {
+      let buffers: A[][] = [];
+      let count          = 0;
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(
+          subscriber,
+          {
+            next: (value) => {
+              let toEmit: A[][] | null = null;
+              if (count++ % startBufferEvery! === 0) {
+                buffers.push([]);
               }
-            }
-            if (toEmit) {
-              for (const buffer of toEmit) {
-                arrayRemove(buffers, buffer);
+              for (const buffer of buffers) {
+                buffer.push(value);
+                if (bufferSize <= buffer.length) {
+                  toEmit = toEmit ?? [];
+                  toEmit.push(buffer);
+                }
+              }
+              if (toEmit) {
+                for (const buffer of toEmit) {
+                  arrayRemove(buffers, buffer);
+                  subscriber.next(buffer);
+                }
+              }
+            },
+            complete: () => {
+              for (const buffer of buffers) {
                 subscriber.next(buffer);
               }
-            }
+              subscriber.complete();
+            },
           },
-          complete: () => {
-            for (const buffer of buffers) {
-              subscriber.next(buffer);
-            }
-            subscriber.complete();
+          () => {
+            buffers = null!;
           },
-        },
-        () => {
-          buffers = null!;
-        },
-      ),
-    );
-  });
+        ),
+      );
+    });
+  };
 }
 
 export interface BufferTimeConfig {
@@ -1011,191 +989,198 @@ export interface BufferTimeConfig {
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable bufferTime
- */
-export function bufferTime_<R, E, A>(
-  fa: Observable<R, E, A>,
-  config: BufferTimeConfig,
-): Observable<R, E, ReadonlyArray<A>> {
-  const {
-    bufferTimeSpan,
-    bufferCreationInterval = null,
-    maxBufferSize = Infinity,
-    scheduler = asyncScheduler,
-  } = config;
-  return fa.operate((source, subscriber) => {
-    let bufferRecords: { buffer: A[]; subs: Subscription }[] | null = [];
-    let restartOnEmit = true;
-    const emit        = (record: { buffer: A[]; subs: Subscription }) => {
-      const { buffer, subs } = record;
-      subs.unsubscribe();
-      arrayRemove(bufferRecords, record);
-      subscriber.next(buffer);
-      restartOnEmit && startBuffer();
-    };
-    const startBuffer = () => {
-      if (bufferRecords) {
-        const subs = new Subscription();
-        subscriber.add(subs);
-        const buffer: A[] = [];
-        const record      = {
-          buffer,
-          subs,
-        };
-        bufferRecords.push(record);
-        subs.add(scheduler.schedule(() => emit(record), bufferTimeSpan));
-      }
-    };
-    bufferCreationInterval !== null && bufferCreationInterval >= 0
-      ? subscriber.add(
-          scheduler.schedule(function () {
-            startBuffer();
-            !this.closed && subscriber.add(this.schedule(null, bufferCreationInterval));
-          }, bufferCreationInterval),
-        )
-      : (restartOnEmit = true);
-    startBuffer();
-    const bufferTimeSubscriber = operatorSubscriber(
-      subscriber,
-      {
-        next: (value: A) => {
-          const recordsCopy = bufferRecords!.slice();
-          for (const record of recordsCopy) {
-            const { buffer } = record;
-            buffer.push(value);
-            maxBufferSize <= buffer.length && emit(record);
-          }
-        },
-        complete: () => {
-          while (bufferRecords?.length) {
-            subscriber.next(bufferRecords.shift()!.buffer);
-          }
-          bufferTimeSubscriber?.unsubscribe();
-          subscriber.complete();
-          subscriber.unsubscribe();
+ * @tsplus pipeable fncts.observable.Observable bufferTime
+ */
+export function bufferTime(config: BufferTimeConfig) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, ReadonlyArray<A>> => {
+    const {
+      bufferTimeSpan,
+      bufferCreationInterval = null,
+      maxBufferSize = Infinity,
+      scheduler = asyncScheduler,
+    } = config;
+    return fa.operate((source, subscriber, environment) => {
+      let bufferRecords:
+        | {
+            buffer: A[];
+            subs: Subscription;
+          }[]
+        | null = [];
+      let restartOnEmit = true;
+      const emit        = (record: { buffer: A[]; subs: Subscription }) => {
+        const { buffer, subs } = record;
+        subs.unsubscribe();
+        arrayRemove(bufferRecords, record);
+        subscriber.next(buffer);
+        restartOnEmit && startBuffer();
+      };
+      const startBuffer = () => {
+        if (bufferRecords) {
+          const subs = new Subscription();
+          subscriber.add(subs);
+          const buffer: A[] = [];
+          const record      = {
+            buffer,
+            subs,
+          };
+          bufferRecords.push(record);
+          subs.add(scheduler.schedule(() => emit(record), bufferTimeSpan));
+        }
+      };
+      bufferCreationInterval !== null && bufferCreationInterval >= 0
+        ? subscriber.add(
+            scheduler.schedule(function () {
+              startBuffer();
+              !this.closed && subscriber.add(this.schedule(null, bufferCreationInterval));
+            }, bufferCreationInterval),
+          )
+        : (restartOnEmit = true);
+      startBuffer();
+      const bufferTimeSubscriber = operatorSubscriber(
+        subscriber,
+        {
+          next: (value: A) => {
+            const recordsCopy = bufferRecords!.slice();
+            for (const record of recordsCopy) {
+              const { buffer } = record;
+              buffer.push(value);
+              maxBufferSize <= buffer.length && emit(record);
+            }
+          },
+          complete: () => {
+            while (bufferRecords?.length) {
+              subscriber.next(bufferRecords.shift()!.buffer);
+            }
+            bufferTimeSubscriber?.unsubscribe();
+            subscriber.complete();
+            subscriber.unsubscribe();
+          },
         },
-      },
-      () => (bufferRecords = null),
-    );
-    source.subscribe(bufferTimeSubscriber);
-  });
+        () => (bufferRecords = null),
+      );
+      source.provideEnvironment(environment).subscribe(bufferTimeSubscriber);
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable bufferToggle
+ * @tsplus pipeable fncts.observable.Observable bufferToggle
  */
-export function bufferToggle_<R, E, A, R1, E1, B, R2, E2>(
-  fa: Observable<R, E, A>,
+export function bufferToggle<R1, E1, B, R2, E2>(
   openings: ObservableInput<R1, E1, B>,
   closingSelector: (value: B) => ObservableInput<R2, E2, any>,
-): Observable<R | R1 | R2, E | E1 | E2, ReadonlyArray<A>> {
-  return fa.operate((source, subscriber) => {
-    const buffers: A[][] = [];
-    from(openings).subscribe(
-      operatorSubscriber(subscriber, {
-        next: (openValue) => {
-          const buffer: A[] = [];
-          buffers.push(buffer);
-          const closingSubscription = new Subscription();
-          const emitBuffer          = () => {
-            arrayRemove(buffers, buffer);
-            subscriber.next(buffer);
-            closingSubscription.unsubscribe();
-          };
-          closingSubscription.add(
-            from(closingSelector(openValue)).subscribe(
-              operatorSubscriber(subscriber, { next: emitBuffer, complete: noop }),
-            ),
-          );
-        },
-        complete: noop,
-      }),
-    );
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          for (const buffer of buffers) {
-            buffer.push(value);
-          }
-        },
-        complete: () => {
-          while (buffers.length > 0) {
-            subscriber.next(buffers.shift()!);
-          }
-          subscriber.complete();
-        },
-      }),
-    );
-  });
+) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1 | R2, E | E1 | E2, ReadonlyArray<A>> => {
+    return fa.operate((source, subscriber, environment) => {
+      const buffers: A[][] = [];
+      from(openings)
+        .provideEnvironment(environment)
+        .subscribe(
+          operatorSubscriber(subscriber, {
+            next: (openValue) => {
+              const buffer: A[] = [];
+              buffers.push(buffer);
+              const closingSubscription = new Subscription();
+              const emitBuffer          = () => {
+                arrayRemove(buffers, buffer);
+                subscriber.next(buffer);
+                closingSubscription.unsubscribe();
+              };
+              closingSubscription.add(
+                from(closingSelector(openValue))
+                  .provideEnvironment(environment)
+                  .subscribe(operatorSubscriber(subscriber, { next: emitBuffer, complete: noop })),
+              );
+            },
+            complete: noop,
+          }),
+        );
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            for (const buffer of buffers) {
+              buffer.push(value);
+            }
+          },
+          complete: () => {
+            while (buffers.length > 0) {
+              subscriber.next(buffers.shift()!);
+            }
+            subscriber.complete();
+          },
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable bufferWhen
- */
-export function bufferWhen_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
-  closingSelector: () => ObservableInput<R1, E1, any>,
-): Observable<R | R1, E | E1, ReadonlyArray<A>> {
-  return fa.operate((source, subscriber) => {
-    let buffer: A[] | null = null;
-    let closingSubscriber: Subscriber<E | E1, A> | null = null;
-    const openBuffer = () => {
-      closingSubscriber?.unsubscribe();
-      const b = buffer;
-      buffer  = [];
-      b && subscriber.next(b);
-      from(closingSelector()).subscribe(
-        (closingSubscriber = operatorSubscriber(subscriber, { next: openBuffer, complete: noop })),
-      );
-    };
-    openBuffer();
-    source.subscribe(
-      operatorSubscriber(
-        subscriber,
-        {
-          next: (value) => buffer?.push(value),
-          complete: () => {
-            buffer && subscriber.next(buffer);
-            subscriber.complete();
+ * @tsplus pipeable fncts.observable.Observable bufferWhen
+ */
+export function bufferWhen<R1, E1>(closingSelector: () => ObservableInput<R1, E1, any>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, ReadonlyArray<A>> => {
+    return fa.operate((source, subscriber, environment) => {
+      let buffer: A[] | null = null;
+      let closingSubscriber: Subscriber<E | E1, A> | null = null;
+      const openBuffer = () => {
+        closingSubscriber?.unsubscribe();
+        const b = buffer;
+        buffer  = [];
+        b && subscriber.next(b);
+        from(closingSelector())
+          .provideEnvironment(environment)
+          .subscribe((closingSubscriber = operatorSubscriber(subscriber, { next: openBuffer, complete: noop })));
+      };
+      openBuffer();
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(
+          subscriber,
+          {
+            next: (value) => buffer?.push(value),
+            complete: () => {
+              buffer && subscriber.next(buffer);
+              subscriber.complete();
+            },
           },
-        },
-        () => (buffer = closingSubscriber = null),
-      ),
-    );
-  });
+          () => (buffer = closingSubscriber = null),
+        ),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable catchAllCause
+ * @tsplus pipeable fncts.observable.Observable catchAllCause
  */
 export function catchAllCause<R, E, A, R1, E1, B>(
-  self: Observable<R, E, A>,
   f: (cause: Cause<E>, caught: Observable<R | R1, E | E1, A | B>) => ObservableInput<R | R1, E1, B>,
-): Observable<R | R1, E1, A | B> {
-  return self.operate((source, subscriber) => {
-    let innerSub: Subscription | null = null;
-    let syncUnsub                     = false;
-    let handledResult: Observable<R | R1, E1, B>;
-    innerSub                          = source.subscribe(
-      operatorSubscriber(subscriber, {
-        error: (cause) => {
-          handledResult = from(f(cause, source.catchAllCause(f)));
-          if (innerSub) {
-            innerSub.unsubscribe();
-            innerSub = null;
-            handledResult.subscribe(subscriber);
-          } else {
-            syncUnsub = true;
-          }
-        },
-      }),
-    );
-    if (syncUnsub) {
-      innerSub.unsubscribe();
-      innerSub = null;
-      handledResult!.subscribe(subscriber);
-    }
-  });
+) {
+  return (self: Observable<R, E, A>): Observable<R | R1, E1, A | B> => {
+    return self.operate((source, subscriber, environment) => {
+      let innerSub: Subscription | null = null;
+      let syncUnsub                     = false;
+      let handledResult: Observable<R | R1, E1, B>;
+      innerSub                          = source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          error: (cause) => {
+            handledResult = from(f(cause, source.catchAllCause(f)));
+            if (innerSub) {
+              innerSub.unsubscribe();
+              innerSub = null;
+              handledResult.provideEnvironment(environment).subscribe(subscriber);
+            } else {
+              syncUnsub = true;
+            }
+          },
+        }),
+      );
+      if (syncUnsub) {
+        innerSub.unsubscribe();
+        innerSub = null;
+        handledResult!.provideEnvironment(environment).subscribe(subscriber);
+      }
+    });
+  };
 }
 
 /**
@@ -1204,23 +1189,26 @@ export function catchAllCause<R, E, A, R1, E1, B>(
 export function concatAll<R, E, R1, E1, A>(
   ffa: Observable<R, E, ObservableInput<R1, E1, A>>,
 ): Observable<R | R1, E | E1, A> {
-  return mergeAll_(ffa, 1);
+  return ffa.mergeAll(1);
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable concat
+ * @tsplus pipeable fncts.observable.Observable concat
  */
-export function concat_<R, E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(
-  fa: Observable<R, E, A>,
-  ...sources: O
-): Observable<
-  R | Observable.EnvironmentOf<O[number]>,
-  E | Observable.ErrorOf<O[number]>,
-  A | Observable.TypeOf<O[number]>
-> {
-  return fa.operate((source, subscriber) => {
-    fromArrayLike([source, ...sources]).concatAll.subscribe(subscriber);
-  });
+export function concat<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: O) {
+  return <R, E, A>(
+    fa: Observable<R, E, A>,
+  ): Observable<
+    R | Observable.EnvironmentOf<O[number]>,
+    E | Observable.ErrorOf<O[number]>,
+    A | Observable.TypeOf<O[number]>
+  > => {
+    return fa.operate((source, subscriber, environment) => {
+      fromArrayLike([source, ...sources])
+        .concatAll.provideEnvironment(environment)
+        .subscribe(subscriber);
+    });
+  };
 }
 
 /**
@@ -1231,20 +1219,21 @@ export function count<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, number
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable countWithIndex
+ * @tsplus pipeable fncts.observable.Observable countWithIndex
  */
-export function countWithIndex<R, E, A>(
-  fa: Observable<R, E, A>,
-  predicate: PredicateWithIndex<number, A>,
-): Observable<R, E, number> {
-  return fa.foldLeftWithIndex(0, (i, total, v) => (predicate(i, v) ? total + 1 : total));
+export function countWithIndex<A>(predicate: PredicateWithIndex<number, A>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, number> => {
+    return fa.foldLeftWithIndex(0, (i, total, v) => (predicate(i, v) ? total + 1 : total));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable countWith
+ * @tsplus pipeable fncts.observable.Observable countWith
  */
-export function countWith_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, number> {
-  return fa.countWithIndex((_, a) => predicate(a));
+export function countWith<A>(predicate: Predicate<A>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, number> => {
+    return fa.countWithIndex((_, a) => predicate(a));
+  };
 }
 
 /**
@@ -1254,134 +1243,145 @@ export function combineLatestAll<R, E, R1, E1, A>(
   fa: Observable<R, E, ObservableInput<R1, E1, A>>,
 ): Observable<R | R1, E | E1, ReadonlyArray<A>> {
   return joinAllInternal(fa, (sources) =>
-    !sources.length ? empty() : (combineLatest_(sources[0]!, ...sources.slice(1)) as any),
+    !sources.length ? empty() : (zipLatest(sources[0]!, ...sources.slice(1)) as any),
   );
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable combineLatest
+ * @tsplus pipeable fncts.observable.Observable zipLatest
  */
-export function combineLatest_<R, E, A, O extends ReadonlyArray<ObservableInput<any, any, any>>>(
-  self: ObservableInput<R, E, A>,
-  ...sources: O
-): Observable<
-  R | Observable.EnvironmentOf<O[number]>,
-  E | Observable.ErrorOf<O[number]>,
-  [A, ...{ [K in keyof O]: Observable.TypeOf<O[K]> }]
-> {
-  if (!sources.length) {
-    return from(self).unsafeCoerce();
-  }
-  return from(self).operate((source, subscriber) => {
-    combineLatestInternal(subscriber, [source, ...sources]);
-  });
+export function zipLatest<O extends ReadonlyArray<ObservableInput<any, any, any>>>(...sources: O) {
+  return <R, E, A>(
+    self: ObservableInput<R, E, A>,
+  ): Observable<
+    R | Observable.EnvironmentOf<O[number]>,
+    E | Observable.ErrorOf<O[number]>,
+    [
+      A,
+      ...{
+        [K in keyof O]: Observable.TypeOf<O[K]>;
+      },
+    ]
+  > => {
+    if (!sources.length) {
+      return from(self).unsafeCoerce();
+    }
+    return from(self).operate((source, subscriber, environment) => {
+      combineLatestInternal(subscriber, environment, [source, ...sources]);
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable debounceWith
+ * @tsplus pipeable fncts.observable.Observable zipWithLatest
  */
-export function debounceWith_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
-  durationSelector: (value: A) => ObservableInput<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return fa.operate((source, subscriber) => {
-    let lastValue: Maybe<A> = Nothing();
-    let durationSubscriber: Subscriber<E1, any> | null = null;
-    const emit = () => {
-      durationSubscriber?.unsubscribe();
-      durationSubscriber = null;
-      if (lastValue.isJust()) {
-        const { value } = lastValue;
-        lastValue       = Nothing();
-        subscriber.next(value);
-      }
-    };
-    source.subscribe(
-      operatorSubscriber(
-        subscriber,
-        {
-          next: (value) => {
-            durationSubscriber?.unsubscribe();
-            lastValue          = Just(value);
-            durationSubscriber = operatorSubscriber(subscriber, { next: emit, complete: noop });
-            from(durationSelector(value)).subscribe(durationSubscriber);
+export function zipWithLatest<A, R1, E1, B, C>(that: ObservableInput<R1, E1, B>, f: (a: A, b: B) => C) {
+  return <R, E>(self: Observable<R, E, A>): Observable<R | R1, E | E1, C> => {
+    return self.zipLatest(Observable.from(that)).map(f.tupled);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.observable.Observable debounceWith
+ */
+export function debounceWith<A, R1, E1>(durationSelector: (value: A) => ObservableInput<R1, E1, any>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let lastValue: Maybe<A> = Nothing();
+      let durationSubscriber: Subscriber<E1, any> | null = null;
+      const emit = () => {
+        durationSubscriber?.unsubscribe();
+        durationSubscriber = null;
+        if (lastValue.isJust()) {
+          const { value } = lastValue;
+          lastValue       = Nothing();
+          subscriber.next(value);
+        }
+      };
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(
+          subscriber,
+          {
+            next: (value) => {
+              durationSubscriber?.unsubscribe();
+              lastValue          = Just(value);
+              durationSubscriber = operatorSubscriber(subscriber, { next: emit, complete: noop });
+              from(durationSelector(value)).provideEnvironment(environment).subscribe(durationSubscriber);
+            },
+            complete: () => {
+              emit();
+              subscriber.complete();
+            },
           },
-          complete: () => {
-            emit();
-            subscriber.complete();
+          () => {
+            lastValue = durationSubscriber = null!;
           },
-        },
-        () => {
-          lastValue = durationSubscriber = null!;
-        },
-      ),
-    );
-  });
+        ),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable debounce
+ * @tsplus pipeable fncts.observable.Observable debounce
  */
-export function debounce_<R, E, A>(
-  fa: Observable<R, E, A>,
-  dueTime: number,
-  scheduler: SchedulerLike = asyncScheduler,
-): Observable<R, E, A> {
-  return fa.operate((source, subscriber) => {
-    let activeTask: Subscription | null = null;
-    let lastValue: A | null             = null;
-    let lastTime: number | null         = null;
-
-    const emit = () => {
-      if (activeTask) {
-        activeTask.unsubscribe();
-        activeTask  = null;
-        const value = lastValue!;
-        lastValue   = null;
-        subscriber.next(value);
-      }
-    };
-    function emitWhenIdle(this: SchedulerAction<unknown>) {
-      const targetTime = lastTime! + dueTime;
-      const now        = scheduler.now();
-      if (now < targetTime) {
-        activeTask = this.schedule(undefined, targetTime - now);
-        subscriber.add(activeTask);
-        return;
+export function debounce(dueTime: number, scheduler: SchedulerLike = asyncScheduler) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let activeTask: Subscription | null = null;
+      let lastValue: A | null             = null;
+      let lastTime: number | null         = null;
+      const emit                          = () => {
+        if (activeTask) {
+          activeTask.unsubscribe();
+          activeTask  = null;
+          const value = lastValue!;
+          lastValue   = null;
+          subscriber.next(value);
+        }
+      };
+      function emitWhenIdle(this: SchedulerAction<unknown>) {
+        const targetTime = lastTime! + dueTime;
+        const now        = scheduler.now();
+        if (now < targetTime) {
+          activeTask = this.schedule(undefined, targetTime - now);
+          subscriber.add(activeTask);
+          return;
+        }
+        emit();
       }
-      emit();
-    }
-    source.subscribe(
-      operatorSubscriber(
-        subscriber,
-        {
-          next: (value) => {
-            lastValue = value;
-            lastTime  = scheduler.now();
-            if (!activeTask) {
-              activeTask = scheduler.schedule(emitWhenIdle, dueTime);
-              subscriber.add(activeTask);
-            }
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(
+          subscriber,
+          {
+            next: (value) => {
+              lastValue = value;
+              lastTime  = scheduler.now();
+              if (!activeTask) {
+                activeTask = scheduler.schedule(emitWhenIdle, dueTime);
+                subscriber.add(activeTask);
+              }
+            },
+            complete: () => {
+              emit();
+              subscriber.complete();
+            },
           },
-          complete: () => {
-            emit();
-            subscriber.complete();
+          () => {
+            lastValue = activeTask = null;
           },
-        },
-        () => {
-          lastValue = activeTask = null;
-        },
-      ),
-    );
-  });
+        ),
+      );
+    });
+  };
 }
 
 /**
  * @tsplus getter fncts.observable.Observable either
  */
 export function either<R, E, A>(fa: Observable<R, E, A>): Observable<R, never, Either<E, A>> {
-  return fa.operate((source, subscriber) => {
-    source.subscribe(
+  return fa.operate((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(
       operatorSubscriber(subscriber, {
         next: (value) => {
           subscriber.next(Either.right(value));
@@ -1398,54 +1398,54 @@ export function either<R, E, A>(fa: Observable<R, E, A>): Observable<R, never, E
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable delayWithIndex
+ * @tsplus pipeable fncts.observable.Observable delayWithIndex
  */
-export function delayWithIndex<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
-  f: (index: number, value: A) => Observable<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return fa.mergeMapWithIndex((i, a) => f(i, a).take(1).as(a));
+export function delayWithIndex<A, R1, E1>(f: (index: number, value: A) => Observable<R1, E1, any>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.mergeMapWithIndex((i, a) => f(i, a).take(1).as(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable delayWith
+ * @tsplus pipeable fncts.observable.Observable delayWith
  */
-export function delayWith_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
-  f: (value: A) => Observable<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return fa.delayWithIndex((_, a) => f(a));
+export function delayWith<A, R1, E1>(f: (value: A) => Observable<R1, E1, any>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.delayWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable delay
+ * @tsplus pipeable fncts.observable.Observable delay
  */
-export function delay_<R, E, A>(
-  fa: Observable<R, E, A>,
-  due: number | Date,
-  scheduler: SchedulerLike = asyncScheduler,
-): Observable<R, E, A> {
-  const duration = timer(due, scheduler);
-  return delayWith_(fa, () => duration);
+export function delay(due: number | Date, scheduler: SchedulerLike = asyncScheduler) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    const duration = timer(due, scheduler);
+    return fa.delayWith(() => duration);
+  };
 }
 
 /**
  * @tsplus getter fncts.observable.Observable dematerialize
  */
 export function dematerialize<R, E, E1, A>(fa: Observable<R, E, Notification<E1, A>>): Observable<R, E | E1, A> {
-  return fa.operate((source, subscriber) => {
-    source.subscribe(operatorSubscriber(subscriber, { next: (notification) => notification.observe(subscriber) }));
+  return fa.operate((source, subscriber, environment) => {
+    source
+      .provideEnvironment(environment)
+      .subscribe(operatorSubscriber(subscriber, { next: (notification) => notification.observe(subscriber) }));
   });
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable ensuring
+ * @tsplus pipeable fncts.observable.Observable ensuring
  */
-export function ensuring_<R, E, A>(fa: Observable<R, E, A>, finalizer: () => void): Observable<R, E, A> {
-  return fa.operate((source, subscriber) => {
-    source.subscribe(subscriber);
-    subscriber.add(finalizer);
-  });
+export function ensuring(finalizer: () => void) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      source.provideEnvironment(environment).subscribe(subscriber);
+      subscriber.add(finalizer);
+    });
+  };
 }
 
 /**
@@ -1454,21 +1454,23 @@ export function ensuring_<R, E, A>(fa: Observable<R, E, A>, finalizer: () => voi
 export function exhaustAll<R, E, R1, E1, A>(
   ffa: Observable<R, E, ObservableInput<R1, E1, A>>,
 ): Observable<R | R1, E | E1, A> {
-  return ffa.operate((source, subscriber) => {
+  return ffa.operate((source, subscriber, environment) => {
     let isComplete                    = false;
     let innerSub: Subscription | null = null;
-    source.subscribe(
+    source.provideEnvironment(environment).subscribe(
       operatorSubscriber(subscriber, {
         next: (inner) => {
           if (!innerSub) {
-            innerSub = from(inner).subscribe(
-              operatorSubscriber(subscriber, {
-                complete: () => {
-                  innerSub = null;
-                  isComplete && subscriber.complete();
-                },
-              }),
-            );
+            innerSub = from(inner)
+              .provideEnvironment(environment)
+              .subscribe(
+                operatorSubscriber(subscriber, {
+                  complete: () => {
+                    innerSub = null;
+                    isComplete && subscriber.complete();
+                  },
+                }),
+              );
           }
         },
         complete: () => {
@@ -1481,130 +1483,126 @@ export function exhaustAll<R, E, R1, E1, A>(
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable exhaustMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable exhaustMapWithIndex
  */
-export function exhaustMapWithIndex<R, E, A, R1, E1, B>(
-  self: Observable<R, E, A>,
-  f: (i: number, a: A) => ObservableInput<R1, E1, B>,
-): Observable<R | R1, E | E1, B> {
-  return self.operate((source, subscriber) => {
-    let index = 0;
-    let innerSub: Subscriber<E1, B> | null = null;
-    let isComplete = false;
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (outerValue) => {
-          if (!innerSub) {
-            innerSub = operatorSubscriber(subscriber, {
-              complete: () => {
-                innerSub = null;
-                isComplete && subscriber.complete();
-              },
-            });
-            from(f(index++, outerValue)).subscribe(innerSub);
-          }
-        },
-        complete: () => {
-          isComplete = true;
-          !innerSub && subscriber.complete();
-        },
-      }),
-    );
-  });
+export function exhaustMapWithIndex<A, R1, E1, B>(f: (i: number, a: A) => ObservableInput<R1, E1, B>) {
+  return <R, E>(self: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return self.operate((source, subscriber, environment) => {
+      let index = 0;
+      let innerSub: Subscriber<E1, B> | null = null;
+      let isComplete = false;
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (outerValue) => {
+            if (!innerSub) {
+              innerSub = operatorSubscriber(subscriber, {
+                complete: () => {
+                  innerSub = null;
+                  isComplete && subscriber.complete();
+                },
+              });
+              from(f(index++, outerValue))
+                .provideEnvironment(environment)
+                .subscribe(innerSub);
+            }
+          },
+          complete: () => {
+            isComplete = true;
+            !innerSub && subscriber.complete();
+          },
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable exhaustMap
+ * @tsplus pipeable fncts.observable.Observable exhaustMap
  */
-export function exhaustMap_<R, E, A, R1, E1, B>(
-  self: Observable<R, E, A>,
-  f: (a: A) => ObservableInput<R1, E1, B>,
-): Observable<R | R1, E | E1, B> {
-  return self.exhaustMapWithIndex((_, a) => f(a));
+export function exhaustMap<A, R1, E1, B>(f: (a: A) => ObservableInput<R1, E1, B>) {
+  return <R, E>(self: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return self.exhaustMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable expandWithIndex
+ * @tsplus pipeable fncts.observable.Observable expandWithIndex
  */
-export function expandWithIndex<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
+export function expandWithIndex<A, R1, E1, B>(
   f: (i: number, a: A) => ObservableInput<R1, E1, B>,
   concurrent = Infinity,
-): Observable<R | R1, E | E1, B> {
-  // eslint-disable-next-line no-param-reassign
-  concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
-  return fa.operate((source, subscriber) => mergeInternal(source, subscriber, f, concurrent, undefined, true));
+) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
+    return fa.operate((source, subscriber, environment) =>
+      mergeInternal(source, subscriber, environment, f, concurrent, undefined, true),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable expand
+ * @tsplus pipeable fncts.observable.Observable expand
  */
-export function expand_<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
-  f: (a: A) => ObservableInput<R1, E1, B>,
-  concurrent = Infinity,
-): Observable<R | R1, E | E1, B> {
-  return fa.expandWithIndex((_, a) => f(a), concurrent);
+export function expand<A, R1, E1, B>(f: (a: A) => ObservableInput<R1, E1, B>, concurrent = Infinity) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return fa.expandWithIndex((_, a) => f(a), concurrent);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable findWithIndex
+ * @tsplus pipeable fncts.observable.Observable findWithIndex
  */
-export function findWithIndex<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function findWithIndex<A, B extends A>(
   refinement: RefinementWithIndex<number, A, B>,
-): Observable<R, E, Maybe<B>>;
-export function findWithIndex<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, Maybe<B>>;
+export function findWithIndex<A>(
   predicate: PredicateWithIndex<number, A>,
-): Observable<R, E, Maybe<A>>;
-export function findWithIndex<R, E, A>(
-  fa: Observable<R, E, A>,
-  predicate: PredicateWithIndex<number, A>,
-): Observable<R, E, Maybe<A>> {
-  return fa.operate(findInternal(predicate, "value"));
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, Maybe<A>>;
+export function findWithIndex<A>(predicate: PredicateWithIndex<number, A>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, Maybe<A>> => {
+    return fa.operate(findInternal(predicate, "value"));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable find
+ * @tsplus pipeable fncts.observable.Observable find
  */
-export function find_<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function find<A, B extends A>(
   refinement: Refinement<A, B>,
-): Observable<R, E, Maybe<B>>;
-export function find_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, Maybe<A>>;
-export function find_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, Maybe<A>> {
-  return fa.findWithIndex((_, a) => predicate(a));
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, Maybe<B>>;
+export function find<A>(predicate: Predicate<A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, Maybe<A>>;
+export function find<A>(predicate: Predicate<A>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, Maybe<A>> => {
+    return fa.findWithIndex((_, a) => predicate(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable findIndexWithIndex
+ * @tsplus pipeable fncts.observable.Observable findIndexWithIndex
  */
-export function findIndexWithIndex<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function findIndexWithIndex<A, B extends A>(
   refinement: RefinementWithIndex<number, A, B>,
-): Observable<R, E, number>;
-export function findIndexWithIndex<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
+export function findIndexWithIndex<A>(
   predicate: PredicateWithIndex<number, A>,
-): Observable<R, E, number>;
-export function findIndexWithIndex<R, E, A>(
-  fa: Observable<R, E, A>,
-  predicate: PredicateWithIndex<number, A>,
-): Observable<R, E, number> {
-  return fa.operate(findInternal(predicate, "index"));
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
+export function findIndexWithIndex<A>(predicate: PredicateWithIndex<number, A>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, number> => {
+    return fa.operate(findInternal(predicate, "index"));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable findIndex
+ * @tsplus pipeable fncts.observable.Observable findIndex
  */
-export function findIndex_<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function findIndex<A, B extends A>(
   refinement: Refinement<A, B>,
-): Observable<R, E, number>;
-export function findIndex_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, number>;
-export function findIndex_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, number> {
-  return findIndexWithIndex(fa, (_, a) => predicate(a));
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
+export function findIndex<A>(predicate: Predicate<A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
+export function findIndex<A>(predicate: Predicate<A>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, number> => {
+    return fa.findIndexWithIndex((_, a) => predicate(a));
+  };
 }
 
 /**
@@ -1615,14 +1613,18 @@ export function forkJoin<S extends Record<string, ObservableInput<any, any>>>(
 ): Observable<
   Observable.EnvironmentOf<S[keyof S]>,
   Observable.ErrorOf<S[keyof S]>,
-  { [K in keyof S]: Observable.TypeOf<S[K]> }
+  {
+    [K in keyof S]: Observable.TypeOf<S[K]>;
+  }
 >;
 export function forkJoin<A extends ReadonlyArray<ObservableInput<any, any>>>(
   ...sources: A
 ): Observable<
   Observable.EnvironmentOf<A[number]>,
   Observable.ErrorOf<A[number]>,
-  { [K in keyof A]: Observable.TypeOf<A[K]> }
+  {
+    [K in keyof A]: Observable.TypeOf<A[K]>;
+  }
 >;
 export function forkJoin(...args: any[]): Observable<any, any, any> {
   const { args: sources, keys } = arrayOrObject(args);
@@ -1671,8 +1673,8 @@ export function forkJoin(...args: any[]): Observable<any, any, any> {
  * @tsplus getter fncts.observable.Observable ignore
  */
 export function ignore<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, never> {
-  return fa.operate((source, subscriber) => {
-    source.subscribe(
+  return fa.operate((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(
       operatorSubscriber(subscriber, {
         next: noop,
       }),
@@ -1684,8 +1686,8 @@ export function ignore<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, never
  * @tsplus getter fncts.observable.Observable isEmpty
  */
 export function isEmpty<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, boolean> {
-  return fa.operate((source, subscriber) => {
-    source.subscribe(
+  return fa.operate((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(
       operatorSubscriber(subscriber, {
         next: () => {
           subscriber.next(false);
@@ -1704,8 +1706,8 @@ export function isEmpty<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, bool
  * @tsplus getter fncts.observable.Observable materialize
  */
 export function materialize<R, E, A>(fa: Observable<R, E, A>): Observable<R, never, Notification<E, A>> {
-  return fa.operate((source, subscriber) => {
-    source.subscribe(
+  return fa.operate((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(
       operatorSubscriber(subscriber, {
         next: (value) => {
           subscriber.next(Notification.next(value));
@@ -1722,51 +1724,53 @@ export function materialize<R, E, A>(fa: Observable<R, E, A>): Observable<R, nev
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable mergeAll
+ * @tsplus pipeable fncts.observable.Observable mergeAll
  */
-export function mergeAll_<R, E, R1, E1, A>(
-  self: Observable<R, E, ObservableInput<R1, E1, A>>,
-  concurrent = Infinity,
-): Observable<R | R1, E | E1, A> {
-  return self.mergeMap(Function.identity, concurrent);
+export function mergeAll(concurrent = Infinity) {
+  return <R, E, R1, E1, A>(self: Observable<R, E, ObservableInput<R1, E1, A>>): Observable<R | R1, E | E1, A> => {
+    return self.mergeMap(Function.identity, concurrent);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable mergeScanWithIndex
+ * @tsplus pipeable fncts.observable.Observable mergeScanWithIndex
  */
-export function mergeScanWithIndex<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
+export function mergeScanWithIndex<A, R1, E1, B>(
   initial: B,
   f: (index: number, acc: B, value: A) => ObservableInput<R1, E1, B>,
   concurrent = Infinity,
-): Observable<R | R1, E | E1, B> {
-  return fa.operate((source, subscriber) => {
-    let state = initial;
-    return mergeInternal(
-      source,
-      subscriber,
-      (index, value) => f(index, state, value),
-      concurrent,
-      (value) => {
-        state = value;
-      },
-      false,
-      undefined,
-      () => (state = null!),
-    );
-  });
+) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return fa.operate((source, subscriber, environment) => {
+      let state = initial;
+      return mergeInternal(
+        source,
+        subscriber,
+        environment,
+        (index, value) => f(index, state, value),
+        concurrent,
+        (value) => {
+          state = value;
+        },
+        false,
+        undefined,
+        () => (state = null!),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable mergeScan
+ * @tsplus pipeable fncts.observable.Observable mergeScan
  */
-export function mergeScan_<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
+export function mergeScan<A, R1, E1, B>(
   initial: B,
   f: (acc: B, value: A) => ObservableInput<R1, E1, B>,
   concurrent = Infinity,
-): Observable<R | R1, E | E1, B> {
-  return fa.mergeScanWithIndex(initial, (_, b, a) => f(b, a), concurrent);
+) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return fa.mergeScanWithIndex(initial, (_, b, a) => f(b, a), concurrent);
+  };
 }
 
 export function onErrorResumeNext<R, E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(
@@ -1777,7 +1781,7 @@ export function onErrorResumeNext<R, E, A, O extends ReadonlyArray<ObservableInp
   E | Observable.ErrorOf<O[number]>,
   A | Observable.TypeOf<O[number]>
 > {
-  return fa.operate((source, subscriber) => {
+  return fa.operate((source, subscriber, environment) => {
     const remaining     = [source, ...sources];
     const subscribeNext = () => {
       if (!subscriber.closed) {
@@ -1794,7 +1798,7 @@ export function onErrorResumeNext<R, E, A, O extends ReadonlyArray<ObservableInp
             return;
           }
           const innerSub = operatorSubscriber(subscriber, { error: noop, complete: noop });
-          subscriber.add(nextSource.subscribe(innerSub));
+          subscriber.add(nextSource.provideEnvironment(environment).subscribe(innerSub));
           innerSub.add(subscribeNext);
         } else {
           subscriber.complete();
@@ -1806,65 +1810,68 @@ export function onErrorResumeNext<R, E, A, O extends ReadonlyArray<ObservableInp
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable onEmpty
+ * @tsplus pipeable fncts.observable.Observable onEmpty
  */
-export function onEmpty_<R, E, A, B>(fa: Observable<R, E, A>, f: Lazy<B>): Observable<R, E, A | B> {
-  return fa.operate((source, subscriber) => {
-    let hasValue = false;
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          hasValue = true;
-          subscriber.next(value);
-        },
-        complete: () => {
-          if (!hasValue) {
-            subscriber.next(f());
-          }
-          subscriber.complete();
-        },
-      }),
-    );
-  });
+export function onEmpty<B>(f: Lazy<B>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A | B> => {
+    return fa.operate((source, subscriber, environment) => {
+      let hasValue = false;
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            hasValue = true;
+            subscriber.next(value);
+          },
+          complete: () => {
+            if (!hasValue) {
+              subscriber.next(f());
+            }
+            subscriber.complete();
+          },
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable repeat
+ * @tsplus pipeable fncts.observable.Observable repeat
  */
-export function repeat_<R, E, A>(fa: Observable<R, E, A>, count = Infinity): Observable<R, E, A> {
-  return count <= 0
-    ? empty()
-    : fa.operate((source, subscriber) => {
-        let repeats = 0;
-        let innerSub: Subscription | null;
-        const loop  = () => {
-          let syncUnsub = false;
-          innerSub      = source.subscribe(
-            operatorSubscriber(subscriber, {
-              complete: () => {
-                if (++repeats < count) {
-                  if (innerSub) {
-                    innerSub.unsubscribe();
-                    innerSub = null;
-                    loop();
+export function repeat(count = Infinity) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return count <= 0
+      ? empty()
+      : fa.operate((source, subscriber, environment) => {
+          let repeats = 0;
+          let innerSub: Subscription | null;
+          const loop  = () => {
+            let syncUnsub = false;
+            innerSub      = source.provideEnvironment(environment).subscribe(
+              operatorSubscriber(subscriber, {
+                complete: () => {
+                  if (++repeats < count) {
+                    if (innerSub) {
+                      innerSub.unsubscribe();
+                      innerSub = null;
+                      loop();
+                    } else {
+                      syncUnsub = true;
+                    }
                   } else {
-                    syncUnsub = true;
+                    subscriber.complete;
                   }
-                } else {
-                  subscriber.complete;
-                }
-              },
-            }),
-          );
-
-          if (syncUnsub) {
-            innerSub.unsubscribe();
-            innerSub = null;
-            loop();
-          }
-        };
-        loop();
-      });
+                },
+              }),
+            );
+            if (syncUnsub) {
+              innerSub.unsubscribe();
+              innerSub = null;
+              loop();
+            }
+          };
+          loop();
+        });
+  };
 }
 
 export interface RetryConfig {
@@ -1873,126 +1880,118 @@ export interface RetryConfig {
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable retry
+ * @tsplus pipeable fncts.observable.Observable retry
  */
-export function retry_<R, E, A>(fa: Observable<R, E, A>, count?: number): Observable<R, E, A>;
-export function retry_<R, E, A>(fa: Observable<R, E, A>, config: RetryConfig): Observable<R, E, A>;
-export function retry_<R, E, A>(
-  fa: Observable<R, E, A>,
-  configOrCount: number | RetryConfig = Infinity,
-): Observable<R, E, A> {
-  let config: RetryConfig;
-  if (configOrCount && typeof configOrCount === "object") {
-    config = configOrCount;
-  } else {
-    config = {
-      count: configOrCount,
-    };
-  }
-
-  const { count, resetOnSuccess = false } = config;
-
-  return count <= 0
-    ? fa
-    : fa.operate((source, subscriber) => {
-        let retries = 0;
-        let innerSub: Subscription | null;
-        const loop  = () => {
-          let syncUnsub = false;
-          innerSub      = source.subscribe(
-            operatorSubscriber(subscriber, {
-              next: (value) => {
-                if (resetOnSuccess) {
-                  retries = 0;
-                }
-                subscriber.next(value);
-              },
-              error: (err) => {
-                if (retries++ < count) {
-                  if (innerSub) {
-                    innerSub.unsubscribe();
-                    innerSub = null;
-                    loop();
+export function retry(count?: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function retry(config: RetryConfig): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function retry(configOrCount: number | RetryConfig = Infinity) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    let config: RetryConfig;
+    if (configOrCount && typeof configOrCount === "object") {
+      config = configOrCount;
+    } else {
+      config = {
+        count: configOrCount,
+      };
+    }
+    const { count, resetOnSuccess = false } = config;
+    return count <= 0
+      ? fa
+      : fa.operate((source, subscriber, environment) => {
+          let retries = 0;
+          let innerSub: Subscription | null;
+          const loop  = () => {
+            let syncUnsub = false;
+            innerSub      = source.provideEnvironment(environment).subscribe(
+              operatorSubscriber(subscriber, {
+                next: (value) => {
+                  if (resetOnSuccess) {
+                    retries = 0;
+                  }
+                  subscriber.next(value);
+                },
+                error: (err) => {
+                  if (retries++ < count) {
+                    if (innerSub) {
+                      innerSub.unsubscribe();
+                      innerSub = null;
+                      loop();
+                    } else {
+                      syncUnsub = true;
+                    }
                   } else {
-                    syncUnsub = true;
+                    subscriber.error(err);
                   }
-                } else {
-                  subscriber.error(err);
-                }
-              },
-            }),
-          );
-          if (syncUnsub) {
-            innerSub.unsubscribe();
-            innerSub = null;
-            loop();
-          }
-        };
-        loop();
-      });
+                },
+              }),
+            );
+            if (syncUnsub) {
+              innerSub.unsubscribe();
+              innerSub = null;
+              loop();
+            }
+          };
+          loop();
+        });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable sample
+ * @tsplus pipeable fncts.observable.Observable sample
  */
-export function sample_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
-  notifier: Observable<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return fa.operate((source, subscriber) => {
-    let hasValue            = false;
-    let lastValue: A | null = null;
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          hasValue  = true;
-          lastValue = value;
-        },
-      }),
-    );
-    const emit = () => {
-      if (hasValue) {
-        hasValue    = false;
-        const value = lastValue!;
-        lastValue   = null;
-        subscriber.next(value);
-      }
-    };
-    notifier.subscribe(operatorSubscriber(subscriber, { next: emit, complete: noop }));
-  });
+export function sample<R1, E1>(notifier: Observable<R1, E1, any>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let hasValue            = false;
+      let lastValue: A | null = null;
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            hasValue  = true;
+            lastValue = value;
+          },
+        }),
+      );
+      const emit = () => {
+        if (hasValue) {
+          hasValue    = false;
+          const value = lastValue!;
+          lastValue   = null;
+          subscriber.next(value);
+        }
+      };
+      notifier
+        .provideEnvironment(environment)
+        .subscribe(operatorSubscriber(subscriber, { next: emit, complete: noop }));
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable sampleTime
+ * @tsplus pipeable fncts.observable.Observable sampleTime
  */
-export function sampleTime_<R, E, A>(
-  fa: Observable<R, E, A>,
-  period: number,
-  scheduler: SchedulerLike = asyncScheduler,
-): Observable<R, E, A> {
-  return sample_(fa, interval(period, scheduler));
+export function sampleTime(period: number, scheduler: SchedulerLike = asyncScheduler) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.sample(interval(period, scheduler));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable scanLeftWithIndex
+ * @tsplus pipeable fncts.observable.Observable scanLeftWithIndex
  */
-export function scanLeftWithIndex<R, E, A, B>(
-  fa: Observable<R, E, A>,
-  initial: B,
-  f: (index: number, acc: B, value: A) => B,
-): Observable<R, E, B> {
-  return fa.operate(scanInternal(f, initial, true, true));
+export function scanLeftWithIndex<A, B>(initial: B, f: (index: number, acc: B, value: A) => B) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, B> => {
+    return fa.operate(scanInternal(f, initial, true, true));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable scanLeft
+ * @tsplus pipeable fncts.observable.Observable scanLeft
  */
-export function scanLeft<R, E, A, B>(
-  fa: Observable<R, E, A>,
-  initial: B,
-  f: (acc: B, value: A) => B,
-): Observable<R, E, B> {
-  return fa.scanLeftWithIndex(initial, (_, b, a) => f(b, a));
+export function scanLeft<A, B>(initial: B, f: (acc: B, value: A) => B) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, B> => {
+    return fa.scanLeftWithIndex(initial, (_, b, a) => f(b, a));
+  };
 }
 
 /**
@@ -2020,112 +2019,108 @@ export function serviceWithObservable<S, R, E, A>(
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable skip
+ * @tsplus pipeable fncts.observable.Observable skip
  */
-export function skip_<R, E, A>(fa: Observable<R, E, A>, count: number): Observable<R, E, A> {
-  return fa.filterWithIndex((index, _) => count <= index);
+export function skip(count: number) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.filterWithIndex((index, _) => count <= index);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable skipLast
+ * @tsplus pipeable fncts.observable.Observable skipLast
  */
-export function skipLast_<R, E, A>(fa: Observable<R, E, A>, skipCount: number): Observable<R, E, A> {
-  return skipCount <= 0
-    ? fa
-    : fa.operate((source, subscriber) => {
-        let ring: A[] = new Array(skipCount);
-        let seen      = 0;
-        source.subscribe(
-          operatorSubscriber(subscriber, {
-            next: (value) => {
-              const valueIndex = seen++;
-              if (valueIndex < skipCount) {
-                ring[valueIndex] = value;
-              } else {
-                const index    = valueIndex % skipCount;
-                const oldValue = ring[index];
-                ring[index]    = value;
-                subscriber.next(oldValue!);
-              }
-            },
-          }),
-        );
-
-        return () => {
-          ring = null!;
-        };
-      });
+export function skipLast(skipCount: number) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return skipCount <= 0
+      ? fa
+      : fa.operate((source, subscriber, environment) => {
+          let ring: A[] = new Array(skipCount);
+          let seen      = 0;
+          source.provideEnvironment(environment).subscribe(
+            operatorSubscriber(subscriber, {
+              next: (value) => {
+                const valueIndex = seen++;
+                if (valueIndex < skipCount) {
+                  ring[valueIndex] = value;
+                } else {
+                  const index    = valueIndex % skipCount;
+                  const oldValue = ring[index];
+                  ring[index]    = value;
+                  subscriber.next(oldValue!);
+                }
+              },
+            }),
+          );
+          return () => {
+            ring = null!;
+          };
+        });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable skipUntil
+ * @tsplus pipeable fncts.observable.Observable skipUntil
  */
-export function skipUntil_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
-  notifier: Observable<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return fa.operate((source, subscriber) => {
-    let taking           = false;
-    const skipSubscriber = operatorSubscriber(subscriber, {
-      next: () => {
-        skipSubscriber?.unsubscribe();
-        taking = true;
-      },
-      complete: noop,
+export function skipUntil<R1, E1>(notifier: Observable<R1, E1, any>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let taking           = false;
+      const skipSubscriber = operatorSubscriber(subscriber, {
+        next: () => {
+          skipSubscriber?.unsubscribe();
+          taking = true;
+        },
+        complete: noop,
+      });
+      from(notifier).provideEnvironment(environment).subscribe(skipSubscriber);
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => taking && subscriber.next(value),
+        }),
+      );
     });
-
-    from(notifier).subscribe(skipSubscriber);
-
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => taking && subscriber.next(value),
-      }),
-    );
-  });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable skipWhile
+ * @tsplus pipeable fncts.observable.Observable skipWhile
  */
-export function skipWhile_<R, E, A>(
-  fa: Observable<R, E, A>,
-  predicate: PredicateWithIndex<number, A>,
-): Observable<R, E, A> {
-  return fa.operate((source, subscriber) => {
-    let taking = false;
-    let index  = 0;
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => (taking || (taking = !predicate(index++, value))) && subscriber.next(value),
-      }),
-    );
-  });
+export function skipWhile<A>(predicate: PredicateWithIndex<number, A>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let taking = false;
+      let index  = 0;
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => (taking || (taking = !predicate(index++, value))) && subscriber.next(value),
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable startWith
+ * @tsplus pipeable fncts.observable.Observable startWith
  */
-export function startWith_<R, E, A, B extends ReadonlyArray<unknown>>(
-  fa: Observable<R, E, A>,
-  ...values: B
-): Observable<R, E, A | B[number]> {
-  return fa.operate((source, subscriber) => {
-    // @ts-expect-error
-    source.concat(values).subscribe(subscriber);
-  });
+export function startWith<B extends ReadonlyArray<unknown>>(...values: B) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A | B[number]> => {
+    return fa.operate((source, subscriber) => {
+      // @ts-expect-error
+      source.concat(values).subscribe(subscriber);
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable subscribeOn
+ * @tsplus pipeable fncts.observable.Observable subscribeOn
  */
-export function subscribeOn_<R, E, A>(
-  fa: Observable<R, E, A>,
-  scheduler: SchedulerLike,
-  delay = 0,
-): Observable<R, E, A> {
-  return fa.operate((source, subscriber) => {
-    subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay));
-  });
+export function subscribeOn(scheduler: SchedulerLike, delay = 0) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      subscriber.add(scheduler.schedule(() => source.provideEnvironment(environment).subscribe(subscriber), delay));
+    });
+  };
 }
 
 /**
@@ -2134,232 +2129,229 @@ export function subscribeOn_<R, E, A>(
 export function switchAll<R, E, R1, E1, A>(
   ffa: Observable<R, E, ObservableInput<R1, E1, A>>,
 ): Observable<R | R1, E | E1, A> {
-  return switchMap_(ffa, Function.identity);
+  return ffa.switchMap(Function.identity);
 }
-
-/**
- * @tsplus fluent fncts.observable.Observable switchMapWithIndex
- */
-export function switchMapWithIndex<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
-  f: (index: number, value: A) => ObservableInput<R1, E1, B>,
-): Observable<R | R1, E | E1, B> {
-  return operate_(fa, (source, subscriber) => {
-    let innerSubscriber: Subscriber<E | E1, B> | null = null;
-    let index      = 0;
-    let isComplete = false;
-
-    const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
-
-    source.subscribe(
-      operatorSubscriber(
-        subscriber,
-        {
-          next: (value) => {
-            innerSubscriber?.unsubscribe();
-            const outerIndex = index++;
-            from(f(outerIndex, value)).subscribe(
-              (innerSubscriber = operatorSubscriber(subscriber, {
-                next: (innerValue) => subscriber.next(innerValue),
-                complete: () => {
-                  innerSubscriber = null!;
-                  checkComplete();
-                },
-              })),
-            );
+
+/**
+ * @tsplus pipeable fncts.observable.Observable switchMapWithIndex
+ */
+export function switchMapWithIndex<A, R1, E1, B>(f: (index: number, value: A) => ObservableInput<R1, E1, B>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return fa.operate((source, subscriber, environment) => {
+      let innerSubscriber: Subscriber<E | E1, B> | null = null;
+      let index           = 0;
+      let isComplete      = false;
+      const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(
+          subscriber,
+          {
+            next: (value) => {
+              innerSubscriber?.unsubscribe();
+              const outerIndex = index++;
+              from(f(outerIndex, value))
+                .provideEnvironment(environment)
+                .subscribe(
+                  (innerSubscriber = operatorSubscriber(subscriber, {
+                    next: (innerValue) => subscriber.next(innerValue),
+                    complete: () => {
+                      innerSubscriber = null!;
+                      checkComplete();
+                    },
+                  })),
+                );
+            },
           },
-        },
-        () => {
-          isComplete = true;
-          checkComplete();
-        },
-      ),
-    );
-  });
+          () => {
+            isComplete = true;
+            checkComplete();
+          },
+        ),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable switchMap
+ * @tsplus pipeable fncts.observable.Observable switchMap
  */
-export function switchMap_<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
-  f: (value: A) => ObservableInput<R1, E1, B>,
-): Observable<R | R1, E | E1, B> {
-  return fa.switchMapWithIndex((_, a) => f(a));
+export function switchMap<A, R1, E1, B>(f: (value: A) => ObservableInput<R1, E1, B>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return fa.switchMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable switchScanWithIndex
+ * @tsplus pipeable fncts.observable.Observable switchScanWithIndex
  */
-export function switchScanWithIndex<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
+export function switchScanWithIndex<A, R1, E1, B>(
   initial: B,
   f: (index: number, acc: B, value: A) => ObservableInput<R1, E1, B>,
-): Observable<R | R1, E | E1, B> {
-  return operate_(fa, (source, subscriber) => {
-    let state = initial;
-    switchMapWithIndex(source, (index, value) => from(f(index, state, value)).map((b) => ((state = b), b))).subscribe(
-      subscriber,
-    );
-    return () => {
-      state = null!;
-    };
-  });
+) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return fa.operate((source, subscriber, environment) => {
+      let state = initial;
+      source
+        .switchMapWithIndex((index, value) => from(f(index, state, value)).map((b) => ((state = b), b)))
+        .provideEnvironment(environment)
+        .subscribe(subscriber);
+      return () => {
+        state = null!;
+      };
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable switchScan
+ * @tsplus pipeable fncts.observable.Observable switchScan
  */
-export function switchScan_<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
-  initial: B,
-  f: (acc: B, value: A) => ObservableInput<R1, E1, B>,
-): Observable<R | R1, E | E1, B> {
-  return fa.switchScanWithIndex(initial, (_, b, a) => f(b, a));
+export function switchScan<A, R1, E1, B>(initial: B, f: (acc: B, value: A) => ObservableInput<R1, E1, B>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    return fa.switchScanWithIndex(initial, (_, b, a) => f(b, a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable take
+ * @tsplus pipeable fncts.observable.Observable take
  */
-export function take_<R, E, A>(fa: Observable<R, E, A>, count: number): Observable<R, E, A> {
-  return count <= 0
-    ? empty()
-    : fa.operate((source, sub) => {
-        let seen = 0;
-        source.subscribe(
-          new OperatorSubscriber(sub, {
-            next: (value) => {
-              if (++seen <= count) {
-                sub.next(value);
-                if (count <= seen) {
-                  sub.complete();
+export function take(count: number) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return count <= 0
+      ? empty()
+      : fa.operate((source, sub, environment) => {
+          let seen = 0;
+          source.provideEnvironment(environment).subscribe(
+            new OperatorSubscriber(sub, {
+              next: (value) => {
+                if (++seen <= count) {
+                  sub.next(value);
+                  if (count <= seen) {
+                    sub.complete();
+                  }
                 }
-              }
-            },
-          }),
-        );
-      });
+              },
+            }),
+          );
+        });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable takeLast
+ * @tsplus pipeable fncts.observable.Observable takeLast
  */
-export function takeLast_<R, E, A>(fa: Observable<R, E, A>, count: number): Observable<R, E, A> {
-  return count <= 0
-    ? empty()
-    : fa.operate((source, subscriber) => {
-        let buffer: A[] = [];
-        source.subscribe(
-          operatorSubscriber(
-            subscriber,
-            {
-              next: (value) => {
-                buffer.push(value);
-                count < buffer.length && buffer.shift();
+export function takeLast(count: number) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return count <= 0
+      ? empty()
+      : fa.operate((source, subscriber, environment) => {
+          let buffer: A[] = [];
+          source.provideEnvironment(environment).subscribe(
+            operatorSubscriber(
+              subscriber,
+              {
+                next: (value) => {
+                  buffer.push(value);
+                  count < buffer.length && buffer.shift();
+                },
+                complete: () => {
+                  for (const value of buffer) {
+                    subscriber.next(value);
+                  }
+                  subscriber.complete();
+                },
               },
-              complete: () => {
-                for (const value of buffer) {
-                  subscriber.next(value);
-                }
-                subscriber.complete();
+              () => {
+                buffer = null!;
               },
-            },
-            () => {
-              buffer = null!;
-            },
-          ),
-        );
-      });
+            ),
+          );
+        });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable takeUntil
+ * @tsplus pipeable fncts.observable.Observable takeUntil
  */
-export function takeUntil_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
-  notifier: ObservableInput<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return fa.operate((source, subscriber) => {
-    from(notifier).subscribe(operatorSubscriber(subscriber, { next: () => subscriber.complete(), complete: noop }));
-    !subscriber.closed && source.subscribe(subscriber);
-  });
+export function takeUntil<R1, E1>(notifier: ObservableInput<R1, E1, any>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      from(notifier)
+        .provideEnvironment(environment)
+        .subscribe(operatorSubscriber(subscriber, { next: () => subscriber.complete(), complete: noop }));
+      !subscriber.closed && source.provideEnvironment(environment).subscribe(subscriber);
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable takeWhileWithIndex
+ * @tsplus pipeable fncts.observable.Observable takeWhileWithIndex
  */
-export function takeWhileWithIndex<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function takeWhileWithIndex<A, B extends A>(
   refinement: RefinementWithIndex<number, A, B>,
   inclusive?: boolean,
-): Observable<R, E, B>;
-export function takeWhileWithIndex<R, E, A>(
-  fa: Observable<R, E, A>,
-  predicate: PredicateWithIndex<number, A>,
-  inclusive?: boolean,
-): Observable<R, E, A>;
-export function takeWhileWithIndex<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
+export function takeWhileWithIndex<A>(
   predicate: PredicateWithIndex<number, A>,
   inclusive?: boolean,
-): Observable<R, E, A> {
-  return fa.operate((source, subscriber) => {
-    let index = 0;
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          const result = predicate(index++, value);
-          (result || inclusive) && subscriber.next(value);
-          !result && subscriber.complete();
-        },
-      }),
-    );
-  });
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function takeWhileWithIndex<A>(predicate: PredicateWithIndex<number, A>, inclusive?: boolean) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            const result = predicate(index++, value);
+            (result || inclusive) && subscriber.next(value);
+            !result && subscriber.complete();
+          },
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable takeWhile
+ * @tsplus pipeable fncts.observable.Observable takeWhile
  */
-export function takeWhile_<R, E, A, B extends A>(
-  fa: Observable<R, E, A>,
+export function takeWhile<A, B extends A>(
   refinement: Refinement<A, B>,
   inclusive?: boolean,
-): Observable<R, E, B>;
-export function takeWhile_<R, E, A>(
-  fa: Observable<R, E, A>,
-  predicate: Predicate<A>,
-  inclusive?: boolean,
-): Observable<R, E, A>;
-export function takeWhile_<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
+export function takeWhile<A>(
   predicate: Predicate<A>,
   inclusive?: boolean,
-): Observable<R, E, A> {
-  return fa.takeWhileWithIndex((_, a) => predicate(a), inclusive);
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function takeWhile<A>(predicate: Predicate<A>, inclusive?: boolean) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.takeWhileWithIndex((_, a) => predicate(a), inclusive);
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable tap
+ * @tsplus pipeable fncts.observable.Observable tap
  */
-export function tap_<R, E, A>(fa: Observable<R, E, A>, observer: Partial<Observer<E, A>>): Observable<R, E, A> {
-  return fa.operate((source, subscriber) => {
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          observer.next?.(value);
-          subscriber.next(value);
-        },
-        error: (err) => {
-          observer.error?.(err);
-          subscriber.error(err);
-        },
-        complete: () => {
-          observer.complete?.();
-          subscriber.complete();
-        },
-      }),
-    );
-  });
+export function tap<E, A>(observer: Partial<Observer<E, A>>) {
+  return <R>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            observer.next?.(value);
+            subscriber.next(value);
+          },
+          error: (err) => {
+            observer.error?.(err);
+            subscriber.error(err);
+          },
+          complete: () => {
+            observer.complete?.();
+            subscriber.complete();
+          },
+        }),
+      );
+    });
+  };
 }
 
 export interface ThrottleConfig {
@@ -2373,77 +2365,80 @@ export const defaultThrottleConfig: ThrottleConfig = {
 };
 
 /**
- * @tsplus fluent fncts.observable.Observable throttle
+ * @tsplus pipeable fncts.observable.Observable throttle
  */
-export function throttle_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
+export function throttle<A, R1, E1>(
   durationSelector: (a: A) => ObservableInput<R1, E1, any>,
   { leading, trailing }: ThrottleConfig = defaultThrottleConfig,
-): Observable<R | R1, E | E1, A> {
-  return fa.operate((source, subscriber) => {
-    let sendValue: Maybe<A>            = Nothing();
-    let throttled: Subscription | null = null;
-    let isComplete                     = false;
-
-    const endThrottling = () => {
-      throttled?.unsubscribe();
-      throttled = null;
-      if (trailing) {
-        send();
+) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let sendValue: Maybe<A>            = Nothing();
+      let throttled: Subscription | null = null;
+      let isComplete                     = false;
+      const endThrottling                = () => {
+        throttled?.unsubscribe();
+        throttled = null;
+        if (trailing) {
+          send();
+          isComplete && subscriber.complete();
+        }
+      };
+      const cleanupThrottling = () => {
+        throttled = null;
         isComplete && subscriber.complete();
-      }
-    };
-
-    const cleanupThrottling = () => {
-      throttled = null;
-      isComplete && subscriber.complete();
-    };
-
-    const startThrottling = (value: A) =>
-      (throttled = from(durationSelector(value)).subscribe(
-        operatorSubscriber(subscriber, { next: endThrottling, complete: cleanupThrottling }),
-      ));
-
-    const send = () => {
-      if (sendValue.isJust()) {
-        const { value } = sendValue;
-        sendValue       = Nothing();
-        subscriber.next(value);
-        !isComplete && startThrottling(value);
-      }
-    };
-
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          sendValue = Just(value);
-          !(throttled && !throttled.closed) && (leading ? send() : startThrottling(value));
-        },
-        complete: () => {
-          isComplete = true;
-          !(trailing && sendValue.isJust() && throttled && !throttled.closed) && subscriber.complete();
-        },
-      }),
-    );
-  });
+      };
+      const startThrottling = (value: A) =>
+        (throttled = from(durationSelector(value))
+          .provideEnvironment(environment)
+          .subscribe(operatorSubscriber(subscriber, { next: endThrottling, complete: cleanupThrottling })));
+      const send = () => {
+        if (sendValue.isJust()) {
+          const { value } = sendValue;
+          sendValue       = Nothing();
+          subscriber.next(value);
+          !isComplete && startThrottling(value);
+        }
+      };
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            sendValue = Just(value);
+            !(throttled && !throttled.closed) && (leading ? send() : startThrottling(value));
+          },
+          complete: () => {
+            isComplete = true;
+            !(trailing && sendValue.isJust() && throttled && !throttled.closed) && subscriber.complete();
+          },
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable throttleTime
+ * @tsplus pipeable fncts.observable.Observable throttleTime
  */
-export function throttleTime_<R, E, A>(
-  fa: Observable<R, E, A>,
+export function throttleTime(
   duration: number,
   scheduler: SchedulerLike = asyncScheduler,
   config = defaultThrottleConfig,
-): Observable<R, E, A> {
-  const duration$ = timer(duration, scheduler);
-  return throttle_(fa, () => duration$, config);
+) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    const duration$ = timer(duration, scheduler);
+    return fa.throttle(() => duration$, config);
+  };
 }
 
 export type TimeoutConfig<R, E, A, B, M = unknown> = (
-  | { readonly each: number; readonly first?: number | Date }
-  | { readonly each?: number; readonly first: number | Date }
+  | {
+      readonly each: number;
+      readonly first?: number | Date;
+    }
+  | {
+      readonly each?: number;
+      readonly first: number | Date;
+    }
 ) & {
   readonly scheduler?: SchedulerLike;
   readonly with?: (info: TimeoutInfo<A, M>) => ObservableInput<R, E, B>;
@@ -2464,74 +2459,75 @@ export class TimeoutError<A, M> extends Error {
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable timeout
+ * @tsplus pipeable fncts.observable.Observable timeout
  */
-export function timeout_<R, E, A, R1, E1, B, M = unknown>(
-  fa: Observable<R, E, A>,
-  config: TimeoutConfig<R1, E1, A, B, M> & { readonly with: (info: TimeoutInfo<A, M>) => ObservableInput<R1, E1, B> },
-): Observable<R | R1, E | E1, A | B>;
-export function timeout_<R, E, A, M = unknown>(
-  fa: Observable<R, E, A>,
+export function timeout<A, R1, E1, B, M = unknown>(
+  config: TimeoutConfig<R1, E1, A, B, M> & {
+    readonly with: (info: TimeoutInfo<A, M>) => ObservableInput<R1, E1, B>;
+  },
+): <R, E>(fa: Observable<R, E, A>) => Observable<R | R1, E | E1, A | B>;
+export function timeout<A, M = unknown>(
   config: Omit<TimeoutConfig<never, never, A, any, M>, "with">,
-): Observable<R, E | TimeoutError<A, M>, A>;
-export function timeout_<R, E, A, R1, E1, B, M = unknown>(
-  fa: Observable<R, E, A>,
-  config: any,
-): Observable<R | R1, E | E1 | TimeoutError<A, M>, A | B> {
-  const {
-    first,
-    each,
-    with: _with = timeoutError,
-    scheduler = asyncScheduler,
-    meta = null!,
-  } = config as TimeoutConfig<R, E1, A, B, M>;
-  return operate_(fa, (source, subscriber) => {
-    // eslint-disable-next-line prefer-const
-    let originalSourceSubscription: Subscription;
-    let timerSubscription: Subscription;
-    let lastValue: Maybe<A> = Nothing();
-    let seen                = 0;
-    const startTimer        = (delay: number) => {
-      timerSubscription = caughtSchedule(
-        subscriber,
-        scheduler,
-        () => {
-          originalSourceSubscription.unsubscribe();
-          from<R | R1, E1 | TimeoutError<A, M>, B>(
-            _with({
-              meta,
-              lastValue,
-              seen,
-            }),
-          ).subscribe(subscriber);
-        },
-        delay,
-      );
-    };
-
-    originalSourceSubscription = source.subscribe(
-      operatorSubscriber(
-        subscriber,
-        {
-          next: (value) => {
-            timerSubscription?.unsubscribe();
-            seen++;
-            lastValue = Just(value);
-            subscriber.next(value);
-            each! > 0 && startTimer(each!);
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E | TimeoutError<A, M>, A>;
+export function timeout(config: any) {
+  return <R, E, A, R1, E1, B, M = unknown>(
+    fa: Observable<R, E, A>,
+  ): Observable<R | R1, E | E1 | TimeoutError<A, M>, A | B> => {
+    const {
+      first,
+      each,
+      with: _with = timeoutError,
+      scheduler = asyncScheduler,
+      meta = null!,
+    } = config as TimeoutConfig<R, E1, A, B, M>;
+    return fa.operate((source, subscriber, environment) => {
+      // eslint-disable-next-line prefer-const
+      let originalSourceSubscription: Subscription;
+      let timerSubscription: Subscription;
+      let lastValue: Maybe<A> = Nothing();
+      let seen                = 0;
+      const startTimer        = (delay: number) => {
+        timerSubscription = caughtSchedule(
+          subscriber,
+          scheduler,
+          () => {
+            originalSourceSubscription.unsubscribe();
+            from<R | R1, E1 | TimeoutError<A, M>, B>(
+              _with({
+                meta,
+                lastValue,
+                seen,
+              }),
+            )
+              .provideEnvironment(environment)
+              .subscribe(subscriber);
           },
-        },
-        () => {
-          if (!timerSubscription?.closed) {
-            timerSubscription?.unsubscribe();
-          }
-          lastValue = Nothing();
-        },
-      ),
-    );
-
-    startTimer(first != null ? (typeof first === "number" ? first : +first - scheduler.now()) : each!);
-  });
+          delay,
+        );
+      };
+      originalSourceSubscription = source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(
+          subscriber,
+          {
+            next: (value) => {
+              timerSubscription?.unsubscribe();
+              seen++;
+              lastValue = Just(value);
+              subscriber.next(value);
+              each! > 0 && startTimer(each!);
+            },
+          },
+          () => {
+            if (!timerSubscription?.closed) {
+              timerSubscription?.unsubscribe();
+            }
+            lastValue = Nothing();
+          },
+        ),
+      );
+      startTimer(first != null ? (typeof first === "number" ? first : +first - scheduler.now()) : each!);
+    });
+  };
 }
 
 function timeoutError<R, A, M>(info: TimeoutInfo<A, M>): Observable<R, TimeoutError<A, M>, never> {
@@ -2546,104 +2542,106 @@ function toArrayAccumulator(arr: any[], value: any) {
  * @tsplus getter fncts.observable.Observable toArray
  */
 export function toArray<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, ReadonlyArray<A>> {
-  return operate_(fa, (source, subscriber) => {
-    source.foldLeft([] as A[], toArrayAccumulator).subscribe(subscriber);
+  return fa.operate((source, subscriber, environment) => {
+    source
+      .foldLeft([] as A[], toArrayAccumulator)
+      .provideEnvironment(environment)
+      .subscribe(subscriber);
   });
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable unique
+ * @tsplus pipeable fncts.observable.Observable unique
  */
-export function unique_<R, E, A, K, R1, E1 = never>(
-  fa: Observable<R, E, A>,
-  toKey?: (value: A) => K,
-  flushes?: Observable<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return operate_(fa, (source, subscriber) => {
-    let distinctKeys = HashSet.makeDefault<A | K>();
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          const key = toKey ? toKey(value) : value;
-          if (!distinctKeys.has(key)) {
-            distinctKeys.add(key);
-            subscriber.next(value);
-          }
-        },
-      }),
-    );
-    flushes?.subscribe(
-      operatorSubscriber(subscriber, { next: () => (distinctKeys = HashSet.makeDefault()), complete: noop }),
-    );
-  });
+export function unique<A, K, R1, E1 = never>(toKey?: (value: A) => K, flushes?: Observable<R1, E1, any>) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let distinctKeys = HashSet.empty<A | K>();
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            const key = toKey ? toKey(value) : value;
+            if (!distinctKeys.has(key)) {
+              distinctKeys.add(key);
+              subscriber.next(value);
+            }
+          },
+        }),
+      );
+      flushes
+        ?.provideEnvironment(environment)
+        .subscribe(operatorSubscriber(subscriber, { next: () => (distinctKeys = HashSet.empty()), complete: noop }));
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable uniqueUntilChanged
+ * @tsplus pipeable fncts.observable.Observable uniqueUntilChanged
  */
-export function uniqueUntilChanged_<R, E, A, K>(
-  fa: Observable<R, E, A>,
+export function uniqueUntilChanged<A, K>(
   E: Eq<K>,
   keySelector: (value: A) => K,
-): Observable<R, E, A>;
-export function uniqueUntilChanged_<R, E, A, K>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function uniqueUntilChanged<A, K>(
   equals: (x: K, y: K) => boolean,
   keySelector: (value: A) => K,
-): Observable<R, E, A>;
-export function uniqueUntilChanged_<R, E, A>(fa: Observable<R, E, A>, E: Eq<A>): Observable<R, E, A>;
-export function uniqueUntilChanged_<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function uniqueUntilChanged<A>(E: Eq<A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function uniqueUntilChanged<A>(
   equals: (x: A, y: A) => boolean,
-): Observable<R, E, A>;
-export function uniqueUntilChanged_<R, E, A, K = A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function uniqueUntilChanged<A, K = A>(
   E: Eq<K> | ((x: K, y: K) => boolean),
   keySelector: (value: A) => K = Function.identity as (_: A) => K,
-): Observable<R, E, A> {
-  const compare = "equals" in E ? E.equals : E;
-  return fa.operate((source, subscriber) => {
-    let previousKey: K;
-    let first = true;
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          const currentKey = keySelector(value);
-          if (first || !compare(previousKey, currentKey)) {
-            first       = false;
-            previousKey = currentKey;
-            subscriber.next(value);
-          }
-        },
-      }),
-    );
-  });
+) {
+  return <R, E>(fa: Observable<R, E, A>): Observable<R, E, A> => {
+    const compare = "equals" in E ? E.equals : E;
+    return fa.operate((source, subscriber, environment) => {
+      let previousKey: K;
+      let first = true;
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            const currentKey = keySelector(value);
+            if (first || !compare(previousKey, currentKey)) {
+              first       = false;
+              previousKey = currentKey;
+              subscriber.next(value);
+            }
+          },
+        }),
+      );
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable uniqueUntilKeyChanged
+ * @tsplus pipeable fncts.observable.Observable uniqueUntilKeyChanged
  */
-export function uniqueUntilKeyChanged_<R, E, A, K extends keyof A>(
-  fa: Observable<R, E, A>,
+export function uniqueUntilKeyChanged<A, K extends keyof A>(
   key: K,
   E: Eq<A[K]>,
-): Observable<R, E, A>;
-export function uniqueUntilKeyChanged_<R, E, A, K extends keyof A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function uniqueUntilKeyChanged<A, K extends keyof A>(
   key: K,
   equals: (x: A[K], y: A[K]) => boolean,
-): Observable<R, E, A>;
-export function uniqueUntilKeyChanged_<R, E, A, K extends keyof A>(
-  fa: Observable<R, E, A>,
+): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export function uniqueUntilKeyChanged<A, K extends keyof A>(
   key: K,
   equals: Eq<A[K]> | ((x: A[K], y: A[K]) => boolean),
-): Observable<R, E, A> {
-  const compare = "equals" in equals ? equals.equals : equals;
-  return fa.uniqueUntilChanged((x, y) => compare(x[key], y[key]));
+) {
+  if ("equals" in equals) {
+    return <R, E>(fa: Observable<R, E, A>): Observable<R, E, A> =>
+      fa.uniqueUntilChanged((x, y) => equals.equals(y[key])(x[key]));
+  } else {
+    return <R, E>(fa: Observable<R, E, A>): Observable<R, E, A> =>
+      fa.uniqueUntilChanged((x, y) => equals(x[key], y[key]));
+  }
 }
 
 function combineLatestInternal(
   subscriber: Subscriber<any, any>,
+  environment: Environment<any>,
   observables: ObservableInput<any, any, any>[],
   scheduler?: SchedulerLike,
   valueTransform: (values: any[]) => any = Function.identity,
@@ -2655,9 +2653,9 @@ function combineLatestInternal(
     let remainingFirstValues = length;
     for (let i = 0; i < length; i++) {
       maybeSchedule(subscriber, scheduler, () => {
-        const source      = scheduler ? scheduled(observables[i]!, scheduler) : from(observables[i]!);
+        const source      = scheduler ? observables[i]!.pipe(scheduled(scheduler)) : from(observables[i]!);
         let hasFirstValue = false;
-        source.subscribe(
+        source.provideEnvironment(environment).subscribe(
           operatorSubscriber(subscriber, {
             next: (value) => {
               values[i] = value;
@@ -2684,11 +2682,11 @@ function combineLatestInternal(
 function findInternal<A>(
   predicate: PredicateWithIndex<number, A>,
   emit: "value" | "index",
-): <R, E>(source: Observable<R, E, A>, subscriber: Subscriber<E, any>) => void {
+): <R, E>(source: Observable<R, E, A>, subscriber: Subscriber<E, any>, environment: Environment<R>) => void {
   const findIndex = emit === "index";
-  return (source, subscriber) => {
+  return (source, subscriber, environment) => {
     let index = 0;
-    source.subscribe(
+    source.provideEnvironment(environment).subscribe(
       operatorSubscriber(subscriber, {
         next: (value) => {
           const i = index++;
@@ -2724,6 +2722,7 @@ function maybeSchedule(subscription: Subscription, scheduler: SchedulerLike | un
 function mergeInternal<R, E, A, R1, E1, B>(
   source: Observable<R, E, A>,
   subscriber: Subscriber<E | E1, B>,
+  environment: Environment<R | R1>,
   f: (i: number, a: A) => ObservableInput<R1, E1, B>,
   concurrent: number,
   onBeforeNext?: (innerValue: B) => void,
@@ -2735,57 +2734,54 @@ function mergeInternal<R, E, A, R1, E1, B>(
   let active             = 0;
   let index              = 0;
   let isComplete         = false;
-
-  const checkComplete = () => {
+  const checkComplete    = () => {
     if (isComplete && !buffer.length && !active) {
       subscriber.complete();
     }
   };
-
-  const outerNext = (a: A) => (active < concurrent ? doInnerSub(a) : buffer.push(a));
-
+  const outerNext  = (a: A) => (active < concurrent ? doInnerSub(a) : buffer.push(a));
   const doInnerSub = (a: A) => {
     expand && subscriber.next(a as any);
     active++;
     let innerComplete = false;
-    from(f(index++, a)).subscribe(
-      new OperatorSubscriber(
-        subscriber,
-        {
-          next: (b) => {
-            onBeforeNext?.(b);
-
-            if (expand) {
-              outerNext(b as any);
-            } else {
-              subscriber.next(b);
-            }
-          },
-          complete: () => {
-            innerComplete = true;
+    from(f(index++, a))
+      .provideEnvironment(environment)
+      .subscribe(
+        new OperatorSubscriber(
+          subscriber,
+          {
+            next: (b) => {
+              onBeforeNext?.(b);
+              if (expand) {
+                outerNext(b as any);
+              } else {
+                subscriber.next(b);
+              }
+            },
+            complete: () => {
+              innerComplete = true;
+            },
           },
-        },
-        () => {
-          if (innerComplete) {
-            try {
-              active--;
-              while (buffer.length && active < concurrent) {
-                const bufferedValue = buffer.shift()!;
-                innerSubScheduler
-                  ? subscriber.add(innerSubScheduler.schedule(() => doInnerSub(bufferedValue)))
-                  : doInnerSub(bufferedValue);
+          () => {
+            if (innerComplete) {
+              try {
+                active--;
+                while (buffer.length && active < concurrent) {
+                  const bufferedValue = buffer.shift()!;
+                  innerSubScheduler
+                    ? subscriber.add(innerSubScheduler.schedule(() => doInnerSub(bufferedValue)))
+                    : doInnerSub(bufferedValue);
+                }
+                checkComplete();
+              } catch (err) {
+                subscriber.error(Cause.halt(err));
               }
-              checkComplete();
-            } catch (err) {
-              subscriber.error(Cause.halt(err));
             }
-          }
-        },
-      ),
-    );
+          },
+        ),
+      );
   };
-
-  source.subscribe(
+  source.provideEnvironment(environment).subscribe(
     new OperatorSubscriber(subscriber, {
       next: outerNext,
       complete: () => {
@@ -2794,7 +2790,6 @@ function mergeInternal<R, E, A, R1, E1, B>(
       },
     }),
   );
-
   return () => {
     additionalTeardown?.();
   };
@@ -2820,12 +2815,12 @@ export function scanInternal<R, E, A, B>(
   hasInitial: boolean,
   emitOnNext: boolean,
   emitBeforeComplete?: undefined | true,
-): (source: Observable<R, E, A>, subscriber: Subscriber<any, any>) => void {
-  return (source, subscriber) => {
+): (source: Observable<R, E, A>, subscriber: Subscriber<any, any>, environment: Environment<R>) => void {
+  return (source, subscriber, environment) => {
     let hasState   = hasInitial;
     let state: any = initial;
     let index      = 0;
-    source.subscribe(
+    source.provideEnvironment(environment).subscribe(
       operatorSubscriber(subscriber, {
         next: (value) => {
           const i = index++;