@fncts/observable 0.0.9 → 0.0.10

package/Observable/api.d.ts

@@ -103,11 +103,11 @@ export declare function of<A>(...items: ReadonlyArray<A>): Observable<never, nev
  */
 export declare function single<A>(a: A): Observable<never, never, A>;
 /**
- * @tsplus fluent fncts.observable.Observable scheduled
+ * @tsplus pipeable fncts.observable.Observable scheduled
  * @tsplus static fncts.observable.ObservableOps scheduled
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function scheduled<R, E, A>(input: ObservableInput<R, E, A>, scheduler: SchedulerLike): Observable<R, E, A>;
+export declare function scheduled(scheduler: SchedulerLike): <R, E, A>(input: ObservableInput<R, E, A>) => Observable<R, E, A>;
 export declare function scheduleArray<A>(input: ArrayLike<A>, scheduler: SchedulerLike): Observable<never, never, A>;
 export declare function scheduleAsyncIterable<A>(input: AsyncIterable<A>, scheduler: SchedulerLike): Observable<never, never, A>;
 export declare function scheduleIterable<A>(input: Iterable<A>, scheduler: SchedulerLike): Observable<never, never, A>;
@@ -138,165 +138,159 @@ export declare function fromIO<R, E, A>(io: IO<R, E, A>, scheduler?: SchedulerLi
  */
 export declare const unit: Observable<never, never, void>;
 /**
- * @tsplus fluent fncts.observable.Observable zipWith
+ * @tsplus pipeable fncts.observable.Observable zipWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function zipWith<R, E, A, R1, E1, B, C>(fa: Observable<R, E, A>, fb: Observable<R1, E1, B>, f: (a: A, b: B) => C): Observable<R | R1, E | E1, C>;
+export declare function zipWith<A, R1, E1, B, C>(fb: Observable<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, C>;
 /**
- * @tsplus fluent fncts.observable.Observable zip
+ * @tsplus pipeable fncts.observable.Observable zip
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function zip<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, fb: Observable<R1, E1, B>): Observable<R | R1, E | E1, readonly [A, B]>;
+export declare function zip<R1, E1, B>(fb: Observable<R1, E1, B>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, readonly [A, B]>;
 /**
- * @tsplus fluent fncts.observable.Observable ap
+ * @tsplus pipeable fncts.observable.Observable ap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function ap<R, E, A, R1, E1, B>(fab: Observable<R, E, (a: A) => B>, fa: Observable<R1, E1, A>): Observable<R | R1, E | E1, B>;
+export declare function ap<A, R1, E1>(fa: Observable<R1, E1, A>): <R, E, B>(fab: Observable<R, E, (a: A) => B>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable mapWithIndex
+ * @tsplus pipeable fncts.observable.Observable mapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mapWithIndex<R, E, A, B>(fa: Observable<R, E, A>, f: (i: number, a: A) => B): Observable<R, E, B>;
+export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable map
+ * @tsplus pipeable fncts.observable.Observable map
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function map_<R, E, A, B>(fa: Observable<R, E, A>, f: (a: A) => B): Observable<R, E, B>;
+export declare function map_<A, B>(f: (a: A) => B): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable as
+ * @tsplus pipeable fncts.observable.Observable as
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function as_<R, E, A, B>(fa: Observable<R, E, A>, b: Lazy<B>): Observable<R, E, B>;
+export declare function as<B>(b: Lazy<B>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable mapError
+ * @tsplus pipeable fncts.observable.Observable mapError
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mapError_<R, E, A, E1>(fa: Observable<R, E, A>, f: (e: E) => E1): Observable<R, E1, A>;
+export declare function mapError<E, E1>(f: (e: E) => E1): <R, A>(fa: Observable<R, E, A>) => Observable<R, E1, A>;
 /**
  * @tsplus getter fncts.observable.Observable swap
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function swap<R, E, A>(fa: Observable<R, E, A>): Observable<R, A, E>;
 /**
- * @tsplus fluent fncts.observable.Observable filterWithIndex
+ * @tsplus pipeable fncts.observable.Observable filterWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function filterWithIndex_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>): Observable<R, E, B>;
-export declare function filterWithIndex_<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, A>;
+export declare function filterWithIndex<A, B extends A>(refinement: RefinementWithIndex<number, A, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
+export declare function filterWithIndex<A>(predicate: PredicateWithIndex<number, A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable filter
+ * @tsplus pipeable fncts.observable.Observable filter
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function filter_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>): Observable<R, E, B>;
-export declare function filter_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, A>;
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
+export declare function filter<A>(predicate: Predicate<A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable filterMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable filterMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function filterMapWithIndex<R, E, A, B>(fa: Observable<R, E, A>, f: (i: number, a: A) => Maybe<B>): Observable<R, E, B>;
+export declare function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable filterMap
+ * @tsplus pipeable fncts.observable.Observable filterMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function filterMap_<R, E, A, B>(fa: Observable<R, E, A>, f: (a: A) => Maybe<B>): Observable<R, E, B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable partitionWithIndex
+ * @tsplus pipeable fncts.observable.Observable partitionWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function partitionWithIndex<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>): readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
-export declare function partitionWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): readonly [Observable<R, E, A>, Observable<R, E, A>];
+export declare function partitionWithIndex<A, B extends A>(refinement: RefinementWithIndex<number, A, B>): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
+export declare function partitionWithIndex<A>(predicate: PredicateWithIndex<number, A>): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, A>, Observable<R, E, A>];
 /**
- * @tsplus fluent fncts.observable.Observable partition
+ * @tsplus pipeable fncts.observable.Observable partition
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function partition_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>): readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
-export declare function partition_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): readonly [Observable<R, E, A>, Observable<R, E, A>];
+export declare function partition<A, B extends A>(refinement: Refinement<A, B>): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
+export declare function partition<A>(predicate: Predicate<A>): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, A>, Observable<R, E, A>];
 /**
- * @tsplus fluent fncts.observable.Observable partitionMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable partitionMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function partitionMapWithIndex_<R, E, A, B, C>(fa: Observable<R, E, A>, f: (i: number, a: A) => Either<B, C>): readonly [Observable<R, E, B>, Observable<R, E, C>];
+export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, B>, Observable<R, E, C>];
 /**
- * @tsplus fluent fncts.observable.Observable partitionMap
+ * @tsplus pipeable fncts.observable.Observable partitionMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function partitionMap_<R, E, A, B, C>(fa: Observable<R, E, A>, f: (a: A) => Either<B, C>): readonly [Observable<R, E, B>, Observable<R, E, C>];
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): <R, E>(fa: Observable<R, E, A>) => readonly [Observable<R, E, B>, Observable<R, E, C>];
 /**
- * @tsplus fluent fncts.observable.Observable provideEnvironment
+ * @tsplus pipeable fncts.observable.Observable provideService
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function provideEnvironment<R, E, A>(self: Observable<R, E, A>, environment: Environment<R>): Observable<never, E, A>;
+export declare function provideService<S>(service: S, /** @tsplus auto */ tag: Tag<S>): <R, E, A>(self: Observable<R, E, A>) => Observable<Exclude<R, S>, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable provideService
+ * @tsplus pipeable fncts.observable.Observable mergeMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function provideService<R, E, A, S>(self: Observable<R, E, A>, service: S, 
-/** @tsplus auto */ tag: Tag<S>): Observable<Exclude<R, S>, E, A>;
+export declare function mergeMapWithIndex<A, R1, E1, B>(f: (i: number, a: A) => ObservableInput<R1, E1, B>, concurrent?: number): <R, E>(ma: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable mergeMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable mergeMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeMapWithIndex<R, E, A, R1, E1, B>(ma: Observable<R, E, A>, f: (i: number, a: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
+export declare function mergeMap<A, R1, E1, B>(f: (a: A) => ObservableInput<R1, E1, B>, concurrent?: number): <R, E>(ma: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable mergeMap
+ * @tsplus pipeable fncts.observable.Observable concatMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeMap_<R, E, A, R1, E1, B>(ma: Observable<R, E, A>, f: (a: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
+export declare function concatMapWithIndex<A, R1, E1, B>(f: (i: number, a: A) => ObservableInput<R1, E1, B>): <R, E>(ma: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable concatMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable concatMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function concatMapWithIndex<R, E, A, R1, E1, B>(ma: Observable<R, E, A>, f: (i: number, a: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
+export declare function concatMap<A, R1, E1, B>(f: (a: A) => ObservableInput<R1, E1, B>): <R, E>(ma: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable concatMap
+ * @tsplus pipeable fncts.observable.Observable contramapEnvironment
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function concatMap_<R, E, A, R1, E1, B>(ma: Observable<R, E, A>, f: (a: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
-/**
- * @tsplus fluent fncts.observable.Observable contramapEnvironment
- * @tsplus location "@fncts/observable/Observable/api"
- */
-export declare function contramapEnvironment<R, E, A, R0>(self: Observable<R, E, A>, f: (r0: Environment<R0>) => Environment<R>): Observable<R0, E, A>;
+export declare function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) => Environment<R>): <E, A>(self: Observable<R, E, A>) => Observable<R0, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable flatten
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function flatten<R, E, R1, E1, A>(mma: Observable<R, E, Observable<R1, E1, A>>): Observable<R | R1, E | E1, A>;
 /**
- * @tsplus fluent fncts.observable.Observable foldLeftWithIndex
+ * @tsplus pipeable fncts.observable.Observable foldLeftWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function foldLeftWithIndex<R, E, A, B>(fa: Observable<R, E, A>, initial: B, f: (index: number, acc: B, value: A) => B): Observable<R, E, B>;
+export declare function foldLeftWithIndex<A, B>(initial: B, f: (index: number, acc: B, value: A) => B): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable foldLeft
+ * @tsplus pipeable fncts.observable.Observable foldLeft
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function foldLeft<R, E, A, B>(fa: Observable<R, E, A>, initial: B, f: (acc: B, value: A) => B): Observable<R, E, B>;
+export declare function foldLeft<A, B>(initial: B, f: (acc: B, value: A) => B): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable at
+ * @tsplus pipeable fncts.observable.Observable at
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function at_<R, E, A>(fa: Observable<R, E, A>, index: number): Observable<R, E, Maybe<A>>;
+export declare function at(index: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, import("@fncts/base/data/Maybe").Maybe<A>>;
 /**
- * @tsplus fluent fncts.observable.Observable audit
+ * @tsplus pipeable fncts.observable.Observable audit
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function audit_<R, E, A, R1, E1>(fa: Observable<R, E, A>, durationSelector: (value: A) => ObservableInput<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function audit<A, R1, E1>(durationSelector: (value: A) => ObservableInput<R1, E1, any>): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable auditTime
+ * @tsplus pipeable fncts.observable.Observable auditTime
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function auditTime_<R, E, A>(fa: Observable<R, E, A>, duration: number, scheduler?: SchedulerLike): Observable<R, E, A>;
+export declare function auditTime(duration: number, scheduler?: SchedulerLike): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable buffer
+ * @tsplus pipeable fncts.observable.Observable buffer
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function buffer_<R, E, A, R1, E1>(fa: Observable<R, E, A>, closingNotifier: Observable<R1, E1, any>): Observable<R | R1, E | E1, ReadonlyArray<A>>;
+export declare function buffer<R1, E1>(closingNotifier: Observable<R1, E1, any>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, readonly A[]>;
 /**
- * @tsplus fluent fncts.observable.Observable bufferCount
+ * @tsplus pipeable fncts.observable.Observable bufferCount
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function bufferCount_<R, E, A>(fa: Observable<R, E, A>, bufferSize: number, startBufferEvery?: number): Observable<R, E, ReadonlyArray<A>>;
+export declare function bufferCount(bufferSize: number, startBufferEvery?: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, readonly A[]>;
 export interface BufferTimeConfig {
     readonly bufferTimeSpan: number;
     readonly bufferCreationInterval?: number;
@@ -304,154 +298,154 @@ export interface BufferTimeConfig {
     readonly scheduler?: SchedulerLike;
 }
 /**
- * @tsplus fluent fncts.observable.Observable bufferTime
+ * @tsplus pipeable fncts.observable.Observable bufferTime
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function bufferTime_<R, E, A>(fa: Observable<R, E, A>, config: BufferTimeConfig): Observable<R, E, ReadonlyArray<A>>;
+export declare function bufferTime(config: BufferTimeConfig): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, readonly A[]>;
 /**
- * @tsplus fluent fncts.observable.Observable bufferToggle
+ * @tsplus pipeable fncts.observable.Observable bufferToggle
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function bufferToggle_<R, E, A, R1, E1, B, R2, E2>(fa: Observable<R, E, A>, openings: ObservableInput<R1, E1, B>, closingSelector: (value: B) => ObservableInput<R2, E2, any>): Observable<R | R1 | R2, E | E1 | E2, ReadonlyArray<A>>;
+export declare function bufferToggle<R1, E1, B, R2, E2>(openings: ObservableInput<R1, E1, B>, closingSelector: (value: B) => ObservableInput<R2, E2, any>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R1 | R2 | R, E1 | E2 | E, readonly A[]>;
 /**
- * @tsplus fluent fncts.observable.Observable bufferWhen
+ * @tsplus pipeable fncts.observable.Observable bufferWhen
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function bufferWhen_<R, E, A, R1, E1>(fa: Observable<R, E, A>, closingSelector: () => ObservableInput<R1, E1, any>): Observable<R | R1, E | E1, ReadonlyArray<A>>;
+export declare function bufferWhen<R1, E1>(closingSelector: () => ObservableInput<R1, E1, any>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, readonly A[]>;
 /**
- * @tsplus fluent fncts.observable.Observable catchAllCause
+ * @tsplus pipeable fncts.observable.Observable catchAllCause
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function catchAllCause<R, E, A, R1, E1, B>(self: Observable<R, E, A>, f: (cause: Cause<E>, caught: Observable<R | R1, E | E1, A | B>) => ObservableInput<R | R1, E1, B>): Observable<R | R1, E1, A | B>;
+export declare function catchAllCause<R, E, A, R1, E1, B>(f: (cause: Cause<E>, caught: Observable<R | R1, E | E1, A | B>) => ObservableInput<R | R1, E1, B>): (self: Observable<R, E, A>) => Observable<R | R1, E1, A | B>;
 /**
  * @tsplus getter fncts.observable.Observable concatAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function concatAll<R, E, R1, E1, A>(ffa: Observable<R, E, ObservableInput<R1, E1, A>>): Observable<R | R1, E | E1, A>;
 /**
- * @tsplus fluent fncts.observable.Observable concat
+ * @tsplus pipeable fncts.observable.Observable concat
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function concat_<R, E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(fa: Observable<R, E, A>, ...sources: O): Observable<R | Observable.EnvironmentOf<O[number]>, E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>>;
+export declare function concat<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: O): <R, E, A>(fa: Observable<R, E, A>) => Observable<R | Observable.EnvironmentOf<O[number]>, E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>>;
 /**
  * @tsplus getter fncts.observable.Observable count
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function count<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, number>;
 /**
- * @tsplus fluent fncts.observable.Observable countWithIndex
+ * @tsplus pipeable fncts.observable.Observable countWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function countWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, number>;
+export declare function countWithIndex<A>(predicate: PredicateWithIndex<number, A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
 /**
- * @tsplus fluent fncts.observable.Observable countWith
+ * @tsplus pipeable fncts.observable.Observable countWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function countWith_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, number>;
+export declare function countWith<A>(predicate: Predicate<A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
 /**
  * @tsplus getter fncts.observable.Observable combineLatestAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function combineLatestAll<R, E, R1, E1, A>(fa: Observable<R, E, ObservableInput<R1, E1, A>>): Observable<R | R1, E | E1, ReadonlyArray<A>>;
 /**
- * @tsplus fluent fncts.observable.Observable combineLatest
+ * @tsplus pipeable fncts.observable.Observable zipLatest
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function zipLatest<O extends ReadonlyArray<ObservableInput<any, any, any>>>(...sources: O): <R, E, A>(self: ObservableInput<R, E, A>) => Observable<R | Observable.EnvironmentOf<O[number]>, E | Observable.ErrorOf<O[number]>, [A, ...{ [K in keyof O]: Observable.TypeOf<O[K]>; }]>;
+/**
+ * @tsplus pipeable fncts.observable.Observable zipWithLatest
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function combineLatest_<R, E, A, O extends ReadonlyArray<ObservableInput<any, any, any>>>(self: ObservableInput<R, E, A>, ...sources: O): Observable<R | Observable.EnvironmentOf<O[number]>, E | Observable.ErrorOf<O[number]>, [
-    A,
-    ...{
-        [K in keyof O]: Observable.TypeOf<O[K]>;
-    }
-]>;
+export declare function zipWithLatest<A, R1, E1, B, C>(that: ObservableInput<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(self: Observable<R, E, A>) => Observable<R1 | R, E1 | E, C>;
 /**
- * @tsplus fluent fncts.observable.Observable debounceWith
+ * @tsplus pipeable fncts.observable.Observable debounceWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function debounceWith_<R, E, A, R1, E1>(fa: Observable<R, E, A>, durationSelector: (value: A) => ObservableInput<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function debounceWith<A, R1, E1>(durationSelector: (value: A) => ObservableInput<R1, E1, any>): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable debounce
+ * @tsplus pipeable fncts.observable.Observable debounce
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function debounce_<R, E, A>(fa: Observable<R, E, A>, dueTime: number, scheduler?: SchedulerLike): Observable<R, E, A>;
+export declare function debounce(dueTime: number, scheduler?: SchedulerLike): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable either
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function either<R, E, A>(fa: Observable<R, E, A>): Observable<R, never, Either<E, A>>;
 /**
- * @tsplus fluent fncts.observable.Observable delayWithIndex
+ * @tsplus pipeable fncts.observable.Observable delayWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function delayWithIndex<R, E, A, R1, E1>(fa: Observable<R, E, A>, f: (index: number, value: A) => Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function delayWithIndex<A, R1, E1>(f: (index: number, value: A) => Observable<R1, E1, any>): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable delayWith
+ * @tsplus pipeable fncts.observable.Observable delayWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function delayWith_<R, E, A, R1, E1>(fa: Observable<R, E, A>, f: (value: A) => Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function delayWith<A, R1, E1>(f: (value: A) => Observable<R1, E1, any>): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable delay
+ * @tsplus pipeable fncts.observable.Observable delay
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function delay_<R, E, A>(fa: Observable<R, E, A>, due: number | Date, scheduler?: SchedulerLike): Observable<R, E, A>;
+export declare function delay(due: number | Date, scheduler?: SchedulerLike): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable dematerialize
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function dematerialize<R, E, E1, A>(fa: Observable<R, E, Notification<E1, A>>): Observable<R, E | E1, A>;
 /**
- * @tsplus fluent fncts.observable.Observable ensuring
+ * @tsplus pipeable fncts.observable.Observable ensuring
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function ensuring_<R, E, A>(fa: Observable<R, E, A>, finalizer: () => void): Observable<R, E, A>;
+export declare function ensuring(finalizer: () => void): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable exhaustAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function exhaustAll<R, E, R1, E1, A>(ffa: Observable<R, E, ObservableInput<R1, E1, A>>): Observable<R | R1, E | E1, A>;
 /**
- * @tsplus fluent fncts.observable.Observable exhaustMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable exhaustMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function exhaustMapWithIndex<R, E, A, R1, E1, B>(self: Observable<R, E, A>, f: (i: number, a: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
+export declare function exhaustMapWithIndex<A, R1, E1, B>(f: (i: number, a: A) => ObservableInput<R1, E1, B>): <R, E>(self: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable exhaustMap
+ * @tsplus pipeable fncts.observable.Observable exhaustMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function exhaustMap_<R, E, A, R1, E1, B>(self: Observable<R, E, A>, f: (a: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
+export declare function exhaustMap<A, R1, E1, B>(f: (a: A) => ObservableInput<R1, E1, B>): <R, E>(self: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable expandWithIndex
+ * @tsplus pipeable fncts.observable.Observable expandWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function expandWithIndex<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, f: (i: number, a: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
+export declare function expandWithIndex<A, R1, E1, B>(f: (i: number, a: A) => ObservableInput<R1, E1, B>, concurrent?: number): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable expand
+ * @tsplus pipeable fncts.observable.Observable expand
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function expand_<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, f: (a: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
+export declare function expand<A, R1, E1, B>(f: (a: A) => ObservableInput<R1, E1, B>, concurrent?: number): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable findWithIndex
+ * @tsplus pipeable fncts.observable.Observable findWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function findWithIndex<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>): Observable<R, E, Maybe<B>>;
-export declare function findWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, Maybe<A>>;
+export declare function findWithIndex<A, B extends A>(refinement: RefinementWithIndex<number, A, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, Maybe<B>>;
+export declare function findWithIndex<A>(predicate: PredicateWithIndex<number, A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, Maybe<A>>;
 /**
- * @tsplus fluent fncts.observable.Observable find
+ * @tsplus pipeable fncts.observable.Observable find
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function find_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>): Observable<R, E, Maybe<B>>;
-export declare function find_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, Maybe<A>>;
+export declare function find<A, B extends A>(refinement: Refinement<A, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, Maybe<B>>;
+export declare function find<A>(predicate: Predicate<A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, Maybe<A>>;
 /**
- * @tsplus fluent fncts.observable.Observable findIndexWithIndex
+ * @tsplus pipeable fncts.observable.Observable findIndexWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function findIndexWithIndex<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>): Observable<R, E, number>;
-export declare function findIndexWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, number>;
+export declare function findIndexWithIndex<A, B extends A>(refinement: RefinementWithIndex<number, A, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
+export declare function findIndexWithIndex<A>(predicate: PredicateWithIndex<number, A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
 /**
- * @tsplus fluent fncts.observable.Observable findIndex
+ * @tsplus pipeable fncts.observable.Observable findIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function findIndex_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>): Observable<R, E, number>;
-export declare function findIndex_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, number>;
+export declare function findIndex<A, B extends A>(refinement: Refinement<A, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
+export declare function findIndex<A>(predicate: Predicate<A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, number>;
 /**
  * @tsplus static fncts.observable.ObservableOps forkJoin
  * @tsplus location "@fncts/observable/Observable/api"
@@ -478,61 +472,61 @@ export declare function isEmpty<R, E, A>(fa: Observable<R, E, A>): Observable<R,
  */
 export declare function materialize<R, E, A>(fa: Observable<R, E, A>): Observable<R, never, Notification<E, A>>;
 /**
- * @tsplus fluent fncts.observable.Observable mergeAll
+ * @tsplus pipeable fncts.observable.Observable mergeAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeAll_<R, E, R1, E1, A>(self: Observable<R, E, ObservableInput<R1, E1, A>>, concurrent?: number): Observable<R | R1, E | E1, A>;
+export declare function mergeAll(concurrent?: number): <R, E, R1, E1, A>(self: Observable<R, E, ObservableInput<R1, E1, A>>) => Observable<R | R1, E | E1, A>;
 /**
- * @tsplus fluent fncts.observable.Observable mergeScanWithIndex
+ * @tsplus pipeable fncts.observable.Observable mergeScanWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeScanWithIndex<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, initial: B, f: (index: number, acc: B, value: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
+export declare function mergeScanWithIndex<A, R1, E1, B>(initial: B, f: (index: number, acc: B, value: A) => ObservableInput<R1, E1, B>, concurrent?: number): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable mergeScan
+ * @tsplus pipeable fncts.observable.Observable mergeScan
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeScan_<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, initial: B, f: (acc: B, value: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
+export declare function mergeScan<A, R1, E1, B>(initial: B, f: (acc: B, value: A) => ObservableInput<R1, E1, B>, concurrent?: number): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 export declare function onErrorResumeNext<R, E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(fa: Observable<R, E, A>, ...sources: O): Observable<R | Observable.EnvironmentOf<O[number]>, E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>>;
 /**
- * @tsplus fluent fncts.observable.Observable onEmpty
+ * @tsplus pipeable fncts.observable.Observable onEmpty
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function onEmpty_<R, E, A, B>(fa: Observable<R, E, A>, f: Lazy<B>): Observable<R, E, A | B>;
+export declare function onEmpty<B>(f: Lazy<B>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, B | A>;
 /**
- * @tsplus fluent fncts.observable.Observable repeat
+ * @tsplus pipeable fncts.observable.Observable repeat
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function repeat_<R, E, A>(fa: Observable<R, E, A>, count?: number): Observable<R, E, A>;
+export declare function repeat(count?: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 export interface RetryConfig {
     readonly count: number;
     readonly resetOnSuccess?: boolean;
 }
 /**
- * @tsplus fluent fncts.observable.Observable retry
+ * @tsplus pipeable fncts.observable.Observable retry
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function retry_<R, E, A>(fa: Observable<R, E, A>, count?: number): Observable<R, E, A>;
-export declare function retry_<R, E, A>(fa: Observable<R, E, A>, config: RetryConfig): Observable<R, E, A>;
+export declare function retry(count?: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export declare function retry(config: RetryConfig): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable sample
+ * @tsplus pipeable fncts.observable.Observable sample
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function sample_<R, E, A, R1, E1>(fa: Observable<R, E, A>, notifier: Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function sample<R1, E1>(notifier: Observable<R1, E1, any>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable sampleTime
+ * @tsplus pipeable fncts.observable.Observable sampleTime
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function sampleTime_<R, E, A>(fa: Observable<R, E, A>, period: number, scheduler?: SchedulerLike): Observable<R, E, A>;
+export declare function sampleTime(period: number, scheduler?: SchedulerLike): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable scanLeftWithIndex
+ * @tsplus pipeable fncts.observable.Observable scanLeftWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function scanLeftWithIndex<R, E, A, B>(fa: Observable<R, E, A>, initial: B, f: (index: number, acc: B, value: A) => B): Observable<R, E, B>;
+export declare function scanLeftWithIndex<A, B>(initial: B, f: (index: number, acc: B, value: A) => B): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable scanLeft
+ * @tsplus pipeable fncts.observable.Observable scanLeft
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function scanLeft<R, E, A, B>(fa: Observable<R, E, A>, initial: B, f: (acc: B, value: A) => B): Observable<R, E, B>;
+export declare function scanLeft<A, B>(initial: B, f: (acc: B, value: A) => B): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
 /**
  * @tsplus static fncts.observable.ObservableOps service
  * @tsplus location "@fncts/observable/Observable/api"
@@ -550,107 +544,107 @@ export declare function serviceWith<S, A>(f: (service: S) => A, /** @tsplus auto
 export declare function serviceWithObservable<S, R, E, A>(f: (service: S) => Observable<R, E, A>, 
 /** @tsplus auto */ tag: Tag<S>): Observable<S | R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable skip
+ * @tsplus pipeable fncts.observable.Observable skip
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function skip_<R, E, A>(fa: Observable<R, E, A>, count: number): Observable<R, E, A>;
+export declare function skip(count: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable skipLast
+ * @tsplus pipeable fncts.observable.Observable skipLast
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function skipLast_<R, E, A>(fa: Observable<R, E, A>, skipCount: number): Observable<R, E, A>;
+export declare function skipLast(skipCount: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable skipUntil
+ * @tsplus pipeable fncts.observable.Observable skipUntil
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function skipUntil_<R, E, A, R1, E1>(fa: Observable<R, E, A>, notifier: Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function skipUntil<R1, E1>(notifier: Observable<R1, E1, any>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable skipWhile
+ * @tsplus pipeable fncts.observable.Observable skipWhile
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function skipWhile_<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, A>;
+export declare function skipWhile<A>(predicate: PredicateWithIndex<number, A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable startWith
+ * @tsplus pipeable fncts.observable.Observable startWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function startWith_<R, E, A, B extends ReadonlyArray<unknown>>(fa: Observable<R, E, A>, ...values: B): Observable<R, E, A | B[number]>;
+export declare function startWith<B extends ReadonlyArray<unknown>>(...values: B): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A | B[number]>;
 /**
- * @tsplus fluent fncts.observable.Observable subscribeOn
+ * @tsplus pipeable fncts.observable.Observable subscribeOn
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function subscribeOn_<R, E, A>(fa: Observable<R, E, A>, scheduler: SchedulerLike, delay?: number): Observable<R, E, A>;
+export declare function subscribeOn(scheduler: SchedulerLike, delay?: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable switchAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function switchAll<R, E, R1, E1, A>(ffa: Observable<R, E, ObservableInput<R1, E1, A>>): Observable<R | R1, E | E1, A>;
 /**
- * @tsplus fluent fncts.observable.Observable switchMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable switchMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function switchMapWithIndex<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, f: (index: number, value: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
+export declare function switchMapWithIndex<A, R1, E1, B>(f: (index: number, value: A) => ObservableInput<R1, E1, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable switchMap
+ * @tsplus pipeable fncts.observable.Observable switchMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function switchMap_<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, f: (value: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
+export declare function switchMap<A, R1, E1, B>(f: (value: A) => ObservableInput<R1, E1, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable switchScanWithIndex
+ * @tsplus pipeable fncts.observable.Observable switchScanWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function switchScanWithIndex<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, initial: B, f: (index: number, acc: B, value: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
+export declare function switchScanWithIndex<A, R1, E1, B>(initial: B, f: (index: number, acc: B, value: A) => ObservableInput<R1, E1, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable switchScan
+ * @tsplus pipeable fncts.observable.Observable switchScan
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function switchScan_<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, initial: B, f: (acc: B, value: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
+export declare function switchScan<A, R1, E1, B>(initial: B, f: (acc: B, value: A) => ObservableInput<R1, E1, B>): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.observable.Observable take
+ * @tsplus pipeable fncts.observable.Observable take
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function take_<R, E, A>(fa: Observable<R, E, A>, count: number): Observable<R, E, A>;
+export declare function take(count: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable takeLast
+ * @tsplus pipeable fncts.observable.Observable takeLast
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function takeLast_<R, E, A>(fa: Observable<R, E, A>, count: number): Observable<R, E, A>;
+export declare function takeLast(count: number): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable takeUntil
+ * @tsplus pipeable fncts.observable.Observable takeUntil
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function takeUntil_<R, E, A, R1, E1>(fa: Observable<R, E, A>, notifier: ObservableInput<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function takeUntil<R1, E1>(notifier: ObservableInput<R1, E1, any>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable takeWhileWithIndex
+ * @tsplus pipeable fncts.observable.Observable takeWhileWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function takeWhileWithIndex<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>, inclusive?: boolean): Observable<R, E, B>;
-export declare function takeWhileWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>, inclusive?: boolean): Observable<R, E, A>;
+export declare function takeWhileWithIndex<A, B extends A>(refinement: RefinementWithIndex<number, A, B>, inclusive?: boolean): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
+export declare function takeWhileWithIndex<A>(predicate: PredicateWithIndex<number, A>, inclusive?: boolean): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable takeWhile
+ * @tsplus pipeable fncts.observable.Observable takeWhile
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function takeWhile_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>, inclusive?: boolean): Observable<R, E, B>;
-export declare function takeWhile_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>, inclusive?: boolean): Observable<R, E, A>;
+export declare function takeWhile<A, B extends A>(refinement: Refinement<A, B>, inclusive?: boolean): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, B>;
+export declare function takeWhile<A>(predicate: Predicate<A>, inclusive?: boolean): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable tap
+ * @tsplus pipeable fncts.observable.Observable tap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function tap_<R, E, A>(fa: Observable<R, E, A>, observer: Partial<Observer<E, A>>): Observable<R, E, A>;
+export declare function tap<E, A>(observer: Partial<Observer<E, A>>): <R>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 export interface ThrottleConfig {
     readonly leading?: boolean;
     readonly trailing?: boolean;
 }
 export declare const defaultThrottleConfig: ThrottleConfig;
 /**
- * @tsplus fluent fncts.observable.Observable throttle
+ * @tsplus pipeable fncts.observable.Observable throttle
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function throttle_<R, E, A, R1, E1>(fa: Observable<R, E, A>, durationSelector: (a: A) => ObservableInput<R1, E1, any>, { leading, trailing }?: ThrottleConfig): Observable<R | R1, E | E1, A>;
+export declare function throttle<A, R1, E1>(durationSelector: (a: A) => ObservableInput<R1, E1, any>, { leading, trailing }?: ThrottleConfig): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable throttleTime
+ * @tsplus pipeable fncts.observable.Observable throttleTime
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function throttleTime_<R, E, A>(fa: Observable<R, E, A>, duration: number, scheduler?: SchedulerLike, config?: ThrottleConfig): Observable<R, E, A>;
+export declare function throttleTime(duration: number, scheduler?: SchedulerLike, config?: ThrottleConfig): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 export type TimeoutConfig<R, E, A, B, M = unknown> = ({
     readonly each: number;
     readonly first?: number | Date;
@@ -672,37 +666,37 @@ export declare class TimeoutError<A, M> extends Error {
     constructor(info: TimeoutInfo<A, M> | null);
 }
 /**
- * @tsplus fluent fncts.observable.Observable timeout
+ * @tsplus pipeable fncts.observable.Observable timeout
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function timeout_<R, E, A, R1, E1, B, M = unknown>(fa: Observable<R, E, A>, config: TimeoutConfig<R1, E1, A, B, M> & {
+export declare function timeout<A, R1, E1, B, M = unknown>(config: TimeoutConfig<R1, E1, A, B, M> & {
     readonly with: (info: TimeoutInfo<A, M>) => ObservableInput<R1, E1, B>;
-}): Observable<R | R1, E | E1, A | B>;
-export declare function timeout_<R, E, A, M = unknown>(fa: Observable<R, E, A>, config: Omit<TimeoutConfig<never, never, A, any, M>, "with">): Observable<R, E | TimeoutError<A, M>, A>;
+}): <R, E>(fa: Observable<R, E, A>) => Observable<R | R1, E | E1, A | B>;
+export declare function timeout<A, M = unknown>(config: Omit<TimeoutConfig<never, never, A, any, M>, "with">): <R, E>(fa: Observable<R, E, A>) => Observable<R, E | TimeoutError<A, M>, A>;
 /**
  * @tsplus getter fncts.observable.Observable toArray
  * @tsplus location "@fncts/observable/Observable/api"
  */
 export declare function toArray<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, ReadonlyArray<A>>;
 /**
- * @tsplus fluent fncts.observable.Observable unique
+ * @tsplus pipeable fncts.observable.Observable unique
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function unique_<R, E, A, K, R1, E1 = never>(fa: Observable<R, E, A>, toKey?: (value: A) => K, flushes?: Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function unique<A, K, R1, E1 = never>(toKey?: (value: A) => K, flushes?: Observable<R1, E1, any>): <R, E>(fa: Observable<R, E, A>) => Observable<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable uniqueUntilChanged
+ * @tsplus pipeable fncts.observable.Observable uniqueUntilChanged
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function uniqueUntilChanged_<R, E, A, K>(fa: Observable<R, E, A>, E: Eq<K>, keySelector: (value: A) => K): Observable<R, E, A>;
-export declare function uniqueUntilChanged_<R, E, A, K>(fa: Observable<R, E, A>, equals: (x: K, y: K) => boolean, keySelector: (value: A) => K): Observable<R, E, A>;
-export declare function uniqueUntilChanged_<R, E, A>(fa: Observable<R, E, A>, E: Eq<A>): Observable<R, E, A>;
-export declare function uniqueUntilChanged_<R, E, A>(fa: Observable<R, E, A>, equals: (x: A, y: A) => boolean): Observable<R, E, A>;
+export declare function uniqueUntilChanged<A, K>(E: Eq<K>, keySelector: (value: A) => K): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export declare function uniqueUntilChanged<A, K>(equals: (x: K, y: K) => boolean, keySelector: (value: A) => K): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export declare function uniqueUntilChanged<A>(E: Eq<A>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export declare function uniqueUntilChanged<A>(equals: (x: A, y: A) => boolean): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 /**
- * @tsplus fluent fncts.observable.Observable uniqueUntilKeyChanged
+ * @tsplus pipeable fncts.observable.Observable uniqueUntilKeyChanged
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function uniqueUntilKeyChanged_<R, E, A, K extends keyof A>(fa: Observable<R, E, A>, key: K, E: Eq<A[K]>): Observable<R, E, A>;
-export declare function uniqueUntilKeyChanged_<R, E, A, K extends keyof A>(fa: Observable<R, E, A>, key: K, equals: (x: A[K], y: A[K]) => boolean): Observable<R, E, A>;
+export declare function uniqueUntilKeyChanged<A, K extends keyof A>(key: K, E: Eq<A[K]>): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
+export declare function uniqueUntilKeyChanged<A, K extends keyof A>(key: K, equals: (x: A[K], y: A[K]) => boolean): <R, E>(fa: Observable<R, E, A>) => Observable<R, E, A>;
 export declare function joinAllInternal<R, E, R1, E1, A, R2, E2, B>(fa: Observable<R, E, ObservableInput<R1, E1, A>>, joiner: (sources: ReadonlyArray<ObservableInput<R1, E1, A>>) => Observable<R2, E2, B>): Observable<R | R1 | R2, E | E1 | E2, B>;
 export declare function scanInternal<R, E, A, B>(f: (index: number, acc: A, value: A) => B, initial: B, hasInitial: false, emitOnNext: boolean, emitBeforeComplete?: undefined | true): (source: Observable<R, E, A>, subscriber: Subscriber<any, any>) => void;
 export declare function scanInternal<R, E, A, B>(f: (index: number, acc: B, value: A) => B, initial: B, hasInitial: true, emitOnNext: boolean, emitBeforeComplete?: undefined | true): (source: Observable<R, E, A>, subscriber: Subscriber<any, any>) => void;