@fncts/io 0.0.13 → 0.0.14

package/_src/IO/api/bracketExit.ts

@@ -12,6 +12,7 @@ export function bracketExit_<R, E, A, E1, R1, A1, R2, E2>(
   acquire: Lazy<IO<R, E, A>>,
   use: (a: A) => IO<R1, E1, A1>,
   release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>,
+  __tsplusTrace?: string,
 ): IO<R | R1 | R2, E | E1 | E2, A1> {
   return IO.uninterruptibleMask(({ restore }) =>
     acquire().flatMap((a) =>

package/_src/IO/api/concurrency.ts

@@ -17,7 +17,10 @@ export const concurrency: UIO<Maybe<number>> = Concurrency.get;
  *
  * @tsplus static fncts.io.IOOps concurrencyWith
  */
-export function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>) => IO<R, E, A>): IO<R, E, A> {
+export function concurrencyWith<R, E, A>(
+  f: (concurrency: Maybe<number>) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return Concurrency.getWith(f);
 }
 
@@ -27,7 +30,7 @@ export function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>) => IO<R
  *
  * @tsplus fluent fncts.io.IO withConcurrency
  */
-export function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number): IO<R, E, A> {
+export function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number, __tsplusTrace?: string): IO<R, E, A> {
   return IO.defer(Concurrency.locally(Just(n))(ma));
 }
 
@@ -37,6 +40,6 @@ export function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number): IO<R, E,
  *
  * @tsplus getter fncts.io.IO withConcurrencyUnbounded
  */
-export function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>): IO<R, E, A> {
+export function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.defer(Concurrency.locally(Nothing())(ma));
 }

package/_src/IO/api/concurrentFinalizers.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.IO concurrentFinalizers
  */
