@fncts/observable 0.0.8 → 0.0.10

package/_cjs/Observable/api.cjs

@@ -5,48 +5,46 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.TimeoutError = void 0;
 exports.ap = ap;
-exports.as_ = void 0;
-exports.at_ = at_;
-exports.auditTime_ = auditTime_;
-exports.audit_ = void 0;
-exports.bufferCount_ = bufferCount_;
-exports.bufferTime_ = bufferTime_;
-exports.bufferToggle_ = bufferToggle_;
-exports.bufferWhen_ = bufferWhen_;
-exports.buffer_ = buffer_;
+exports.as = void 0;
+exports.at = at;
+exports.audit = void 0;
+exports.auditTime = auditTime;
+exports.buffer = buffer;
+exports.bufferCount = bufferCount;
+exports.bufferTime = bufferTime;
+exports.bufferToggle = bufferToggle;
+exports.bufferWhen = bufferWhen;
 exports.catchAllCause = void 0;
 exports.combineLatestAll = combineLatestAll;
-exports.concatAll = exports.combineLatest_ = void 0;
+exports.concatAll = exports.concat = void 0;
+exports.concatMap = concatMap;
 exports.concatMapWithIndex = concatMapWithIndex;
-exports.concatMap_ = concatMap_;
-exports.contramapEnvironment = exports.concat_ = void 0;
+exports.contramapEnvironment = void 0;
 exports.count = count;
+exports.countWith = countWith;
 exports.countWithIndex = void 0;
-exports.countWith_ = countWith_;
-exports.debounceWith_ = debounceWith_;
-exports.debounce_ = debounce_;
-exports.delayWith_ = exports.delayWithIndex = exports.defer = exports.defaultThrottleConfig = void 0;
-exports.delay_ = delay_;
+exports.debounce = debounce;
+exports.debounceWith = debounceWith;
+exports.defer = exports.defaultThrottleConfig = void 0;
+exports.delay = delay;
+exports.delayWithIndex = exports.delayWith = void 0;
 exports.dematerialize = dematerialize;
 exports.either = either;
 exports.empty = void 0;
-exports.ensuring_ = ensuring_;
+exports.ensuring = ensuring;
 exports.environmentWithObservable = void 0;
 exports.exhaustAll = exhaustAll;
+exports.exhaustMap = exhaustMap;
 exports.exhaustMapWithIndex = void 0;
-exports.exhaustMap_ = exhaustMap_;
-exports.expandWithIndex = void 0;
-exports.expand_ = expand_;
-exports.fail = void 0;
+exports.expand = expand;
+exports.fail = exports.expandWithIndex = void 0;
 exports.failCause = failCause;
-exports.filterMapWithIndex = void 0;
-exports.filterMap_ = filterMap_;
-exports.filterWithIndex_ = void 0;
-exports.filter_ = filter_;
-exports.findIndexWithIndex = void 0;
-exports.findIndex_ = findIndex_;
-exports.findWithIndex = void 0;
-exports.find_ = find_;
+exports.filter = filter;
+exports.filterMap = filterMap;
+exports.filterWithIndex = exports.filterMapWithIndex = void 0;
+exports.find = find;
+exports.findIndex = findIndex;
+exports.findWithIndex = exports.findIndexWithIndex = void 0;
 exports.flatten = flatten;
 exports.foldLeftWithIndex = exports.foldLeft = void 0;
 exports.forkJoin = forkJoin;
@@ -67,24 +65,22 @@ exports.isEmpty = isEmpty;
 exports.iterate = iterate;
 exports.joinAllInternal = joinAllInternal;
 exports.makeZip = makeZip;
-exports.mapError_ = mapError_;
+exports.mapError = mapError;
 exports.map_ = exports.mapWithIndex = void 0;
 exports.materialize = materialize;
 exports.merge = merge;
-exports.mergeScanWithIndex = exports.mergeMap_ = exports.mergeMapWithIndex = exports.mergeAll_ = void 0;
-exports.mergeScan_ = mergeScan_;
-exports.onEmpty_ = exports.of = void 0;
+exports.mergeMapWithIndex = exports.mergeMap = exports.mergeAll = void 0;
+exports.mergeScan = mergeScan;
+exports.onEmpty = exports.of = exports.mergeScanWithIndex = void 0;
 exports.onErrorResumeNext = onErrorResumeNext;
-exports.partitionMapWithIndex_ = void 0;
-exports.partitionMap_ = partitionMap_;
-exports.partitionWithIndex = void 0;
-exports.partition_ = partition_;
-exports.provideEnvironment = provideEnvironment;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.partitionWithIndex = exports.partitionMapWithIndex = void 0;
 exports.provideService = provideService;
-exports.repeat_ = repeat_;
-exports.retry_ = retry_;
-exports.sampleTime_ = sampleTime_;
-exports.sample_ = void 0;
+exports.repeat = repeat;
+exports.retry = retry;
+exports.sample = void 0;
+exports.sampleTime = sampleTime;
 exports.scanInternal = scanInternal;
 exports.scanLeft = scanLeft;
 exports.scanLeftWithIndex = void 0;
@@ -98,31 +94,33 @@ exports.scheduled = void 0;
 exports.service = service;
 exports.serviceWith = serviceWith;
 exports.single = exports.serviceWithObservable = void 0;
-exports.skipLast_ = skipLast_;
-exports.skipUntil_ = skipUntil_;
-exports.skipWhile_ = skipWhile_;
-exports.skip_ = skip_;
-exports.startWith_ = startWith_;
-exports.subscribeOn_ = subscribeOn_;
+exports.skip = skip;
+exports.skipLast = skipLast;
+exports.skipUntil = skipUntil;
+exports.skipWhile = skipWhile;
+exports.startWith = startWith;
+exports.subscribeOn = subscribeOn;
 exports.swap = swap;
 exports.switchAll = switchAll;
-exports.switchScanWithIndex = exports.switchMap_ = exports.switchMapWithIndex = void 0;
-exports.switchScan_ = switchScan_;
-exports.takeLast_ = takeLast_;
-exports.takeUntil_ = takeUntil_;
+exports.switchMapWithIndex = exports.switchMap = void 0;
+exports.switchScan = switchScan;
+exports.take = exports.switchScanWithIndex = void 0;
+exports.takeLast = takeLast;
+exports.takeUntil = takeUntil;
+exports.takeWhile = takeWhile;
 exports.takeWhileWithIndex = void 0;
-exports.takeWhile_ = takeWhile_;
-exports.take_ = void 0;
-exports.tap_ = tap_;
-exports.throttleTime_ = throttleTime_;
-exports.throttle_ = void 0;
-exports.timeout_ = timeout_;
-exports.uniqueUntilChanged_ = exports.toArray = exports.timer = void 0;
-exports.uniqueUntilKeyChanged_ = uniqueUntilKeyChanged_;
-exports.unique_ = unique_;
+exports.tap = tap;
+exports.throttle = void 0;
+exports.throttleTime = throttleTime;
+exports.timeout = timeout;
+exports.toArray = exports.timer = void 0;
+exports.unique = unique;
+exports.uniqueUntilChanged = void 0;
+exports.uniqueUntilKeyChanged = uniqueUntilKeyChanged;
 exports.unit = void 0;
 exports.zip = zip;
-exports.zipWith = void 0;
+exports.zipWith = exports.zipLatest = void 0;
+exports.zipWithLatest = zipWithLatest;
 
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api"));
 
@@ -205,42 +203,42 @@ const mapWithIndex = mapWithIndex_1;
 exports.mapWithIndex = mapWithIndex;
 const map_ = map_1;
 exports.map_ = map_;
-const as_ = as_1;
-exports.as_ = as_;
-const filterWithIndex_ = filterWithIndex_1;
-exports.filterWithIndex_ = filterWithIndex_;
+const as = as_1;
+exports.as = as;
+const filterWithIndex = filterWithIndex_1;
+exports.filterWithIndex = filterWithIndex;
 const filterMapWithIndex = filterMapWithIndex_1;
 exports.filterMapWithIndex = filterMapWithIndex;
 const partitionWithIndex = partitionWithIndex_1;
 exports.partitionWithIndex = partitionWithIndex;
-const partitionMapWithIndex_ = partitionMapWithIndex_1;
-exports.partitionMapWithIndex_ = partitionMapWithIndex_;
+const partitionMapWithIndex = partitionMapWithIndex_1;
+exports.partitionMapWithIndex = partitionMapWithIndex;
 const mergeMapWithIndex = mergeMapWithIndex_1;
 exports.mergeMapWithIndex = mergeMapWithIndex;
-const mergeMap_ = mergeMap_1;
-exports.mergeMap_ = mergeMap_;
+const mergeMap = mergeMap_1;
+exports.mergeMap = mergeMap;
 const contramapEnvironment = contramapEnvironment_1;
 exports.contramapEnvironment = contramapEnvironment;
 const foldLeftWithIndex = foldLeftWithIndex_1;
 exports.foldLeftWithIndex = foldLeftWithIndex;
 const foldLeft = foldLeft_1;
 exports.foldLeft = foldLeft;
-const audit_ = audit_1;
-exports.audit_ = audit_;
+const audit = audit_1;
+exports.audit = audit;
 const catchAllCause = catchAllCause_1;
 exports.catchAllCause = catchAllCause;
 const concatAll = concatAll_1;
 exports.concatAll = concatAll;
-const concat_ = concat_1;
-exports.concat_ = concat_;
+const concat = concat_1;
+exports.concat = concat;
 const countWithIndex = countWithIndex_1;
 exports.countWithIndex = countWithIndex;
-const combineLatest_ = combineLatest_1;
-exports.combineLatest_ = combineLatest_;
+const zipLatest = zipLatest_1;
+exports.zipLatest = zipLatest;
 const delayWithIndex = delayWithIndex_1;
 exports.delayWithIndex = delayWithIndex;
-const delayWith_ = delayWith_1;
-exports.delayWith_ = delayWith_;
+const delayWith = delayWith_1;
+exports.delayWith = delayWith;
 const exhaustMapWithIndex = exhaustMapWithIndex_1;
 exports.exhaustMapWithIndex = exhaustMapWithIndex;
 const expandWithIndex = expandWithIndex_1;
@@ -249,34 +247,34 @@ const findWithIndex = findWithIndex_1;
 exports.findWithIndex = findWithIndex;
 const findIndexWithIndex = findIndexWithIndex_1;
 exports.findIndexWithIndex = findIndexWithIndex;
