@fncts/io 0.0.19 → 0.0.21

package/_src/STM/api.ts

@@ -12,10 +12,12 @@ import { TryCommitTag } from "./internal/TryCommit.js";
 /**
  * Maps the success value of this effect to the specified constant value.
  *
- * @tsplus fluent fncts.io.STM as
+ * @tsplus pipeable fncts.io.STM as
  */
-export function as_<R, E, A, B>(stm: STM<R, E, A>, b: Lazy<B>, __tsplusTrace?: string): STM<R, E, B> {
-  return stm.map(() => b());
+export function as<B>(b: Lazy<B>, __tsplusTrace?: string) {
+  return <R, E, A>(stm: STM<R, E, A>): STM<R, E, B> => {
+    return stm.map(() => b());
+  };
 }
 
 /**
@@ -124,83 +126,125 @@ export function atomically<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string):
 /**
  * Returns an `STM` effect whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
+ *
+ * @tsplus pipeable fncts.io.STM bimap
  */
-export function bimap_<R, E, A, E1, B>(
-  stm: STM<R, E, A>,
-  g: (e: E) => E1,
-  f: (a: A) => B,
-  __tsplusTrace?: string,
-): STM<R, E1, B> {
-  return stm.matchSTM(
-    (e) => STM.failNow(g(e)),
-    (a) => STM.succeedNow(f(a)),
-  );
+export function bimap<E, A, E1, B>(g: (e: E) => E1, f: (a: A) => B, __tsplusTrace?: string) {
+  return <R>(self: STM<R, E, A>) =>
+    self.matchSTM(
+      (e) => STM.failNow(g(e)),
+      (a) => STM.succeedNow(f(a)),
+    );
 }
 
 /**
  * Recovers from specified error.
  *
- * @tsplus fluent fncts.io.STM catch
+ * @tsplus pipeable fncts.io.STM catch
  */
-export function catch_<N extends keyof E, K extends E[N] & string, E, R, A, R1, E1, A1>(
-  stm: STM<R, E, A>,
+export function catchWith<N extends keyof E, K extends E[N] & string, E, R1, E1, A1>(
   tag: N,
   k: K,
-  f: (e: Extract<E, { [n in N]: K }>) => STM<R1, E1, A1>,
+  f: (
+    e: Extract<
+      E,
+      {
+        [n in N]: K;
+      }
+    >,
+  ) => STM<R1, E1, A1>,
   __tsplusTrace?: string,
-): STM<R | R1, Exclude<E, { [n in N]: K }> | E1, A | A1> {
-  return stm.catchAll((e) => {
-    if (tag in e && e[tag] === k) {
-      return f(e as any);
-    }
-    return STM.failNow(e as any);
-  });
+) {
+  return <R, A>(
+    stm: STM<R, E, A>,
+  ): STM<
+    R | R1,
+    | Exclude<
+        E,
+        {
+          [n in N]: K;
+        }
+      >
+    | E1,
+    A | A1
+  > => {
+    return stm.catchAll((e) => {
+      if (isObject(e) && tag in e && e[tag] === k) {
+        return f(e as any);
+      }
+      return STM.failNow(e as any);
+    });
+  };
 }
 
 /**
  * Recovers from some or all of the error cases.
  *
- * @tsplus fluent fncts.io.STM catchJust
+ * @tsplus pipeable fncts.io.STM catchJust
  */
-export function catchJust_<R, E, A, R1, E1, B>(
-  stm: STM<R, E, A>,
-  f: (e: E) => Maybe<STM<R1, E1, B>>,
-  __tsplusTrace?: string,
-): STM<R1 | R, E | E1, A | B> {
-  return stm.catchAll((e): STM<R1, E | E1, A | B> => f(e).getOrElse(STM.failNow(e)));
+export function catchJust<E, R1, E1, B>(f: (e: E) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string) {
+  return <R, A>(stm: STM<R, E, A>): STM<R1 | R, E | E1, A | B> => {
+    return stm.catchAll((e): STM<R1, E | E1, A | B> => f(e).getOrElse(STM.failNow(e)));
+  };
 }
 
 /**
  * Recovers from specified error.
  *
- * @tsplus fluent fncts.io.STM catchTag
- */
-export function catchTag_<K extends E["_tag"] & string, E extends { _tag: string }, R, A, R1, E1, A1>(
-  stm: STM<R, E, A>,
+ * @tsplus pipeable fncts.io.STM catchTag
+ */
+export function catchTag<
+  K extends E["_tag"] & string,
+  E extends {
+    _tag: string;
+  },
+  R1,
+  E1,
+  A1,
+>(
   k: K,
-  f: (e: Extract<E, { _tag: K }>) => STM<R1, E1, A1>,
+  f: (
+    e: Extract<
+      E,
+      {
+        _tag: K;
+      }
+    >,
+  ) => STM<R1, E1, A1>,
   __tsplusTrace?: string,
-): STM<R | R1, Exclude<E, { _tag: K }> | E1, A | A1> {
-  return stm.catchAll((e) => {
-    if ("_tag" in e && e["_tag"] === k) {
-      return f(e as any);
-    }
-    return STM.failNow(e as any);
-  });
+) {
+  return <R, A>(
+    stm: STM<R, E, A>,
+  ): STM<
+    R | R1,
+    | Exclude<
+        E,
+        {
+          _tag: K;
+        }
+      >
+    | E1,
+    A | A1
+  > => {
+    return stm.catchAll((e) => {
+      if ("_tag" in e && e["_tag"] === k) {
+        return f(e as any);
+      }
+      return STM.failNow(e as any);
+    });
+  };
 }
 
 /**
  * Creates a composite effect that represents this effect followed by another
  * one that may depend on the error produced by this one.
  *
- * @tsplus fluent fncts.io.STM flatMapError
+ * @tsplus pipeable fncts.io.STM flatMapError
  */
-export function chainError_<R, E, A, R2, E2>(
-  stm: STM<R, E, A>,
-  f: (e: E) => STM<R2, never, E2>,
-  __tsplusTrace?: string,
-): STM<R2 | R, E2, A> {
-  return stm.swapWith((effect) => effect.flatMap(f));
+export function chainError<E, R2, E2>(f: (e: E) => STM<R2, never, E2>, __tsplusTrace?: string) {
+  return <R, A>(stm: STM<R, E, A>): STM<R2 | R, E2, A> => {
+    return stm.swapWith((effect) => effect.flatMap(f));
+  };
 }
 
 /**
@@ -224,58 +268,52 @@ export function commitEither<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string)
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * succeed with the returned value.
  *
- * @tsplus fluent fncts.io.STM continueOrFail
+ * @tsplus pipeable fncts.io.STM continueOrFail
  */
-export function continueOrFail_<R, E, E1, A, A2>(
-  fa: STM<R, E, A>,
-  e: Lazy<E1>,
-  pf: (a: A) => Maybe<A2>,
-  __tsplusTrace?: string,
-): STM<R, E | E1, A2> {
-  return fa.continueOrFailSTM(e, (a) => pf(a).map(STM.succeedNow));
+export function continueOrFail<E1, A, A2>(e: Lazy<E1>, pf: (a: A) => Maybe<A2>, __tsplusTrace?: string) {
+  return <R, E>(fa: STM<R, E, A>): STM<R, E | E1, A2> => {
+    return fa.continueOrFailSTM(e, (a) => pf(a).map(STM.succeedNow));
+  };
 }
 
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * continue with the returned value.
  *
- * @tsplus fluent fncts.io.STM continueOrFailSTM
+ * @tsplus pipeable fncts.io.STM continueOrFailSTM
  */
-export function continueOrFailSTM_<R, E, E1, A, R2, E2, A2>(
-  fa: STM<R, E, A>,
+export function continueOrFailSTM<E1, A, R2, E2, A2>(
   e: Lazy<E1>,
   pf: (a: A) => Maybe<STM<R2, E2, A2>>,
   __tsplusTrace?: string,
-): STM<R2 | R, E | E1 | E2, A2> {
-  return fa.flatMap((a) => pf(a).getOrElse(STM.fail(e)));
+) {
+  return <R, E>(fa: STM<R, E, A>): STM<R2 | R, E | E1 | E2, A2> => {
+    return fa.flatMap((a) => pf(a).getOrElse(STM.fail(e)));
+  };
 }
 
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * succeed with the returned value.
  *
- * @tsplus fluent fncts.io.STM continueOrRetry
+ * @tsplus pipeable fncts.io.STM continueOrRetry
  */
-export function continueOrRetry_<R, E, A, A2>(
-  fa: STM<R, E, A>,
-  pf: (a: A) => Maybe<A2>,
-  __tsplusTrace?: string,
-): STM<R, E, A2> {
-  return fa.continueOrRetrySTM((a) => pf(a).map(STM.succeedNow));
+export function continueOrRetry<A, A2>(pf: (a: A) => Maybe<A2>, __tsplusTrace?: string) {
+  return <R, E>(fa: STM<R, E, A>): STM<R, E, A2> => {
+    return fa.continueOrRetrySTM((a) => pf(a).map(STM.succeedNow));
+  };
 }
 
 /**
  * Simultaneously filters and flatMaps the value produced by this effect.
  * Continues on the effect returned from pf.
  *
- * @tsplus fluent fncts.io.STM continueOrRetrySTM
+ * @tsplus pipeable fncts.io.STM continueOrRetrySTM
  */
-export function continueOrRetrySTM_<R, E, A, R2, E2, A2>(
-  fa: STM<R, E, A>,
-  pf: (a: A) => Maybe<STM<R2, E2, A2>>,
-  __tsplusTrace?: string,
-): STM<R2 | R, E | E2, A2> {
-  return fa.flatMap((a) => pf(a).getOrElse(STM.retry));
+export function continueOrRetrySTM<A, R2, E2, A2>(pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string) {
+  return <R, E>(fa: STM<R, E, A>): STM<R2 | R, E | E2, A2> => {
+    return fa.flatMap((a) => pf(a).getOrElse(STM.retry));
+  };
 }
 
 /**
@@ -308,92 +346,78 @@ export function eventually<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string):
 /**
  * Simultaneously filters and maps the value produced by this effect.
  *
- * @tsplus fluent fncts.io.STM filterMap
+ * @tsplus pipeable fncts.io.STM filterMap
  */
-export function filterMap_<R, E, A, B>(stm: STM<R, E, A>, f: (a: A) => Maybe<B>, __tsplusTrace?: string): STM<R, E, B> {
-  return stm.filterMapSTM((a) => f(a).map(STM.succeedNow));
+export function filterMap<A, B>(f: (a: A) => Maybe<B>, __tsplusTrace?: string) {
+  return <R, E>(stm: STM<R, E, A>): STM<R, E, B> => {
+    return stm.filterMapSTM((a) => f(a).map(STM.succeedNow));
+  };
 }
 
 /**
  * Simultaneously filters and chains the value produced by this effect.
  * Continues on the effect returned from f.
  *
- * @tsplus fluent fncts.io.STM filterMapSTM
+ * @tsplus pipeable fncts.io.STM filterMapSTM
  */
-export function filterMapSTM_<R, E, A, R1, E1, B>(
-  self: STM<R, E, A>,
-  f: (a: A) => Maybe<STM<R1, E1, B>>,
-  __tsplusTrace?: string,
-): STM<R | R1, E | E1, B> {
-  return self.matchSTM(STM.failNow, (a) => f(a).getOrElse(STM.retry));
+export function filterMapSTM<A, R1, E1, B>(f: (a: A) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string) {
+  return <R, E>(self: STM<R, E, A>): STM<R | R1, E | E1, B> => {
+    return self.matchSTM(STM.failNow, (a) => f(a).getOrElse(STM.retry));
+  };
 }
 
 /**
  * Applies `or` if the predicate fails.
  *
- * @tsplus fluent fncts.io.STM filterOrElse
+ * @tsplus pipeable fncts.io.STM filterOrElse
  */
-export function filterOrElse_<R, E, A, B extends A, R2, E2, A2>(
-  fa: STM<R, E, A>,
+export function filterOrElse<A, B extends A, R2, E2, A2>(
   p: Refinement<A, B>,
   or: (a: Exclude<A, B>) => STM<R2, E2, A2>,
-): STM<R | R2, E | E2, B | A2>;
-export function filterOrElse_<R, E, A, R2, E2, A2>(
-  fa: STM<R, E, A>,
+): <R, E>(fa: STM<R, E, A>) => STM<R | R2, E | E2, B | A2>;
+export function filterOrElse<A, R2, E2, A2>(
   p: Predicate<A>,
   or: (a: A) => STM<R2, E2, A2>,
-): STM<R | R2, E | E2, A | A2>;
-export function filterOrElse_<R, E, A, R2, E2, A2>(
-  fa: STM<R, E, A>,
-  p: Predicate<A>,
-  or: unknown,
-  __tsplusTrace?: string,
-): STM<R | R2, E | E2, A | A2> {
-  return fa.flatMap((a) => (p(a) ? STM.succeedNow(a) : STM.defer((or as (a: A) => STM<R2, E2, A2>)(a))));
+): <R, E>(fa: STM<R, E, A>) => STM<R | R2, E | E2, A | A2>;
+export function filterOrElse<A>(p: Predicate<A>, or: unknown, __tsplusTrace?: string) {
+  return <R, E, R2, E2, A2>(fa: STM<R, E, A>): STM<R | R2, E | E2, A | A2> => {
+    return fa.flatMap((a) => (p(a) ? STM.succeedNow(a) : STM.defer((or as (a: A) => STM<R2, E2, A2>)(a))));
+  };
 }
 
 /**
  * Fails with `failWith` if the predicate fails.
  *
- * @tsplus fluent fncts.io.STM filterOrFail
+ * @tsplus pipeable fncts.io.STM filterOrFail
  */
-export function filterOrFail_<R, E, E1, A, B extends A>(
-  fa: STM<R, E, A>,
+export function filterOrFail<E1, A, B extends A>(
   p: Refinement<A, B>,
   failWith: (a: Exclude<A, B>) => E1,
-): STM<R, E | E1, B>;
-export function filterOrFail_<R, E, E1, A>(
-  fa: STM<R, E, A>,
+): <R, E>(fa: STM<R, E, A>) => STM<R, E | E1, B>;
+export function filterOrFail<E1, A>(
   p: Predicate<A>,
   failWith: (a: A) => E1,
-): STM<R, E | E1, A>;
-export function filterOrFail_<R, E, E1, A>(
-  fa: STM<R, E, A>,
-  p: Predicate<A>,
-  failWith: unknown,
-  __tsplusTrace?: string,
-): STM<R, E | E1, A> {
-  return fa.filterOrElse(p, (a) => STM.fail((failWith as (a: A) => E1)(a)));
+): <R, E>(fa: STM<R, E, A>) => STM<R, E | E1, A>;
+export function filterOrFail<A>(p: Predicate<A>, failWith: unknown, __tsplusTrace?: string) {
+  return <R, E, E1>(fa: STM<R, E, A>): STM<R, E | E1, A> => {
+    return fa.filterOrElse(p, (a) => STM.fail((failWith as (a: A) => E1)(a)));
+  };
 }
 
 /**
  * Halts with specified `unknown` if the predicate fails.
  *
- * @tsplus fluent fncts.io.STM filterOrHalt
+ * @tsplus pipeable fncts.io.STM filterOrHalt
  */
-export function filterOrHalt_<R, E, A, B extends A>(
-  fa: STM<R, E, A>,
+export function filterOrHalt<A, B extends A>(
   p: Refinement<A, B>,
   haltWith: (a: Exclude<A, B>) => unknown,
-): STM<R, E, B>;
-export function filterOrHalt_<R, E, A>(fa: STM<R, E, A>, p: Predicate<A>, haltWith: (a: A) => unknown): STM<R, E, A>;
-export function filterOrHalt_<R, E, A>(
-  fa: STM<R, E, A>,
-  p: Predicate<A>,
-  haltWith: unknown,
-  __tsplusTrace?: string,
-): STM<R, E, A> {
-  return fa.filterOrElse(p, (a) => STM.halt((haltWith as (a: A) => unknown)(a)));
+): <R, E>(fa: STM<R, E, A>) => STM<R, E, B>;
+export function filterOrHalt<A>(p: Predicate<A>, haltWith: (a: A) => unknown): <R, E>(fa: STM<R, E, A>) => STM<R, E, A>;
+export function filterOrHalt<A>(p: Predicate<A>, haltWith: unknown, __tsplusTrace?: string) {
+  return <R, E>(fa: STM<R, E, A>): STM<R, E, A> => {
+    return fa.filterOrElse(p, (a) => STM.halt((haltWith as (a: A) => unknown)(a)));
+  };
 }
 
 /**
@@ -411,14 +435,12 @@ export function flatten<R, E, R1, E1, B>(
 /**
  * Unwraps the optional error, defaulting to the provided value.
  *
- * @tsplus fluent fncts.io.STM flattenErrorOption
+ * @tsplus pipeable fncts.io.STM flattenErrorOption
  */
-export function flattenErrorOption_<R, E, A, E2>(
-  stm: STM<R, Maybe<E>, A>,
-  def: Lazy<E2>,
-  __tsplusTrace?: string,
-): STM<R, E | E2, A> {
-  return stm.mapError((me) => me.getOrElse(def));
+export function flattenErrorOption<E2>(def: Lazy<E2>, __tsplusTrace?: string) {
+  return <R, E, A>(stm: STM<R, Maybe<E>, A>): STM<R, E | E2, A> => {
+    return stm.mapError((me) => me.getOrElse(def));
+  };
 }
 
 /**
@@ -427,21 +449,19 @@ export function flattenErrorOption_<R, E, A, E2>(
  *
  * @tsplus static fncts.io.STMOps foreach
  */
-export function foreach_<A, R, E, B>(
+export function foreach<A, R, E, B>(
   it: Iterable<A>,
   f: (a: A) => STM<R, E, B>,
   __tsplusTrace?: string,
 ): STM<R, E, readonly B[]> {
   return STM.defer(() => {
     let stm = STM.succeedNow([]) as STM<R, E, B[]>;
-
     for (const a of it) {
       stm = stm.zipWith(f(a), (acc, b) => {
         acc.push(b);
         return acc;
       });
     }
-
     return stm;
   });
 }
@@ -478,28 +498,24 @@ export function get<R, E, A>(stm: STM<R, E, Maybe<A>>, __tsplusTrace?: string):
  * Provides the transaction its required environment, which eliminates
  * its dependency on `R`.
  *
- * @tsplus fluent fncts.io.STM provideEnvironment
+ * @tsplus pipeable fncts.io.STM provideEnvironment
  */
-export function provideEnvironment_<R, E, A>(
-  stm: STM<R, E, A>,
-  r: Environment<R>,
-  __tsplusTrace?: string,
-): STM<never, E, A> {
-  return stm.contramapEnvironment(() => r);
+export function provideEnvironment<R>(r: Environment<R>, __tsplusTrace?: string) {
+  return <E, A>(stm: STM<R, E, A>): STM<never, E, A> => {
+    return stm.contramapEnvironment(() => r);
+  };
 }
 
 /**
  * Provides some of the environment required to run this effect,
  * leaving the remainder `R0`.
  *
- * @tsplus fluent fncts.io.STM contramapEnvironment
+ * @tsplus pipeable fncts.io.STM contramapEnvironment
  */
-export function contramapEnvironment_<R, E, A, R0>(
-  self: STM<R, E, A>,
-  f: (r: Environment<R0>) => Environment<R>,
-  __tsplusTrace?: string,
-): STM<R0, E, A> {
-  return new ContramapEnvironment(self, f);
+export function contramapEnvironment<R, R0>(f: (r: Environment<R0>) => Environment<R>, __tsplusTrace?: string) {
+  return <E, A>(self: STM<R, E, A>): STM<R0, E, A> => {
+    return new ContramapEnvironment(self, f);
+  };
 }
 
 /**
@@ -587,41 +603,38 @@ export function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusTrace?: s
 /**
  * Returns a successful effect if the value is `Left`, or fails with the error e.
  *
- * @tsplus fluent fncts.io.STM leftOrFail
+ * @tsplus pipeable fncts.io.STM leftOrFail
  */
-export function leftOrFail_<R, E, B, C, E1>(
-  stm: STM<R, E, Either<B, C>>,
-  orFail: (c: C) => E1,
-  __tsplusTrace?: string,
-): STM<R, E | E1, B> {
-  return stm.flatMap((bc) => bc.match(STM.succeedNow, (c) => STM.fail(orFail(c))));
+export function leftOrFail<C, E1>(orFail: (c: C) => E1, __tsplusTrace?: string) {
+  return <R, E, B>(stm: STM<R, E, Either<B, C>>): STM<R, E | E1, B> => {
+    return stm.flatMap((bc) => bc.match(STM.succeedNow, (c) => STM.fail(orFail(c))));
+  };
 }
 
 /**
  * Maps from one error type to another.
  *
- * @tsplus fluent fncts.io.STM mapError
+ * @tsplus pipeable fncts.io.STM mapError
  */
-export function mapError_<R, E, A, E1>(stm: STM<R, E, A>, f: (a: E) => E1, __tsplusTrace?: string): STM<R, E1, A> {
-  return stm.matchSTM((e) => STM.failNow(f(e)), STM.succeedNow);
+export function mapError<E, E1>(f: (a: E) => E1, __tsplusTrace?: string) {
+  return <R, A>(stm: STM<R, E, A>): STM<R, E1, A> => {
+    return stm.matchSTM((e) => STM.failNow(f(e)), STM.succeedNow);
+  };
 }
 
 /**
  * Folds over the `STM` effect, handling both failure and success, but not
  * retry.
  *
- * @tsplus fluent fncts.io.STM match
+ * @tsplus pipeable fncts.io.STM match
  */
-export function match_<R, E, A, B, C>(
-  stm: STM<R, E, A>,
-  g: (e: E) => C,
-  f: (a: A) => B,
-  __tsplusTrace?: string,
-): STM<R, never, B | C> {
-  return stm.matchSTM(
-    (e) => STM.succeedNow(g(e)),
-    (a) => STM.succeedNow(f(a)),
-  );
+export function match<E, A, B, C>(g: (e: E) => C, f: (a: A) => B, __tsplusTrace?: string) {
+  return <R>(stm: STM<R, E, A>): STM<R, never, B | C> => {
+    return stm.matchSTM(
+      (e) => STM.succeedNow(g(e)),
+      (a) => STM.succeedNow(f(a)),
+    );
+  };
 }
 
 /**
@@ -636,10 +649,12 @@ export function match_<R, E, A, B, C>(
  * - Use `retryUntil` instead if you don't need to maintain transaction state for repeats.
  * - Ensure repeating the STM effect will eventually satisfy the predicate.
  *
- * @tsplus fluent fncts.io.STM repeatUntil
+ * @tsplus pipeable fncts.io.STM repeatUntil
  */
-export function repeatUntil_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): STM<R, E, A> {
-  return stm.flatMap((a) => (f(a) ? STM.succeedNow(a) : stm.repeatUntil(f)));
+export function repeatUntil<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
+  return <R, E>(stm: STM<R, E, A>): STM<R, E, A> => {
+    return stm.flatMap((a) => (f(a) ? STM.succeedNow(a) : stm.repeatUntil(f)));
+  };
 }
 
 /**
@@ -654,10 +669,12 @@ export function repeatUntil_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean, _
  * - Use `retryWhile` instead if you don't need to maintain transaction state for repeats.
  * - Ensure repeating the STM effect will eventually not satisfy the predicate.
  *
- * @tsplus fluent fncts.io.STM repeatWhile
+ * @tsplus pipeable fncts.io.STM repeatWhile
  */
-export function repeatWhile_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): STM<R, E, A> {
-  return stm.flatMap((a) => (f(a) ? stm.repeatWhile(f) : STM.succeedNow(a)));
+export function repeatWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
+  return <R, E>(stm: STM<R, E, A>): STM<R, E, A> => {
+    return stm.flatMap((a) => (f(a) ? stm.repeatWhile(f) : STM.succeedNow(a)));
+  };
 }
 
 /**
@@ -673,27 +690,23 @@ export function swap<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R,
 /**
  * Swaps the error/value parameters, applies the function `f` and flips the parameters back
  *
- * @tsplus fluent fncts.io.STM swapWith
+ * @tsplus pipeable fncts.io.STM swapWith
  */
-export function swapWith_<R, E, A, R2, E2, A2>(
-  stm: STM<R, E, A>,
-  f: (stm: STM<R, A, E>) => STM<R2, A2, E2>,
-  __tsplusTrace?: string,
-): STM<R2, E2, A2> {
-  return f(stm.swap).swap;
+export function swapWith<R, E, A, R2, E2, A2>(f: (stm: STM<R, A, E>) => STM<R2, A2, E2>, __tsplusTrace?: string) {
+  return (stm: STM<R, E, A>): STM<R2, E2, A2> => {
+    return f(stm.swap).swap;
+  };
 }
 
 /**
  * "Peeks" at the success of transactional effect.
  *
- * @tsplus fluent fncts.io.STM tap
+ * @tsplus pipeable fncts.io.STM tap
  */
-export function tap_<R, E, A, R1, E1, B>(
-  stm: STM<R, E, A>,
-  f: (a: A) => STM<R1, E1, B>,
-  __tsplusTrace?: string,
-): STM<R1 | R, E | E1, A> {
-  return stm.flatMap((a) => f(a).as(a));
+export function tap<A, R1, E1, B>(f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E>(stm: STM<R, E, A>): STM<R1 | R, E | E1, A> => {
+    return stm.flatMap((a) => f(a).as(a));
+  };
 }
 
 /**
@@ -716,13 +729,10 @@ export const unit = STM.succeedNow<void>(undefined);
  * Sequentially zips this value with the specified one, combining the values
  * using the specified combiner function.
  *
- * @tsplus fluent fncts.io.STM zipWith
+ * @tsplus pipeable fncts.io.STM zipWith
  */
-export function zipWith_<R, E, A, R1, E1, B, C>(
-  self: STM<R, E, A>,
-  that: STM<R1, E1, B>,
-  f: (a: A, b: B) => C,
-  __tsplusTrace?: string,
-): STM<R | R1, E | E1, C> {
-  return self.flatMap((a) => that.map((b) => f(a, b)));
+export function zipWith<A, R1, E1, B, C>(that: STM<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
+  return <R, E>(self: STM<R, E, A>): STM<R | R1, E | E1, C> => {
+    return self.flatMap((a) => that.map((b) => f(a, b)));
+  };
 }