effect 2.2.5 → 2.3.1

package/src/internal/stm/tPubSub.ts

@@ -57,12 +57,12 @@ class TPubSubImpl<in out A> implements TPubSub.TPubSub<A> {
     readonly subscribers: TRef.TRef<HashSet.HashSet<TRef.TRef<TRef.TRef<Node<A>> | undefined>>>
   ) {}
 
-  isShutdown: STM.STM<never, never, boolean> = core.effect<never, boolean>((journal) => {
+  isShutdown: STM.STM<boolean> = core.effect<never, boolean>((journal) => {
     const currentPublisherTail = tRef.unsafeGet(this.publisherTail, journal)
     return currentPublisherTail === undefined
   })
 
-  awaitShutdown: STM.STM<never, never, void> = core.flatMap(
+  awaitShutdown: STM.STM<void> = core.flatMap(
     this.isShutdown,
     (isShutdown) => isShutdown ? stm.unit : core.retry
   )
@@ -71,7 +71,7 @@ class TPubSubImpl<in out A> implements TPubSub.TPubSub<A> {
     return this.requestedCapacity
   }
 
-  size: STM.STM<never, never, number> = core.withSTMRuntime((runtime) => {
+  size: STM.STM<number> = core.withSTMRuntime((runtime) => {
     const currentPublisherTail = tRef.unsafeGet(this.publisherTail, runtime.journal)
     if (currentPublisherTail === undefined) {
       return core.interruptAs(runtime.fiberId)
@@ -79,11 +79,11 @@ class TPubSubImpl<in out A> implements TPubSub.TPubSub<A> {
     return core.succeed(tRef.unsafeGet(this.pubsubSize, runtime.journal))
   })
 
-  isEmpty: STM.STM<never, never, boolean> = core.map(this.size, (size) => size === 0)
+  isEmpty: STM.STM<boolean> = core.map(this.size, (size) => size === 0)
 
-  isFull: STM.STM<never, never, boolean> = core.map(this.size, (size) => size === this.capacity())
+  isFull: STM.STM<boolean> = core.map(this.size, (size) => size === this.capacity())
 
-  offer(value: A): STM.STM<never, never, boolean> {
+  offer(value: A): STM.STM<boolean> {
     return core.withSTMRuntime((runtime) => {
       const currentPublisherTail = tRef.unsafeGet(this.publisherTail, runtime.journal)
       if (currentPublisherTail === undefined) {
@@ -155,14 +155,14 @@ class TPubSubImpl<in out A> implements TPubSub.TPubSub<A> {
     })
   }
 
-  offerAll(iterable: Iterable<A>): STM.STM<never, never, boolean> {
+  offerAll(iterable: Iterable<A>): STM.STM<boolean> {
     return core.map(
       stm.forEach(iterable, (a) => this.offer(a)),
       RA.every(identity)
     )
   }
 
-  shutdown: STM.STM<never, never, void> = core.effect<never, void>((journal) => {
+  shutdown: STM.STM<void> = core.effect<never, void>((journal) => {
     const currentPublisherTail = tRef.unsafeGet(this.publisherTail, journal)
     if (currentPublisherTail !== undefined) {
       tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(this.publisherTail, void 0, journal)
@@ -188,12 +188,12 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
     readonly subscribers: TRef.TRef<HashSet.HashSet<TRef.TRef<TRef.TRef<Node<A>> | undefined>>>
   ) {}
 
-  isShutdown: STM.STM<never, never, boolean> = core.effect<never, boolean>((journal) => {
+  isShutdown: STM.STM<boolean> = core.effect<never, boolean>((journal) => {
     const currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, journal)
     return currentSubscriberHead === undefined
   })
 
-  awaitShutdown: STM.STM<never, never, void> = core.flatMap(
+  awaitShutdown: STM.STM<void> = core.flatMap(
     this.isShutdown,
     (isShutdown) => isShutdown ? stm.unit : core.retry
   )
@@ -201,7 +201,7 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
   capacity(): number {
     return this.requestedCapacity
   }
-  size: STM.STM<never, never, number> = core.withSTMRuntime((runtime) => {
+  size: STM.STM<number> = core.withSTMRuntime((runtime) => {
     let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
     if (currentSubscriberHead === undefined) {
       return core.interruptAs(runtime.fiberId)
@@ -227,11 +227,11 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
     return core.succeed(size)
   })
 
-  isEmpty: STM.STM<never, never, boolean> = core.map(this.size, (size) => size === 0)
+  isEmpty: STM.STM<boolean> = core.map(this.size, (size) => size === 0)
 
-  isFull: STM.STM<never, never, boolean> = core.map(this.size, (size) => size === this.capacity())
+  isFull: STM.STM<boolean> = core.map(this.size, (size) => size === this.capacity())
 
-  peek: STM.STM<never, never, A> = core.withSTMRuntime((runtime) => {
+  peek: STM.STM<A> = core.withSTMRuntime((runtime) => {
     let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
     if (currentSubscriberHead === undefined) {
       return core.interruptAs(runtime.fiberId)
@@ -255,7 +255,7 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
     return core.succeed(value as A)
   })
 
-  peekOption: STM.STM<never, never, Option.Option<A>> = core.withSTMRuntime((runtime) => {
+  peekOption: STM.STM<Option.Option<A>> = core.withSTMRuntime((runtime) => {
     let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
     if (currentSubscriberHead === undefined) {
       return core.interruptAs(runtime.fiberId)
@@ -281,7 +281,7 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
     return core.succeed(value)
   })
 
-  shutdown: STM.STM<never, never, void> = core.effect<never, void>((journal) => {
+  shutdown: STM.STM<void> = core.effect<never, void>((journal) => {
     let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, journal)
     if (currentSubscriberHead !== undefined) {
       tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(this.subscriberHead, void 0, journal)
@@ -322,7 +322,7 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
     }
   })
 
-  take: STM.STM<never, never, A> = core.withSTMRuntime((runtime) => {
+  take: STM.STM<A> = core.withSTMRuntime((runtime) => {
     let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
     if (currentSubscriberHead === undefined) {
       return core.interruptAs(runtime.fiberId)
@@ -362,9 +362,9 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
     return core.succeed(value as A)
   })
 
-  takeAll: STM.STM<never, never, Array<A>> = this.takeUpTo(Number.POSITIVE_INFINITY)
+  takeAll: STM.STM<Array<A>> = this.takeUpTo(Number.POSITIVE_INFINITY)
 
-  takeUpTo(max: number): STM.STM<never, never, Array<A>> {
+  takeUpTo(max: number): STM.STM<Array<A>> {
     return core.withSTMRuntime((runtime) => {
       let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
       if (currentSubscriberHead === undefined) {
@@ -411,7 +411,7 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
 const makeTPubSub = <A>(
   requestedCapacity: number,
   strategy: tQueue.TQueueStrategy
-): STM.STM<never, never, TPubSub.TPubSub<A>> =>
+): STM.STM<TPubSub.TPubSub<A>> =>
   pipe(
     stm.all([
       tRef.make<Node<A> | undefined>(void 0),
@@ -447,7 +447,7 @@ const makeSubscription = <A>(
   requestedCapacity: number,
   subscriberCount: TRef.TRef<number>,
   subscribers: TRef.TRef<HashSet.HashSet<TRef.TRef<TRef.TRef<Node<A>> | undefined>>>
-): STM.STM<never, never, TQueue.TDequeue<A>> =>
+): STM.STM<TQueue.TDequeue<A>> =>
   pipe(
     tRef.get(publisherTail),
     core.flatMap((currentPublisherTail) =>
@@ -484,52 +484,52 @@ const makeSubscription = <A>(
   )
 
 /** @internal */
-export const awaitShutdown = <A>(self: TPubSub.TPubSub<A>): STM.STM<never, never, void> => self.awaitShutdown
+export const awaitShutdown = <A>(self: TPubSub.TPubSub<A>): STM.STM<void> => self.awaitShutdown
 
 /** @internal */
-export const bounded = <A>(requestedCapacity: number): STM.STM<never, never, TPubSub.TPubSub<A>> =>
+export const bounded = <A>(requestedCapacity: number): STM.STM<TPubSub.TPubSub<A>> =>
   makeTPubSub<A>(requestedCapacity, tQueue.BackPressure)
 
 /** @internal */
 export const capacity = <A>(self: TPubSub.TPubSub<A>): number => self.capacity()
 
 /** @internal */
-export const dropping = <A>(requestedCapacity: number): STM.STM<never, never, TPubSub.TPubSub<A>> =>
+export const dropping = <A>(requestedCapacity: number): STM.STM<TPubSub.TPubSub<A>> =>
   makeTPubSub<A>(requestedCapacity, tQueue.Dropping)
 
 /** @internal */
-export const isEmpty = <A>(self: TPubSub.TPubSub<A>): STM.STM<never, never, boolean> => self.isEmpty
+export const isEmpty = <A>(self: TPubSub.TPubSub<A>): STM.STM<boolean> => self.isEmpty
 
 /** @internal */
-export const isFull = <A>(self: TPubSub.TPubSub<A>): STM.STM<never, never, boolean> => self.isFull
+export const isFull = <A>(self: TPubSub.TPubSub<A>): STM.STM<boolean> => self.isFull
 
 /** @internal */
-export const isShutdown = <A>(self: TPubSub.TPubSub<A>): STM.STM<never, never, boolean> => self.isShutdown
+export const isShutdown = <A>(self: TPubSub.TPubSub<A>): STM.STM<boolean> => self.isShutdown
 
 /** @internal */
 export const publish = dual<
-  <A>(value: A) => (self: TPubSub.TPubSub<A>) => STM.STM<never, never, boolean>,
-  <A>(self: TPubSub.TPubSub<A>, value: A) => STM.STM<never, never, boolean>
+  <A>(value: A) => (self: TPubSub.TPubSub<A>) => STM.STM<boolean>,
+  <A>(self: TPubSub.TPubSub<A>, value: A) => STM.STM<boolean>
 >(2, (self, value) => self.offer(value))
 
 /** @internal */
 export const publishAll = dual<
-  <A>(iterable: Iterable<A>) => (self: TPubSub.TPubSub<A>) => STM.STM<never, never, boolean>,
-  <A>(self: TPubSub.TPubSub<A>, iterable: Iterable<A>) => STM.STM<never, never, boolean>
+  <A>(iterable: Iterable<A>) => (self: TPubSub.TPubSub<A>) => STM.STM<boolean>,
+  <A>(self: TPubSub.TPubSub<A>, iterable: Iterable<A>) => STM.STM<boolean>
 >(2, (self, iterable) => self.offerAll(iterable))
 
 /** @internal */
-export const size = <A>(self: TPubSub.TPubSub<A>): STM.STM<never, never, number> => self.size
+export const size = <A>(self: TPubSub.TPubSub<A>): STM.STM<number> => self.size
 
 /** @internal */
-export const shutdown = <A>(self: TPubSub.TPubSub<A>): STM.STM<never, never, void> => self.shutdown
+export const shutdown = <A>(self: TPubSub.TPubSub<A>): STM.STM<void> => self.shutdown
 
 /** @internal */
-export const sliding = <A>(requestedCapacity: number): STM.STM<never, never, TPubSub.TPubSub<A>> =>
+export const sliding = <A>(requestedCapacity: number): STM.STM<TPubSub.TPubSub<A>> =>
   makeTPubSub<A>(requestedCapacity, tQueue.Sliding)
 
 /** @internal */
-export const subscribe = <A>(self: TPubSub.TPubSub<A>): STM.STM<never, never, TQueue.TDequeue<A>> =>
+export const subscribe = <A>(self: TPubSub.TPubSub<A>): STM.STM<TQueue.TDequeue<A>> =>
   makeSubscription(
     self.pubsubSize,
     self.publisherHead,
@@ -540,12 +540,11 @@ export const subscribe = <A>(self: TPubSub.TPubSub<A>): STM.STM<never, never, TQ
   )
 
 /** @internal */
-export const subscribeScoped = <A>(self: TPubSub.TPubSub<A>): Effect.Effect<Scope.Scope, never, TQueue.TDequeue<A>> =>
+export const subscribeScoped = <A>(self: TPubSub.TPubSub<A>): Effect.Effect<TQueue.TDequeue<A>, never, Scope.Scope> =>
   Effect.acquireRelease(
     subscribe(self),
     (dequeue) => tQueue.shutdown(dequeue)
   )
 
 /** @internal */
-export const unbounded = <A>(): STM.STM<never, never, TPubSub.TPubSub<A>> =>
-  makeTPubSub<A>(Number.MAX_SAFE_INTEGER, tQueue.Dropping)
+export const unbounded = <A>(): STM.STM<TPubSub.TPubSub<A>> => makeTPubSub<A>(Number.MAX_SAFE_INTEGER, tQueue.Dropping)

package/src/internal/stm/tQueue.ts

@@ -96,7 +96,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
     return this.requestedCapacity
   }
 
-  size: STM.STM<never, never, number> = core.withSTMRuntime((runtime) => {
+  size: STM.STM<number> = core.withSTMRuntime((runtime) => {
     const queue = tRef.unsafeGet(this.ref, runtime.journal)
     if (queue === undefined) {
       return STM.interruptAs(runtime.fiberId)
@@ -104,26 +104,26 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
     return core.succeed(queue.length)
   })
 
-  isFull: STM.STM<never, never, boolean> = core.map(this.size, (size) => size === this.requestedCapacity)
+  isFull: STM.STM<boolean> = core.map(this.size, (size) => size === this.requestedCapacity)
 
-  isEmpty: STM.STM<never, never, boolean> = core.map(this.size, (size) => size === 0)
+  isEmpty: STM.STM<boolean> = core.map(this.size, (size) => size === 0)
 
-  shutdown: STM.STM<never, never, void> = core.withSTMRuntime<never, never, void>((runtime) => {
+  shutdown: STM.STM<void> = core.withSTMRuntime((runtime) => {
     tRef.unsafeSet(this.ref, void 0, runtime.journal)
     return stm.unit
   })
 
-  isShutdown: STM.STM<never, never, boolean> = core.effect<never, boolean>((journal) => {
+  isShutdown: STM.STM<boolean> = core.effect<never, boolean>((journal) => {
     const queue = tRef.unsafeGet(this.ref, journal)
     return queue === undefined
   })
 
-  awaitShutdown: STM.STM<never, never, void> = core.flatMap(
+  awaitShutdown: STM.STM<void> = core.flatMap(
     this.isShutdown,
     (isShutdown) => isShutdown ? stm.unit : core.retry
   )
 
-  offer(value: A): STM.STM<never, never, boolean> {
+  offer(value: A): STM.STM<boolean> {
     return core.withSTMRuntime((runtime) => {
       const queue = pipe(this.ref, tRef.unsafeGet(runtime.journal))
       if (queue === undefined) {
@@ -154,7 +154,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
     })
   }
 
-  offerAll(iterable: Iterable<A>): STM.STM<never, never, boolean> {
+  offerAll(iterable: Iterable<A>): STM.STM<boolean> {
     return core.withSTMRuntime((runtime) => {
       const as = Array.from(iterable)
       const queue = tRef.unsafeGet(this.ref, runtime.journal)
@@ -185,7 +185,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
     })
   }
 
-  peek: STM.STM<never, never, A> = core.withSTMRuntime((runtime) => {
+  peek: STM.STM<A> = core.withSTMRuntime((runtime) => {
     const queue = tRef.unsafeGet(this.ref, runtime.journal)
     if (queue === undefined) {
       return core.interruptAs(runtime.fiberId)
@@ -196,7 +196,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
     return core.succeed(queue[0])
   })
 
-  peekOption: STM.STM<never, never, Option.Option<A>> = core.withSTMRuntime((runtime) => {
+  peekOption: STM.STM<Option.Option<A>> = core.withSTMRuntime((runtime) => {
     const queue = tRef.unsafeGet(this.ref, runtime.journal)
     if (queue === undefined) {
       return core.interruptAs(runtime.fiberId)
@@ -204,7 +204,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
     return core.succeed(Option.fromNullable(queue[0]))
   })
 
-  take: STM.STM<never, never, A> = core.withSTMRuntime((runtime) => {
+  take: STM.STM<A> = core.withSTMRuntime((runtime) => {
     const queue = tRef.unsafeGet(this.ref, runtime.journal)
     if (queue === undefined) {
       return core.interruptAs(runtime.fiberId)
@@ -217,7 +217,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
     return core.succeed(dequeued)
   })
 
-  takeAll: STM.STM<never, never, Array<A>> = core.withSTMRuntime((runtime) => {
+  takeAll: STM.STM<Array<A>> = core.withSTMRuntime((runtime) => {
     const queue = tRef.unsafeGet(this.ref, runtime.journal)
     if (queue === undefined) {
       return core.interruptAs(runtime.fiberId)
@@ -226,7 +226,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
     return core.succeed(queue)
   })
 
-  takeUpTo(max: number): STM.STM<never, never, Array<A>> {
+  takeUpTo(max: number): STM.STM<Array<A>> {
     return core.withSTMRuntime((runtime) => {
       const queue = tRef.unsafeGet(this.ref, runtime.journal)
       if (queue === undefined) {
@@ -251,11 +251,10 @@ export const isTEnqueue = (u: unknown): u is TQueue.TEnqueue<unknown> => hasProp
 export const isTDequeue = (u: unknown): u is TQueue.TDequeue<unknown> => hasProperty(u, TDequeueTypeId)
 
 /** @internal */
-export const awaitShutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<never, never, void> =>
-  self.awaitShutdown
+export const awaitShutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<void> => self.awaitShutdown
 
 /** @internal */
-export const bounded = <A>(requestedCapacity: number): STM.STM<never, never, TQueue.TQueue<A>> =>
+export const bounded = <A>(requestedCapacity: number): STM.STM<TQueue.TQueue<A>> =>
   makeQueue<A>(requestedCapacity, BackPressure)
 
 /** @internal */
@@ -264,83 +263,81 @@ export const capacity = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): numb
 }
 
 /** @internal */
-export const dropping = <A>(requestedCapacity: number): STM.STM<never, never, TQueue.TQueue<A>> =>
+export const dropping = <A>(requestedCapacity: number): STM.STM<TQueue.TQueue<A>> =>
   makeQueue<A>(requestedCapacity, Dropping)
 
 /** @internal */
-export const isEmpty = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<never, never, boolean> =>
-  self.isEmpty
+export const isEmpty = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<boolean> => self.isEmpty
 
 /** @internal */
-export const isFull = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<never, never, boolean> => self.isFull
+export const isFull = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<boolean> => self.isFull
 
 /** @internal */
-export const isShutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<never, never, boolean> =>
-  self.isShutdown
+export const isShutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<boolean> => self.isShutdown
 
 /** @internal */
 export const offer = dual<
-  <A>(value: A) => (self: TQueue.TEnqueue<A>) => STM.STM<never, never, void>,
-  <A>(self: TQueue.TEnqueue<A>, value: A) => STM.STM<never, never, void>
+  <A>(value: A) => (self: TQueue.TEnqueue<A>) => STM.STM<void>,
+  <A>(self: TQueue.TEnqueue<A>, value: A) => STM.STM<void>
 >(2, (self, value) => self.offer(value))
 
 /** @internal */
 export const offerAll = dual<
-  <A>(iterable: Iterable<A>) => (self: TQueue.TEnqueue<A>) => STM.STM<never, never, boolean>,
-  <A>(self: TQueue.TEnqueue<A>, iterable: Iterable<A>) => STM.STM<never, never, boolean>
+  <A>(iterable: Iterable<A>) => (self: TQueue.TEnqueue<A>) => STM.STM<boolean>,
+  <A>(self: TQueue.TEnqueue<A>, iterable: Iterable<A>) => STM.STM<boolean>
 >(2, (self, iterable) => self.offerAll(iterable))
 
 /** @internal */
-export const peek = <A>(self: TQueue.TDequeue<A>): STM.STM<never, never, A> => self.peek
+export const peek = <A>(self: TQueue.TDequeue<A>): STM.STM<A> => self.peek
 
 /** @internal */
-export const peekOption = <A>(self: TQueue.TDequeue<A>): STM.STM<never, never, Option.Option<A>> => self.peekOption
+export const peekOption = <A>(self: TQueue.TDequeue<A>): STM.STM<Option.Option<A>> => self.peekOption
 
 /** @internal */
-export const poll = <A>(self: TQueue.TDequeue<A>): STM.STM<never, never, Option.Option<A>> =>
+export const poll = <A>(self: TQueue.TDequeue<A>): STM.STM<Option.Option<A>> =>
   pipe(self.takeUpTo(1), core.map(RA.head))
 
 /** @internal */
 export const seek = dual<
-  <A>(predicate: Predicate<A>) => (self: TQueue.TDequeue<A>) => STM.STM<never, never, A>,
-  <A>(self: TQueue.TDequeue<A>, predicate: Predicate<A>) => STM.STM<never, never, A>
+  <A>(predicate: Predicate<A>) => (self: TQueue.TDequeue<A>) => STM.STM<A>,
+  <A>(self: TQueue.TDequeue<A>, predicate: Predicate<A>) => STM.STM<A>
 >(2, (self, predicate) => seekLoop(self, predicate))
 
-const seekLoop = <A>(self: TQueue.TDequeue<A>, predicate: Predicate<A>): STM.STM<never, never, A> =>
+const seekLoop = <A>(self: TQueue.TDequeue<A>, predicate: Predicate<A>): STM.STM<A> =>
   core.flatMap(
     self.take,
     (a) => predicate(a) ? core.succeed(a) : seekLoop(self, predicate)
   )
 
 /** @internal */
-export const shutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<never, never, void> => self.shutdown
+export const shutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<void> => self.shutdown
 
 /** @internal */
-export const size = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<never, never, number> => self.size
+export const size = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<number> => self.size
 
 /** @internal */
-export const sliding = <A>(requestedCapacity: number): STM.STM<never, never, TQueue.TQueue<A>> =>
+export const sliding = <A>(requestedCapacity: number): STM.STM<TQueue.TQueue<A>> =>
   makeQueue<A>(requestedCapacity, Sliding)
 
 /** @internal */
-export const take = <A>(self: TQueue.TDequeue<A>): STM.STM<never, never, A> => self.take
+export const take = <A>(self: TQueue.TDequeue<A>): STM.STM<A> => self.take
 
 /** @internal */
-export const takeAll = <A>(self: TQueue.TDequeue<A>): STM.STM<never, never, Array<A>> => self.takeAll
+export const takeAll = <A>(self: TQueue.TDequeue<A>): STM.STM<Array<A>> => self.takeAll
 
 /** @internal */
 export const takeBetween = dual<
-  (min: number, max: number) => <A>(self: TQueue.TDequeue<A>) => STM.STM<never, never, Array<A>>,
-  <A>(self: TQueue.TDequeue<A>, min: number, max: number) => STM.STM<never, never, Array<A>>
+  (min: number, max: number) => <A>(self: TQueue.TDequeue<A>) => STM.STM<Array<A>>,
+  <A>(self: TQueue.TDequeue<A>, min: number, max: number) => STM.STM<Array<A>>
 >(
   3,
-  <A>(self: TQueue.TDequeue<A>, min: number, max: number): STM.STM<never, never, Array<A>> =>
+  <A>(self: TQueue.TDequeue<A>, min: number, max: number): STM.STM<Array<A>> =>
     stm.suspend(() => {
       const takeRemainder = (
         min: number,
         max: number,
         acc: Chunk.Chunk<A>
-      ): STM.STM<never, never, Chunk.Chunk<A>> => {
+      ): STM.STM<Chunk.Chunk<A>> => {
         if (max < min) {
           return core.succeed(acc)
         }
@@ -376,21 +373,20 @@ export const takeBetween = dual<
 
 /** @internal */
 export const takeN = dual<
-  (n: number) => <A>(self: TQueue.TDequeue<A>) => STM.STM<never, never, Array<A>>,
-  <A>(self: TQueue.TDequeue<A>, n: number) => STM.STM<never, never, Array<A>>
+  (n: number) => <A>(self: TQueue.TDequeue<A>) => STM.STM<Array<A>>,
+  <A>(self: TQueue.TDequeue<A>, n: number) => STM.STM<Array<A>>
 >(2, (self, n) => pipe(self, takeBetween(n, n)))
 
 /** @internal */
 export const takeUpTo = dual<
-  (max: number) => <A>(self: TQueue.TDequeue<A>) => STM.STM<never, never, Array<A>>,
-  <A>(self: TQueue.TDequeue<A>, max: number) => STM.STM<never, never, Array<A>>
+  (max: number) => <A>(self: TQueue.TDequeue<A>) => STM.STM<Array<A>>,
+  <A>(self: TQueue.TDequeue<A>, max: number) => STM.STM<Array<A>>
 >(2, (self, max) => self.takeUpTo(max))
 
 /** @internal */
-export const unbounded = <A>(): STM.STM<never, never, TQueue.TQueue<A>> =>
-  makeQueue<A>(Number.MAX_SAFE_INTEGER, Dropping)
+export const unbounded = <A>(): STM.STM<TQueue.TQueue<A>> => makeQueue<A>(Number.MAX_SAFE_INTEGER, Dropping)
 
-const makeQueue = <A>(requestedCapacity: number, strategy: TQueueStrategy): STM.STM<never, never, TQueue.TQueue<A>> =>
+const makeQueue = <A>(requestedCapacity: number, strategy: TQueueStrategy): STM.STM<TQueue.TQueue<A>> =>
   core.map(
     tRef.make<Array<A> | undefined>([]),
     (ref) => new TQueueImpl<A>(ref, requestedCapacity, strategy)

package/src/internal/stm/tRandom.ts

@@ -41,15 +41,15 @@ const randomNumber = (state: Random.PCGRandomState): [number, Random.PCGRandomSt
 const withState = <A>(
   state: TRef.TRef<Random.PCGRandomState>,
   f: (state: Random.PCGRandomState) => [A, Random.PCGRandomState]
-): STM.STM<never, never, A> => {
+): STM.STM<A> => {
   return pipe(state, tRef.modify(f))
 }
 
 const shuffleWith = <A>(
   iterable: Iterable<A>,
-  nextIntBounded: (n: number) => STM.STM<never, never, number>
-): STM.STM<never, never, Array<A>> => {
-  const swap = (buffer: TArray.TArray<A>, index1: number, index2: number): STM.STM<never, never, void> =>
+  nextIntBounded: (n: number) => STM.STM<number>
+): STM.STM<Array<A>> => {
+  const swap = (buffer: TArray.TArray<A>, index1: number, index2: number): STM.STM<void> =>
     pipe(
       buffer,
       tArray.get(index1),
@@ -83,7 +83,7 @@ const shuffleWith = <A>(
 }
 
 /** @internal */
-export const Tag = Context.Tag<TRandom.TRandom>()
+export const Tag = Context.GenericTag<TRandom.TRandom>("effect/TRandom")
 
 class TRandomImpl implements TRandom.TRandom {
   readonly [TRandomTypeId]: TRandom.TRandomTypeId = TRandomTypeId
@@ -93,23 +93,23 @@ class TRandomImpl implements TRandom.TRandom {
     this.nextInt = withState(this.state, randomInteger)
   }
 
-  next: STM.STM<never, never, number>
-  nextBoolean: STM.STM<never, never, boolean>
-  nextInt: STM.STM<never, never, number>
+  next: STM.STM<number>
+  nextBoolean: STM.STM<boolean>
+  nextInt: STM.STM<number>
 
-  nextRange(min: number, max: number): STM.STM<never, never, number> {
+  nextRange(min: number, max: number): STM.STM<number> {
     return core.flatMap(this.next, (n) => core.succeed((max - min) * n + min))
   }
-  nextIntBetween(low: number, high: number): STM.STM<never, never, number> {
+  nextIntBetween(low: number, high: number): STM.STM<number> {
     return withState(this.state, randomIntegerBetween(low, high))
   }
-  shuffle<A>(elements: Iterable<A>): STM.STM<never, never, Array<A>> {
+  shuffle<A>(elements: Iterable<A>): STM.STM<Array<A>> {
     return shuffleWith(elements, (n) => this.nextIntBetween(0, n))
   }
 }
 
 /** @internal */
-export const live: Layer.Layer<never, never, TRandom.TRandom> = Layer.effect(
+export const live: Layer.Layer<TRandom.TRandom> = Layer.effect(
   Tag,
   pipe(
     tRef.make(new Random.PCGRandom((Math.random() * 4294967296) >>> 0).getState()),
@@ -119,22 +119,22 @@ export const live: Layer.Layer<never, never, TRandom.TRandom> = Layer.effect(
 )
 
 /** @internal */
-export const next: STM.STM<TRandom.TRandom, never, number> = core.flatMap(Tag, (random) => random.next)
+export const next: STM.STM<number, never, TRandom.TRandom> = core.flatMap(Tag, (random) => random.next)
 
 /** @internal */
-export const nextBoolean: STM.STM<TRandom.TRandom, never, boolean> = core.flatMap(Tag, (random) => random.nextBoolean)
+export const nextBoolean: STM.STM<boolean, never, TRandom.TRandom> = core.flatMap(Tag, (random) => random.nextBoolean)
 
 /** @internal */
-export const nextInt: STM.STM<TRandom.TRandom, never, number> = core.flatMap(Tag, (random) => random.nextInt)
+export const nextInt: STM.STM<number, never, TRandom.TRandom> = core.flatMap(Tag, (random) => random.nextInt)
 
 /** @internal */
-export const nextIntBetween = (low: number, high: number): STM.STM<TRandom.TRandom, never, number> =>
+export const nextIntBetween = (low: number, high: number): STM.STM<number, never, TRandom.TRandom> =>
   core.flatMap(Tag, (random) => random.nextIntBetween(low, high))
 
 /** @internal */
-export const nextRange = (min: number, max: number): STM.STM<TRandom.TRandom, never, number> =>
+export const nextRange = (min: number, max: number): STM.STM<number, never, TRandom.TRandom> =>
   core.flatMap(Tag, (random) => random.nextRange(min, max))
 
 /** @internal */
-export const shuffle = <A>(elements: Iterable<A>): STM.STM<TRandom.TRandom, never, Array<A>> =>
+export const shuffle = <A>(elements: Iterable<A>): STM.STM<Array<A>, never, TRandom.TRandom> =>
   core.flatMap(Tag, (random) => random.shuffle(elements))