-const mergeAll_ = mergeAll_1;
-exports.mergeAll_ = mergeAll_;
+const mergeAll = mergeAll_1;
+exports.mergeAll = mergeAll;
 const mergeScanWithIndex = mergeScanWithIndex_1;
 exports.mergeScanWithIndex = mergeScanWithIndex;
-const onEmpty_ = onEmpty_1;
-exports.onEmpty_ = onEmpty_;
-const sample_ = sample_1;
-exports.sample_ = sample_;
+const onEmpty = onEmpty_1;
+exports.onEmpty = onEmpty;
+const sample = sample_1;
+exports.sample = sample;
 const scanLeftWithIndex = scanLeftWithIndex_1;
 exports.scanLeftWithIndex = scanLeftWithIndex;
 const serviceWithObservable = serviceWithObservable_1;
 exports.serviceWithObservable = serviceWithObservable;
 const switchMapWithIndex = switchMapWithIndex_1;
 exports.switchMapWithIndex = switchMapWithIndex;
-const switchMap_ = switchMap_1;
-exports.switchMap_ = switchMap_;
+const switchMap = switchMap_1;
+exports.switchMap = switchMap;
 const switchScanWithIndex = switchScanWithIndex_1;
 exports.switchScanWithIndex = switchScanWithIndex;
-const take_ = take_1;
-exports.take_ = take_;
+const take = take_1;
+exports.take = take;
 const takeWhileWithIndex = takeWhileWithIndex_1;
 exports.takeWhileWithIndex = takeWhileWithIndex;
-const throttle_ = throttle_1;
-exports.throttle_ = throttle_;
+const throttle = throttle_1;
+exports.throttle = throttle;
 const toArray = toArray_1;
 exports.toArray = toArray;
-const uniqueUntilChanged_ = uniqueUntilChanged_1;
-exports.uniqueUntilChanged_ = uniqueUntilChanged_;
+const uniqueUntilChanged = uniqueUntilChanged_1;
+exports.uniqueUntilChanged = uniqueUntilChanged;
 
 /**
  * @tsplus static fncts.observable.ObservableOps halt
@@ -290,8 +288,8 @@ function halt(defect) {
 
 
 function defer_1(observable) {
-  return new _definition2.Observable(s => {
-    from_1(observable()).subscribe(s);
+  return new _definition2.Observable((s, environment) => {
+    from_1(observable()).provideEnvironment(environment).subscribe(s);
   });
 }
 /**
@@ -476,7 +474,7 @@ function interval_1(period = 0, scheduler = tsplus_module_5.asyncScheduler) {
 
 function merge(...sources) {
   const concurrency = (0, _args.popNumber)(sources, Infinity);
-  return !sources.length ? empty_1() : sources.length === 1 ? from_1(sources[0]) : mergeAll_1(fromArrayLike(sources), concurrency);
+  return !sources.length ? empty_1() : sources.length === 1 ? from_1(sources[0]) : mergeAll_1(concurrency)(fromArrayLike(sources));
 }
 /**
  * @tsplus static fncts.observable.ObservableOps of
@@ -498,33 +496,35 @@ function single_1(a) {
   });
 }
 /**
- * @tsplus fluent fncts.observable.Observable scheduled
+ * @tsplus pipeable fncts.observable.Observable scheduled
  * @tsplus static fncts.observable.ObservableOps scheduled
  */
 
 
-function scheduled_1(input, scheduler) {
-  if (tsplus_module_2.isArrayLike(input)) {
-    return scheduleArray(input, scheduler);
-  }
+function scheduled_1(scheduler) {
+  return input => {
+    if (tsplus_module_2.isArrayLike(input)) {
+      return scheduleArray(input, scheduler);
+    }
 
-  if (tsplus_module_2.isPromiseLike(input)) {
-    return schedulePromise(input, scheduler);
-  }
+    if (tsplus_module_2.isPromiseLike(input)) {
+      return schedulePromise(input, scheduler);
+    }
 
-  if (tsplus_module_3.isIterable(input)) {
-    return scheduleIterable(input, scheduler);
-  }
+    if (tsplus_module_3.isIterable(input)) {
+      return scheduleIterable(input, scheduler);
+    }
 
-  if (tsplus_module_2.isAsyncIterable(input)) {
-    return scheduleAsyncIterable(input, scheduler);
-  }
+    if (tsplus_module_2.isAsyncIterable(input)) {
+      return scheduleAsyncIterable(input, scheduler);
+    }
 
-  if (tsplus_module_2.isReadableStream(input)) {
-    return scheduleReadableStreamLike(input, scheduler);
-  }
+    if (tsplus_module_2.isReadableStream(input)) {
+      return scheduleReadableStreamLike(input, scheduler);
+    }
 
-  return scheduleObservable(from_1(input), scheduler);
+    return scheduleObservable(from_1(input), scheduler);
+  };
 }
 
 function scheduleArray(input, scheduler) {
@@ -588,10 +588,10 @@ function scheduleIterable(input, scheduler) {
 }
 
 function scheduleObservable(input, scheduler) {
-  return new _definition2.Observable(subscriber => {
+  return new _definition2.Observable((subscriber, environment) => {
     const sub = new tsplus_module_6.Subscription();
     sub.add(scheduler.schedule(() => {
-      sub.add(input.subscribe({
+      sub.add(input.provideEnvironment(environment).subscribe({
         next: value => {
           sub.add(scheduler.schedule(() => subscriber.next(value)));
         },
@@ -664,7 +664,7 @@ function timer_1(time = 0, intervalOrScheduler, scheduler = tsplus_module_5.asyn
 
 
 function makeZip(...sources) {
-  return sources.length ? new _definition2.Observable(subscriber => {
+  return sources.length ? new _definition2.Observable((subscriber, environment) => {
     let buffers = sources.map(() => []);
     let completed = sources.map(() => false);
     subscriber.add(() => {
@@ -672,7 +672,7 @@ function makeZip(...sources) {
     });
 
     for (let sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
-      from_1(sources[sourceIndex]).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+      from_1(sources[sourceIndex]).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
         next: value => {
           buffers[sourceIndex].push(value);
 
@@ -706,17 +706,17 @@ function fromIO_1(io, scheduler = tsplus_module_5.asyncScheduler) {
   return new _definition2.Observable((s, env) => {
     let fiber;
     const scheduled = scheduler.schedule(() => {
-      fiber = tsplus_module_10.unsafeRunFiber(tsplus_module_9.provideEnvironment_(io, env, fileName_1 + ":487:36"), fileName_1 + ":487:56");
+      fiber = tsplus_module_10.unsafeRunFiber(tsplus_module_9.provideEnvironment(env, fileName_1 + ":489:36")(io), fileName_1 + ":489:56");
       fiber.unsafeOnDone(exit => {
         if (!s.closed) {
-          tsplus_module_11.match_(tsplus_module_11.flatten(exit), cause => s.error(cause), a => s.next(a));
+          tsplus_module_11.match(cause => s.error(cause), a => s.next(a))(tsplus_module_11.flatten(exit));
           s.complete();
         }
       });
     });
     return () => {
       scheduled.unsubscribe();
-      fiber && tsplus_module_10.unsafeRunAsync(tsplus_module_12.interrupt(fiber, fileName_1 + ":500:21"), fileName_1 + ":500:46");
+      fiber && tsplus_module_10.unsafeRunAsync(tsplus_module_12.interrupt(fiber, fileName_1 + ":502:21"), fileName_1 + ":502:46");
     };
   });
 }
@@ -727,74 +727,88 @@ function fromIO_1(io, scheduler = tsplus_module_5.asyncScheduler) {
 
 const unit = /*#__PURE__*/single_1(undefined);
 /**
- * @tsplus fluent fncts.observable.Observable zipWith
+ * @tsplus pipeable fncts.observable.Observable zipWith
  */
 
 exports.unit = unit;
 
-function zipWith_1(fa, fb, f) {
-  return mergeMap_1(fa, a => map_1(fb, b => f(a, b)));
+function zipWith_1(fb, f) {
+  return fa => {
+    return mergeMap_1(a => map_1(b => f(a, b))(fb))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable zip
+ * @tsplus pipeable fncts.observable.Observable zip
  */
 
 
-function zip(fa, fb) {
-  return zipWith_1(fa, fb, tsplus_module_13.tuple);
+function zip(fb) {
+  return fa => {
+    return zipWith_1(fb, tsplus_module_13.tuple)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable ap
+ * @tsplus pipeable fncts.observable.Observable ap
  */
 
 
-function ap(fab, fa) {
-  return zipWith_1(fab, fa, (f, a) => f(a));
+function ap(fa) {
+  return fab => {
+    return zipWith_1(fa, (f, a) => f(a))(fab);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mapWithIndex
+ * @tsplus pipeable fncts.observable.Observable mapWithIndex
  */
 
 
-function mapWithIndex_1(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let i = 0;
-    source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
-      next: value => {
-        subscriber.next(f(i++, value));
-      }
-    }));
-  });
+function mapWithIndex_1(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let i = 0;
+      source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
+        next: value => {
+          subscriber.next(f(i++, value));
+        }
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable map
+ * @tsplus pipeable fncts.observable.Observable map
  */
 
 
-function map_1(fa, f) {
-  return mapWithIndex_1(fa, (_, a) => f(a));
+function map_1(f) {
+  return fa => {
+    return mapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable as
+ * @tsplus pipeable fncts.observable.Observable as
  */
 
 
-function as_1(fa, b) {
-  return map_1(fa, b);
+function as_1(b) {
+  return fa => {
+    return map_1(b)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mapError
+ * @tsplus pipeable fncts.observable.Observable mapError
  */
 
 
-function mapError_(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
-      error: err => {
-        subscriber.error(tsplus_module_1.map_(err, f));
-      }
-    }));
-  });
+function mapError(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
+        error: err => {
+          subscriber.error(tsplus_module_1.map(f)(err));
+        }
+      }));
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable swap
@@ -802,150 +816,170 @@ function mapError_(fa, f) {
 
 
 function swap(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
       next: value => {
         subscriber.error(tsplus_module_1.fail(value));
       },
       error: err => {
-        tsplus_module_14.match_(tsplus_module_1.failureOrCause(err), e => {
+        tsplus_module_14.match(e => {
           subscriber.next(e);
         }, cause => {
           subscriber.error(cause);
-        });
+        })(tsplus_module_1.failureOrCause(err));
       }
     }));
-  });
+  })(fa);
 }
 
-function filterWithIndex_1(fa, predicate) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => predicate(index++, value) && subscriber.next(value)
-    }));
-  });
+function filterWithIndex_1(predicate) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => predicate(index++, value) && subscriber.next(value)
+      }));
+    })(fa);
+  };
 }
 
-function filter_(fa, predicate) {
-  return filterWithIndex_1(fa, (_, a) => predicate(a));
+function filter(predicate) {
+  return fa => {
+    return filterWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable filterMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable filterMapWithIndex
  */
 
 
-function filterMapWithIndex_1(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => tsplus_module_15.match_(f(index++, value), () => tsplus_module_2.noop, b => subscriber.next(b))
-    }));
-  });
+function filterMapWithIndex_1(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => tsplus_module_15.match(() => tsplus_module_2.noop, b => subscriber.next(b))(f(index++, value))
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable filterMap
+ * @tsplus pipeable fncts.observable.Observable filterMap
  */
 
 
-function filterMap_(fa, f) {
-  return filterMapWithIndex_1(fa, (_, a) => f(a));
-}
-
-function partitionWithIndex_1(fa, predicate) {
-  return [filterWithIndex_1(fa, (i, a) => !predicate(i, a)), filterWithIndex_1(fa, predicate)];
+function filterMap(f) {
+  return fa => {
+    return filterMapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 
-function partition_(fa, predicate) {
-  return partitionWithIndex_1(fa, (_, a) => predicate(a));
+function partitionWithIndex_1(predicate) {
+  return fa => {
+    return [filterWithIndex_1((i, a) => !predicate(i, a))(fa), filterWithIndex_1(predicate)(fa)];
+  };
 }
-/**
- * @tsplus fluent fncts.observable.Observable partitionMapWithIndex
- */
-
 
-function partitionMapWithIndex_1(fa, f) {
-  return [tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        tsplus_module_14.match_(f(index++, value), b => subscriber.next(b), tsplus_module_2.noop);
-      }
-    }));
-  }), tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        tsplus_module_14.match_(f(index++, value), tsplus_module_2.noop, c => subscriber.next(c));
-      }
-    }));
-  })];
+function partition(predicate) {
+  return fa => {
+    return partitionWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable partitionMap
+ * @tsplus pipeable fncts.observable.Observable partitionMapWithIndex
  */
 
 
-function partitionMap_(fa, f) {
-  return partitionMapWithIndex_1(fa, (_, a) => f(a));
+function partitionMapWithIndex_1(f) {
+  return fa => {
+    return [tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          tsplus_module_14.match(b => subscriber.next(b), tsplus_module_2.noop)(f(index++, value));
+        }
+      }));
+    })(fa), tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          tsplus_module_14.match(tsplus_module_2.noop, c => subscriber.next(c))(f(index++, value));
+        }
+      }));
+    })(fa)];
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable provideEnvironment
+ * @tsplus pipeable fncts.observable.Observable partitionMap
  */
 
 
