@fncts/io 0.0.12 → 0.0.15

package/_src/Layer/api.ts

@@ -10,8 +10,9 @@ import { DecisionTag } from "@fncts/io/Schedule";
 export function and_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   that: Layer<RIn1, E1, ROut1>,
-): Layer<RIn & RIn1, E | E1, ROut & ROut1> {
-  return new ZipWithC(self, that, (a, b) => a.union(b));
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1, E | E1, ROut | ROut1> {
+  return new ZipWithC(self, that, (a, b) => a.union(b), __tsplusTrace);
 }
 
 /**
@@ -24,7 +25,8 @@ export function and_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   that: Layer<RIn1, E1, ROut1>,
-): Layer<RIn & Erase<ROut & RIn1, ROut>, E | E1, ROut & ROut1> {
+  __tsplusTrace?: string,
+): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1> {
   return self.and(self.to(that));
 }
 
@@ -38,7 +40,8 @@ export function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function andUsing_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn1, E1, ROut1>,
   that: Layer<RIn, E, ROut>,
-): Layer<RIn & Erase<ROut & RIn1, ROut>, E | E1, ROut & ROut1> {
+  __tsplusTrace?: string,
+): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1> {
   return that.and(that.to(self));
 }
 
@@ -48,7 +51,8 @@ export function andUsing_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function catchAll_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   f: (e: E) => Layer<RIn1, E1, ROut1>,
-): Layer<RIn & RIn1, E1, ROut | ROut1> {
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1, E1, ROut | ROut1> {
   return self.matchLayer(f, Layer.succeedEnvironmentNow);
 }
 
@@ -58,7 +62,8 @@ export function catchAll_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function flatMap_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>,
-): Layer<RIn & RIn1, E | E1, ROut1> {
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1, E | E1, ROut1> {
   return self.matchLayer(Layer.failNow, f);
 }
 
@@ -68,42 +73,43 @@ export function flatMap_<RIn, E, ROut, RIn1, E1, ROut1>(
 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);
+  return new To(self, that, __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps environment
  */
-export function environment<RIn>(): Layer<RIn, never, RIn> {
+export function environment<RIn>(__tsplusTrace?: string): Layer<RIn, never, RIn> {
   return Layer(IO.environment<RIn>());
 }
 
 /**
  * @tsplus static fncts.io.LayerOps fail
  */
-export function fail<E>(e: Lazy<E>): Layer<unknown, E, never> {
+export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Layer<never, E, never> {
   return Layer(IO.fail(e));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps failCause
  */
-export function failCause<E>(cause: Lazy<Cause<E>>): Layer<unknown, E, never> {
+export function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Layer<never, E, never> {
   return Layer(IO.failCause(cause));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps failCauseNow
  */
-export function failCauseNow<E>(cause: Cause<E>): Layer<unknown, E, never> {
+export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Layer<never, E, never> {
   return Layer(IO.failCauseNow(cause));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps failNow
  */
-export function failNow<E>(e: E): Layer<unknown, E, never> {
+export function failNow<E>(e: E, __tsplusTrace?: string): Layer<never, E, never> {
   return Layer(IO.failNow(e));
 }
 
@@ -111,16 +117,17 @@ export function failNow<E>(e: E): Layer<unknown, E, never> {
  * @tsplus getter fncts.io.Layer flatten
  */
 export function flatten<RIn, E, RIn1, E1, ROut>(
-  self: Layer<RIn, E, Has<Layer<RIn1, E1, ROut>>>,
+  self: Layer<RIn, E, Layer<RIn1, E1, ROut>>,
   tag: Tag<Layer<RIn1, E1, ROut>>,
-): Layer<RIn & RIn1, E | E1, ROut> {
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1, E | E1, ROut> {
   return self.flatMap((environment) => environment.get(tag));
 }
 
 /**
  * @tsplus getter fncts.io.Layer fresh
  */
-export function fresh<R, E, A>(self: Layer<R, E, A>): Layer<R, E, A> {
+export function fresh<R, E, A>(self: Layer<R, E, A>, __tsplusTrace?: string): Layer<R, E, A> {
   return new Fresh(self);
 }
 
@@ -131,7 +138,8 @@ export function fromFunction<R, A>(
   f: (r: R) => A,
   /** @tsplus implicit local */ tagR: Tag<R>,
   /** @tsplus implicit local */ tagA: Tag<A>,
-): Layer<Has<R>, never, Has<A>> {
+  __tsplusTrace?: string,
+): Layer<R, never, A> {
   return Layer.fromIOEnvironment(IO.serviceWith((service) => Environment.empty.add(f(service), Derive()), Derive()));
 }
 
@@ -142,7 +150,8 @@ export function fromFunctionIO<R, E, A, R1>(
   f: (r: R) => IO<R1, E, A>,
   tagR: Tag<R>,
   tagA: Tag<A>,
-): Layer<R1 & Has<R>, E, Has<A>> {
+  __tsplusTrace?: string,
+): Layer<R1 | R, E, A> {
   return Layer.fromIOEnvironment(
     IO.serviceWithIO((service) => f(service).map((a) => Environment.empty.add(a, tagA)), tagR),
   );
@@ -153,34 +162,34 @@ export function fromFunctionIO<R, E, A, R1>(
  * @tsplus static fncts.io.LayerOps __call
  */
 export function fromIOEnvironment<R, E, A>(io: IO<R, E, Environment<A>>, __tsplusTrace?: string): Layer<R, E, A> {
-  return new FromScoped(io);
+  return new FromScoped(io, __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps fromIO
  */
-export function fromIO<R, E, A>(resource: IO<R, E, A>, tag: Tag<A>): Layer<R, E, Has<A>> {
+export function fromIO<R, E, A>(resource: IO<R, E, A>, tag: Tag<A>, __tsplusTrace?: string): Layer<R, E, A> {
   return Layer.fromIOEnvironment(resource.map((a) => Environment().add(a, tag)));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps fromValue
  */
-export function fromValue<A>(value: Lazy<A>, tag: Tag<A>): Layer<unknown, never, Has<A>> {
+export function fromValue<A>(value: Lazy<A>, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIO(IO.succeed(value), tag);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps halt
  */
-export function halt(defect: Lazy<unknown>): Layer<unknown, never, never> {
+export function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Layer<never, never, never> {
   return Layer(IO.halt(defect));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps haltNow
  */
-export function haltNow(defect: unknown): Layer<unknown, never, never> {
+export function haltNow(defect: unknown, __tsplusTrace?: string): Layer<never, never, never> {
   return Layer(IO.haltNow(defect));
 }
 
@@ -191,8 +200,9 @@ export function matchCauseLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>
   self: Layer<RIn, E, ROut>,
   failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>,
   success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>,
-): Layer<RIn & RIn1 & RIn2, E1 | E2, ROut1 | ROut2> {
-  return new Fold(self, failure, success);
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> {
+  return new Fold(self, failure, success, __tsplusTrace);
 }
 
 /**
@@ -202,7 +212,8 @@ export function matchLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
   self: Layer<RIn, E, ROut>,
   failure: (e: E) => Layer<RIn1, E1, ROut1>,
   success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>,
-): Layer<RIn & RIn1 & RIn2, E1 | E2, ROut1 | ROut2> {
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> {
   return self.matchCauseLayer((cause) => cause.failureOrCause.match(failure, Layer.failCauseNow), success);
 }
 
@@ -212,6 +223,7 @@ export function matchLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
 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)));
 }
@@ -219,14 +231,21 @@ export function map_<RIn, E, ROut, ROut1>(
 /**
  * @tsplus fluent fncts.io.Layer mapError
  */
-export function mapError_<RIn, E, ROut, E1>(self: Layer<RIn, E, ROut>, f: (e: E) => E1): Layer<RIn, E1, ROut> {
+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)));
 }
 
 /**
  * @tsplus getter fncts.io.Layer memoize
  */
-export function memoize<RIn, E, ROut>(self: Layer<RIn, E, ROut>): URIO<Has<Scope>, Layer<RIn, E, ROut>> {
+export function memoize<RIn, E, ROut>(
+  self: Layer<RIn, E, ROut>,
+  __tsplusTrace?: string,
+): URIO<Scope, Layer<RIn, E, ROut>> {
   return IO.serviceWithIO((scope: Scope) => self.build(scope), Scope.Tag).memoize.map((_) => new FromScoped(_));
 }
 
@@ -236,14 +255,15 @@ export function memoize<RIn, E, ROut>(self: Layer<RIn, E, ROut>): URIO<Has<Scope
 export function orElse_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   that: Layer<RIn1, E1, ROut1>,
-): Layer<RIn & RIn1, E | E1, ROut | ROut1> {
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1, E | E1, ROut | ROut1> {
   return self.catchAll(() => that);
 }
 
 /**
  * @tsplus getter fncts.io.Layer orHalt
  */
-export function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn, never, ROut> {
+export function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>, __tsplusTrace?: string): Layer<RIn, never, ROut> {
   return self.catchAll(Layer.haltNow);
 }
 
@@ -252,6 +272,7 @@ export function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn, neve
  */
 export function passthrough<RIn extends Spreadable, E, ROut extends Spreadable>(
   self: Layer<RIn, E, ROut>,
+  __tsplusTrace?: string,
 ): Layer<RIn, E, RIn & ROut> {
   return Layer.environment<RIn>().and(self);
 }
@@ -262,7 +283,8 @@ export function passthrough<RIn extends Spreadable, E, ROut extends Spreadable>(
 export function retry_<RIn, E, ROut, S, RIn1>(
   self: Layer<RIn, E, ROut>,
   schedule: Schedule.WithState<S, RIn1, E, any>,
-): Layer<RIn & RIn1, E, ROut> {
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1, E, ROut> {
   const tag = Tag<{ readonly state: S }>();
   return Layer.succeedNow({ state: schedule.initial }, tag).flatMap((environment) =>
     retryLoop(self, schedule, environment.get(tag).state, tag),
@@ -274,7 +296,8 @@ function retryUpdate<S, RIn, E, X>(
   e: E,
   s: S,
   tag: Tag<{ readonly state: S }>,
-): Layer<RIn, E, Has<{ readonly state: S }>> {
+  __tsplusTrace?: string,
+): Layer<RIn, E, { readonly state: S }> {
   return Layer.fromIO(
     Clock.currentTime.flatMap((now) =>
       schedule
@@ -282,7 +305,7 @@ function retryUpdate<S, RIn, E, X>(
         .flatMap(([state, _, decision]) =>
           decision._tag === DecisionTag.Done
             ? IO.failNow(e)
-            : Clock.sleep(Duration.fromInterval(now, decision.interval.startMilliseconds)).as({ state }),
+            : Clock.sleep(Duration.fromInterval(now, decision.interval.start)).as({ state }),
         ),
     ),
     tag,
@@ -294,7 +317,8 @@ function retryLoop<RIn, E, ROut, S, RIn1, X>(
   schedule: Schedule.WithState<S, RIn1, E, X>,
   s: S,
   tag: Tag<{ readonly state: S }>,
-): Layer<RIn & RIn1, E, ROut> {
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1, E, ROut> {
   return self.catchAll((e) =>
     retryUpdate(schedule, e, s, tag).flatMap((env) => retryLoop(self, schedule, env.get(tag).state, tag).fresh),
   );
@@ -303,49 +327,56 @@ function retryLoop<RIn, E, ROut, S, RIn1, X>(
 /**
  * @tsplus static fncts.io.LayerOps scoped
  */
-export function scoped<R, E, A>(io: Lazy<IO<R & Has<Scope>, E, A>>, tag: Tag<A>): Layer<R, E, Has<A>> {
+export function scoped<R, E, A>(
+  io: Lazy<IO<R, E, A>>,
+  tag: Tag<A>,
+  __tsplusTrace?: string,
+): Layer<Exclude<R, Scope>, E, A> {
   return Layer.scopedEnvironment(io().map((a) => Environment.empty.add(a, tag)));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps scopedEnvironment
  */
-export function scopedEnvironment<R, E, A>(io: Lazy<IO<R & Has<Scope>, E, Environment<A>>>): Layer<R, E, A> {
-  return new FromScoped(IO.defer(io));
+export function scopedEnvironment<R, E, A>(
+  io: Lazy<IO<R, E, Environment<A>>>,
+  __tsplusTrace?: string,
+): Layer<Exclude<R, Scope>, E, A> {
+  return new FromScoped(IO.defer(io), __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps service
  */
-export function service<A>(tag: Tag<A>): Layer<Has<A>, never, Has<A>> {
+export function service<A>(tag: Tag<A>, __tsplusTrace?: string): Layer<A, never, A> {
   return Layer.fromIO(IO.service(tag), tag);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps succeed
  */
-export function succeed<A>(resource: Lazy<A>, tag: Tag<A>): Layer<unknown, never, Has<A>> {
+export function succeed<A>(resource: Lazy<A>, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIOEnvironment(IO.succeed(Environment.empty.add(resource(), tag)));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps succeedEnvironment
  */
-export function succeedEnvironment<A>(a: Lazy<Environment<A>>): Layer<unknown, never, A> {
+export function succeedEnvironment<A>(a: Lazy<Environment<A>>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIOEnvironment(IO.succeed(a));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps succeedEnvironmentNow
  */
-export function succeedEnvironmentNow<A>(a: Environment<A>): Layer<unknown, never, A> {
+export function succeedEnvironmentNow<A>(a: Environment<A>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIOEnvironment(IO.succeedNow(a));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps succeedNow
  */
-export function succeedNow<A>(resource: A, tag: Tag<A>): Layer<unknown, never, Has<A>> {
+export function succeedNow<A>(resource: A, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIOEnvironment(IO.succeedNow(Environment.empty.add(resource, tag)));
 }
 
@@ -355,12 +386,13 @@ export function succeedNow<A>(resource: A, tag: Tag<A>): Layer<unknown, never, H
 export function to_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   that: Layer<RIn1, E1, ROut1>,
-): Layer<RIn & Erase<RIn1, ROut>, E | 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>,
-): Layer<RIn & RIn1, E | E1, ROut1> {
-  return new To(Layer(IO.environment<RIn1>()).and(self), that);
+  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);
 }
 
 /**
@@ -369,10 +401,11 @@ export function to_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function using_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn1, E1, ROut1>,
   that: Layer<RIn, E, ROut>,
-): Layer<RIn & Erase<RIn1, ROut>, E | E1, ROut1>;
+): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
 export function using_<RIn, E, ROut, RIn1, E1, ROut1>(
-  self: Layer<ROut & RIn1, E1, ROut1>,
+  self: Layer<ROut | RIn1, E1, ROut1>,
   that: Layer<RIn, E, ROut>,
-): Layer<RIn & RIn1, E | E1, ROut1> {
-  return new To(Layer(IO.environment<RIn1>()).and(that), self);
+  __tsplusTrace?: string,
+): Layer<RIn | RIn1, E | E1, ROut1> {
+  return new To(Layer(IO.environment<RIn1>(), __tsplusTrace).and(that), self);
 }

package/_src/Layer/definition.ts

@@ -6,7 +6,7 @@ export type LayerHash = typeof LayerHash;
  * @tsplus companion fncts.io.LayerOps
  */
 export abstract class Layer<RIn, E, ROut> {
-  readonly _R!: (_: RIn) => void;
+  readonly _R!: () => RIn;
   readonly _E!: () => E;
   readonly _A!: () => ROut;
 
@@ -55,6 +55,7 @@ export class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extends Layer<
     readonly self: Layer<RIn, E, ROut>,
     readonly failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>,
     readonly success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>,
+    readonly trace?: string,
   ) {
     super();
   }
@@ -62,49 +63,51 @@ export class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extends Layer<
 
 export class Fresh<RIn, E, ROut> extends Layer<RIn, E, ROut> {
   readonly _tag = LayerTag.Fresh;
-  constructor(readonly self: Layer<RIn, E, ROut>) {
+  constructor(readonly self: Layer<RIn, E, ROut>, readonly trace?: string) {
     super();
   }
 }
 
-export class FromScoped<RIn, E, ROut> extends Layer<RIn, E, ROut> {
+export class FromScoped<RIn, E, ROut> extends Layer<Exclude<RIn, Scope>, E, ROut> {
   readonly _tag = LayerTag.Scoped;
-  constructor(readonly self: IO<RIn & Has<Scope>, E, Environment<ROut>>) {
+  constructor(readonly self: IO<RIn, E, Environment<ROut>>, readonly trace?: string) {
     super();
   }
 }
 
 export class Defer<RIn, E, ROut> extends Layer<RIn, E, ROut> {
   readonly _tag = LayerTag.Defer;
-  constructor(readonly self: () => Layer<RIn, E, ROut>) {
+  constructor(readonly self: () => Layer<RIn, E, ROut>, readonly trace?: string) {
     super();
   }
 }
 
 export class To<RIn, E, ROut, E1, ROut1> extends Layer<RIn, E | E1, ROut1> {
   readonly _tag = LayerTag.To;
-  constructor(readonly self: Layer<RIn, E, ROut>, readonly that: Layer<ROut, E1, ROut1>) {
+  constructor(readonly self: Layer<RIn, E, ROut>, readonly that: Layer<ROut, E1, ROut1>, readonly trace?: string) {
     super();
   }
 }
 
-export class ZipWith<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn & RIn1, E | E1, ROut2> {
+export class ZipWith<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | RIn1, E | E1, ROut2> {
   readonly _tag = LayerTag.ZipWith;
   constructor(
     readonly self: Layer<RIn, E, ROut>,
     readonly that: Layer<RIn1, E1, ROut1>,
     readonly f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>,
+    readonly trace?: string,
   ) {
     super();
   }
 }
 
-export class ZipWithC<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn & RIn1, E | E1, ROut2> {
+export class ZipWithC<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | RIn1, E | E1, ROut2> {
   readonly _tag = LayerTag.ZipWithC;
   constructor(
     readonly self: Layer<RIn, E, ROut>,
     readonly that: Layer<RIn1, E1, ROut1>,
     readonly f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>,
+    readonly trace?: string,
   ) {
     super();
   }

package/_src/Queue/api/dimapIO.ts

@@ -1,8 +1,8 @@
 import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
 
 class DimapIO<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D> extends QueueInternal<
-  RC & RA,
-  RD & RB,
+  RC | RA,
+  RD | RB,
   EC | EA,
   ED | EB,
   C,
@@ -22,11 +22,11 @@ class DimapIO<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D> extends QueueInternal<
 
   isShutdown: UIO<boolean> = this.queue.isShutdown;
 
-  offer(c: C): IO<RC & RA, EA | EC, boolean> {
+  offer(c: C): IO<RC | RA, EA | EC, boolean> {
     return this.f(c).flatMap((a) => this.queue.offer(a));
   }
 
-  offerAll(cs: Iterable<C>): IO<RC & RA, EC | EA, boolean> {
+  offerAll(cs: Iterable<C>): IO<RC | RA, EC | EA, boolean> {
     return IO.foreach(cs, this.f).flatMap((as) => this.queue.offerAll(as));
   }
 
@@ -34,11 +34,11 @@ class DimapIO<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D> extends QueueInternal<
 
   size: UIO<number> = this.queue.size;
 
-  take: IO<RD & RB, ED | EB, D> = this.queue.take.flatMap(this.g);
+  take: IO<RD | RB, ED | EB, D> = this.queue.take.flatMap(this.g);
 
-  takeAll: IO<RD & RB, ED | EB, Conc<D>> = this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.g));
+  takeAll: IO<RD | RB, ED | EB, Conc<D>> = this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.g));
 
-  takeUpTo(n: number): IO<RD & RB, ED | EB, Conc<D>> {
+  takeUpTo(n: number): IO<RD | RB, ED | EB, Conc<D>> {
     return this.queue.takeUpTo(n).flatMap((bs) => IO.foreach(bs, this.g));
   }
 }
@@ -49,7 +49,12 @@ class DimapIO<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D> extends QueueInternal<
  *
  * @tsplus fluent fncts.io.Queue dimap
  */
-export function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A, g: (b: B) => D) {
+export function dimap_<RA, RB, EA, EB, A, B, C, D>(
+  self: PQueue<RA, RB, EA, EB, A, B>,
+  f: (c: C) => A,
+  g: (b: B) => D,
+  __tsplusTrace?: string,
+) {
   return self.dimapIO(
     (c: C) => IO.succeedNow(f(c)),
     (b) => IO.succeedNow(g(b)),
@@ -66,7 +71,8 @@ export function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
   g: (b: B) => IO<RD, ED, D>,
-): PQueue<RC & RA, RD & RB, EC | EA, ED | EB, C, D> {
+  __tsplusTrace?: string,
+): PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D> {
   concrete(queue);
   return new DimapIO(queue, f, g);
 }
@@ -79,7 +85,8 @@ export function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(
 export function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
-): PQueue<RA & RC, RB, EA | EC, EB, C, B> {
+  __tsplusTrace?: string,
+): PQueue<RA | RC, RB, EA | EC, EB, C, B> {
   return queue.dimapIO(f, IO.succeedNow);
 }
 
@@ -91,6 +98,7 @@ export function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
 export function contramap_<RA, RB, EA, EB, A, B, C>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (c: C) => A,
+  __tsplusTrace?: string,
 ): PQueue<RA, RB, EA, EB, C, B> {
   return queue.contramapIO((c) => IO.succeedNow(f(c)));
 }
@@ -103,7 +111,8 @@ export function contramap_<RA, RB, EA, EB, A, B, C>(
 export function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (b: B) => IO<R2, E2, C>,
-): PQueue<RA, R2 & RB, EA, EB | E2, A, C> {
+  __tsplusTrace?: string,
+): PQueue<RA, R2 | RB, EA, EB | E2, A, C> {
   return queue.dimapIO(IO.succeedNow, f);
 }
 
@@ -115,6 +124,7 @@ export function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(
 export function map_<RA, RB, EA, EB, A, B, C>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (b: B) => C,
+  __tsplusTrace?: string,
 ): PQueue<RA, RB, EA, EB, A, C> {
   return queue.mapIO((b) => IO.succeedNow(f(b)));
 }

package/_src/Queue/api/filterInputIO.ts

@@ -1,7 +1,7 @@
 import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
 
 export class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<
-  RA & R2,
+  RA | R2,
   RB,
   EA | E2,
   EB,
@@ -18,11 +18,11 @@ export class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends Q
 
   isShutdown: UIO<boolean> = this.queue.isShutdown;
 
-  offer(a: A1): IO<RA & R2, EA | E2, boolean> {
+  offer(a: A1): IO<RA | R2, EA | E2, boolean> {
     return this.f(a).flatMap((b) => (b ? this.queue.offer(a) : IO.succeedNow(false)));
   }
 
-  offerAll(as: Iterable<A1>): IO<RA & R2, EA | E2, boolean> {
+  offerAll(as: Iterable<A1>): IO<RA | R2, EA | E2, boolean> {
     return IO.foreach(as, (a) => this.f(a).map((b) => (b ? Just(a) : Nothing()))).flatMap((ms) => {
       const filtered = ms.compact;
       if (filtered.isEmpty) {
@@ -54,7 +54,8 @@ export class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends Q
 export function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (_: A1) => IO<R2, E2, boolean>,
-): PQueue<RA & R2, RB, EA | E2, EB, A1, B> {
+  __tsplusTrace?: string,
+): PQueue<RA | R2, RB, EA | E2, EB, A1, B> {
   concrete(queue);
   return new FilterInputIO(queue, f);
 }
@@ -68,6 +69,7 @@ export function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(
 export function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (_: A1) => boolean,
+  __tsplusTrace?: string,
 ): PQueue<RA, RB, EA, EB, A1, B> {
   return queue.filterInputIO((a) => IO.succeedNow(f(a)));
 }

package/_src/Queue/api/filterOutputIO.ts

@@ -1,6 +1,6 @@
 import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
 
-export class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB & RB1, EA, EB | EB1, A, B> {
+export class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
   constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {
     super();
   }
@@ -23,13 +23,13 @@ export class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInterna
 
   size: UIO<number> = this.queue.size;
 
-  take: IO<RB & RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
+  take: IO<RB | RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
     this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)),
   );
 
-  takeAll: IO<RB & RB1, EB | EB1, Conc<B>> = this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
+  takeAll: IO<RB | RB1, EB | EB1, Conc<B>> = this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
 
-  loop(max: number, acc: Conc<B>): IO<RB & RB1, EB | EB1, Conc<B>> {
+  loop(max: number, acc: Conc<B>): IO<RB | RB1, EB | EB1, Conc<B>> {
     return this.queue.takeUpTo(max).flatMap((bs) => {
       if (bs.isEmpty) {
         return IO.succeedNow(acc);
@@ -47,7 +47,7 @@ export class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInterna
     });
   }
 
-  takeUpTo(n: number): IO<RB & RB1, EB | EB1, Conc<B>> {
+  takeUpTo(n: number): IO<RB | RB1, EB | EB1, Conc<B>> {
     return IO.defer(this.loop(n, Conc.empty()));
   }
 }
@@ -58,7 +58,8 @@ export class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInterna
 export function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (b: B) => IO<RB1, EB1, boolean>,
-): PQueue<RA, RB & RB1, EA, EB | EB1, A, B> {
+  __tsplusTrace?: string,
+): PQueue<RA, RB | RB1, EA, EB | EB1, A, B> {
   concrete(queue);
   return new FilterOutputIO(queue, f);
 }
@@ -69,6 +70,7 @@ export function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(
 export function filterOutput_<RA, RB, EA, EB, A, B>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   p: Predicate<B>,
+  __tsplusTrace?: string,
 ): PQueue<RA, RB, EA, EB, A, B> {
   return queue.filterOutputIO((b) => IO.succeedNow(p(b)));
 }