@fncts/io 0.0.49 → 0.0.51

package/_src/Push/definition.ts

@@ -1,53 +1,246 @@
+import type { Sink as Sink_, UnsafeSink, UnsafeSink as UnsafeSink_ } from "./Sink.js";
+import type { FlattenStrategy } from "@fncts/io/Push/FlattenStrategy";
+import type { IOProducer } from "@fncts/io/Push/Producer/IOProducer";
+
+import { type SyncProducer } from "@fncts/io/Push/Producer/SyncProducer";
+
+import { Sink } from "./Sink.js";
+
 export const PushVariance = Symbol.for("fncts.io.Push.Variance");
 export type PushVariance = typeof PushVariance;
 
 export const PushTypeId = Symbol.for("fncts.io.Push");
 export type PushTypeId = typeof PushTypeId;
 
+export const enum PushTag {
+  Defer,
+  ProducerSync,
+  ProducerIO,
+  FailCause,
+  OnSuccess,
+  OnSuccessWithStrategy,
+  OnSuccessAndFailure,
+  External,
+  FromPush,
+  Transform,
+}
+
 /**
  * @tsplus type fncts.io.Push
  * @tsplus companion fncts.io.PushOps
  */
-export class Push<R, E, A> {
-  readonly [PushTypeId]: PushTypeId = PushTypeId;
+export abstract class Push<R, E, A> {
+  readonly [PushTypeId]: PushTypeId    = PushTypeId;
+  readonly _pushOpCode: PushTag | null = null;
+
   declare [PushVariance]: {
     readonly _R: (_: never) => R;
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => A;
   };
-  constructor(readonly run: <R1>(emitter: Sink<R1, E, A>) => IO<R | R1, never, unknown>) {}
+
+  constructor() {
+    this.run = this.run.bind(this);
+  }
+
+  run<R1>(sink: UnsafeSink<R1, E, A>): IO<R | R1, never, void> {
+    return this.unsafeRun(sink);
+  }
 }
 
 export declare namespace Push {
+  export type Run<R, E, A> = <R1>(emitter: UnsafeSink<R1, E, A>) => IO<R | R1, never, unknown>;
   export type EnvironmentOf<X> = [X] extends [{ [PushVariance]: { readonly _R: (_: never) => infer R } }] ? R : never;
   export type ErrorOf<X> = [X] extends [{ [PushVariance]: { readonly _E: (_: never) => infer E } }] ? E : never;
   export type ValueOf<X> = [X] extends [{ [PushVariance]: { readonly _A: (_: never) => infer A } }] ? A : never;
+  export type Sink<Env, R, E, A> = Sink_<Env, R, E, A>;
+  export type UnsafeSink<R, E, A> = UnsafeSink_<R, E, A>;
 }
 
 /**
- * @tsplus type fncts.io.Push.Sink
- * @tsplus companion fncts.io.Push.SinkOps
+ * @tsplus pipeable fncts.io.Push unsafeRun
  */
-export class Sink<R, E, A> {
-  constructor(
-    readonly event: (value: A) => IO<R, never, void>,
-    readonly error: (cause: Cause<E>) => IO<R, never, void>,
-  ) {}
+export function unsafeRun<E, A, R1>(sink: UnsafeSink<R1, E, A>) {
+  return <R>(push: Push<R, E, A>): IO<R | R1, never, void> => unsafeRunPush(push, sink);
 }
 
-/**
- * @tsplus static fncts.io.PushOps __call
- */
-export function makePush<R, E, A>(run: <R1>(sink: Sink<R1, E, A>) => IO<R | R1, never, unknown>): Push<R, E, A> {
-  return new Push(run);
+export type PushOp<Tag extends string | number | null, Body = {}> = Push<never, any, any> &
+  Body & {
+    readonly _pushOpCode: Tag;
+  };
+
+export class PushPrimitive extends Push<never, any, any> {
+  public i0: any                   = undefined;
+  public i1: any                   = undefined;
+  public i2: any                   = undefined;
+  public i3: any                   = undefined;
+  public i4: any                   = undefined;
+  public trace: string | undefined = undefined;
+  constructor(readonly _pushOpCode: PushTag | null) {
+    super();
+  }
 }
 
-/**
- * @tsplus static fncts.io.Push.SinkOps __call
- */
-export function makeSink<R, E, A>(
-  value: (value: A) => IO<R, never, unknown>,
-  error: (cause: Cause<E>) => IO<R, never, unknown>,
-): Sink<R, E, A> {
-  return new Sink(value, error);
+export interface Base<R = never, E = any, A = any>
+  extends PushOp<
+    null,
+    {
+      readonly run: Push.Run<R, E, A>;
+    }
+  > {}
+
+export interface Defer
+  extends PushOp<
+    PushTag.Defer,
+    {
+      readonly i0: () => Primitive;
+    }
+  > {}
+
+export interface FromPush<R = never, E = any, A = any>
+  extends PushOp<
+    PushTag.FromPush,
+    {
+      readonly i0: Push.Run<R, E, A>;
+    }
+  > {}
+
+export interface ProducerSync<A = any>
+  extends PushOp<
+    PushTag.ProducerSync,
+    {
+      readonly i0: SyncProducer<A>;
+    }
+  > {}
+
+export interface ProducerIO<R = never, E = any, A = any>
+  extends PushOp<
+    PushTag.ProducerIO,
+    {
+      readonly i0: IOProducer<R, E, A>;
+    }
+  > {}
+
+export interface Fail<E = any>
+  extends PushOp<
+    PushTag.FailCause,
+    {
+      readonly i0: () => Cause<E>;
+    }
+  > {}
+
+export interface OnSuccess<A = any>
+  extends PushOp<
+    PushTag.OnSuccess,
+    {
+      readonly i0: Primitive;
+      readonly i1: (a: A) => Primitive;
+    }
+  > {}
+
+export interface OnSuccessWithStrategy<A = any>
+  extends PushOp<
+    PushTag.OnSuccessWithStrategy,
+    {
+      readonly i0: Primitive;
+      readonly i1: (a: A) => Primitive;
+      readonly i2: FlattenStrategy;
+      readonly i3: ExecutionStrategy;
+    }
+  > {}
+
+export interface OnSuccessAndFailure<E = any, A = any>
+  extends PushOp<
+    PushTag.OnSuccessAndFailure,
+    {
+      readonly i0: Primitive;
+      readonly i1: (cause: Cause<E>) => Primitive;
+      readonly i2: (a: A) => Primitive;
+      readonly i3: FlattenStrategy;
+      readonly i4: ExecutionStrategy;
+    }
+  > {}
+
+export interface Transform
+  extends PushOp<
+    PushTag.Transform,
+    {
+      i0: Primitive;
+      i1: (io: IO<any, any, any>) => IO<any, never, void>;
+    }
+  > {}
+
+type Primitive =
+  | Base
+  | ProducerSync
+  | ProducerIO
+  | Fail
+  | OnSuccess
+  | OnSuccessWithStrategy
+  | OnSuccessAndFailure
+  | FromPush
+  | Defer
+  | Transform;
+
+export function concrete(push: Push<any, any, any>): asserts push is Primitive {
+  //
+}
+
+export function unsafeRunPush(push: Push<any, any, any>, sink: UnsafeSink<any, any, any>): IO<any, never, void> {
+  concrete(push);
+  switch (push._pushOpCode) {
+    case PushTag.Defer: {
+      return IO.defer(push.i0().unsafeRun(sink));
+    }
+    case PushTag.ProducerSync: {
+      return push.i0.runSink(sink);
+    }
+    case PushTag.ProducerIO: {
+      return push.i0.runSink(sink);
+    }
+    case PushTag.FailCause: {
+      return sink.onFailure(push.i0());
+    }
+    case PushTag.OnSuccessWithStrategy: {
+      return push.i2.withFork(
+        (fork) =>
+          push.i0.unsafeRun(
+            Sink.unsafeMake(
+              (value) => fork(push.i1(value).unsafeRun(sink)),
+              (cause) => sink.onFailure(cause),
+            ),
+          ),
+        push.i3,
+      );
+    }
+    case PushTag.OnSuccess: {
+      return push.i0.unsafeRun(
+        Sink.unsafeMake(
+          (value) => push.i1(value).unsafeRun(sink),
+          (cause) => sink.onFailure(cause),
+        ),
+      );
+    }
+    case PushTag.OnSuccessAndFailure: {
+      return push.i3.withFork(
+        (fork) =>
+          push.i0.unsafeRun(
+            Sink.unsafeMake(
+              (value) => fork(push.i2(value).unsafeRun(sink)),
+              (cause) => fork(push.i1(cause).unsafeRun(sink)),
+            ),
+          ),
+        push.i4,
+      );
+    }
+    case PushTag.FromPush: {
+      return IO.environmentWith((environment) => push.i0(sink).provideSomeEnvironment(environment));
+    }
+    case PushTag.Transform: {
+      return IO.defer(push.i1(push.i0.unsafeRun(sink)));
+    }
+    case null: {
+      return push.run(sink);
+    }
+  }
 }

package/_src/Push/internal.ts

@@ -1,5 +1,16 @@
 import type { RuntimeFiber } from "@fncts/io/Fiber";
 
+export function withScope<R, E, A>(
+  f: (scope: Scope.Closeable) => IO<R, E, A>,
+  executionStrategy: ExecutionStrategy,
+): IO<R | Scope, E, A> {
+  return IO.bracketExit(
+    IO.scopeWith((scope) => scope.forkWith(executionStrategy)),
+    f,
+    (scope, exit) => scope.close(exit),
+  );
+}
+
 export function withScopedFork<R, E, A>(
   f: (fork: <R, E, A>(io: IO<R, E, A>) => IO<R, never, RuntimeFiber<E, A>>) => IO<R, E, A>,
 ): IO<R, E, A> {

package/_src/Push.ts

@@ -1,5 +1,11 @@
-// codegen:start { preset: barrel, include: ./Push/*.ts }
+// codegen:start { preset: barrel, include: ./Push/*.ts, exclude: ./Push/Sink.ts }
 export * from "./Push/api.js";
+export * from "./Push/Bounds.js";
 export * from "./Push/definition.js";
+export * from "./Push/FlattenStrategy.js";
+export * from "./Push/IndexedBuffer.js";
 export * from "./Push/internal.js";
+export * from "./Push/MergeStrategy.js";
+export * from "./Push/Operator.js";
+export * from "./Push/Producer.js";
 // codegen:end

package/_src/Queue/api/dimapIO.ts

@@ -27,11 +27,17 @@ class DimapIO<RA, RB, EA, EB, A, B, RC, EC, C, RD, ED, D> extends QueueInternal<
     super();
   }
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -49,13 +55,21 @@ class DimapIO<RA, RB, EA, EB, A, B, RC, EC, C, RD, ED, D> extends QueueInternal<
     return IO.foreach(cs, this.f).flatMap((as) => this.queue.offerAll(as));
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
-  take: IO<RD | RB, ED | EB, D> = this.queue.take.flatMap(this.g);
+  get take(): IO<RD | RB, ED | EB, D> {
+    return this.queue.take.flatMap(this.g);
+  }
 
-  takeAll: IO<RD | RB, ED | EB, Conc<D>> = this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.g));
+  get takeAll(): IO<RD | RB, ED | EB, Conc<D>> {
+    return this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.g));
+  }
 
   takeUpTo(n: number): IO<RD | RB, ED | EB, Conc<D>> {
     return this.queue.takeUpTo(n).flatMap((bs) => IO.foreach(bs, this.g));
@@ -154,11 +168,17 @@ class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<R
     readonly f: (c: C) => IO<RC, EC, A>,
   ) {}
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -176,9 +196,13 @@ class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<R
     return IO.foreach(cs, this.f).flatMap((as) => this.queue.offerAll(as));
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 }
 
 /**
@@ -209,15 +233,25 @@ class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB
     readonly f: (b: B) => IO<RC, EC, C>,
   ) {}
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -227,9 +261,13 @@ class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB
     throw new Error("Cannot unsafely offer to an effectful Queue");
   }
 
-  take: IO<RB | RC, EB | EC, C> = this.queue.take.flatMap(this.f);
+  get take(): IO<RB | RC, EB | EC, C> {
+    return this.queue.take.flatMap(this.f);
+  }
 
-  takeAll: IO<RB | RC, EB | EC, Conc<C>> = this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.f));
+  get takeAll(): IO<RB | RC, EB | EC, Conc<C>> {
+    return this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.f));
+  }
 
   takeUpTo(n: number): IO<RB | RC, EB | EC, Conc<C>> {
     return this.queue.takeUpTo(n).flatMap((bs) => IO.foreach(bs, this.f));

package/_src/Queue/api/filterInputIO.ts

@@ -10,11 +10,17 @@ class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInt
     super();
   }
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -39,13 +45,21 @@ class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInt
     });
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
-  take: IO<RB, EB, B> = this.queue.take;
+  get take(): IO<RB, EB, B> {
+    return this.queue.take;
+  }
 
-  takeAll: IO<RB, EB, Conc<B>> = this.queue.takeAll;
+  get takeAll(): IO<RB, EB, Conc<B>> {
+    return this.queue.takeAll;
+  }
 
   takeUpTo(max: number): IO<RB, EB, Conc<B>> {
     return this.queue.takeUpTo(max);
@@ -94,11 +108,17 @@ class FilterInputEnqueueIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>
     readonly f: (_: A1) => IO<R2, E2, boolean>,
   ) {}
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -123,9 +143,13 @@ class FilterInputEnqueueIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>
     });
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 }
 
 /**

package/_src/Queue/api/filterOutputIO.ts

@@ -10,11 +10,17 @@ class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, R
     super();
   }
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -32,15 +38,21 @@ class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, R
     return this.queue.offerAll(as);
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
-  take: IO<RB | RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
-    this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)),
-  );
+  get take(): IO<RB | RB1, EB1 | EB, B> {
+    return 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));
+  get takeAll(): IO<RB | RB1, EB | EB1, Conc<B>> {
+    return this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
+  }
 
   loop(max: number, acc: Conc<B>): IO<RB | RB1, EB | EB1, Conc<B>> {
     return this.queue.takeUpTo(max).flatMap((bs) => {
@@ -102,15 +114,25 @@ class FilterOutputDequeueIO<RA, RB, EA, EB, A, B, RB1, EB1>
     readonly f: (b: B) => IO<RB1, EB1, boolean>,
   ) {}
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -120,11 +142,13 @@ class FilterOutputDequeueIO<RA, RB, EA, EB, A, B, RB1, EB1>
     throw new Error("Cannot unsafely offer to an effectful Queue");
   }
 
-  take: IO<RB | RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
-    this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)),
-  );
+  get take(): IO<RB | RB1, EB1 | EB, B> {
+    return 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));
+  get takeAll(): IO<RB | RB1, EB | EB1, Conc<B>> {
+    return this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
+  }
 
   loop(max: number, acc: Conc<B>): IO<RB | RB1, EB | EB1, Conc<B>> {
     return this.queue.takeUpTo(max).flatMap((bs) => {

package/_src/Queue/api/zipWithIO.ts

@@ -17,11 +17,17 @@ class ZipWithIO<RA, RB, EA, EB, A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3,
     super();
   }
 
-  awaitShutdown: UIO<void> = this.fa.awaitShutdown.flatMap(() => this.fb.awaitShutdown);
+  get awaitShutdown(): UIO<void> {
+    return this.fa.awaitShutdown.flatMap(() => this.fb.awaitShutdown);
+  }
 
-  capacity: number = Math.min(this.fa.capacity, this.fb.capacity);
+  get capacity(): number {
+    return Math.min(this.fa.capacity, this.fb.capacity);
+  }
 
-  isShutdown: UIO<boolean> = this.fa.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.fa.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.fa.unsafeSize.zipWith(this.fb.unsafeSize, (a, b) => Math.max(a, b));
@@ -39,17 +45,23 @@ class ZipWithIO<RA, RB, EA, EB, A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3,
     return this.fa.offerAll(as).zipWithConcurrent(this.fb.offerAll(as), (x, y) => x && y);
   }
 
-  shutdown: UIO<void> = this.fa.shutdown.zipWithConcurrent(this.fb.shutdown, () => undefined);
+  get shutdown(): UIO<void> {
+    return this.fa.shutdown.zipWithConcurrent(this.fb.shutdown, () => undefined);
+  }
 
-  size: UIO<number> = this.fa.size.zipWithConcurrent(this.fb.size, (x, y) => Math.max(x, y));
+  get size(): UIO<number> {
+    return this.fa.size.zipWithConcurrent(this.fb.size, (x, y) => Math.max(x, y));
+  }
 
-  take: IO<RB | RB1 | R3, E3 | EB | EB1, C> = this.fa.take
-    .zipConcurrent(this.fb.take)
-    .flatMap(([b, c]) => this.f(b, c));
+  get take(): IO<RB | RB1 | R3, E3 | EB | EB1, C> {
+    return this.fa.take.zipConcurrent(this.fb.take).flatMap(([b, c]) => this.f(b, c));
+  }
 
-  takeAll: IO<RB | RB1 | R3, E3 | EB | EB1, Conc<C>> = this.fa.takeAll
-    .zipConcurrent(this.fb.takeAll)
-    .flatMap(([bs, cs]) => IO.foreach(bs.zip(cs), ([b, c]) => this.f(b, c)));
+  get takeAll(): IO<RB | RB1 | R3, E3 | EB | EB1, Conc<C>> {
+    return this.fa.takeAll
+      .zipConcurrent(this.fb.takeAll)
+      .flatMap(([bs, cs]) => IO.foreach(bs.zip(cs), ([b, c]) => this.f(b, c)));
+  }
 
   takeUpTo(max: number): IO<RB | RB1 | R3, E3 | EB | EB1, Conc<C>> {
     return this.fa

package/_src/Queue/internal.ts

@@ -16,11 +16,17 @@ class UnsafeQueue<A> extends QueueInternal<never, never, never, never, A, A> {
     super();
   }
 
-  awaitShutdown: UIO<void> = this.shutdownHook.await;
+  get awaitShutdown(): UIO<void> {
+    return this.shutdownHook.await;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = IO.succeed(this.shutdownFlag.get);
+  get isShutdown(): UIO<boolean> {
+    return IO.succeed(this.shutdownFlag.get);
+  }
 
   get unsafeSize(): Maybe<number> {
     if (this.shutdownFlag.get) {