-function provideEnvironment(self, environment) {
-  return self.provide(environment);
+function partitionMap(f) {
+  return fa => {
+    return partitionMapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable provideService
+ * @tsplus pipeable fncts.observable.Observable provideService
  */
 
 
-function provideService(self, service,
+function provideService(service,
 /** @tsplus auto */
 tag) {
-  return contramapEnvironment_1(self, environment => tsplus_module_16.add(environment, service, tag));
+  return self => {
+    return contramapEnvironment_1(environment => tsplus_module_16.add(service, tag)(environment))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable mergeMapWithIndex
  */
 
 
-function mergeMapWithIndex_1(ma, f, concurrent = Infinity) {
-  return tsplus_module_8.operate_(ma, (source, sub) => mergeInternal(source, sub, f, concurrent));
+function mergeMapWithIndex_1(f, concurrent = Infinity) {
+  return ma => {
+    return tsplus_module_8.operate_((source, sub, environment) => mergeInternal(source, sub, environment, f, concurrent))(ma);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeMap
+ * @tsplus pipeable fncts.observable.Observable mergeMap
  */
 
 
-function mergeMap_1(ma, f, concurrent = Infinity) {
-  return mergeMapWithIndex_1(ma, (_, a) => f(a), concurrent);
+function mergeMap_1(f, concurrent = Infinity) {
+  return ma => {
+    return mergeMapWithIndex_1((_, a) => f(a), concurrent)(ma);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable concatMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable concatMapWithIndex
  */
 
 
-function concatMapWithIndex(ma, f) {
-  return mergeMapWithIndex_1(ma, f, 1);
+function concatMapWithIndex(f) {
+  return ma => {
+    return mergeMapWithIndex_1(f, 1)(ma);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable concatMap
+ * @tsplus pipeable fncts.observable.Observable concatMap
  */
 
 
-function concatMap_(ma, f) {
-  return mergeMapWithIndex_1(ma, (_, a) => f(a), 1);
+function concatMap(f) {
+  return ma => {
+    return mergeMapWithIndex_1((_, a) => f(a), 1)(ma);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable contramapEnvironment
+ * @tsplus pipeable fncts.observable.Observable contramapEnvironment
  */
 
 
-function contramapEnvironment_1(self, f) {
-  return environmentWithObservable_1(environment => self.provide(f(environment)));
+function contramapEnvironment_1(f) {
+  return self => {
+    return environmentWithObservable_1(environment => self.provideEnvironment(f(environment)));
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable flatten
@@ -956,336 +990,358 @@ function flatten(mma) {
   return concatAll_1(mma);
 }
 /**
- * @tsplus fluent fncts.observable.Observable foldLeftWithIndex
+ * @tsplus pipeable fncts.observable.Observable foldLeftWithIndex
  */
 
 
-function foldLeftWithIndex_1(fa, initial, f) {
-  return tsplus_module_8.operate_(fa, scanInternal(f, initial, true, false, true));
+function foldLeftWithIndex_1(initial, f) {
+  return fa => {
+    return tsplus_module_8.operate_(scanInternal(f, initial, true, false, true))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable foldLeft
+ * @tsplus pipeable fncts.observable.Observable foldLeft
  */
 
 
-function foldLeft_1(fa, initial, f) {
-  return foldLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+function foldLeft_1(initial, f) {
+  return fa => {
+    return foldLeftWithIndex_1(initial, (_, b, a) => f(b, a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable at
+ * @tsplus pipeable fncts.observable.Observable at
  */
 
 
-function at_(fa, index) {
-  return onEmpty_1(map_1(take_1(filterWithIndex_1(fa, i => i === index), 1), tsplus_module_17.just), () => tsplus_module_17.nothing());
+function at(index) {
+  return fa => {
+    return onEmpty_1(() => tsplus_module_17.nothing())(map_1(tsplus_module_17.just)(take_1(1)(filterWithIndex_1(i => i === index)(fa))));
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable audit
+ * @tsplus pipeable fncts.observable.Observable audit
  */
 
 
-function audit_1(fa, durationSelector) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let lastValue = tsplus_module_17.nothing();
-    let durationSubscriber = null;
-    let isComplete = false;
+function audit_1(durationSelector) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let lastValue = tsplus_module_17.nothing();
+      let durationSubscriber = null;
+      let isComplete = false;
 
-    const endDuration = () => {
-      durationSubscriber?.unsubscribe();
-      durationSubscriber = null;
+      const endDuration = () => {
+        durationSubscriber?.unsubscribe();
+        durationSubscriber = null;
 
-      if (tsplus_module_18.isJust(lastValue)) {
-        const {
-          value
-        } = lastValue;
-        lastValue = tsplus_module_17.nothing();
-        subscriber.next(value);
-      }
+        if (tsplus_module_18.isJust(lastValue)) {
+          const {
+            value
+          } = lastValue;
+          lastValue = tsplus_module_17.nothing();
+          subscriber.next(value);
+        }
 
-      isComplete && subscriber.complete();
-    };
+        isComplete && subscriber.complete();
+      };
 
-    const cleanupDuration = () => {
-      durationSubscriber = null;
-      isComplete && subscriber.complete();
-    };
+      const cleanupDuration = () => {
+        durationSubscriber = null;
+        isComplete && subscriber.complete();
+      };
 
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        lastValue = tsplus_module_17.just(value);
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          lastValue = tsplus_module_17.just(value);
 
-        if (!durationSubscriber) {
-          from_1(durationSelector(value)).subscribe(durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-            next: endDuration,
-            complete: cleanupDuration
-          }));
+          if (!durationSubscriber) {
+            from_1(durationSelector(value)).provideEnvironment(environment).subscribe(durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+              next: endDuration,
+              complete: cleanupDuration
+            }));
+          }
+        },
+        complete: () => {
+          isComplete = true;
+          (tsplus_module_18.isNothing(lastValue) || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
         }
-      },
-      complete: () => {
-        isComplete = true;
-        (tsplus_module_18.isNothing(lastValue) || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
-      }
-    }));
-  });
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable auditTime
+ * @tsplus pipeable fncts.observable.Observable auditTime
  */
 
 
-function auditTime_(fa, duration, scheduler = tsplus_module_5.asyncScheduler) {
-  return audit_1(fa, () => timer_1(duration, scheduler));
+function auditTime(duration, scheduler = tsplus_module_5.asyncScheduler) {
+  return fa => {
+    return audit_1(() => timer_1(duration, scheduler))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable buffer
+ * @tsplus pipeable fncts.observable.Observable buffer
  */
 
 
-function buffer_(fa, closingNotifier) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let buffer = [];
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => buffer.push(value),
-      complete: () => {
-        subscriber.next(buffer);
-        subscriber.complete();
-      }
-    }));
-    closingNotifier.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: () => {
-        const b = buffer;
-        buffer = [];
-        subscriber.next(b);
-      },
-      complete: tsplus_module_2.noop
-    }));
-    return () => {
-      buffer = null;
-    };
-  });
+function buffer(closingNotifier) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let buffer = [];
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => buffer.push(value),
+        complete: () => {
+          subscriber.next(buffer);
+          subscriber.complete();
+        }
+      }));
+      closingNotifier.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: () => {
+          const b = buffer;
+          buffer = [];
+          subscriber.next(b);
+        },
+        complete: tsplus_module_2.noop
+      }));
+      return () => {
+        buffer = null;
+      };
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable bufferCount
+ * @tsplus pipeable fncts.observable.Observable bufferCount
  */
 
 
-function bufferCount_(fa, bufferSize, startBufferEvery) {
-  // eslint-disable-next-line no-param-reassign
-  startBufferEvery = startBufferEvery ?? bufferSize;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let buffers = [];
-    let count = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        let toEmit = null;
+function bufferCount(bufferSize, startBufferEvery) {
+  return fa => {
+    // eslint-disable-next-line no-param-reassign
+    startBufferEvery = startBufferEvery ?? bufferSize;
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let buffers = [];
+      let count = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          let toEmit = null;
 
-        if (count++ % startBufferEvery === 0) {
-          buffers.push([]);
-        }
+          if (count++ % startBufferEvery === 0) {
+            buffers.push([]);
+          }
 
-        for (const buffer of buffers) {
-          buffer.push(value);
+          for (const buffer of buffers) {
+            buffer.push(value);
 
-          if (bufferSize <= buffer.length) {
-            toEmit = toEmit ?? [];
-            toEmit.push(buffer);
+            if (bufferSize <= buffer.length) {
+              toEmit = toEmit ?? [];
+              toEmit.push(buffer);
+            }
           }
-        }
 
-        if (toEmit) {
-          for (const buffer of toEmit) {
-            (0, tsplus_module_2.arrayRemove)(buffers, buffer);
+          if (toEmit) {
+            for (const buffer of toEmit) {
+              (0, tsplus_module_2.arrayRemove)(buffers, buffer);
+              subscriber.next(buffer);
+            }
+          }
+        },
+        complete: () => {
+          for (const buffer of buffers) {
             subscriber.next(buffer);
           }
-        }
-      },
-      complete: () => {
-        for (const buffer of buffers) {
-          subscriber.next(buffer);
-        }
 
-        subscriber.complete();
-      }
-    }, () => {
-      buffers = null;
-    }));
-  });
+          subscriber.complete();
+        }
+      }, () => {
+        buffers = null;
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable bufferTime
+ * @tsplus pipeable fncts.observable.Observable bufferTime
  */
 
 
-function bufferTime_(fa, config) {
-  const {
-    bufferTimeSpan,
-    bufferCreationInterval = null,
-    maxBufferSize = Infinity,
-    scheduler = tsplus_module_5.asyncScheduler
-  } = config;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let bufferRecords = [];
-    let restartOnEmit = true;
-
-    const emit = record => {
-      const {
-        buffer,
-        subs
-      } = record;
-      subs.unsubscribe();
-      (0, tsplus_module_2.arrayRemove)(bufferRecords, record);
-      subscriber.next(buffer);
-      restartOnEmit && startBuffer();
-    };
-
-    const startBuffer = () => {
-      if (bufferRecords) {
-        const subs = new tsplus_module_6.Subscription();
-        subscriber.add(subs);
-        const buffer = [];
-        const record = {
+function bufferTime(config) {
+  return fa => {
+    const {
+      bufferTimeSpan,
+      bufferCreationInterval = null,
+      maxBufferSize = Infinity,
+      scheduler = tsplus_module_5.asyncScheduler
+    } = config;
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let bufferRecords = [];
+      let restartOnEmit = true;
+
+      const emit = record => {
+        const {
           buffer,
           subs
-        };
-        bufferRecords.push(record);
-        subs.add(scheduler.schedule(() => emit(record), bufferTimeSpan));
-      }
-    };
+        } = record;
+        subs.unsubscribe();
+        (0, tsplus_module_2.arrayRemove)(bufferRecords, record);
+        subscriber.next(buffer);
+        restartOnEmit && startBuffer();
+      };
+
+      const startBuffer = () => {
+        if (bufferRecords) {
+          const subs = new tsplus_module_6.Subscription();
+          subscriber.add(subs);
+          const buffer = [];
+          const record = {
+            buffer,
+            subs
+          };
+          bufferRecords.push(record);
+          subs.add(scheduler.schedule(() => emit(record), bufferTimeSpan));
+        }
+      };
 
-    bufferCreationInterval !== null && bufferCreationInterval >= 0 ? subscriber.add(scheduler.schedule(function () {
+      bufferCreationInterval !== null && bufferCreationInterval >= 0 ? subscriber.add(scheduler.schedule(function () {
+        startBuffer();
+        !this.closed && subscriber.add(this.schedule(null, bufferCreationInterval));
+      }, bufferCreationInterval)) : restartOnEmit = true;
       startBuffer();
-      !this.closed && subscriber.add(this.schedule(null, bufferCreationInterval));
-    }, bufferCreationInterval)) : restartOnEmit = true;
-    startBuffer();
-    const bufferTimeSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        const recordsCopy = bufferRecords.slice();
+      const bufferTimeSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          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);
+          }
 
-        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();
         }
-
-        bufferTimeSubscriber?.unsubscribe();
-        subscriber.complete();
-        subscriber.unsubscribe();
-      }
-    }, () => bufferRecords = null);
-    source.subscribe(bufferTimeSubscriber);
-  });
+      }, () => bufferRecords = null);
+      source.provideEnvironment(environment).subscribe(bufferTimeSubscriber);
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable bufferToggle
+ * @tsplus pipeable fncts.observable.Observable bufferToggle
  */
 
 
-function bufferToggle_(fa, openings, closingSelector) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    const buffers = [];
-    from_1(openings).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: openValue => {
-        const buffer = [];
-        buffers.push(buffer);
-        const closingSubscription = new tsplus_module_6.Subscription();
+function bufferToggle(openings, closingSelector) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      const buffers = [];
+      from_1(openings).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: openValue => {
+          const buffer = [];
+          buffers.push(buffer);
+          const closingSubscription = new tsplus_module_6.Subscription();
 
-        const emitBuffer = () => {
-          (0, tsplus_module_2.arrayRemove)(buffers, buffer);
-          subscriber.next(buffer);
-          closingSubscription.unsubscribe();
-        };
+          const emitBuffer = () => {
+            (0, tsplus_module_2.arrayRemove)(buffers, buffer);
+            subscriber.next(buffer);
+            closingSubscription.unsubscribe();
+          };
 
-        closingSubscription.add(from_1(closingSelector(openValue)).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-          next: emitBuffer,
-          complete: tsplus_module_2.noop
-        })));
-      },
-      complete: tsplus_module_2.noop
-    }));
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        for (const buffer of buffers) {
-          buffer.push(value);
-        }
-      },
-      complete: () => {
-        while (buffers.length > 0) {
-          subscriber.next(buffers.shift());
-        }
+          closingSubscription.add(from_1(closingSelector(openValue)).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+            next: emitBuffer,
+            complete: tsplus_module_2.noop
+          })));
+        },
+        complete: tsplus_module_2.noop
+      }));
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          for (const buffer of buffers) {
+            buffer.push(value);
+          }
+        },
+        complete: () => {
+          while (buffers.length > 0) {
+            subscriber.next(buffers.shift());
+          }
 
-        subscriber.complete();
-      }
-    }));
-  });
+          subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable bufferWhen
+ * @tsplus pipeable fncts.observable.Observable bufferWhen
  */
 
 
