effect 2.2.5 → 2.3.0

package/src/internal/pubsub.ts

@@ -4,6 +4,7 @@ import type * as Effect from "../Effect.js"
 import { dual, pipe } from "../Function.js"
 import * as MutableQueue from "../MutableQueue.js"
 import * as MutableRef from "../MutableRef.js"
+import { nextPow2 } from "../Number.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import type * as PubSub from "../PubSub.js"
@@ -41,12 +42,12 @@ interface Subscription<out A> {
 /** @internal */
 type Subscribers<A> = Map<
   Subscription<A>,
-  Set<MutableQueue.MutableQueue<Deferred.Deferred<never, A>>>
+  Set<MutableQueue.MutableQueue<Deferred.Deferred<A>>>
 >
 
 const addSubscribers = <A>(
   subscription: Subscription<A>,
-  pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+  pollers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
 ) =>
 (subscribers: Subscribers<A>) => {
   if (!subscribers.has(subscription)) {
@@ -58,7 +59,7 @@ const addSubscribers = <A>(
 
 const removeSubscribers = <A>(
   subscription: Subscription<A>,
-  pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+  pollers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
 ) =>
 (subscribers: Subscribers<A>) => {
   if (!subscribers.has(subscription)) {
@@ -72,28 +73,28 @@ const removeSubscribers = <A>(
 }
 
 /** @internal */
-export const bounded = <A>(requestedCapacity: number): Effect.Effect<never, never, PubSub.PubSub<A>> =>
+export const bounded = <A>(requestedCapacity: number): Effect.Effect<PubSub.PubSub<A>> =>
   pipe(
     core.sync(() => makeBoundedPubSub<A>(requestedCapacity)),
     core.flatMap((atomicPubSub) => makePubSub(atomicPubSub, new BackPressureStrategy()))
   )
 
 /** @internal */
-export const dropping = <A>(requestedCapacity: number): Effect.Effect<never, never, PubSub.PubSub<A>> =>
+export const dropping = <A>(requestedCapacity: number): Effect.Effect<PubSub.PubSub<A>> =>
   pipe(
     core.sync(() => makeBoundedPubSub<A>(requestedCapacity)),
     core.flatMap((atomicPubSub) => makePubSub(atomicPubSub, new DroppingStrategy()))
   )
 
 /** @internal */
-export const sliding = <A>(requestedCapacity: number): Effect.Effect<never, never, PubSub.PubSub<A>> =>
+export const sliding = <A>(requestedCapacity: number): Effect.Effect<PubSub.PubSub<A>> =>
   pipe(
     core.sync(() => makeBoundedPubSub<A>(requestedCapacity)),
     core.flatMap((atomicPubSub) => makePubSub(atomicPubSub, new SlidingStrategy()))
   )
 
 /** @internal */
-export const unbounded = <A>(): Effect.Effect<never, never, PubSub.PubSub<A>> =>
+export const unbounded = <A>(): Effect.Effect<PubSub.PubSub<A>> =>
   pipe(
     core.sync(() => makeUnboundedPubSub<A>()),
     core.flatMap((atomicPubSub) => makePubSub(atomicPubSub, new DroppingStrategy()))
@@ -103,37 +104,37 @@ export const unbounded = <A>(): Effect.Effect<never, never, PubSub.PubSub<A>> =>
 export const capacity = <A>(self: PubSub.PubSub<A>): number => self.capacity()
 
 /** @internal */
-export const size = <A>(self: PubSub.PubSub<A>): Effect.Effect<never, never, number> => self.size
+export const size = <A>(self: PubSub.PubSub<A>): Effect.Effect<number> => self.size
 
 /** @internal */
-export const isFull = <A>(self: PubSub.PubSub<A>): Effect.Effect<never, never, boolean> => self.isFull
+export const isFull = <A>(self: PubSub.PubSub<A>): Effect.Effect<boolean> => self.isFull
 
 /** @internal */
-export const isEmpty = <A>(self: PubSub.PubSub<A>): Effect.Effect<never, never, boolean> => self.isEmpty
+export const isEmpty = <A>(self: PubSub.PubSub<A>): Effect.Effect<boolean> => self.isEmpty
 
 /** @internal */
-export const shutdown = <A>(self: PubSub.PubSub<A>): Effect.Effect<never, never, void> => self.shutdown
+export const shutdown = <A>(self: PubSub.PubSub<A>): Effect.Effect<void> => self.shutdown
 
 /** @internal */
-export const isShutdown = <A>(self: PubSub.PubSub<A>): Effect.Effect<never, never, boolean> => self.isShutdown
+export const isShutdown = <A>(self: PubSub.PubSub<A>): Effect.Effect<boolean> => self.isShutdown
 
 /** @internal */
-export const awaitShutdown = <A>(self: PubSub.PubSub<A>): Effect.Effect<never, never, void> => self.awaitShutdown
+export const awaitShutdown = <A>(self: PubSub.PubSub<A>): Effect.Effect<void> => self.awaitShutdown
 
 /** @internal */
 export const publish = dual<
-  <A>(value: A) => (self: PubSub.PubSub<A>) => Effect.Effect<never, never, boolean>,
-  <A>(self: PubSub.PubSub<A>, value: A) => Effect.Effect<never, never, boolean>
+  <A>(value: A) => (self: PubSub.PubSub<A>) => Effect.Effect<boolean>,
+  <A>(self: PubSub.PubSub<A>, value: A) => Effect.Effect<boolean>
 >(2, (self, value) => self.publish(value))
 
 /** @internal */
 export const publishAll = dual<
-  <A>(elements: Iterable<A>) => (self: PubSub.PubSub<A>) => Effect.Effect<never, never, boolean>,
-  <A>(self: PubSub.PubSub<A>, elements: Iterable<A>) => Effect.Effect<never, never, boolean>
+  <A>(elements: Iterable<A>) => (self: PubSub.PubSub<A>) => Effect.Effect<boolean>,
+  <A>(self: PubSub.PubSub<A>, elements: Iterable<A>) => Effect.Effect<boolean>
 >(2, (self, elements) => self.publishAll(elements))
 
 /** @internal */
-export const subscribe = <A>(self: PubSub.PubSub<A>): Effect.Effect<Scope.Scope, never, Queue.Dequeue<A>> =>
+export const subscribe = <A>(self: PubSub.PubSub<A>): Effect.Effect<Queue.Dequeue<A>, never, Scope.Scope> =>
   self.subscribe
 
 /** @internal */
@@ -158,13 +159,13 @@ const makeSubscription = <A>(
   pubsub: AtomicPubSub<A>,
   subscribers: Subscribers<A>,
   strategy: PubSubStrategy<A>
-): Effect.Effect<never, never, Queue.Dequeue<A>> =>
-  core.map(core.deferredMake<never, void>(), (deferred) =>
+): Effect.Effect<Queue.Dequeue<A>> =>
+  core.map(core.deferredMake<void>(), (deferred) =>
     unsafeMakeSubscription(
       pubsub,
       subscribers,
       pubsub.subscribe(),
-      MutableQueue.unbounded<Deferred.Deferred<never, A>>(),
+      MutableQueue.unbounded<Deferred.Deferred<A>>(),
       deferred,
       MutableRef.make(false),
       strategy
@@ -175,8 +176,8 @@ export const unsafeMakeSubscription = <A>(
   pubsub: AtomicPubSub<A>,
   subscribers: Subscribers<A>,
   subscription: Subscription<A>,
-  pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>,
-  shutdownHook: Deferred.Deferred<never, void>,
+  pollers: MutableQueue.MutableQueue<Deferred.Deferred<A>>,
+  shutdownHook: Deferred.Deferred<void>,
   shutdownFlag: MutableRef.MutableRef<boolean>,
   strategy: PubSubStrategy<A>
 ): Queue.Dequeue<A> => {
@@ -826,8 +827,8 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
     readonly pubsub: AtomicPubSub<A>,
     readonly subscribers: Subscribers<A>,
     readonly subscription: Subscription<A>,
-    readonly pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>,
-    readonly shutdownHook: Deferred.Deferred<never, void>,
+    readonly pollers: MutableQueue.MutableQueue<Deferred.Deferred<A>>,
+    readonly shutdownHook: Deferred.Deferred<void>,
     readonly shutdownFlag: MutableRef.MutableRef<boolean>,
     readonly strategy: PubSubStrategy<A>
   ) {
@@ -845,7 +846,7 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
     return !MutableRef.get(this.shutdownFlag)
   }
 
-  get size(): Effect.Effect<never, never, number> {
+  get size(): Effect.Effect<number> {
     return core.suspend(() =>
       MutableRef.get(this.shutdownFlag)
         ? core.interrupt
@@ -860,17 +861,17 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
     return Option.some(this.subscription.size())
   }
 
-  get isFull(): Effect.Effect<never, never, boolean> {
+  get isFull(): Effect.Effect<boolean> {
     return core.map(this.size, (size) => size === this.capacity())
   }
 
-  get isEmpty(): Effect.Effect<never, never, boolean> {
+  get isEmpty(): Effect.Effect<boolean> {
     return core.map(this.size, (size) => size === 0)
   }
 
-  get shutdown(): Effect.Effect<never, never, void> {
+  get shutdown(): Effect.Effect<void> {
     return core.uninterruptible(
-      core.withFiberRuntime<never, never, void>((state) => {
+      core.withFiberRuntime<void>((state) => {
         MutableRef.set(this.shutdownFlag, true)
         return pipe(
           fiberRuntime.forEachParUnbounded(
@@ -890,16 +891,16 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
     )
   }
 
-  get isShutdown(): Effect.Effect<never, never, boolean> {
+  get isShutdown(): Effect.Effect<boolean> {
     return core.sync(() => MutableRef.get(this.shutdownFlag))
   }
 
-  get awaitShutdown(): Effect.Effect<never, never, void> {
+  get awaitShutdown(): Effect.Effect<void> {
     return core.deferredAwait(this.shutdownHook)
   }
 
-  get take(): Effect.Effect<never, never, A> {
-    return core.withFiberRuntime<never, never, A>((state) => {
+  get take(): Effect.Effect<A> {
+    return core.withFiberRuntime((state) => {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
       }
@@ -907,7 +908,7 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
         ? this.subscription.poll(MutableQueue.EmptyMutableQueue)
         : MutableQueue.EmptyMutableQueue
       if (message === MutableQueue.EmptyMutableQueue) {
-        const deferred = core.deferredUnsafeMake<never, A>(state.id())
+        const deferred = core.deferredUnsafeMake<A>(state.id())
         return pipe(
           core.suspend(() => {
             pipe(this.pollers, MutableQueue.offer(deferred))
@@ -929,7 +930,7 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
     })
   }
 
-  get takeAll(): Effect.Effect<never, never, Chunk.Chunk<A>> {
+  get takeAll(): Effect.Effect<Chunk.Chunk<A>> {
     return core.suspend(() => {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
@@ -942,7 +943,7 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
     })
   }
 
-  takeUpTo(this: this, max: number): Effect.Effect<never, never, Chunk.Chunk<A>> {
+  takeUpTo(this: this, max: number): Effect.Effect<Chunk.Chunk<A>> {
     return core.suspend(() => {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
@@ -955,7 +956,7 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
     })
   }
 
-  takeBetween(min: number, max: number): Effect.Effect<never, never, Chunk.Chunk<A>> {
+  takeBetween(min: number, max: number): Effect.Effect<Chunk.Chunk<A>> {
     return core.suspend(() => takeRemainderLoop(this, min, max, Chunk.empty()))
   }
 }
@@ -966,7 +967,7 @@ const takeRemainderLoop = <A>(
   min: number,
   max: number,
   acc: Chunk.Chunk<A>
-): Effect.Effect<never, never, Chunk.Chunk<A>> => {
+): Effect.Effect<Chunk.Chunk<A>> => {
   if (max < min) {
     return core.succeed(acc)
   }
@@ -1004,7 +1005,7 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
     readonly pubsub: AtomicPubSub<A>,
     readonly subscribers: Subscribers<A>,
     readonly scope: Scope.Scope.Closeable,
-    readonly shutdownHook: Deferred.Deferred<never, void>,
+    readonly shutdownHook: Deferred.Deferred<void>,
     readonly shutdownFlag: MutableRef.MutableRef<boolean>,
     readonly strategy: PubSubStrategy<A>
   ) {
@@ -1014,7 +1015,7 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
     return this.pubsub.capacity
   }
 
-  get size(): Effect.Effect<never, never, number> {
+  get size(): Effect.Effect<number> {
     return core.suspend(() =>
       MutableRef.get(this.shutdownFlag) ?
         core.interrupt :
@@ -1029,24 +1030,24 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
     return Option.some(this.pubsub.size())
   }
 
-  get isFull(): Effect.Effect<never, never, boolean> {
+  get isFull(): Effect.Effect<boolean> {
     return core.map(this.size, (size) => size === this.capacity())
   }
 
-  get isEmpty(): Effect.Effect<never, never, boolean> {
+  get isEmpty(): Effect.Effect<boolean> {
     return core.map(this.size, (size) => size === 0)
   }
 
-  get awaitShutdown(): Effect.Effect<never, never, void> {
+  get awaitShutdown(): Effect.Effect<void> {
     return core.deferredAwait(this.shutdownHook)
   }
 
-  get isShutdown(): Effect.Effect<never, never, boolean> {
+  get isShutdown(): Effect.Effect<boolean> {
     return core.sync(() => MutableRef.get(this.shutdownFlag))
   }
 
-  get shutdown(): Effect.Effect<never, never, void> {
-    return core.uninterruptible(core.withFiberRuntime<never, never, void>((state) => {
+  get shutdown(): Effect.Effect<void> {
+    return core.uninterruptible(core.withFiberRuntime((state) => {
       pipe(this.shutdownFlag, MutableRef.set(true))
       return pipe(
         this.scope.close(core.exitInterrupt(state.id())),
@@ -1057,7 +1058,7 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
     }))
   }
 
-  publish(value: A): Effect.Effect<never, never, boolean> {
+  publish(value: A): Effect.Effect<boolean> {
     return core.suspend(() => {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
@@ -1094,7 +1095,7 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
     return false
   }
 
-  publishAll(elements: Iterable<A>): Effect.Effect<never, never, boolean> {
+  publishAll(elements: Iterable<A>): Effect.Effect<boolean> {
     return core.suspend(() => {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
@@ -1113,7 +1114,7 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
     })
   }
 
-  get subscribe(): Effect.Effect<Scope.Scope, never, Queue.Dequeue<A>> {
+  get subscribe(): Effect.Effect<Queue.Dequeue<A>, never, Scope.Scope> {
     const acquire = core.tap(
       fiberRuntime.all([
         this.scope.fork(executionStrategy.sequential),
@@ -1127,11 +1128,11 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
     )
   }
 
-  offer(value: A): Effect.Effect<never, never, boolean> {
+  offer(value: A): Effect.Effect<boolean> {
     return this.publish(value)
   }
 
-  offerAll(elements: Iterable<A>): Effect.Effect<never, never, boolean> {
+  offerAll(elements: Iterable<A>): Effect.Effect<boolean> {
     return this.publishAll(elements)
   }
 
@@ -1144,11 +1145,11 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
 export const makePubSub = <A>(
   pubsub: AtomicPubSub<A>,
   strategy: PubSubStrategy<A>
-): Effect.Effect<never, never, PubSub.PubSub<A>> =>
+): Effect.Effect<PubSub.PubSub<A>> =>
   core.flatMap(
     fiberRuntime.scopeMake(),
     (scope) =>
-      core.map(core.deferredMake<never, void>(), (deferred) =>
+      core.map(core.deferredMake<void>(), (deferred) =>
         unsafeMakePubSub(
           pubsub,
           new Map(),
@@ -1164,19 +1165,13 @@ export const unsafeMakePubSub = <A>(
   pubsub: AtomicPubSub<A>,
   subscribers: Subscribers<A>,
   scope: Scope.Scope.Closeable,
-  shutdownHook: Deferred.Deferred<never, void>,
+  shutdownHook: Deferred.Deferred<void>,
   shutdownFlag: MutableRef.MutableRef<boolean>,
   strategy: PubSubStrategy<A>
 ): PubSub.PubSub<A> => {
   return new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy)
 }
 
-/** @internal */
-const nextPow2 = (n: number): number => {
-  const nextPow = Math.ceil(Math.log(n) / Math.log(2.0))
-  return Math.max(Math.pow(2, nextPow), 2)
-}
-
 /** @internal */
 const ensureCapacity = (capacity: number): void => {
   if (capacity <= 0) {
@@ -1185,7 +1180,7 @@ const ensureCapacity = (capacity: number): void => {
 }
 
 /** @internal */
-const unsafeCompleteDeferred = <A>(deferred: Deferred.Deferred<never, A>, a: A): void => {
+const unsafeCompleteDeferred = <A>(deferred: Deferred.Deferred<A>, a: A): void => {
   core.deferredUnsafeDone(deferred, core.succeed(a))
 }
 
@@ -1236,7 +1231,7 @@ export interface PubSubStrategy<in out A> {
   /**
    * Describes any finalization logic associated with this strategy.
    */
-  readonly shutdown: Effect.Effect<never, never, void>
+  readonly shutdown: Effect.Effect<void>
 
   /**
    * Describes how publishers should signal to subscribers that they are
@@ -1247,7 +1242,7 @@ export interface PubSubStrategy<in out A> {
     subscribers: Subscribers<A>,
     elements: Iterable<A>,
     isShutdown: MutableRef.MutableRef<boolean>
-  ): Effect.Effect<never, never, boolean>
+  ): Effect.Effect<boolean>
 
   /**
    * Describes how subscribers should signal to publishers waiting for space
@@ -1267,7 +1262,7 @@ export interface PubSubStrategy<in out A> {
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>,
     subscription: Subscription<A>,
-    pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+    pollers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   ): void
 
   /**
@@ -1291,14 +1286,10 @@ export interface PubSubStrategy<in out A> {
  */
 class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
   publishers: MutableQueue.MutableQueue<
-    readonly [
-      A,
-      Deferred.Deferred<never, boolean>,
-      boolean
-    ]
+    readonly [A, Deferred.Deferred<boolean>, boolean]
   > = MutableQueue.unbounded()
 
-  get shutdown(): Effect.Effect<never, never, void> {
+  get shutdown(): Effect.Effect<void> {
     return core.flatMap(core.fiberId, (fiberId) =>
       core.flatMap(
         core.sync(() => unsafePollAllQueue(this.publishers)),
@@ -1320,9 +1311,9 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
     subscribers: Subscribers<A>,
     elements: Iterable<A>,
     isShutdown: MutableRef.MutableRef<boolean>
-  ): Effect.Effect<never, never, boolean> {
-    return core.withFiberRuntime<never, never, boolean>((state) => {
-      const deferred = core.deferredUnsafeMake<never, boolean>(state.id())
+  ): Effect.Effect<boolean> {
+    return core.withFiberRuntime((state) => {
+      const deferred = core.deferredUnsafeMake<boolean>(state.id())
       return pipe(
         core.suspend(() => {
           this.unsafeOffer(elements, deferred)
@@ -1365,7 +1356,7 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>,
     subscription: Subscription<A>,
-    pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+    pollers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   ): void {
     return unsafeStrategyCompletePollers(this, pubsub, subscribers, subscription, pollers)
   }
@@ -1374,7 +1365,7 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
     return unsafeStrategyCompleteSubscribers(this, pubsub, subscribers)
   }
 
-  private unsafeOffer(elements: Iterable<A>, deferred: Deferred.Deferred<never, boolean>): void {
+  private unsafeOffer(elements: Iterable<A>, deferred: Deferred.Deferred<boolean>): void {
     const iterator = elements[Symbol.iterator]()
     let next: IteratorResult<A> = iterator.next()
     if (!next.done) {
@@ -1397,7 +1388,7 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
     }
   }
 
-  unsafeRemove(deferred: Deferred.Deferred<never, boolean>): void {
+  unsafeRemove(deferred: Deferred.Deferred<boolean>): void {
     unsafeOfferAll(
       this.publishers,
       pipe(unsafePollAllQueue(this.publishers), Chunk.filter(([_, a]) => a !== deferred))
@@ -1416,7 +1407,7 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
  * @internal
  */
 export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
-  get shutdown(): Effect.Effect<never, never, void> {
+  get shutdown(): Effect.Effect<void> {
     return core.unit
   }
 
@@ -1425,7 +1416,7 @@ export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
     _subscribers: Subscribers<A>,
     _elements: Iterable<A>,
     _isShutdown: MutableRef.MutableRef<boolean>
-  ): Effect.Effect<never, never, boolean> {
+  ): Effect.Effect<boolean> {
     return core.succeed(false)
   }
 
@@ -1440,7 +1431,7 @@ export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>,
     subscription: Subscription<A>,
-    pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+    pollers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   ): void {
     return unsafeStrategyCompletePollers(this, pubsub, subscribers, subscription, pollers)
   }
@@ -1460,7 +1451,7 @@ export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
  * @internal
  */
 export class SlidingStrategy<in out A> implements PubSubStrategy<A> {
-  get shutdown(): Effect.Effect<never, never, void> {
+  get shutdown(): Effect.Effect<void> {
     return core.unit
   }
 
@@ -1469,7 +1460,7 @@ export class SlidingStrategy<in out A> implements PubSubStrategy<A> {
     subscribers: Subscribers<A>,
     elements: Iterable<A>,
     _isShutdown: MutableRef.MutableRef<boolean>
-  ): Effect.Effect<never, never, boolean> {
+  ): Effect.Effect<boolean> {
     return core.sync(() => {
       this.unsafeSlidingPublish(pubsub, elements)
       this.unsafeCompleteSubscribers(pubsub, subscribers)
@@ -1488,7 +1479,7 @@ export class SlidingStrategy<in out A> implements PubSubStrategy<A> {
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>,
     subscription: Subscription<A>,
-    pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+    pollers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   ): void {
     return unsafeStrategyCompletePollers(this, pubsub, subscribers, subscription, pollers)
   }
@@ -1522,7 +1513,7 @@ const unsafeStrategyCompletePollers = <A>(
   pubsub: AtomicPubSub<A>,
   subscribers: Subscribers<A>,
   subscription: Subscription<A>,
-  pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+  pollers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
 ): void => {
   let keepPolling = true
   while (keepPolling && !subscription.isEmpty()) {

package/src/internal/query.ts

@@ -42,21 +42,19 @@ export const currentCacheEnabled = globalValue(
 export const fromRequest = <
   A extends Request.Request<any, any>,
   Ds extends
-    | RequestResolver.RequestResolver<A, never>
-    | Effect.Effect<any, any, RequestResolver.RequestResolver<A, never>>
+    | RequestResolver.RequestResolver<A>
+    | Effect.Effect<RequestResolver.RequestResolver<A>, any, any>
 >(
   request: A,
   dataSource: Ds
 ): Effect.Effect<
-  [Ds] extends [Effect.Effect<any, any, any>] ? Effect.Effect.Context<Ds> : never,
+  Request.Request.Success<A>,
   Request.Request.Error<A>,
-  Request.Request.Success<A>
+  [Ds] extends [Effect.Effect<any, any, any>] ? Effect.Effect.Context<Ds> : never
 > =>
   core.flatMap(
     (core.isEffect(dataSource) ? dataSource : core.succeed(dataSource)) as Effect.Effect<
-      never,
-      never,
-      RequestResolver.RequestResolver<A, never>
+      RequestResolver.RequestResolver<A>
     >,
     (ds) =>
       core.fiberIdWith((id) => {
@@ -92,7 +90,7 @@ export const fromRequest = <
                     orNew.right.listeners.increment()
                     return core.blocked(
                       BlockedRequests.single(
-                        ds as RequestResolver.RequestResolver<A, never>,
+                        ds as RequestResolver.RequestResolver<A>,
                         BlockedRequests.makeEntry({
                           request: proxy,
                           result: orNew.right.handle,
@@ -118,11 +116,11 @@ export const fromRequest = <
           const listeners = new Listeners()
           listeners.increment()
           return core.flatMap(
-            core.deferredMake<Request.Request.Error<A>, Request.Request.Success<A>>(),
+            core.deferredMake<Request.Request.Success<A>, Request.Request.Error<A>>(),
             (ref) =>
               core.blocked(
                 BlockedRequests.single(
-                  ds as RequestResolver.RequestResolver<A, never>,
+                  ds as RequestResolver.RequestResolver<A>,
                   BlockedRequests.makeEntry({
                     request: proxy,
                     result: ref,
@@ -145,7 +143,7 @@ export const fromRequest = <
 export const cacheRequest = <A extends Request.Request<any, any>>(
   request: A,
   result: Request.Request.Result<A>
-): Effect.Effect<never, never, void> => {
+): Effect.Effect<void> => {
   return core.fiberRefGetWith(currentCacheEnabled, (cacheEnabled) => {
     if (cacheEnabled) {
       return core.fiberRefGetWith(currentCache, (cache) =>
@@ -166,36 +164,36 @@ export const cacheRequest = <A extends Request.Request<any, any>>(
 
 /** @internal */
 export const withRequestCaching: {
-  (strategy: boolean): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
-  <R, E, A>(
-    self: Effect.Effect<R, E, A>,
+  (strategy: boolean): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
     strategy: boolean
-  ): Effect.Effect<R, E, A>
+  ): Effect.Effect<A, E, R>
 } = dual<
   (
     strategy: boolean
-  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
     strategy: boolean
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(2, (self, strategy) => core.fiberRefLocally(self, currentCacheEnabled, strategy))
 
 /** @internal */
 export const withRequestCache: {
-  (cache: Request.Cache): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
-  <R, E, A>(
-    self: Effect.Effect<R, E, A>,
+  (cache: Request.Cache): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
     cache: Request.Cache
-  ): Effect.Effect<R, E, A>
+  ): Effect.Effect<A, E, R>
 } = dual<
   (
     cache: Request.Cache
-  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
     cache: Request.Cache
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(
   2,
   // @ts-expect-error