@fncts/io 0.0.19 → 0.0.21

package/_src/IO/definition.ts

@@ -41,9 +41,27 @@ export const IOAspects: IOAspects = {};
 export function unifyIO<X extends IO<any, any, any>>(
   self: X,
 ): IO<
-  [X] extends [{ _R: () => infer R }] ? R : never,
-  [X] extends [{ _E: () => infer E }] ? E : never,
-  [X] extends [{ _A: () => infer A }] ? A : never
+  [X] extends [
+    {
+      _R: () => infer R;
+    },
+  ]
+    ? R
+    : never,
+  [X] extends [
+    {
+      _E: () => infer E;
+    },
+  ]
+    ? E
+    : never,
+  [X] extends [
+    {
+      _A: () => infer A;
+    },
+  ]
+    ? A
+    : never
 > {
   return self;
 }
@@ -157,7 +175,6 @@ export type FailureReporter = (e: Cause<unknown>) => void;
  */
 export class Fork<R, E, A> extends IO<R, never, FiberContext<E, A>> {
   readonly _tag = IOTag.Fork;
-
   constructor(readonly io: IO<R, E, A>, readonly scope: Maybe<FiberScope>, readonly trace?: string) {
     super();
   }
@@ -168,7 +185,6 @@ export class Fork<R, E, A> extends IO<R, never, FiberContext<E, A>> {
  */
 export class Fail<E> extends IO<never, E, never> {
   readonly _tag = IOTag.Fail;
-
   constructor(readonly cause: Lazy<Cause<E>>, readonly trace?: string) {
     super();
   }
@@ -179,7 +195,6 @@ export class Fail<E> extends IO<never, E, never> {
  */
 export class Yield extends IO<never, never, void> {
   readonly _tag = IOTag.Yield;
-
   constructor(readonly trace?: string) {
     super();
   }
@@ -190,7 +205,6 @@ export class Yield extends IO<never, never, void> {
  */
 export class Defer<R, E, A> extends IO<R, E, A> {
   readonly _tag = IOTag.Defer;
-
   constructor(readonly make: () => IO<R, E, A>, readonly trace?: string) {
     super();
   }
@@ -201,7 +215,6 @@ export class Defer<R, E, A> extends IO<R, E, A> {
  */
 export class DeferWith<R, E, A> extends IO<R, E, A> {
   readonly _tag = IOTag.DeferWith;
-
   constructor(readonly make: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, readonly trace?: string) {
     super();
   }
@@ -212,7 +225,6 @@ export class DeferWith<R, E, A> extends IO<R, E, A> {
  */
 export class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> {
   readonly _tag = "Race";
-
   constructor(
     readonly left: IO<R, E, A>,
     readonly right: IO<R1, E1, A1>,

package/_src/IO/runtime.ts

@@ -1,4 +1,3 @@
-import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 import { Stack } from "@fncts/base/internal/Stack";
 import { FiberContext } from "@fncts/io/Fiber";
 import { concrete } from "@fncts/io/IO/definition";
@@ -23,15 +22,11 @@ export class Runtime<R> {
       ),
       children,
     );
-
     FiberScope.global.unsafeAdd(context);
-
     if (supervisor !== Supervisor.none) {
       supervisor.unsafeOnStart(this.environment, io, Nothing(), context);
-
       context.unsafeOnDone((exit) => supervisor.unsafeOnEnd(exit.flatten, context));
     }
-
     context.nextIO = concrete(io);
     context.run();
     return context;
@@ -76,25 +71,18 @@ export class Runtime<R> {
       ),
       children,
     );
-
     FiberScope.global.unsafeAdd(context);
-
     if (supervisor !== Supervisor.none) {
       supervisor.unsafeOnStart(this.environment, io, Nothing(), context);
-
       context.unsafeOnDone((exit) => supervisor.unsafeOnEnd(exit.flatten, context));
     }
-
     context.nextIO = concrete(io);
     context.run();
     scheduler.flush();
-
     const result = context.unsafePoll();
-
     if (result.isJust()) {
       return result.value;
     }
-
     return Exit.halt(context);
   };
 }

package/_src/IO.ts

@@ -3,7 +3,6 @@ export * from "./IO/api.js";
 export * from "./IO/definition.js";
 export * from "./IO/runtime.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: IO/api/*.ts }
 export * from "./IO/api/acquireRelease.js";
 export * from "./IO/api/acquireReleaseExit.js";

package/_src/IOEnv/definition.ts

@@ -1,5 +1,3 @@
-import type { Patch } from "@fncts/base/data/Patch";
-
 import { Console } from "@fncts/io/Console";
 
 export type IOEnv = Clock | Console | Random;

package/_src/IOEnv/services.ts

@@ -1,10 +1,11 @@
-import type { Patch } from "@fncts/base/data/Patch";
+import type { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";
 
 import { environment } from "@fncts/io/IOEnv/definition";
 
 /**
  * @tsplus static fncts.io.IOEnvOps services
  */
-export const services: FiberRef.WithPatch<Environment<IOEnv>, Patch<IOEnv, IOEnv>> = FiberRef.unsafeMakeEnvironment(
-  environment,
-);
+export const services: FiberRef.WithPatch<
+  Environment<IOEnv>,
+  EnvironmentPatch<IOEnv, IOEnv>
+> = FiberRef.unsafeMakeEnvironment(environment);

package/_src/Layer/MemoMap.ts

@@ -35,13 +35,11 @@ export class MemoMap {
           const observers    = _(Ref.make(0));
           const future       = _(Future.make<E, Environment<A>>());
           const finalizerRef = _(Ref.make<Finalizer>(Finalizer.noop));
-
-          const resource = IO.uninterruptibleMask(({ restore }) =>
+          const resource     = IO.uninterruptibleMask(({ restore }) =>
             Do((_) => {
               const outerScope = scope;
               const innerScope = _(Scope.make);
-
-              const tp = _(
+              const tp         = _(
                 restore(layer.scope(innerScope).flatMap((f) => f(this))).result.flatMap((exit) =>
                   exit.match(
                     (cause) => future.failCause(cause) > innerScope.close(exit) > IO.failCauseNow(cause),
@@ -107,71 +105,71 @@ export function build<R, E, A>(self: Layer<R, E, A>, __tsplusTrace?: string): IO
 }
 
 /**
- * @tsplus fluent fncts.io.Layer build
+ * @tsplus pipeable fncts.io.Layer build
  */
-export function build_<R, E, A>(self: Layer<R, E, A>, scope: Scope, __tsplusTrace?: string): IO<R, E, Environment<A>> {
-  return Do((_) => {
-    const memoMap = _(makeMemoMap());
-    const run     = _(self.scope(scope));
-    return _(run(memoMap));
-  });
+export function build_(scope: Scope, __tsplusTrace?: string) {
+  return <R, E, A>(self: Layer<R, E, A>): IO<R, E, Environment<A>> => {
+    return Do((_) => {
+      const memoMap = _(makeMemoMap());
+      const run     = _(self.scope(scope));
+      return _(run(memoMap));
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Layer scope
+ * @tsplus pipeable fncts.io.Layer scope
  */
-export function scope<R, E, A>(
-  layer: Layer<R, E, A>,
-  scope: Scope,
-  __tsplusTrace?: string,
-): IO<never, never, (_: MemoMap) => IO<R, E, Environment<A>>> {
-  layer.concrete();
-  switch (layer._tag) {
-    case LayerTag.Fold: {
-      return IO.succeed(
-        () => (memoMap: MemoMap) =>
-          memoMap.getOrElseMemoize(scope, layer.self, layer.trace).matchCauseIO(
-            (cause) => memoMap.getOrElseMemoize(scope, layer.failure(cause), layer.trace),
-            (r) => memoMap.getOrElseMemoize(scope, layer.success(r)),
-            layer.trace,
-          ),
-      );
-    }
-    case LayerTag.Fresh: {
-      return IO.succeed(() => () => layer.self.build(scope, layer.trace));
-    }
-    case LayerTag.Scoped: {
-      return IO.succeed(() => () => scope.extend(layer.self, layer.trace));
-    }
-    case LayerTag.Defer: {
-      return IO.succeed(() => (memoMap: MemoMap) => memoMap.getOrElseMemoize(scope, layer.self(), layer.trace));
-    }
-    case LayerTag.To: {
-      return IO.succeed(
-        () => (memoMap: MemoMap) =>
-          memoMap
-            .getOrElseMemoize(scope, layer.self, layer.trace)
-            .flatMap(
-              (r) => memoMap.getOrElseMemoize(scope, layer.that, layer.trace).provideEnvironment(r),
+export function scope(scope: Scope, __tsplusTrace?: string) {
+  return <R, E, A>(layer: Layer<R, E, A>): IO<never, never, (_: MemoMap) => IO<R, E, Environment<A>>> => {
+    layer.concrete();
+    switch (layer._tag) {
+      case LayerTag.Fold: {
+        return IO.succeed(
+          () => (memoMap: MemoMap) =>
+            memoMap.getOrElseMemoize(scope, layer.self, layer.trace).matchCauseIO(
+              (cause) => memoMap.getOrElseMemoize(scope, layer.failure(cause), layer.trace),
+              (r) => memoMap.getOrElseMemoize(scope, layer.success(r)),
               layer.trace,
             ),
-      );
-    }
-    case LayerTag.ZipWith: {
-      return IO.succeed(
-        () => (memoMap: MemoMap) =>
-          memoMap
-            .getOrElseMemoize(scope, layer.self, layer.trace)
-            .zipWith(memoMap.getOrElseMemoize(scope, layer.that, layer.trace), layer.f, layer.trace),
-      );
-    }
-    case LayerTag.ZipWithC: {
-      return IO.succeed(
-        () => (memoMap: MemoMap) =>
-          memoMap
-            .getOrElseMemoize(scope, layer.self, layer.trace)
-            .zipWithC(memoMap.getOrElseMemoize(scope, layer.that, layer.trace), layer.f, layer.trace),
-      );
+        );
+      }
+      case LayerTag.Fresh: {
+        return IO.succeed(() => () => layer.self.build(scope, layer.trace));
+      }
+      case LayerTag.Scoped: {
+        return IO.succeed(() => () => scope.extend(layer.self, layer.trace));
+      }
+      case LayerTag.Defer: {
+        return IO.succeed(() => (memoMap: MemoMap) => memoMap.getOrElseMemoize(scope, layer.self(), layer.trace));
+      }
+      case LayerTag.To: {
+        return IO.succeed(
+          () => (memoMap: MemoMap) =>
+            memoMap
+              .getOrElseMemoize(scope, layer.self, layer.trace)
+              .flatMap(
+                (r) => memoMap.getOrElseMemoize(scope, layer.that, layer.trace).provideEnvironment(r),
+                layer.trace,
+              ),
+        );
+      }
+      case LayerTag.ZipWith: {
+        return IO.succeed(
+          () => (memoMap: MemoMap) =>
+            memoMap
+              .getOrElseMemoize(scope, layer.self, layer.trace)
+              .zipWith(memoMap.getOrElseMemoize(scope, layer.that, layer.trace), layer.f, layer.trace),
+        );
+      }
+      case LayerTag.ZipWithC: {
+        return IO.succeed(
+          () => (memoMap: MemoMap) =>
+            memoMap
+              .getOrElseMemoize(scope, layer.self, layer.trace)
+              .zipWithC(memoMap.getOrElseMemoize(scope, layer.that, layer.trace), layer.f, layer.trace),
+        );
+      }
     }
-  }
+  };
 }

package/_src/Layer/api.ts

@@ -5,14 +5,12 @@ import { Fold, Fresh, FromScoped, Layer, To, ZipWithC } from "@fncts/io/Layer/de
 import { DecisionTag } from "@fncts/io/Schedule";
 
 /**
- * @tsplus fluent fncts.io.Layer and
+ * @tsplus pipeable fncts.io.Layer and
  */
-export function and_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<RIn, E, ROut>,
-  that: Layer<RIn1, E1, ROut1>,
-  __tsplusTrace?: string,
-): Layer<RIn | RIn1, E | E1, ROut | ROut1> {
-  return new ZipWithC(self, that, (a, b) => a.union(b), __tsplusTrace);
+export function and<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string) {
+  return <RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1, E | E1, ROut | ROut1> => {
+    return new ZipWithC(self, that, (a, b) => a.union(b), __tsplusTrace);
+  };
 }
 
 /**
@@ -20,14 +18,12 @@ export function and_<RIn, E, ROut, RIn1, E1, ROut1>(
  * layer, resulting in a new layer with the inputs of this layer, and the
  * outputs of both layers.
  *
- * @tsplus fluent fncts.io.Layer andTo
+ * @tsplus pipeable fncts.io.Layer andTo
  */
-export function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<RIn, E, ROut>,
-  that: Layer<RIn1, E1, ROut1>,
-  __tsplusTrace?: string,
-): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1> {
-  return self.and(self.to(that));
+export function andTo<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string) {
+  return <RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1> => {
+    return self.and(self.to(that));
+  };
 }
 
 /**
@@ -35,47 +31,42 @@ export function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(
  * layer, resulting in a new layer with the inputs of this layer, and the
  * outputs of both layers.
  *
- * @tsplus fluent fncts.io.Layer andTo
+ * @tsplus pipeable fncts.io.Layer andTo
  */
-export function andUsing_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<RIn1, E1, ROut1>,
-  that: Layer<RIn, E, ROut>,
-  __tsplusTrace?: string,
-): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1> {
-  return that.and(that.to(self));
+export function andUsing<RIn, E, ROut>(that: Layer<RIn, E, ROut>, __tsplusTrace?: string) {
+  return <RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1> => {
+    return that.and(that.to(self));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Layer catchAll
+ * @tsplus pipeable fncts.io.Layer catchAll
  */
-export function catchAll_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<RIn, E, ROut>,
-  f: (e: E) => Layer<RIn1, E1, ROut1>,
-  __tsplusTrace?: string,
-): Layer<RIn | RIn1, E1, ROut | ROut1> {
-  return self.matchLayer(f, Layer.succeedEnvironmentNow);
+export function catchAll<E, RIn1, E1, ROut1>(f: (e: E) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string) {
+  return <RIn, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1, E1, ROut | ROut1> => {
+    return self.matchLayer(f, Layer.succeedEnvironmentNow);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Layer flatMap
+ * @tsplus pipeable fncts.io.Layer flatMap
  */
-export function flatMap_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<RIn, E, ROut>,
+export function flatMap<ROut, RIn1, E1, ROut1>(
   f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>,
   __tsplusTrace?: string,
-): Layer<RIn | RIn1, E | E1, ROut1> {
-  return self.matchLayer(Layer.failNow, f);
+) {
+  return <RIn, E>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1, E | E1, ROut1> => {
+    return self.matchLayer(Layer.failNow, f);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Layer compose
+ * @tsplus pipeable fncts.io.Layer compose
  */
-export function compose_<RIn, E, ROut, E1, ROut1>(
-  self: Layer<RIn, E, ROut>,
-  that: Layer<ROut, E1, ROut1>,
-  __tsplusTrace?: string,
-): Layer<RIn, E | E1, ROut1> {
-  return new To(self, that, __tsplusTrace);
+export function compose<ROut, E1, ROut1>(that: Layer<ROut, E1, ROut1>, __tsplusTrace?: string) {
+  return <RIn, E>(self: Layer<RIn, E, ROut>): Layer<RIn, E | E1, ROut1> => {
+    return new To(self, that, __tsplusTrace);
+  };
 }
 
 /**
@@ -194,49 +185,47 @@ export function haltNow(defect: unknown, __tsplusTrace?: string): Layer<never, n
 }
 
 /**
- * @tsplus fluent fncts.io.Layer matchCauseLayer
+ * @tsplus pipeable fncts.io.Layer matchCauseLayer
  */
-export function matchCauseLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
-  self: Layer<RIn, E, ROut>,
+export function matchCauseLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
   failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>,
   success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>,
   __tsplusTrace?: string,
-): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> {
-  return new Fold(self, failure, success, __tsplusTrace);
+) {
+  return <RIn>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> => {
+    return new Fold(self, failure, success, __tsplusTrace);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Layer matchLayer
+ * @tsplus pipeable fncts.io.Layer matchLayer
  */
-export function matchLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
-  self: Layer<RIn, E, ROut>,
+export function matchLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
   failure: (e: E) => Layer<RIn1, E1, ROut1>,
   success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>,
   __tsplusTrace?: string,
-): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> {
-  return self.matchCauseLayer((cause) => cause.failureOrCause.match(failure, Layer.failCauseNow), success);
+) {
+  return <RIn>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> => {
+    return self.matchCauseLayer((cause) => cause.failureOrCause.match(failure, Layer.failCauseNow), success);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Layer map
+ * @tsplus pipeable fncts.io.Layer map
  */
-export function map_<RIn, E, ROut, ROut1>(
-  self: Layer<RIn, E, ROut>,
-  f: (r: Environment<ROut>) => Environment<ROut1>,
-  __tsplusTrace?: string,
-): Layer<RIn, E, ROut1> {
-  return self.flatMap((a) => Layer.succeedEnvironmentNow(f(a)));
+export function map<ROut, ROut1>(f: (r: Environment<ROut>) => Environment<ROut1>, __tsplusTrace?: string) {
+  return <RIn, E>(self: Layer<RIn, E, ROut>): Layer<RIn, E, ROut1> => {
+    return self.flatMap((a) => Layer.succeedEnvironmentNow(f(a)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Layer mapError
+ * @tsplus pipeable fncts.io.Layer mapError
  */
-export function mapError_<RIn, E, ROut, E1>(
-  self: Layer<RIn, E, ROut>,
-  f: (e: E) => E1,
-  __tsplusTrace?: string,
-): Layer<RIn, E1, ROut> {
-  return self.catchAll((e) => Layer.failNow(f(e)));
+export function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string) {
+  return <RIn, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn, E1, ROut> => {
+    return self.catchAll((e) => Layer.failNow(f(e)));
+  };
 }
 
 /**
@@ -250,14 +239,12 @@ export function memoize<RIn, E, ROut>(
 }
 
 /**
- * @tsplus fluent fncts.io.Layer orElse
+ * @tsplus pipeable fncts.io.Layer orElse
  */
-export function orElse_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<RIn, E, ROut>,
-  that: Layer<RIn1, E1, ROut1>,
-  __tsplusTrace?: string,
-): Layer<RIn | RIn1, E | E1, ROut | ROut1> {
-  return self.catchAll(() => that);
+export function orElse<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string) {
+  return <RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1, E | E1, ROut | ROut1> => {
+    return self.catchAll(() => that);
+  };
 }
 
 /**
@@ -278,26 +265,34 @@ export function passthrough<RIn extends Spreadable, E, ROut extends Spreadable>(
 }
 
 /**
- * @tsplus fluent fncts.io.Layer retry
+ * @tsplus pipeable fncts.io.Layer retry
  */
-export function retry_<RIn, E, ROut, S, RIn1>(
-  self: Layer<RIn, E, ROut>,
-  schedule: Schedule.WithState<S, RIn1, E, any>,
-  __tsplusTrace?: string,
-): Layer<RIn | RIn1, E, ROut> {
-  const tag = Tag<{ readonly state: S }>("fncts.io.Layer.retryState");
-  return Layer.succeedNow({ state: schedule.initial }, tag).flatMap((environment) =>
-    retryLoop(self, schedule, environment.get(tag).state, tag),
-  );
+export function retry<E, S, RIn1>(schedule: Schedule.WithState<S, RIn1, E, any>, __tsplusTrace?: string) {
+  return <RIn, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1, E, ROut> => {
+    const tag = Tag<{
+      readonly state: S;
+    }>("fncts.io.Layer.retryState");
+    return Layer.succeedNow({ state: schedule.initial }, tag).flatMap((environment) =>
+      retryLoop(self, schedule, environment.get(tag).state, tag),
+    );
+  };
 }
 
 function retryUpdate<S, RIn, E, X>(
   schedule: Schedule.WithState<S, RIn, E, X>,
   e: E,
   s: S,
-  tag: Tag<{ readonly state: S }>,
+  tag: Tag<{
+    readonly state: S;
+  }>,
   __tsplusTrace?: string,
-): Layer<RIn, E, { readonly state: S }> {
+): Layer<
+  RIn,
+  E,
+  {
+    readonly state: S;
+  }
+> {
   return Layer.fromIO(
     Clock.currentTime.flatMap((now) =>
       schedule
@@ -316,7 +311,9 @@ function retryLoop<RIn, E, ROut, S, RIn1, X>(
   self: Layer<RIn, E, ROut>,
   schedule: Schedule.WithState<S, RIn1, E, X>,
   s: S,
-  tag: Tag<{ readonly state: S }>,
+  tag: Tag<{
+    readonly state: S;
+  }>,
   __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E, ROut> {
   return self.catchAll((e) =>
@@ -381,31 +378,25 @@ export function succeedNow<A>(resource: A, tag: Tag<A>, __tsplusTrace?: string):
 }
 
 /**
- * @tsplus fluent fncts.io.Layer to
+ * @tsplus pipeable fncts.io.Layer to
  */
-export function to_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<RIn, E, ROut>,
+export function to<RIn1, E1, ROut1>(
   that: Layer<RIn1, E1, ROut1>,
-): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
-export function to_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<RIn, E, ROut>,
-  that: Layer<ROut | RIn1, E1, ROut1>,
-  __tsplusTrace?: string,
-): Layer<RIn | RIn1, E | E1, ROut1> {
-  return new To(Layer(IO.environment<RIn1>(), __tsplusTrace).and(self), that);
+): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
+export function to<ROut, RIn1, E1, ROut1>(that: Layer<ROut | RIn1, E1, ROut1>, __tsplusTrace?: string) {
+  return <RIn, E>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1, E | E1, ROut1> => {
+    return new To(Layer(IO.environment<RIn1>(), __tsplusTrace).and(self), that);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Layer using
+ * @tsplus pipeable fncts.io.Layer using
  */
-export function using_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<RIn1, E1, ROut1>,
-  that: Layer<RIn, E, ROut>,
-): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
-export function using_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<ROut | RIn1, E1, ROut1>,
+export function using<RIn, E, ROut>(
   that: Layer<RIn, E, ROut>,
-  __tsplusTrace?: string,
-): Layer<RIn | RIn1, E | E1, ROut1> {
-  return new To(Layer(IO.environment<RIn1>(), __tsplusTrace).and(that), self);
+): <RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>) => Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
+export function using<RIn, E, ROut>(that: Layer<RIn, E, ROut>, __tsplusTrace?: string) {
+  return <RIn1, E1, ROut1>(self: Layer<ROut | RIn1, E1, ROut1>): Layer<RIn | RIn1, E | E1, ROut1> => {
+    return new To(Layer(IO.environment<RIn1>(), __tsplusTrace).and(that), self);
+  };
 }

package/_src/Layer/definition.ts

@@ -50,7 +50,6 @@ export class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extends Layer<
   ROut1 | ROut2
 > {
   readonly _tag = LayerTag.Fold;
-
   constructor(
     readonly self: Layer<RIn, E, ROut>,
     readonly failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>,