-function bufferWhen_(fa, closingSelector) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let buffer = null;
-    let closingSubscriber = null;
+function bufferWhen(closingSelector) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let buffer = null;
+      let closingSubscriber = null;
 
-    const openBuffer = () => {
-      closingSubscriber?.unsubscribe();
-      const b = buffer;
-      buffer = [];
-      b && subscriber.next(b);
-      from_1(closingSelector()).subscribe(closingSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-        next: openBuffer,
-        complete: tsplus_module_2.noop
-      }));
-    };
+      const openBuffer = () => {
+        closingSubscriber?.unsubscribe();
+        const b = buffer;
+        buffer = [];
+        b && subscriber.next(b);
+        from_1(closingSelector()).provideEnvironment(environment).subscribe(closingSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+          next: openBuffer,
+          complete: tsplus_module_2.noop
+        }));
+      };
 
-    openBuffer();
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => buffer?.push(value),
-      complete: () => {
-        buffer && subscriber.next(buffer);
-        subscriber.complete();
-      }
-    }, () => buffer = closingSubscriber = null));
-  });
+      openBuffer();
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => buffer?.push(value),
+        complete: () => {
+          buffer && subscriber.next(buffer);
+          subscriber.complete();
+        }
+      }, () => buffer = closingSubscriber = null));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable catchAllCause
+ * @tsplus pipeable fncts.observable.Observable catchAllCause
  */
 
 
-function catchAllCause_1(self, f) {
-  return tsplus_module_8.operate_(self, (source, subscriber) => {
-    let innerSub = null;
-    let syncUnsub = false;
-    let handledResult;
-    innerSub = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      error: cause => {
-        handledResult = from_1(f(cause, catchAllCause_1(source, f)));
-
-        if (innerSub) {
-          innerSub.unsubscribe();
-          innerSub = null;
-          handledResult.subscribe(subscriber);
-        } else {
-          syncUnsub = true;
+function catchAllCause_1(f) {
+  return self => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let innerSub = null;
+      let syncUnsub = false;
+      let handledResult;
+      innerSub = source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        error: cause => {
+          handledResult = from_1(f(cause, catchAllCause_1(f)(source)));
+
+          if (innerSub) {
+            innerSub.unsubscribe();
+            innerSub = null;
+            handledResult.provideEnvironment(environment).subscribe(subscriber);
+          } else {
+            syncUnsub = true;
+          }
         }
-      }
-    }));
+      }));
 