-export function concurrentFinalizers<R, E, A>(io: IO<R, E, A>): IO<R | Scope, E, A> {
+export function concurrentFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, A> {
   return Do((Δ) => {
     const outerScope = Δ(IO.scope);
     const innerScope = Δ(Scope.concurrent);

package/_src/IO/api/consoleWith.ts

@@ -3,7 +3,7 @@ import { Console } from "@fncts/io/Console";
 /**
  * @tsplus static fncts.io.IOOps consoleWith
  */
-export function consoleWith<R, E, A>(f: (console: Console) => IO<R, E, A>): IO<R, E, A> {
+export function consoleWith<R, E, A>(f: (console: Console) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IOEnv.services.getWith((services) => f(services.get(Console.Tag)));
 }
 

package/_src/IO/api/ensuringChildren.ts

@@ -4,6 +4,7 @@
 export function ensuringChildren<R, E, A, R1>(
   self: IO<R, E, A>,
   children: (_: Conc<Fiber.Runtime<any, any>>) => IO<R1, never, void>,
+  __tsplusTrace?: string,
 ): IO<R | R1, E, A> {
   return Supervisor.track(true).flatMap((supervisor) =>
     self.supervised(supervisor).ensuring(supervisor.value.flatMap(children)),

package/_src/IO/api/environment.ts

@@ -108,7 +108,7 @@ export function service<T>(tag: Tag<T>, __tsplusTrace?: string): IO<T, never, T>
 /**
  * @tsplus static fncts.io.IOOps serviceWith
  */
-export function serviceWith<S, A>(f: (service: S) => A, tag: Tag<S>): IO<S, never, A> {
+export function serviceWith<S, A>(f: (service: S) => A, tag: Tag<S>, __tsplusTrace?: string): IO<S, never, A> {
   return IO.serviceWithIO((s) => IO.succeedNow(f(s)), tag);
 }
 

package/_src/IO/api/foreachC.ts

@@ -16,7 +16,11 @@ import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
  * @tsplus static fncts.io.IOOps foreachDiscardC
  * @tsplus fluent fncts.Iterable traverseIODiscardC
  */
-export function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void> {
+export function foreachDiscardC_<R, E, A>(
+  as: Iterable<A>,
+  f: (a: A) => IO<R, E, any>,
+  __tsplusTrace?: string,
+): IO<R, E, void> {
   return IO.concurrencyWith((conc) =>
     conc.match(
       () => foreachConcurrentUnboundedDiscard(as, f),
@@ -34,7 +38,11 @@ export function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E,
  * @tsplus static fncts.io.IOOps foreachC
  * @tsplus fluent fncts.Iterable traverseIOC
  */
-export function foreachC_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+export function foreachC_<R, E, A, B>(
+  as: Iterable<A>,
+  f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<B>> {
   return IO.concurrencyWith((conc) =>
     conc.match(
       () => foreachConcurrentUnbounded(as, f),
@@ -43,7 +51,11 @@ export function foreachC_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>)
   );
 }
 
-function foreachConcurrentUnboundedDiscard<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void> {
+function foreachConcurrentUnboundedDiscard<R, E, A>(
+  as: Iterable<A>,
+  f: (a: A) => IO<R, E, any>,
+  __tsplusTrace?: string,
+): IO<R, E, void> {
   return IO.defer(() => {
     const arr  = Array.from(as);
     const size = arr.length;
@@ -91,7 +103,11 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(as: Iterable<A>, f: (a: A) =
   });
 }
 
-function foreachConcurrentUnbounded<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+function foreachConcurrentUnbounded<R, E, A, B>(
+  as: Iterable<A>,
+  f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<B>> {
   return IO.succeed<B[]>([])
     .flatMap((array) =>
       foreachConcurrentUnboundedDiscard(as.zipWithIndex, ([n, a]) =>
@@ -105,7 +121,11 @@ function foreachConcurrentUnbounded<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO
     .map(Conc.from);
 }
 
-function foreachConcurrentBoundedDiscardWorker<R, E, A>(queue: Queue<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void> {
+function foreachConcurrentBoundedDiscardWorker<R, E, A>(
+  queue: Queue<A>,
+  f: (a: A) => IO<R, E, any>,
+  __tsplusTrace?: string,
+): IO<R, E, void> {
   return queue.poll.flatMap((ma) =>
     ma.match(
       () => IO.unit,
@@ -118,6 +138,7 @@ function foreachConcurrentBoundedDiscard<R, E, A>(
   as: Iterable<A>,
   n: number,
   f: (a: A) => IO<R, E, any>,
+  __tsplusTrace?: string,
 ): IO<R, E, void> {
   return IO.defer(() => {
     const size =
@@ -141,6 +162,7 @@ function foreachConcurrentBoundedWorker<R, E, A, B>(
   queue: Queue<readonly [number, A]>,
   array: Array<any>,
   f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
 ): IO<R, E, void> {
   return queue.poll.flatMap((ma) =>
     ma.match(
@@ -157,7 +179,12 @@ function foreachConcurrentBoundedWorker<R, E, A, B>(
   );
 }
 
-function foreachConcurrentBounded<R, E, A, B>(as: Iterable<A>, n: number, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+function foreachConcurrentBounded<R, E, A, B>(
+  as: Iterable<A>,
+  n: number,
+  f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<B>> {
   return IO.defer(() => {
     const size =
       "length" in as && typeof (as as Iterable<A> & { length: unknown })["length"] === "number"

package/_src/IO/api/foreachExec.ts

@@ -10,6 +10,7 @@ export function foreachExec_<R, E, A, B>(
   as: Iterable<A>,
   es: ExecutionStrategy,
   f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
 ): IO<R, E, Conc<B>> {
   return es.match(
     () => IO.foreach(as, f),

package/_src/IO/api/fulfill.ts

@@ -5,6 +5,6 @@
  *
  * @tsplus fluent fncts.io.IO fulfill
  */
-export function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>): IO<R, never, boolean> {
+export function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>, __tsplusTrace?: string): IO<R, never, boolean> {
   return IO.uninterruptibleMask(({ restore }) => restore(effect).result.flatMap((exit) => p.done(exit)));
 }

package/_src/IO/api/interrupt.ts

@@ -73,7 +73,10 @@ export function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: stri
  *
  * @tsplus static fncts.io.IOOps uninterruptibleMask
  */
-export function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A> {
+export function uninterruptibleMask<R, E, A>(
+  f: (restore: InterruptStatusRestore) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return IO.checkInterruptible((flag) => f(new InterruptStatusRestore(flag)).uninterruptible);
 }
 
@@ -84,7 +87,10 @@ export function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore
  *
  * @tsplus static fncts.io.IOOps interruptibleMask
  */
-export function interruptibleMask<R, E, A>(k: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A> {
+export function interruptibleMask<R, E, A>(
+  k: (restore: InterruptStatusRestore) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return IO.checkInterruptible((flag) => k(new InterruptStatusRestore(flag)).interruptible);
 }
 
@@ -97,6 +103,7 @@ export function interruptibleMask<R, E, A>(k: (restore: InterruptStatusRestore)
 export function onInterrupt_<R, E, A, R1>(
   ma: IO<R, E, A>,
   cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>,
+  __tsplusTrace?: string,
 ): IO<R | R1, E, A> {
   return uninterruptibleMask(({ restore }) =>
     restore(ma).matchCauseIO(
@@ -116,6 +123,7 @@ export function onInterrupt_<R, E, A, R1>(
 export function onInterruptExtended_<R, E, A, R2, E2>(
   self: IO<R, E, A>,
   cleanup: Lazy<IO<R2, E2, any>>,
+  __tsplusTrace?: string,
 ): IO<R | R2, E | E2, A> {
   return uninterruptibleMask(({ restore }) =>
     restore(self).matchCauseIO(

package/_src/IO/api/onExit.ts

@@ -4,6 +4,7 @@
 export function onExit_<R, E, A, R1, E1>(
   self: IO<R, E, A>,
   cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>,
+  __tsplusTrace?: string,
 ): IO<R | R1, E | E1, A> {
   return IO.unit.bracketExit(
     () => self,

package/_src/IO/api/onTermination.ts

@@ -4,7 +4,7 @@
 export function onTermination<R, E, A, R1>(
   self: Lazy<IO<R, E, A>>,
   cleanup: (cause: Cause<never>) => URIO<R1, any>,
-  __tsPlusTrace?: string,
+  __tsplusTrace?: string,
 ): IO<R | R1, E, A> {
   return IO.unit.bracketExit(
     () => self(),

package/_src/IO/api/provideLayer.ts

@@ -4,6 +4,7 @@
 export function provideLayer_<RIn, E, ROut, E1, A>(
   self: IO<ROut, E1, A>,
   layer: Layer<RIn, E, ROut>,
+  __tsplusTrace?: string,
 ): IO<RIn, E | E1, A> {
   return Scope.make.bracketExit(
     (scope) => layer.build(scope).flatMap((r) => self.provideEnvironment(r)),

package/_src/IO/api/provideSomeLayer.ts

@@ -17,6 +17,5 @@ export function provideSomeLayer_<R, E, A, RIn, E1, ROut>(
  * @tsplus static fncts.io.IOAspects provideSomeLayer
  */
 export function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R | ROut, E, A>): IO<R | RIn, E | E1, A> =>
-    self.provideSomeLayer(layer);
+  return <R, E, A>(self: IO<R | ROut, E, A>): IO<R | RIn, E | E1, A> => self.provideSomeLayer(layer);
 }

package/_src/IO/api/race.ts

@@ -1,4 +1,4 @@
-function maybeDisconnect<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+function maybeDisconnect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.uninterruptibleMask((restore) => restore.force(io));
 }
 
@@ -13,7 +13,11 @@ function maybeDisconnect<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
  *
  * @tsplus fluent fncts.io.IO race
  */
-export function race_<R, E, A, R1, E1, A1>(io: IO<R, E, A>, that: IO<R1, E1, A1>): IO<R | R1, E | E1, A | A1> {
+export function race_<R, E, A, R1, E1, A1>(
+  io: IO<R, E, A>,
+  that: IO<R1, E1, A1>,
+  __tsplusTrace?: string,
+): IO<R | R1, E | E1, A | A1> {
   return IO.descriptorWith((descriptor) =>
     maybeDisconnect(io).raceWith(
       maybeDisconnect(that),

package/_src/IO/api/raceFirst.ts

@@ -12,6 +12,10 @@
  *
  * @tsplus fluent fncts.io.IO raceFirst
  */
-export function raceFirst_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, that: IO<R1, E1, A1>): IO<R | R1, E | E1, A | A1> {
-  return ma.result.race(that.result).flatMap(IO.fromExitNow);
+export function raceFirst_<R, E, A, R1, E1, A1>(
+  ma: IO<R, E, A>,
+  that: IO<R1, E1, A1>,
+  __tsplusTrace?: string,
+): IO<R | R1, E | E1, A | A1> {
+  return ma.result.race(that.result).flatMap((exit) => IO.fromExitNow<E | E1, A | A1>(exit));
 }

package/_src/IO/api/randomWith.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus static fncts.io.IOOps randomWith
  */
-export function randomWith<R, E, A>(f: (random: Random) => IO<R, E, A>): IO<R, E, A> {
+export function randomWith<R, E, A>(f: (random: Random) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IOEnv.services.getWith((services) => f(services.get(Random.Tag)));
 }
 

package/_src/IO/api/repeat.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.IO repeat
  */
-export function repeat_<R, E, A>(self: IO<R, E, A>) {
+export function repeat_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, B>(schedule0: Lazy<Schedule<R1, A, B>>, __tsplusTrace?: string): IO<R | R1, E, B> =>
     self.repeatOrElse(schedule0, (e, _) => IO.fail(e));
 }
@@ -9,7 +9,7 @@ export function repeat_<R, E, A>(self: IO<R, E, A>) {
 /**
  * @tsplus getter fncts.io.IO repeatOrElse
  */
-export function repeatOrElse_<R, E, A>(self: IO<R, E, A>) {
+export function repeatOrElse_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, B, R2, E2>(
     schedule0: Lazy<Schedule<R1, A, B>>,
     orElse: (e: E, out: Maybe<B>) => IO<R2, E2, B>,
@@ -20,7 +20,7 @@ export function repeatOrElse_<R, E, A>(self: IO<R, E, A>) {
 /**
  * @tsplus getter fncts.io.IO repeatOrElseEither
  */
-export function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>) {
+export function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, B, R2, E2, C>(
     schedule0: Lazy<Schedule<R1, A, B>>,
     orElse: (e: E, out: Maybe<B>) => IO<R2, E2, C>,

package/_src/IO/api/retry.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.IO retry
  */
-export function retry<R, E, A>(self: IO<R, E, A>) {
+export function retry<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, O>(schedule0: Lazy<Schedule<R1, E, O>>, __tsplusTrace?: string): IO<R | R1, E, A> =>
     self.retryOrElse(schedule0, (e, _) => IO.fail(e));
 }
@@ -9,7 +9,7 @@ export function retry<R, E, A>(self: IO<R, E, A>) {
 /**
  * @tsplus getter fncts.io.IO retryOrElse
  */
-export function retryOrElse<R, E, A>(self: IO<R, E, A>) {
+export function retryOrElse<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, O, R2, E2>(
     schedule0: Lazy<Schedule<R1, E, O>>,
     orElse: (e: E, out: O) => IO<R2, E2, A>,
@@ -20,7 +20,7 @@ export function retryOrElse<R, E, A>(self: IO<R, E, A>) {
 /**
  * @tsplus getter fncts.io.IO retryOrElseEither
  */
-export function retryOrElseEither_<R, E, A>(self: IO<R, E, A>) {
+export function retryOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, O, R2, E2, B>(
     schedule0: Lazy<Schedule<R1, E, O>>,
     orElse: (e: E, out: O) => IO<R2, E2, B>,

package/_src/IO/api/schedule.ts

@@ -5,6 +5,7 @@ export function scheduleFrom<R, E, A extends A1, R1, A1, B>(
   self: IO<R, E, A>,
   a: Lazy<A>,
   schedule0: Lazy<Schedule<R1, A1, B>>,
+  __tsplusTrace?: string,
 ): IO<R | R1, E, B> {
   return IO.defer(() => {
     const schedule = schedule0();

package/_src/IO/api/scopeWith.ts

@@ -1,6 +1,6 @@
 /**
  * @tsplus static fncts.io.IOOps scopeWith
  */
-export function scopeWith<R, E, A>(f: (scope: Scope) => IO<R, E, A>): IO<R | Scope, E, A> {
+export function scopeWith<R, E, A>(f: (scope: Scope) => IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, A> {
   return IO.serviceWithIO(f, Scope.Tag);
 }

package/_src/IO/api/scoped.ts

@@ -1,13 +1,13 @@
 /**
  * @tsplus static fncts.io.IOOps scoped
  */
-export function scoped<R, E, A>(io: Lazy<IO<R, E, A>>): IO<Exclude<R, Scope>, E, A> {
+export function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A> {
   return Scope.make.flatMap((scope) => scope.use(io));
 }
 
 /**
  * @tsplus getter fncts.io.IO scoped
  */
-export function scoped_<R, E, A>(io: IO<R, E, A>): IO<Exclude<R, Scope>, E, A> {
+export function scoped_<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A> {
   return IO.scoped(io);
 }

package/_src/IO/api/timeout.ts

@@ -14,6 +14,10 @@ export function timeoutTo<R, E, A, B, B1>(
 /**
  * @tsplus fluent fncts.io.IO timeout
  */
-export function timeout<R, E, A>(self: IO<R, E, A>, duration: Lazy<Duration>): IO<R, E, Maybe<A>> {
+export function timeout<R, E, A>(
+  self: IO<R, E, A>,
+  duration: Lazy<Duration>,
+  __tsplusTrace?: string,
+): IO<R, E, Maybe<A>> {
   return self.timeoutTo(duration, Nothing(), Maybe.just);
 }

package/_src/IO/api/withEarlyRelease.ts

@@ -4,7 +4,10 @@
  *
  * @tsplus getter fncts.io.IO withEarlyRelease
  */
-export function withEarlyRelease<R, E, A>(self: IO<R, E, A>): IO<R | Scope, E, readonly [UIO<void>, A]> {
+export function withEarlyRelease<R, E, A>(
+  self: IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R | Scope, E, readonly [UIO<void>, A]> {
   return IO.scopeWith((parent) =>
     parent.fork.flatMap((child) =>
       child.extend(self).map((a) => [IO.fiberId.flatMap((fiberId) => child.close(Exit.interrupt(fiberId))), a]),

package/_src/IO/api/withFinalizer.ts

@@ -4,6 +4,7 @@
 export function withFinalizer_<R, E, A, R1>(
   self: IO<R, E, A>,
   finalizer: (a: A) => URIO<R1, any>,
+  __tsplusTrace?: string,
 ): IO<R | R1 | Scope, E, A> {
   return IO.acquireRelease(self, finalizer);
 }

package/_src/IO/api/withFinalizerExit.ts

@@ -4,6 +4,7 @@
 export function withFinalizerExit_<R, E, A, R1>(
   self: IO<R, E, A>,
   finalizer: (a: A, exit: Exit<any, any>) => URIO<R1, any>,
+  __tsplusTrace?: string,
 ): IO<R | R1 | Scope, E, A> {
   return IO.acquireReleaseExit(self, finalizer);
 }

package/_src/IO/api/withRuntimeConfig.ts

@@ -4,7 +4,11 @@
  *
  * @tsplus fluent fncts.io.IO withRuntimeConfig
  */
-export function withRuntimeConfig_<R, E, A>(self: IO<R, E, A>, runtimeConfig: Lazy<RuntimeConfig>): IO<R, E, A> {
+export function withRuntimeConfig_<R, E, A>(
+  self: IO<R, E, A>,
+  runtimeConfig: Lazy<RuntimeConfig>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return IO.runtimeConfig.flatMap((currentRuntimeConfig) =>
     IO.setRuntimeConfig(runtimeConfig)
       .apSecond(IO.yieldNow)

package/_src/IO/api/zipC.ts

@@ -4,7 +4,11 @@ import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 /**
  * @tsplus fluent fncts.io.IO zipC
  */
-export function zipC_<R, E, A, R1, E1, B>(self: IO<R, E, A>, that: IO<R1, E1, B>): IO<R | R1, E | E1, readonly [A, B]> {
+export function zipC_<R, E, A, R1, E1, B>(
+  self: IO<R, E, A>,
+  that: IO<R1, E1, B>,
+  __tsplusTrace?: string,
+): IO<R | R1, E | E1, readonly [A, B]> {
   return self.zipWithC(that, tuple);
 }
 
@@ -15,6 +19,7 @@ export function zipWithC_<R, E, A, R1, E1, B, C>(
   self: IO<R, E, A>,
   that: IO<R1, E1, B>,
   f: (a: A, b: B) => C,
+  __tsplusTrace?: string,
 ): IO<R | R1, E | E1, C> {
   return IO.descriptorWith((descriptor) =>
     IO.uninterruptibleMask(({ restore }) => {