-    if (syncUnsub) {
-      innerSub.unsubscribe();
-      innerSub = null;
-      handledResult.subscribe(subscriber);
-    }
-  });
+      if (syncUnsub) {
+        innerSub.unsubscribe();
+        innerSub = null;
+        handledResult.provideEnvironment(environment).subscribe(subscriber);
+      }
+    })(self);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable concatAll
@@ -1293,17 +1349,19 @@ function catchAllCause_1(self, f) {
 
 
 function concatAll_1(ffa) {
-  return mergeAll_1(ffa, 1);
+  return mergeAll_1(1)(ffa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable concat
+ * @tsplus pipeable fncts.observable.Observable concat
  */
 
 
-function concat_1(fa, ...sources) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    concatAll_1(fromArrayLike([source, ...sources])).subscribe(subscriber);
-  });
+function concat_1(...sources) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      concatAll_1(fromArrayLike([source, ...sources])).provideEnvironment(environment).subscribe(subscriber);
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable count
@@ -1311,23 +1369,27 @@ function concat_1(fa, ...sources) {
 
 
 function count(fa) {
-  return foldLeft_1(fa, 0, (total, _) => total + 1);
+  return foldLeft_1(0, (total, _) => total + 1)(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable countWithIndex
+ * @tsplus pipeable fncts.observable.Observable countWithIndex
  */
 
 
-function countWithIndex_1(fa, predicate) {
-  return foldLeftWithIndex_1(fa, 0, (i, total, v) => predicate(i, v) ? total + 1 : total);
+function countWithIndex_1(predicate) {
+  return fa => {
+    return foldLeftWithIndex_1(0, (i, total, v) => predicate(i, v) ? total + 1 : total)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable countWith
+ * @tsplus pipeable fncts.observable.Observable countWith
  */
 
 
-function countWith_(fa, predicate) {
-  return countWithIndex_1(fa, (_, a) => predicate(a));
+function countWith(predicate) {
+  return fa => {
+    return countWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable combineLatestAll
@@ -1335,116 +1397,132 @@ function countWith_(fa, predicate) {
 
 
 function combineLatestAll(fa) {
-  return joinAllInternal(fa, sources => !sources.length ? empty_1() : combineLatest_1(sources[0], ...sources.slice(1)));
+  return joinAllInternal(fa, sources => !sources.length ? empty_1() : zipLatest_1(sources[0], ...sources.slice(1)));
 }
 /**
- * @tsplus fluent fncts.observable.Observable combineLatest
+ * @tsplus pipeable fncts.observable.Observable zipLatest
  */
 
 
-function combineLatest_1(self, ...sources) {
-  if (!sources.length) {
-    return from_1(self).unsafeCoerce();
-  }
+function zipLatest_1(...sources) {
+  return self => {
+    if (!sources.length) {
+      return from_1(self).unsafeCoerce();
+    }
 
-  return tsplus_module_8.operate_(from_1(self), (source, subscriber) => {
-    combineLatestInternal(subscriber, [source, ...sources]);
-  });
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      combineLatestInternal(subscriber, environment, [source, ...sources]);
+    })(from_1(self));
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable debounceWith
+ * @tsplus pipeable fncts.observable.Observable zipWithLatest
  */
 
 
-function debounceWith_(fa, durationSelector) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let lastValue = tsplus_module_17.nothing();
-    let durationSubscriber = null;
+function zipWithLatest(that, f) {
+  return self => {
+    return map_1(tsplus_module_13.tupled(f))(zipLatest_1(from_1(that))(self));
+  };
+}
+/**
+ * @tsplus pipeable fncts.observable.Observable debounceWith
+ */
 
-    const emit = () => {
-      durationSubscriber?.unsubscribe();
-      durationSubscriber = null;
 
-      if (tsplus_module_18.isJust(lastValue)) {
-        const {
-          value
-        } = lastValue;
-        lastValue = tsplus_module_17.nothing();
-        subscriber.next(value);
-      }
-    };
+function debounceWith(durationSelector) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let lastValue = tsplus_module_17.nothing();
+      let durationSubscriber = null;
 
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
+      const emit = () => {
         durationSubscriber?.unsubscribe();
-        lastValue = tsplus_module_17.just(value);
-        durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-          next: emit,
-          complete: tsplus_module_2.noop
-        });
-        from_1(durationSelector(value)).subscribe(durationSubscriber);
-      },
-      complete: () => {
-        emit();
-        subscriber.complete();
-      }
-    }, () => {
-      lastValue = durationSubscriber = null;
-    }));
-  });
+        durationSubscriber = null;
+
+        if (tsplus_module_18.isJust(lastValue)) {
+          const {
+            value
+          } = lastValue;
+          lastValue = tsplus_module_17.nothing();
+          subscriber.next(value);
+        }
+      };
+
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          durationSubscriber?.unsubscribe();
+          lastValue = tsplus_module_17.just(value);
+          durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+            next: emit,
+            complete: tsplus_module_2.noop
+          });
+          from_1(durationSelector(value)).provideEnvironment(environment).subscribe(durationSubscriber);
+        },
+        complete: () => {
+          emit();
+          subscriber.complete();
+        }
+      }, () => {
+        lastValue = durationSubscriber = null;
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable debounce
+ * @tsplus pipeable fncts.observable.Observable debounce
  */
 
 
-function debounce_(fa, dueTime, scheduler = tsplus_module_5.asyncScheduler) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let activeTask = null;
-    let lastValue = null;
-    let lastTime = null;
-
-    const emit = () => {
-      if (activeTask) {
-        activeTask.unsubscribe();
-        activeTask = null;
-        const value = lastValue;
-        lastValue = null;
-        subscriber.next(value);
-      }
-    };
-
-    function emitWhenIdle() {
-      const targetTime = lastTime + dueTime;
-      const now = scheduler.now();
-
-      if (now < targetTime) {
-        activeTask = this.schedule(undefined, targetTime - now);
-        subscriber.add(activeTask);
-        return;
-      }
+function debounce(dueTime, scheduler = tsplus_module_5.asyncScheduler) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let activeTask = null;
+      let lastValue = null;
+      let lastTime = null;
 
-      emit();
-    }
+      const emit = () => {
+        if (activeTask) {
+          activeTask.unsubscribe();
+          activeTask = null;
+          const value = lastValue;
+          lastValue = null;
+          subscriber.next(value);
+        }
+      };
 
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        lastValue = value;
-        lastTime = scheduler.now();
+      function emitWhenIdle() {
+        const targetTime = lastTime + dueTime;
+        const now = scheduler.now();
 
-        if (!activeTask) {
-          activeTask = scheduler.schedule(emitWhenIdle, dueTime);
+        if (now < targetTime) {
+          activeTask = this.schedule(undefined, targetTime - now);
           subscriber.add(activeTask);
+          return;
         }
-      },
-      complete: () => {
+
         emit();
-        subscriber.complete();
       }
-    }, () => {
-      lastValue = activeTask = null;
-    }));
-  });
+
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          lastValue = value;
+          lastTime = scheduler.now();
+
+          if (!activeTask) {
+            activeTask = scheduler.schedule(emitWhenIdle, dueTime);
+            subscriber.add(activeTask);
+          }
+        },
+        complete: () => {
+          emit();
+          subscriber.complete();
+        }
+      }, () => {
+        lastValue = activeTask = null;
+      }));
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable either
@@ -1452,41 +1530,47 @@ function debounce_(fa, dueTime, scheduler = tsplus_module_5.asyncScheduler) {
 
 
 function either(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         subscriber.next(tsplus_module_19.right(value));
       },
       error: error => {
-        tsplus_module_14.match_(tsplus_module_1.failureOrCause(error), e => subscriber.next(tsplus_module_19.left(e)), cause => subscriber.error(cause));
+        tsplus_module_14.match(e => subscriber.next(tsplus_module_19.left(e)), cause => subscriber.error(cause))(tsplus_module_1.failureOrCause(error));
       }
     }));
-  });
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable delayWithIndex
+ * @tsplus pipeable fncts.observable.Observable delayWithIndex
  */
 
 
-function delayWithIndex_1(fa, f) {
-  return mergeMapWithIndex_1(fa, (i, a) => as_1(take_1(f(i, a), 1), () => a));
+function delayWithIndex_1(f) {
+  return fa => {
+    return mergeMapWithIndex_1((i, a) => as_1(() => a)(take_1(1)(f(i, a))))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable delayWith
+ * @tsplus pipeable fncts.observable.Observable delayWith
  */
 
 
-function delayWith_1(fa, f) {
-  return delayWithIndex_1(fa, (_, a) => f(a));
+function delayWith_1(f) {
+  return fa => {
+    return delayWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable delay
+ * @tsplus pipeable fncts.observable.Observable delay
  */
 
 
-function delay_(fa, due, scheduler = tsplus_module_5.asyncScheduler) {
-  const duration = timer_1(due, scheduler);
-  return delayWith_1(fa, () => duration);
+function delay(due, scheduler = tsplus_module_5.asyncScheduler) {
+  return fa => {
+    const duration = timer_1(due, scheduler);
+    return delayWith_1(() => duration)(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable dematerialize
@@ -1494,22 +1578,24 @@ function delay_(fa, due, scheduler = tsplus_module_5.asyncScheduler) {
 
 
 function dematerialize(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: notification => tsplus_module_20.observe_(notification, subscriber)
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+      next: notification => tsplus_module_20.observe(subscriber)(notification)
     }));
-  });
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable ensuring
+ * @tsplus pipeable fncts.observable.Observable ensuring
  */
 
 
-function ensuring_(fa, finalizer) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(subscriber);
-    subscriber.add(finalizer);
-  });
+function ensuring(finalizer) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      source.provideEnvironment(environment).subscribe(subscriber);
+      subscriber.add(finalizer);
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable exhaustAll
@@ -1517,13 +1603,13 @@ function ensuring_(fa, finalizer) {
 
 
 function exhaustAll(ffa) {
-  return tsplus_module_8.operate_(ffa, (source, subscriber) => {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
     let isComplete = false;
     let innerSub = null;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: inner => {
         if (!innerSub) {
-          innerSub = from_1(inner).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+          innerSub = from_1(inner).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
             complete: () => {
               innerSub = null;
               isComplete && subscriber.complete();
@@ -1536,78 +1622,93 @@ function exhaustAll(ffa) {
         !innerSub && subscriber.complete();
       }
     }));
-  });
+  })(ffa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable exhaustMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable exhaustMapWithIndex
  */
 
 
-function exhaustMapWithIndex_1(self, f) {
-  return tsplus_module_8.operate_(self, (source, subscriber) => {
-    let index = 0;
-    let innerSub = null;
-    let isComplete = false;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: outerValue => {
-        if (!innerSub) {
-          innerSub = tsplus_module_8.operatorSubscriber(subscriber, {
-            complete: () => {
-              innerSub = null;
-              isComplete && subscriber.complete();
-            }
-          });
-          from_1(f(index++, outerValue)).subscribe(innerSub);
+function exhaustMapWithIndex_1(f) {
+  return self => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      let innerSub = null;
+      let isComplete = false;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: outerValue => {
+          if (!innerSub) {
+            innerSub = tsplus_module_8.operatorSubscriber(subscriber, {
+              complete: () => {
+                innerSub = null;
+                isComplete && subscriber.complete();
+              }
+            });
+            from_1(f(index++, outerValue)).provideEnvironment(environment).subscribe(innerSub);
+          }
+        },
+        complete: () => {
+          isComplete = true;
+          !innerSub && subscriber.complete();
         }
-      },
-      complete: () => {
-        isComplete = true;
-        !innerSub && subscriber.complete();
-      }
-    }));
-  });
+      }));
+    })(self);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable exhaustMap
+ * @tsplus pipeable fncts.observable.Observable exhaustMap
  */
 
 
-function exhaustMap_(self, f) {
-  return exhaustMapWithIndex_1(self, (_, a) => f(a));
+function exhaustMap(f) {
+  return self => {
+    return exhaustMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable expandWithIndex
+ * @tsplus pipeable fncts.observable.Observable expandWithIndex
  */
 
 
-function expandWithIndex_1(fa, f, concurrent = Infinity) {
-  // eslint-disable-next-line no-param-reassign
-  concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => mergeInternal(source, subscriber, f, concurrent, undefined, true));
+function expandWithIndex_1(f, concurrent = Infinity) {
+  return fa => {
+    concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
+    return tsplus_module_8.operate_((source, subscriber, environment) => mergeInternal(source, subscriber, environment, f, concurrent, undefined, true))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable expand
+ * @tsplus pipeable fncts.observable.Observable expand
  */
 
 
-function expand_(fa, f, concurrent = Infinity) {
-  return expandWithIndex_1(fa, (_, a) => f(a), concurrent);
+function expand(f, concurrent = Infinity) {
+  return fa => {
+    return expandWithIndex_1((_, a) => f(a), concurrent)(fa);
+  };
 }
 
-function findWithIndex_1(fa, predicate) {
-  return tsplus_module_8.operate_(fa, findInternal(predicate, "value"));
+function findWithIndex_1(predicate) {
+  return fa => {
+    return tsplus_module_8.operate_(findInternal(predicate, "value"))(fa);
+  };
 }
 
-function find_(fa, predicate) {
-  return findWithIndex_1(fa, (_, a) => predicate(a));
+function find(predicate) {
+  return fa => {
+    return findWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 
-function findIndexWithIndex_1(fa, predicate) {
-  return tsplus_module_8.operate_(fa, findInternal(predicate, "index"));
+function findIndexWithIndex_1(predicate) {
+  return fa => {
+    return tsplus_module_8.operate_(findInternal(predicate, "index"))(fa);
+  };
 }
 
-function findIndex_(fa, predicate) {
-  return findIndexWithIndex_1(fa, (_, a) => predicate(a));
+function findIndex(predicate) {
+  return fa => {
+    return findIndexWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 
 function forkJoin(...args) {
@@ -1660,11 +1761,11 @@ function forkJoin(...args) {
 
 
 function ignore(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: tsplus_module_2.noop
     }));
-  });
+  })(fa);
 }
 /**
  * @tsplus getter fncts.observable.Observable isEmpty
@@ -1672,8 +1773,8 @@ function ignore(fa) {
 
 
 function isEmpty(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: () => {
         subscriber.next(false);
         subscriber.complete();
@@ -1683,7 +1784,7 @@ function isEmpty(fa) {
         subscriber.complete();
       }
     }));
-  });
+  })(fa);
 }
 /**
  * @tsplus getter fncts.observable.Observable materialize
@@ -1691,8 +1792,8 @@ function isEmpty(fa) {
 
 
 function materialize(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         subscriber.next(tsplus_module_20.next(value));
       },
@@ -1703,40 +1804,46 @@ function materialize(fa) {
         subscriber.next(tsplus_module_20.complete());
       }
     }));
-  });
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeAll
+ * @tsplus pipeable fncts.observable.Observable mergeAll
  */
 
 
-function mergeAll_1(self, concurrent = Infinity) {
-  return mergeMap_1(self, tsplus_module_13.identity, concurrent);
+function mergeAll_1(concurrent = Infinity) {
+  return self => {
+    return mergeMap_1(tsplus_module_13.identity, concurrent)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeScanWithIndex
+ * @tsplus pipeable fncts.observable.Observable mergeScanWithIndex
  */
 
 
-function mergeScanWithIndex_1(fa, initial, f, concurrent = Infinity) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let state = initial;
-    return mergeInternal(source, subscriber, (index, value) => f(index, state, value), concurrent, value => {
-      state = value;
-    }, false, undefined, () => state = null);
-  });
+function mergeScanWithIndex_1(initial, f, concurrent = Infinity) {
+  return fa => {
+    return tsplus_module_8.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);
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeScan
+ * @tsplus pipeable fncts.observable.Observable mergeScan
  */
 
 
-function mergeScan_(fa, initial, f, concurrent = Infinity) {
-  return mergeScanWithIndex_1(fa, initial, (_, b, a) => f(b, a), concurrent);
+function mergeScan(initial, f, concurrent = Infinity) {
+  return fa => {
+    return mergeScanWithIndex_1(initial, (_, b, a) => f(b, a), concurrent)(fa);
+  };
 }
 
 function onErrorResumeNext(fa, ...sources) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
     const remaining = [source, ...sources];
 
     const subscribeNext = () => {
@@ -1755,7 +1862,7 @@ function onErrorResumeNext(fa, ...sources) {
             error: tsplus_module_2.noop,
             complete: tsplus_module_2.noop
           });
-          subscriber.add(nextSource.subscribe(innerSub));
+          subscriber.add(nextSource.provideEnvironment(environment).subscribe(innerSub));
           innerSub.add(subscribeNext);
         } else {
           subscriber.complete();
@@ -1764,178 +1871,192 @@ function onErrorResumeNext(fa, ...sources) {
     };
 
     subscribeNext();
-  });
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable onEmpty
+ * @tsplus pipeable fncts.observable.Observable onEmpty
  */
 
 
-function onEmpty_1(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let hasValue = false;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        hasValue = true;
-        subscriber.next(value);
-      },
-      complete: () => {
-        if (!hasValue) {
-          subscriber.next(f());
-        }
+function onEmpty_1(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let hasValue = false;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          hasValue = true;
+          subscriber.next(value);
+        },
+        complete: () => {
+          if (!hasValue) {
+            subscriber.next(f());
+          }
 
-        subscriber.complete();
-      }
-    }));
-  });
+          subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable repeat
+ * @tsplus pipeable fncts.observable.Observable repeat
  */
 
 
-function repeat_(fa, count = Infinity) {
-  return count <= 0 ? empty_1() : tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let repeats = 0;
-    let innerSub;
+function repeat(count = Infinity) {
+  return fa => {
+    return count <= 0 ? empty_1() : tsplus_module_8.operate_((source, subscriber, environment) => {
+      let repeats = 0;
+      let innerSub;
 
-    const loop = () => {
-      let syncUnsub = false;
-      innerSub = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-        complete: () => {
-          if (++repeats < count) {
-            if (innerSub) {
-              innerSub.unsubscribe();
-              innerSub = null;
-              loop();
+      const loop = () => {
+        let syncUnsub = false;
+        innerSub = source.provideEnvironment(environment).subscribe(tsplus_module_8.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();
-      }
-    };
+        if (syncUnsub) {
+          innerSub.unsubscribe();
+          innerSub = null;
+          loop();
+        }
+      };
 
-    loop();
-  });
+      loop();
+    })(fa);
+  };
 }
 
-function retry_(fa, configOrCount = Infinity) {
-  let config;
+function retry(configOrCount = Infinity) {
+  return fa => {
+    let config;
 
-  if (configOrCount && typeof configOrCount === "object") {
-    config = configOrCount;
-  } else {
-    config = {
-      count: configOrCount
-    };
-  }
+    if (configOrCount && typeof configOrCount === "object") {
+      config = configOrCount;
+    } else {
+      config = {
+        count: configOrCount
+      };
+    }
 
-  const {
-    count,
-    resetOnSuccess = false
-  } = config;
-  return count <= 0 ? fa : tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let retries = 0;
-    let innerSub;
-
-    const loop = () => {
-      let syncUnsub = false;
-      innerSub = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-        next: value => {
-          if (resetOnSuccess) {
-            retries = 0;
-          }
+    const {
+      count,
+      resetOnSuccess = false
+    } = config;
+    return count <= 0 ? fa : tsplus_module_8.operate_((source, subscriber, environment) => {
+      let retries = 0;
+      let innerSub;
+
+      const loop = () => {
+        let syncUnsub = false;
+        innerSub = source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+          next: value => {
+            if (resetOnSuccess) {
+              retries = 0;
+            }
 
-          subscriber.next(value);
-        },
-        error: err => {
-          if (retries++ < count) {
-            if (innerSub) {
-              innerSub.unsubscribe();
-              innerSub = null;
-              loop();
+            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();
-      }
-    };
+        if (syncUnsub) {
+          innerSub.unsubscribe();
+          innerSub = null;
+          loop();
+        }
+      };
 
-    loop();
-  });
+      loop();
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable sample
+ * @tsplus pipeable fncts.observable.Observable sample
  */
 
 
-function sample_1(fa, notifier) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let hasValue = false;
-    let lastValue = null;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        hasValue = true;
-        lastValue = value;
-      }
-    }));
+function sample_1(notifier) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let hasValue = false;
+      let lastValue = null;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          hasValue = true;
+          lastValue = value;
+        }
+      }));
 
-    const emit = () => {
-      if (hasValue) {
-        hasValue = false;
-        const value = lastValue;
-        lastValue = null;
-        subscriber.next(value);
-      }
-    };
+      const emit = () => {
+        if (hasValue) {
+          hasValue = false;
+          const value = lastValue;
+          lastValue = null;
+          subscriber.next(value);
+        }
+      };
 
-    notifier.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: emit,
-      complete: tsplus_module_2.noop
-    }));
-  });
+      notifier.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: emit,
+        complete: tsplus_module_2.noop
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable sampleTime
+ * @tsplus pipeable fncts.observable.Observable sampleTime
  */
 
 
-function sampleTime_(fa, period, scheduler = tsplus_module_5.asyncScheduler) {
-  return sample_1(fa, interval_1(period, scheduler));
+function sampleTime(period, scheduler = tsplus_module_5.asyncScheduler) {
+  return fa => {
+    return sample_1(interval_1(period, scheduler))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable scanLeftWithIndex
+ * @tsplus pipeable fncts.observable.Observable scanLeftWithIndex
  */
 
 
-function scanLeftWithIndex_1(fa, initial, f) {
-  return tsplus_module_8.operate_(fa, scanInternal(f, initial, true, true));
+function scanLeftWithIndex_1(initial, f) {
+  return fa => {
+    return tsplus_module_8.operate_(scanInternal(f, initial, true, true))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable scanLeft
+ * @tsplus pipeable fncts.observable.Observable scanLeft
  */
 
 
-function scanLeft(fa, initial, f) {
-  return scanLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+function scanLeft(initial, f) {
+  return fa => {
+    return scanLeftWithIndex_1(initial, (_, b, a) => f(b, a))(fa);
+  };
 }
 /**
  * @tsplus static fncts.observable.ObservableOps service
@@ -1965,99 +2086,111 @@ tag) {
 function serviceWithObservable_1(f,
 /** @tsplus auto */
 tag) {
-  return environmentWithObservable_1(environment => f(tsplus_module_16.unsafeGet(environment, tag)));
+  return environmentWithObservable_1(environment => f(tsplus_module_16.unsafeGet(tag)(environment)));
 }
 /**
- * @tsplus fluent fncts.observable.Observable skip
+ * @tsplus pipeable fncts.observable.Observable skip
  */
 
 
-function skip_(fa, count) {
-  return filterWithIndex_1(fa, (index, _) => count <= index);
+function skip(count) {
+  return fa => {
+    return filterWithIndex_1((index, _) => count <= index)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable skipLast
+ * @tsplus pipeable fncts.observable.Observable skipLast
  */
 
 
-function skipLast_(fa, skipCount) {
-  return skipCount <= 0 ? fa : tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let ring = new Array(skipCount);
-    let seen = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        const valueIndex = seen++;
+function skipLast(skipCount) {
+  return fa => {
+    return skipCount <= 0 ? fa : tsplus_module_8.operate_((source, subscriber, environment) => {
+      let ring = new Array(skipCount);
+      let seen = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.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);
+          if (valueIndex < skipCount) {
+            ring[valueIndex] = value;
+          } else {
+            const index = valueIndex % skipCount;
+            const oldValue = ring[index];
+            ring[index] = value;
+            subscriber.next(oldValue);
+          }
         }
-      }
-    }));
-    return () => {
-      ring = null;
-    };
-  });
+      }));
+      return () => {
+        ring = null;
+      };
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable skipUntil
+ * @tsplus pipeable fncts.observable.Observable skipUntil
  */
 
 
-function skipUntil_(fa, notifier) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let taking = false;
-    const skipSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-      next: () => {
-        skipSubscriber?.unsubscribe();
-        taking = true;
-      },
-      complete: tsplus_module_2.noop
-    });
-    from_1(notifier).subscribe(skipSubscriber);
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => taking && subscriber.next(value)
-    }));
-  });
+function skipUntil(notifier) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let taking = false;
+      const skipSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+        next: () => {
+          skipSubscriber?.unsubscribe();
+          taking = true;
+        },
+        complete: tsplus_module_2.noop
+      });
+      from_1(notifier).provideEnvironment(environment).subscribe(skipSubscriber);
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => taking && subscriber.next(value)
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable skipWhile
+ * @tsplus pipeable fncts.observable.Observable skipWhile
  */
 
 
-function skipWhile_(fa, predicate) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let taking = false;
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => (taking || (taking = !predicate(index++, value))) && subscriber.next(value)
-    }));
-  });
+function skipWhile(predicate) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let taking = false;
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => (taking || (taking = !predicate(index++, value))) && subscriber.next(value)
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable startWith
+ * @tsplus pipeable fncts.observable.Observable startWith
  */
 
 
-function startWith_(fa, ...values) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    // @ts-expect-error
-    concat_1(source, values).subscribe(subscriber);
-  });
+function startWith(...values) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber) => {
+      // @ts-expect-error
+      concat_1(values)(source).subscribe(subscriber);
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable subscribeOn
+ * @tsplus pipeable fncts.observable.Observable subscribeOn
  */
 
 
-function subscribeOn_(fa, scheduler, delay = 0) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay));
-  });
+function subscribeOn(scheduler, delay = 0) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      subscriber.add(scheduler.schedule(() => source.provideEnvironment(environment).subscribe(subscriber), delay));
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable switchAll
@@ -2065,168 +2198,188 @@ function subscribeOn_(fa, scheduler, delay = 0) {
 
 
 function switchAll(ffa) {
-  return switchMap_1(ffa, tsplus_module_13.identity);
+  return switchMap_1(tsplus_module_13.identity)(ffa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable switchMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable switchMapWithIndex
  */
 
 
-function switchMapWithIndex_1(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let innerSubscriber = null;
-    let index = 0;
-    let isComplete = false;
+function switchMapWithIndex_1(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let innerSubscriber = null;
+      let index = 0;
+      let isComplete = false;
 
-    const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
+      const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
 
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        innerSubscriber?.unsubscribe();
-        const outerIndex = index++;
-        from_1(f(outerIndex, value)).subscribe(innerSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-          next: innerValue => subscriber.next(innerValue),
-          complete: () => {
-            innerSubscriber = null;
-            checkComplete();
-          }
-        }));
-      }
-    }, () => {
-      isComplete = true;
-      checkComplete();
-    }));
-  });
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          innerSubscriber?.unsubscribe();
+          const outerIndex = index++;
+          from_1(f(outerIndex, value)).provideEnvironment(environment).subscribe(innerSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+            next: innerValue => subscriber.next(innerValue),
+            complete: () => {
+              innerSubscriber = null;
+              checkComplete();
+            }
+          }));
+        }
+      }, () => {
+        isComplete = true;
+        checkComplete();
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable switchMap
+ * @tsplus pipeable fncts.observable.Observable switchMap
  */
 
 
-function switchMap_1(fa, f) {
-  return switchMapWithIndex_1(fa, (_, a) => f(a));
+function switchMap_1(f) {
+  return fa => {
+    return switchMapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable switchScanWithIndex
+ * @tsplus pipeable fncts.observable.Observable switchScanWithIndex
  */
 
 
-function switchScanWithIndex_1(fa, initial, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let state = initial;
-    switchMapWithIndex_1(source, (index, value) => map_1(from_1(f(index, state, value)), b => (state = b, b))).subscribe(subscriber);
-    return () => {
-      state = null;
-    };
-  });
+function switchScanWithIndex_1(initial, f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let state = initial;
+      switchMapWithIndex_1((index, value) => map_1(b => (state = b, b))(from_1(f(index, state, value))))(source).provideEnvironment(environment).subscribe(subscriber);
+      return () => {
+        state = null;
+      };
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable switchScan
+ * @tsplus pipeable fncts.observable.Observable switchScan
  */
 
 
-function switchScan_(fa, initial, f) {
-  return switchScanWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+function switchScan(initial, f) {
+  return fa => {
+    return switchScanWithIndex_1(initial, (_, b, a) => f(b, a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable take
+ * @tsplus pipeable fncts.observable.Observable take
  */
 
 
-function take_1(fa, count) {
-  return count <= 0 ? empty_1() : tsplus_module_8.operate_(fa, (source, sub) => {
-    let seen = 0;
-    source.subscribe(new tsplus_module_8.OperatorSubscriber(sub, {
-      next: value => {
-        if (++seen <= count) {
-          sub.next(value);
+function take_1(count) {
+  return fa => {
+    return count <= 0 ? empty_1() : tsplus_module_8.operate_((source, sub, environment) => {
+      let seen = 0;
+      source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(sub, {
+        next: value => {
+          if (++seen <= count) {
+            sub.next(value);
 
-          if (count <= seen) {
-            sub.complete();
+            if (count <= seen) {
+              sub.complete();
+            }
           }
         }
-      }
-    }));
-  });
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable takeLast
+ * @tsplus pipeable fncts.observable.Observable takeLast
  */
 
 
-function takeLast_(fa, count) {
-  return count <= 0 ? empty_1() : tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let buffer = [];
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        buffer.push(value);
-        count < buffer.length && buffer.shift();
-      },
-      complete: () => {
-        for (const value of buffer) {
-          subscriber.next(value);
-        }
+function takeLast(count) {
+  return fa => {
+    return count <= 0 ? empty_1() : tsplus_module_8.operate_((source, subscriber, environment) => {
+      let buffer = [];
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          buffer.push(value);
+          count < buffer.length && buffer.shift();
+        },
+        complete: () => {
+          for (const value of buffer) {
+            subscriber.next(value);
+          }
 
-        subscriber.complete();
-      }
-    }, () => {
-      buffer = null;
-    }));
-  });
+          subscriber.complete();
+        }
+      }, () => {
+        buffer = null;
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable takeUntil
+ * @tsplus pipeable fncts.observable.Observable takeUntil
  */
 
 
-function takeUntil_(fa, notifier) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    from_1(notifier).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: () => subscriber.complete(),
-      complete: tsplus_module_2.noop
-    }));
-    !subscriber.closed && source.subscribe(subscriber);
-  });
+function takeUntil(notifier) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      from_1(notifier).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: () => subscriber.complete(),
+        complete: tsplus_module_2.noop
+      }));
+      !subscriber.closed && source.provideEnvironment(environment).subscribe(subscriber);
+    })(fa);
+  };
 }
 
-function takeWhileWithIndex_1(fa, predicate, inclusive) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        const result = predicate(index++, value);
-        (result || inclusive) && subscriber.next(value);
-        !result && subscriber.complete();
-      }
-    }));
-  });
+function takeWhileWithIndex_1(predicate, inclusive) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          const result = predicate(index++, value);
+          (result || inclusive) && subscriber.next(value);
+          !result && subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 
-function takeWhile_(fa, predicate, inclusive) {
-  return takeWhileWithIndex_1(fa, (_, a) => predicate(a), inclusive);
+function takeWhile(predicate, inclusive) {
+  return fa => {
+    return takeWhileWithIndex_1((_, a) => predicate(a), inclusive)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable tap
+ * @tsplus pipeable fncts.observable.Observable tap
  */
 
 
-function tap_(fa, observer) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        observer.next?.(value);
-        subscriber.next(value);
-      },
-      error: err => {
-        observer.error?.(err);
-        subscriber.error(err);
-      },
-      complete: () => {
-        observer.complete?.();
-        subscriber.complete();
-      }
-    }));
-  });
+function tap(observer) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          observer.next?.(value);
+          subscriber.next(value);
+        },
+        error: err => {
+          observer.error?.(err);
+          subscriber.error(err);
+        },
+        complete: () => {
+          observer.complete?.();
+          subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 
 const defaultThrottleConfig = {
@@ -2234,71 +2387,75 @@ const defaultThrottleConfig = {
   trailing: false
 };
 /**
- * @tsplus fluent fncts.observable.Observable throttle
+ * @tsplus pipeable fncts.observable.Observable throttle
  */
 
 exports.defaultThrottleConfig = defaultThrottleConfig;
 
-function throttle_1(fa, durationSelector, {
+function throttle_1(durationSelector, {
   leading,
   trailing
 } = defaultThrottleConfig) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let sendValue = tsplus_module_17.nothing();
-    let throttled = null;
-    let isComplete = false;
-
-    const endThrottling = () => {
-      throttled?.unsubscribe();
-      throttled = null;
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let sendValue = tsplus_module_17.nothing();
+      let throttled = null;
+      let isComplete = false;
+
+      const endThrottling = () => {
+        throttled?.unsubscribe();
+        throttled = null;
+
+        if (trailing) {
+          send();
+          isComplete && subscriber.complete();
+        }
+      };
 
-      if (trailing) {
-        send();
+      const cleanupThrottling = () => {
+        throttled = null;
         isComplete && subscriber.complete();
-      }
-    };
-
-    const cleanupThrottling = () => {
-      throttled = null;
-      isComplete && subscriber.complete();
-    };
+      };
 
-    const startThrottling = value => throttled = from_1(durationSelector(value)).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: endThrottling,
-      complete: cleanupThrottling
-    }));
+      const startThrottling = value => throttled = from_1(durationSelector(value)).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: endThrottling,
+        complete: cleanupThrottling
+      }));
 
-    const send = () => {
-      if (tsplus_module_18.isJust(sendValue)) {
-        const {
-          value
-        } = sendValue;
-        sendValue = tsplus_module_17.nothing();
-        subscriber.next(value);
-        !isComplete && startThrottling(value);
-      }
-    };
+      const send = () => {
+        if (tsplus_module_18.isJust(sendValue)) {
+          const {
+            value
+          } = sendValue;
+          sendValue = tsplus_module_17.nothing();
+          subscriber.next(value);
+          !isComplete && startThrottling(value);
+        }
+      };
 
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        sendValue = tsplus_module_17.just(value);
-        !(throttled && !throttled.closed) && (leading ? send() : startThrottling(value));
-      },
-      complete: () => {
-        isComplete = true;
-        !(trailing && tsplus_module_18.isJust(sendValue) && throttled && !throttled.closed) && subscriber.complete();
-      }
-    }));
-  });
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          sendValue = tsplus_module_17.just(value);
+          !(throttled && !throttled.closed) && (leading ? send() : startThrottling(value));
+        },
+        complete: () => {
+          isComplete = true;
+          !(trailing && tsplus_module_18.isJust(sendValue) && throttled && !throttled.closed) && subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable throttleTime
+ * @tsplus pipeable fncts.observable.Observable throttleTime
  */
 
 
-function throttleTime_(fa, duration, scheduler = tsplus_module_5.asyncScheduler, config = defaultThrottleConfig) {
-  const duration$ = timer_1(duration, scheduler);
-  return throttle_1(fa, () => duration$, config);
+function throttleTime(duration, scheduler = tsplus_module_5.asyncScheduler, config = defaultThrottleConfig) {
+  return fa => {
+    const duration$ = timer_1(duration, scheduler);
+    return throttle_1(() => duration$, config)(fa);
+  };
 }
 
 class TimeoutError extends Error {
@@ -2312,49 +2469,51 @@ class TimeoutError extends Error {
 
 exports.TimeoutError = TimeoutError;
 
-function timeout_(fa, config) {
-  const {
-    first,
-    each,
-    with: _with = timeoutError,
-    scheduler = tsplus_module_5.asyncScheduler,
-    meta = null
-  } = config;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    // eslint-disable-next-line prefer-const
-    let originalSourceSubscription;
-    let timerSubscription;
-    let lastValue = tsplus_module_17.nothing();
-    let seen = 0;
-
-    const startTimer = delay => {
-      timerSubscription = (0, tsplus_module_7.caughtSchedule)(subscriber, scheduler, () => {
-        originalSourceSubscription.unsubscribe();
-        from_1(_with({
-          meta,
-          lastValue,
-          seen
-        })).subscribe(subscriber);
-      }, delay);
-    };
-
-    originalSourceSubscription = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        timerSubscription?.unsubscribe();
-        seen++;
-        lastValue = tsplus_module_17.just(value);
-        subscriber.next(value);
-        each > 0 && startTimer(each);
-      }
-    }, () => {
-      if (!timerSubscription?.closed) {
-        timerSubscription?.unsubscribe();
-      }
+function timeout(config) {
+  return fa => {
+    const {
+      first,
+      each,
+      with: _with = timeoutError,
+      scheduler = tsplus_module_5.asyncScheduler,
+      meta = null
+    } = config;
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      // eslint-disable-next-line prefer-const
+      let originalSourceSubscription;
+      let timerSubscription;
+      let lastValue = tsplus_module_17.nothing();
+      let seen = 0;
+
+      const startTimer = delay => {
+        timerSubscription = (0, tsplus_module_7.caughtSchedule)(subscriber, scheduler, () => {
+          originalSourceSubscription.unsubscribe();
+          from_1(_with({
+            meta,
+            lastValue,
+            seen
+          })).provideEnvironment(environment).subscribe(subscriber);
+        }, delay);
+      };
+
+      originalSourceSubscription = source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          timerSubscription?.unsubscribe();
+          seen++;
+          lastValue = tsplus_module_17.just(value);
+          subscriber.next(value);
+          each > 0 && startTimer(each);
+        }
+      }, () => {
+        if (!timerSubscription?.closed) {
+          timerSubscription?.unsubscribe();
+        }
 
-      lastValue = tsplus_module_17.nothing();
-    }));
-    startTimer(first != null ? typeof first === "number" ? first : +first - scheduler.now() : each);
-  });
+        lastValue = tsplus_module_17.nothing();
+      }));
+      startTimer(first != null ? typeof first === "number" ? first : +first - scheduler.now() : each);
+    })(fa);
+  };
 }
 
 function timeoutError(info) {
@@ -2370,60 +2529,66 @@ function toArrayAccumulator(arr, value) {
 
 
 function toArray_1(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    foldLeft_1(source, [], toArrayAccumulator).subscribe(subscriber);
-  });
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    foldLeft_1([], toArrayAccumulator)(source).provideEnvironment(environment).subscribe(subscriber);
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable unique
+ * @tsplus pipeable fncts.observable.Observable unique
  */
 
 
-function unique_(fa, toKey, flushes) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let distinctKeys = tsplus_module_21.makeDefault();
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        const key = toKey ? toKey(value) : value;
+function unique(toKey, flushes) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let distinctKeys = tsplus_module_21.makeDefault();
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          const key = toKey ? toKey(value) : value;
 
-        if (!tsplus_module_21.has_(distinctKeys, key)) {
-          tsplus_module_21.add_(distinctKeys, key);
-          subscriber.next(value);
+          if (!tsplus_module_21.has(key)(distinctKeys)) {
+            tsplus_module_21.add(key)(distinctKeys);
+            subscriber.next(value);
+          }
         }
-      }
-    }));
-    flushes?.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: () => distinctKeys = tsplus_module_21.makeDefault(),
-      complete: tsplus_module_2.noop
-    }));
-  });
+      }));
+      flushes?.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: () => distinctKeys = tsplus_module_21.makeDefault(),
+        complete: tsplus_module_2.noop
+      }));
+    })(fa);
+  };
 }
 
-function uniqueUntilChanged_1(fa, E, keySelector = tsplus_module_13.identity) {
-  const compare = "equals" in E ? E.equals : E;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let previousKey;
-    let first = true;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        const currentKey = keySelector(value);
+function uniqueUntilChanged_1(E, keySelector = tsplus_module_13.identity) {
+  return fa => {
+    const compare = "equals" in E ? E.equals : E;
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let previousKey;
+      let first = true;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          const currentKey = keySelector(value);
 
-        if (first || !compare(previousKey, currentKey)) {
-          first = false;
-          previousKey = currentKey;
-          subscriber.next(value);
+          if (first || !compare(previousKey, currentKey)) {
+            first = false;
+            previousKey = currentKey;
+            subscriber.next(value);
+          }
         }
-      }
-    }));
-  });
+      }));
+    })(fa);
+  };
 }
 
-function uniqueUntilKeyChanged_(fa, key, equals) {
-  const compare = "equals" in equals ? equals.equals : equals;
-  return uniqueUntilChanged_1(fa, (x, y) => compare(x[key], y[key]));
+function uniqueUntilKeyChanged(key, equals) {
+  return fa => {
+    const compare = "equals" in equals ? equals.equals : equals;
+    return uniqueUntilChanged_1((x, y) => compare(x[key], y[key]))(fa);
+  };
 }
 
-function combineLatestInternal(subscriber, observables, scheduler, valueTransform = tsplus_module_13.identity) {
+function combineLatestInternal(subscriber, environment, observables, scheduler, valueTransform = tsplus_module_13.identity) {
   return maybeSchedule(subscriber, scheduler, () => {
     const {
       length
@@ -2434,9 +2599,9 @@ function combineLatestInternal(subscriber, observables, scheduler, valueTransfor
 
     for (let i = 0; i < length; i++) {
       maybeSchedule(subscriber, scheduler, () => {
-        const source = scheduler ? scheduled_1(observables[i], scheduler) : from_1(observables[i]);
+        const source = scheduler ? scheduled_1(scheduler)(observables[i]) : from_1(observables[i]);
         let hasFirstValue = false;
-        source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
           next: value => {
             values[i] = value;
 
@@ -2462,9 +2627,9 @@ function combineLatestInternal(subscriber, observables, scheduler, valueTransfor
 
 function findInternal(predicate, emit) {
   const findIndex = emit === "index";
-  return (source, subscriber) => {
+  return (source, subscriber, environment) => {
     let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const i = index++;
 
@@ -2482,7 +2647,7 @@ function findInternal(predicate, emit) {
 }
 
 function joinAllInternal(fa, joiner) {
-  return mergeMap_1(toArray_1(fa), joiner);
+  return mergeMap_1(joiner)(toArray_1(fa));
 }
 
 function maybeSchedule(subscription, scheduler, execute) {
@@ -2493,7 +2658,7 @@ function maybeSchedule(subscription, scheduler, execute) {
   }
 }
 
-function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand, innerSubScheduler, additionalTeardown) {
+function mergeInternal(source, subscriber, environment, f, concurrent, onBeforeNext, expand, innerSubScheduler, additionalTeardown) {
   const buffer = [];
   let active = 0;
   let index = 0;
@@ -2511,7 +2676,7 @@ function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand,
     expand && subscriber.next(a);
     active++;
     let innerComplete = false;
-    from_1(f(index++, a)).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
+    from_1(f(index++, a)).provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
       next: b => {
         onBeforeNext?.(b);
 
@@ -2542,7 +2707,7 @@ function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand,
     }));
   };
 
-  source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
+  source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
     next: outerNext,
     complete: () => {
       isComplete = true;
@@ -2555,11 +2720,11 @@ function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand,
 }
 
 function scanInternal(f, initial, hasInitial, emitOnNext, emitBeforeComplete) {
-  return (source, subscriber) => {
+  return (source, subscriber, environment) => {
     let hasState = hasInitial;
     let state = initial;
     let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const i = index++;
         state = hasState ? f(i, state, value) : (hasState = true, value);