effect 2.2.5 → 2.3.1

package/src/TPriorityQueue.ts

@@ -64,7 +64,7 @@ export declare namespace TPriorityQueue {
  * @since 2.0.0
  * @category constructors
  */
-export const empty: <A>(order: Order.Order<A>) => STM.STM<never, never, TPriorityQueue<A>> = internal.empty
+export const empty: <A>(order: Order.Order<A>) => STM.STM<TPriorityQueue<A>> = internal.empty
 
 /**
  * Creates a new `TPriorityQueue` from an iterable collection of values.
@@ -74,7 +74,7 @@ export const empty: <A>(order: Order.Order<A>) => STM.STM<never, never, TPriorit
  */
 export const fromIterable: <A>(
   order: Order.Order<A>
-) => (iterable: Iterable<A>) => STM.STM<never, never, TPriorityQueue<A>> = internal.fromIterable
+) => (iterable: Iterable<A>) => STM.STM<TPriorityQueue<A>> = internal.fromIterable
 
 /**
  * Checks whether the queue is empty.
@@ -82,7 +82,7 @@ export const fromIterable: <A>(
  * @since 2.0.0
  * @category getters
  */
-export const isEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, boolean> = internal.isEmpty
+export const isEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<boolean> = internal.isEmpty
 
 /**
  * Checks whether the queue is not empty.
@@ -90,7 +90,7 @@ export const isEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, bool
  * @since 2.0.0
  * @category getters
  */
-export const isNonEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, boolean> = internal.isNonEmpty
+export const isNonEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<boolean> = internal.isNonEmpty
 
 /**
  * Makes a new `TPriorityQueue` that is initialized with specified values.
@@ -98,8 +98,7 @@ export const isNonEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, b
  * @since 2.0.0
  * @category constructors
  */
-export const make: <A>(order: Order.Order<A>) => (...elements: Array<A>) => STM.STM<never, never, TPriorityQueue<A>> =
-  internal.make
+export const make: <A>(order: Order.Order<A>) => (...elements: Array<A>) => STM.STM<TPriorityQueue<A>> = internal.make
 
 /**
  * Offers the specified value to the queue.
@@ -108,8 +107,8 @@ export const make: <A>(order: Order.Order<A>) => (...elements: Array<A>) => STM.
  * @category mutations
  */
 export const offer: {
-  <A>(value: A): (self: TPriorityQueue<A>) => STM.STM<never, never, void>
-  <A>(self: TPriorityQueue<A>, value: A): STM.STM<never, never, void>
+  <A>(value: A): (self: TPriorityQueue<A>) => STM.STM<void>
+  <A>(self: TPriorityQueue<A>, value: A): STM.STM<void>
 } = internal.offer
 
 /**
@@ -119,8 +118,8 @@ export const offer: {
  * @category mutations
  */
 export const offerAll: {
-  <A>(values: Iterable<A>): (self: TPriorityQueue<A>) => STM.STM<never, never, void>
-  <A>(self: TPriorityQueue<A>, values: Iterable<A>): STM.STM<never, never, void>
+  <A>(values: Iterable<A>): (self: TPriorityQueue<A>) => STM.STM<void>
+  <A>(self: TPriorityQueue<A>, values: Iterable<A>): STM.STM<void>
 } = internal.offerAll
 
 /**
@@ -130,7 +129,7 @@ export const offerAll: {
  * @since 2.0.0
  * @category getters
  */
-export const peek: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, A> = internal.peek
+export const peek: <A>(self: TPriorityQueue<A>) => STM.STM<A> = internal.peek
 
 /**
  * Peeks at the first value in the queue without removing it, returning `None`
@@ -139,7 +138,7 @@ export const peek: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, A> = in
  * @since 2.0.0
  * @category getters
  */
-export const peekOption: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Option.Option<A>> = internal.peekOption
+export const peekOption: <A>(self: TPriorityQueue<A>) => STM.STM<Option.Option<A>> = internal.peekOption
 
 /**
  * Removes all elements from the queue matching the specified predicate.
@@ -148,8 +147,8 @@ export const peekOption: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, O
  * @category getters
  */
 export const removeIf: {
-  <A>(predicate: Predicate<A>): (self: TPriorityQueue<A>) => STM.STM<never, never, void>
-  <A>(self: TPriorityQueue<A>, predicate: Predicate<A>): STM.STM<never, never, void>
+  <A>(predicate: Predicate<A>): (self: TPriorityQueue<A>) => STM.STM<void>
+  <A>(self: TPriorityQueue<A>, predicate: Predicate<A>): STM.STM<void>
 } = internal.removeIf
 
 /**
@@ -159,8 +158,8 @@ export const removeIf: {
  * @category getters
  */
 export const retainIf: {
-  <A>(predicate: Predicate<A>): (self: TPriorityQueue<A>) => STM.STM<never, never, void>
-  <A>(self: TPriorityQueue<A>, predicate: Predicate<A>): STM.STM<never, never, void>
+  <A>(predicate: Predicate<A>): (self: TPriorityQueue<A>) => STM.STM<void>
+  <A>(self: TPriorityQueue<A>, predicate: Predicate<A>): STM.STM<void>
 } = internal.retainIf
 
 /**
@@ -169,7 +168,7 @@ export const retainIf: {
  * @since 2.0.0
  * @category getters
  */
-export const size: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, number> = internal.size
+export const size: <A>(self: TPriorityQueue<A>) => STM.STM<number> = internal.size
 
 /**
  * Takes a value from the queue, retrying until a value is in the queue.
@@ -177,7 +176,7 @@ export const size: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, number>
  * @since 2.0.0
  * @category mutations
  */
-export const take: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, A> = internal.take
+export const take: <A>(self: TPriorityQueue<A>) => STM.STM<A> = internal.take
 
 /**
  * Takes all values from the queue.
@@ -185,7 +184,7 @@ export const take: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, A> = in
  * @since 2.0.0
  * @category mutations
  */
-export const takeAll: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Array<A>> = internal.takeAll
+export const takeAll: <A>(self: TPriorityQueue<A>) => STM.STM<Array<A>> = internal.takeAll
 
 /**
  * Takes a value from the queue, returning `None` if there is not a value in
@@ -194,7 +193,7 @@ export const takeAll: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Arra
  * @since 2.0.0
  * @category mutations
  */
-export const takeOption: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Option.Option<A>> = internal.takeOption
+export const takeOption: <A>(self: TPriorityQueue<A>) => STM.STM<Option.Option<A>> = internal.takeOption
 
 /**
  * Takes up to the specified maximum number of elements from the queue.
@@ -203,8 +202,8 @@ export const takeOption: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, O
  * @category mutations
  */
 export const takeUpTo: {
-  (n: number): <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Array<A>>
-  <A>(self: TPriorityQueue<A>, n: number): STM.STM<never, never, Array<A>>
+  (n: number): <A>(self: TPriorityQueue<A>) => STM.STM<Array<A>>
+  <A>(self: TPriorityQueue<A>, n: number): STM.STM<Array<A>>
 } = internal.takeUpTo
 
 /**
@@ -213,7 +212,7 @@ export const takeUpTo: {
  * @since 2.0.0
  * @category destructors
  */
-export const toChunk: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Chunk.Chunk<A>> = internal.toChunk
+export const toChunk: <A>(self: TPriorityQueue<A>) => STM.STM<Chunk.Chunk<A>> = internal.toChunk
 
 /**
  * Collects all values into an array.
@@ -221,4 +220,4 @@ export const toChunk: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Chun
  * @since 2.0.0
  * @category destructors
  */
-export const toArray: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Array<A>> = internal.toArray
+export const toArray: <A>(self: TPriorityQueue<A>) => STM.STM<Array<A>> = internal.toArray

package/src/TPubSub.ts

@@ -61,7 +61,7 @@ export interface TPubSub<in out A> {
  * @since 2.0.0
  * @category mutations
  */
-export const awaitShutdown: <A>(self: TPubSub<A>) => STM.STM<never, never, void> = internal.awaitShutdown
+export const awaitShutdown: <A>(self: TPubSub<A>) => STM.STM<void> = internal.awaitShutdown
 
 /**
  * Creates a bounded `TPubSub` with the back pressure strategy. The `TPubSub` will retain
@@ -71,7 +71,7 @@ export const awaitShutdown: <A>(self: TPubSub<A>) => STM.STM<never, never, void>
  * @since 2.0.0
  * @category constructors
  */
-export const bounded: <A>(requestedCapacity: number) => STM.STM<never, never, TPubSub<A>> = internal.bounded
+export const bounded: <A>(requestedCapacity: number) => STM.STM<TPubSub<A>> = internal.bounded
 
 /**
  * Returns the number of elements the `TPubSub` can hold.
@@ -88,7 +88,7 @@ export const capacity: <A>(self: TPubSub<A>) => number = internal.capacity
  * @since 2.0.0
  * @category constructors
  */
-export const dropping: <A>(requestedCapacity: number) => STM.STM<never, never, TPubSub<A>> = internal.dropping
+export const dropping: <A>(requestedCapacity: number) => STM.STM<TPubSub<A>> = internal.dropping
 
 /**
  * Returns `true` if the `TPubSub` contains zero elements, `false` otherwise.
@@ -96,7 +96,7 @@ export const dropping: <A>(requestedCapacity: number) => STM.STM<never, never, T
  * @since 2.0.0
  * @category getters
  */
-export const isEmpty: <A>(self: TPubSub<A>) => STM.STM<never, never, boolean> = internal.isEmpty
+export const isEmpty: <A>(self: TPubSub<A>) => STM.STM<boolean> = internal.isEmpty
 
 /**
  * Returns `true` if the `TPubSub` contains at least one element, `false`
@@ -105,7 +105,7 @@ export const isEmpty: <A>(self: TPubSub<A>) => STM.STM<never, never, boolean> =
  * @since 2.0.0
  * @category getters
  */
-export const isFull: <A>(self: TPubSub<A>) => STM.STM<never, never, boolean> = internal.isFull
+export const isFull: <A>(self: TPubSub<A>) => STM.STM<boolean> = internal.isFull
 
 /**
  * Returns `true` if `shutdown` has been called, otherwise returns `false`.
@@ -113,7 +113,7 @@ export const isFull: <A>(self: TPubSub<A>) => STM.STM<never, never, boolean> = i
  * @since 2.0.0
  * @category getters
  */
-export const isShutdown: <A>(self: TPubSub<A>) => STM.STM<never, never, boolean> = internal.isShutdown
+export const isShutdown: <A>(self: TPubSub<A>) => STM.STM<boolean> = internal.isShutdown
 
 /**
  * Publishes a message to the `TPubSub`, returning whether the message was published
@@ -123,8 +123,8 @@ export const isShutdown: <A>(self: TPubSub<A>) => STM.STM<never, never, boolean>
  * @category mutations
  */
 export const publish: {
-  <A>(value: A): (self: TPubSub<A>) => STM.STM<never, never, boolean>
-  <A>(self: TPubSub<A>, value: A): STM.STM<never, never, boolean>
+  <A>(value: A): (self: TPubSub<A>) => STM.STM<boolean>
+  <A>(self: TPubSub<A>, value: A): STM.STM<boolean>
 } = internal.publish
 
 /**
@@ -135,8 +135,8 @@ export const publish: {
  * @category mutations
  */
 export const publishAll: {
-  <A>(iterable: Iterable<A>): (self: TPubSub<A>) => STM.STM<never, never, boolean>
-  <A>(self: TPubSub<A>, iterable: Iterable<A>): STM.STM<never, never, boolean>
+  <A>(iterable: Iterable<A>): (self: TPubSub<A>) => STM.STM<boolean>
+  <A>(self: TPubSub<A>, iterable: Iterable<A>): STM.STM<boolean>
 } = internal.publishAll
 
 /**
@@ -147,7 +147,7 @@ export const publishAll: {
  * @since 2.0.0
  * @category getters
  */
-export const size: <A>(self: TPubSub<A>) => STM.STM<never, never, number> = internal.size
+export const size: <A>(self: TPubSub<A>) => STM.STM<number> = internal.size
 
 /**
  * Creates a bounded `TPubSub` with the sliding strategy. The `TPubSub` will add new
@@ -158,7 +158,7 @@ export const size: <A>(self: TPubSub<A>) => STM.STM<never, never, number> = inte
  * @since 2.0.0
  * @category constructors
  */
-export const sliding: <A>(requestedCapacity: number) => STM.STM<never, never, TPubSub<A>> = internal.sliding
+export const sliding: <A>(requestedCapacity: number) => STM.STM<TPubSub<A>> = internal.sliding
 
 /**
  * Subscribes to receive messages from the `TPubSub`. The resulting subscription can
@@ -169,7 +169,7 @@ export const sliding: <A>(requestedCapacity: number) => STM.STM<never, never, TP
  * @since 2.0.0
  * @category mutations
  */
-export const subscribe: <A>(self: TPubSub<A>) => STM.STM<never, never, TQueue.TDequeue<A>> = internal.subscribe
+export const subscribe: <A>(self: TPubSub<A>) => STM.STM<TQueue.TDequeue<A>> = internal.subscribe
 
 /**
  * Subscribes to receive messages from the `TPubSub`. The resulting subscription can
@@ -179,7 +179,7 @@ export const subscribe: <A>(self: TPubSub<A>) => STM.STM<never, never, TQueue.TD
  * @since 2.0.0
  * @category mutations
  */
-export const subscribeScoped: <A>(self: TPubSub<A>) => Effect.Effect<Scope.Scope, never, TQueue.TDequeue<A>> =
+export const subscribeScoped: <A>(self: TPubSub<A>) => Effect.Effect<TQueue.TDequeue<A>, never, Scope.Scope> =
   internal.subscribeScoped
 
 /**
@@ -188,4 +188,4 @@ export const subscribeScoped: <A>(self: TPubSub<A>) => Effect.Effect<Scope.Scope
  * @since 2.0.0
  * @category constructors
  */
-export const unbounded: <A>() => STM.STM<never, never, TPubSub<A>> = internal.unbounded
+export const unbounded: <A>() => STM.STM<TPubSub<A>> = internal.unbounded

package/src/TQueue.ts

@@ -45,7 +45,7 @@ export interface TEnqueue<in A> extends TQueue.TEnqueueVariance<A>, BaseTQueue {
   /**
    * Places one value in the queue.
    */
-  offer(value: A): STM.STM<never, never, boolean>
+  offer(value: A): STM.STM<boolean>
 
   /**
    * For Bounded TQueue: uses the `BackPressure` Strategy, places the values in
@@ -62,7 +62,7 @@ export interface TEnqueue<in A> extends TQueue.TEnqueueVariance<A>, BaseTQueue {
    * For Dropping TQueue: uses `Dropping` Strategy, It places the values in the
    * queue but if there is no room it will not enqueue them and return false.
    */
-  offerAll(iterable: Iterable<A>): STM.STM<never, never, boolean>
+  offerAll(iterable: Iterable<A>): STM.STM<boolean>
 }
 
 /**
@@ -74,30 +74,30 @@ export interface TDequeue<out A> extends TQueue.TDequeueVariance<A>, BaseTQueue
    * Views the next element in the queue without removing it, retrying if the
    * queue is empty.
    */
-  readonly peek: STM.STM<never, never, A>
+  readonly peek: STM.STM<A>
 
   /**
    * Views the next element in the queue without removing it, returning `None`
    * if the queue is empty.
    */
-  readonly peekOption: STM.STM<never, never, Option.Option<A>>
+  readonly peekOption: STM.STM<Option.Option<A>>
 
   /**
    * Takes the oldest value in the queue. If the queue is empty, this will return
    * a computation that resumes when an item has been added to the queue.
    */
-  readonly take: STM.STM<never, never, A>
+  readonly take: STM.STM<A>
 
   /**
    * Takes all the values in the queue and returns the values. If the queue is
    * empty returns an empty collection.
    */
-  readonly takeAll: STM.STM<never, never, Array<A>>
+  readonly takeAll: STM.STM<Array<A>>
 
   /**
    * Takes up to max number of values from the queue.
    */
-  takeUpTo(max: number): STM.STM<never, never, Array<A>>
+  takeUpTo(max: number): STM.STM<Array<A>>
 }
 
 /**
@@ -117,36 +117,36 @@ export interface BaseTQueue {
    * in the queue. This may be negative if fibers are suspended waiting for
    * elements to be added to the queue.
    */
-  readonly size: STM.STM<never, never, number>
+  readonly size: STM.STM<number>
 
   /**
    * Returns `true` if the `TQueue` contains at least one element, `false`
    * otherwise.
    */
-  readonly isFull: STM.STM<never, never, boolean>
+  readonly isFull: STM.STM<boolean>
 
   /**
    * Returns `true` if the `TQueue` contains zero elements, `false` otherwise.
    */
-  readonly isEmpty: STM.STM<never, never, boolean>
+  readonly isEmpty: STM.STM<boolean>
 
   /**
    * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
    * to `offer*` and `take*` will be interrupted immediately.
    */
-  readonly shutdown: STM.STM<never, never, void>
+  readonly shutdown: STM.STM<void>
 
   /**
    * Returns `true` if `shutdown` has been called, otherwise returns `false`.
    */
-  readonly isShutdown: STM.STM<never, never, boolean>
+  readonly isShutdown: STM.STM<boolean>
 
   /**
    * Waits until the queue is shutdown. The `STM` returned by this method will
    * not resume until the queue has been shutdown. If the queue is already
    * shutdown, the `STM` will resume right away.
    */
-  readonly awaitShutdown: STM.STM<never, never, void>
+  readonly awaitShutdown: STM.STM<void>
 }
 
 /**
@@ -206,7 +206,7 @@ export const isTEnqueue: (u: unknown) => u is TEnqueue<unknown> = internal.isTEn
  * @since 2.0.0
  * @category mutations
  */
-export const awaitShutdown: <A>(self: TQueue<A>) => STM.STM<never, never, void> = internal.awaitShutdown
+export const awaitShutdown: <A>(self: TQueue<A>) => STM.STM<void> = internal.awaitShutdown
 
 /**
  * Creates a bounded queue with the back pressure strategy. The queue will
@@ -218,7 +218,7 @@ export const awaitShutdown: <A>(self: TQueue<A>) => STM.STM<never, never, void>
  * @since 2.0.0
  * @category constructors
  */
-export const bounded: <A>(requestedCapacity: number) => STM.STM<never, never, TQueue<A>> = internal.bounded
+export const bounded: <A>(requestedCapacity: number) => STM.STM<TQueue<A>> = internal.bounded
 
 /**
  * Returns the number of elements the queue can hold.
@@ -237,7 +237,7 @@ export const capacity: <A>(self: TQueue<A>) => number = internal.capacity
  * @since 2.0.0
  * @category constructors
  */
-export const dropping: <A>(requestedCapacity: number) => STM.STM<never, never, TQueue<A>> = internal.dropping
+export const dropping: <A>(requestedCapacity: number) => STM.STM<TQueue<A>> = internal.dropping
 
 /**
  * Returns `true` if the `TQueue` contains zero elements, `false` otherwise.
@@ -245,7 +245,7 @@ export const dropping: <A>(requestedCapacity: number) => STM.STM<never, never, T
  * @since 2.0.0
  * @category getters
  */
-export const isEmpty: <A>(self: TQueue<A>) => STM.STM<never, never, boolean> = internal.isEmpty
+export const isEmpty: <A>(self: TQueue<A>) => STM.STM<boolean> = internal.isEmpty
 
 /**
  * Returns `true` if the `TQueue` contains at least one element, `false`
@@ -254,7 +254,7 @@ export const isEmpty: <A>(self: TQueue<A>) => STM.STM<never, never, boolean> = i
  * @since 2.0.0
  * @category getters
  */
-export const isFull: <A>(self: TQueue<A>) => STM.STM<never, never, boolean> = internal.isFull
+export const isFull: <A>(self: TQueue<A>) => STM.STM<boolean> = internal.isFull
 
 /**
  * Returns `true` if `shutdown` has been called, otherwise returns `false`.
@@ -262,7 +262,7 @@ export const isFull: <A>(self: TQueue<A>) => STM.STM<never, never, boolean> = in
  * @since 2.0.0
  * @category getters
  */
-export const isShutdown: <A>(self: TQueue<A>) => STM.STM<never, never, boolean> = internal.isShutdown
+export const isShutdown: <A>(self: TQueue<A>) => STM.STM<boolean> = internal.isShutdown
 
 /**
  * Places one value in the queue.
@@ -271,8 +271,8 @@ export const isShutdown: <A>(self: TQueue<A>) => STM.STM<never, never, boolean>
  * @category mutations
  */
 export const offer: {
-  <A>(value: A): (self: TEnqueue<A>) => STM.STM<never, never, void>
-  <A>(self: TEnqueue<A>, value: A): STM.STM<never, never, void>
+  <A>(value: A): (self: TEnqueue<A>) => STM.STM<void>
+  <A>(self: TEnqueue<A>, value: A): STM.STM<void>
 } = internal.offer
 
 /**
@@ -294,8 +294,8 @@ export const offer: {
  * @category mutations
  */
 export const offerAll: {
-  <A>(iterable: Iterable<A>): (self: TEnqueue<A>) => STM.STM<never, never, boolean>
-  <A>(self: TEnqueue<A>, iterable: Iterable<A>): STM.STM<never, never, boolean>
+  <A>(iterable: Iterable<A>): (self: TEnqueue<A>) => STM.STM<boolean>
+  <A>(self: TEnqueue<A>, iterable: Iterable<A>): STM.STM<boolean>
 } = internal.offerAll
 
 /**
@@ -305,7 +305,7 @@ export const offerAll: {
  * @since 2.0.0
  * @category getters
  */
-export const peek: <A>(self: TDequeue<A>) => STM.STM<never, never, A> = internal.peek
+export const peek: <A>(self: TDequeue<A>) => STM.STM<A> = internal.peek
 
 /**
  * Views the next element in the queue without removing it, returning `None`
@@ -314,7 +314,7 @@ export const peek: <A>(self: TDequeue<A>) => STM.STM<never, never, A> = internal
  * @since 2.0.0
  * @category getters
  */
-export const peekOption: <A>(self: TDequeue<A>) => STM.STM<never, never, Option.Option<A>> = internal.peekOption
+export const peekOption: <A>(self: TDequeue<A>) => STM.STM<Option.Option<A>> = internal.peekOption
 
 /**
  * Takes a single element from the queue, returning `None` if the queue is
@@ -323,7 +323,7 @@ export const peekOption: <A>(self: TDequeue<A>) => STM.STM<never, never, Option.
  * @since 2.0.0
  * @category getters
  */
-export const poll: <A>(self: TDequeue<A>) => STM.STM<never, never, Option.Option<A>> = internal.poll
+export const poll: <A>(self: TDequeue<A>) => STM.STM<Option.Option<A>> = internal.poll
 
 /**
  * Drops elements from the queue while they do not satisfy the predicate,
@@ -334,8 +334,8 @@ export const poll: <A>(self: TDequeue<A>) => STM.STM<never, never, Option.Option
  * @category mutations
  */
 export const seek: {
-  <A>(predicate: Predicate<A>): (self: TDequeue<A>) => STM.STM<never, never, A>
-  <A>(self: TDequeue<A>, predicate: Predicate<A>): STM.STM<never, never, A>
+  <A>(predicate: Predicate<A>): (self: TDequeue<A>) => STM.STM<A>
+  <A>(self: TDequeue<A>, predicate: Predicate<A>): STM.STM<A>
 } = internal.seek
 
 /**
@@ -345,7 +345,7 @@ export const seek: {
  * @since 2.0.0
  * @category mutations
  */
-export const shutdown: <A>(self: TQueue<A>) => STM.STM<never, never, void> = internal.shutdown
+export const shutdown: <A>(self: TQueue<A>) => STM.STM<void> = internal.shutdown
 
 /**
  * Retrieves the size of the queue, which is equal to the number of elements
@@ -355,7 +355,7 @@ export const shutdown: <A>(self: TQueue<A>) => STM.STM<never, never, void> = int
  * @since 2.0.0
  * @category getters
  */
-export const size: <A>(self: TQueue<A>) => STM.STM<never, never, number> = internal.size
+export const size: <A>(self: TQueue<A>) => STM.STM<number> = internal.size
 
 /**
  * Creates a bounded queue with the sliding strategy. The queue will add new
@@ -366,7 +366,7 @@ export const size: <A>(self: TQueue<A>) => STM.STM<never, never, number> = inter
  * @since 2.0.0
  * @category constructors
  */
-export const sliding: <A>(requestedCapacity: number) => STM.STM<never, never, TQueue<A>> = internal.sliding
+export const sliding: <A>(requestedCapacity: number) => STM.STM<TQueue<A>> = internal.sliding
 
 /**
  * Takes the oldest value in the queue. If the queue is empty, this will return
@@ -375,7 +375,7 @@ export const sliding: <A>(requestedCapacity: number) => STM.STM<never, never, TQ
  * @since 2.0.0
  * @category mutations
  */
-export const take: <A>(self: TDequeue<A>) => STM.STM<never, never, A> = internal.take
+export const take: <A>(self: TDequeue<A>) => STM.STM<A> = internal.take
 
 /**
  * Takes all the values in the queue and returns the values. If the queue is
@@ -384,7 +384,7 @@ export const take: <A>(self: TDequeue<A>) => STM.STM<never, never, A> = internal
  * @since 2.0.0
  * @category mutations
  */
-export const takeAll: <A>(self: TDequeue<A>) => STM.STM<never, never, Array<A>> = internal.takeAll
+export const takeAll: <A>(self: TDequeue<A>) => STM.STM<Array<A>> = internal.takeAll
 
 /**
  * Takes a number of elements from the queue between the specified minimum and
@@ -395,8 +395,8 @@ export const takeAll: <A>(self: TDequeue<A>) => STM.STM<never, never, Array<A>>
  * @category mutations
  */
 export const takeBetween: {
-  (min: number, max: number): <A>(self: TDequeue<A>) => STM.STM<never, never, Array<A>>
-  <A>(self: TDequeue<A>, min: number, max: number): STM.STM<never, never, Array<A>>
+  (min: number, max: number): <A>(self: TDequeue<A>) => STM.STM<Array<A>>
+  <A>(self: TDequeue<A>, min: number, max: number): STM.STM<Array<A>>
 } = internal.takeBetween
 
 /**
@@ -408,8 +408,8 @@ export const takeBetween: {
  * @category mutations
  */
 export const takeN: {
-  (n: number): <A>(self: TDequeue<A>) => STM.STM<never, never, Array<A>>
-  <A>(self: TDequeue<A>, n: number): STM.STM<never, never, Array<A>>
+  (n: number): <A>(self: TDequeue<A>) => STM.STM<Array<A>>
+  <A>(self: TDequeue<A>, n: number): STM.STM<Array<A>>
 } = internal.takeN
 
 /**
@@ -419,8 +419,8 @@ export const takeN: {
  * @category mutations
  */
 export const takeUpTo: {
-  (max: number): <A>(self: TDequeue<A>) => STM.STM<never, never, Array<A>>
-  <A>(self: TDequeue<A>, max: number): STM.STM<never, never, Array<A>>
+  (max: number): <A>(self: TDequeue<A>) => STM.STM<Array<A>>
+  <A>(self: TDequeue<A>, max: number): STM.STM<Array<A>>
 } = internal.takeUpTo
 
 /**
@@ -429,4 +429,4 @@ export const takeUpTo: {
  * @since 2.0.0
  * @category constructors
  */
-export const unbounded: <A>() => STM.STM<never, never, TQueue<A>> = internal.unbounded
+export const unbounded: <A>() => STM.STM<TQueue<A>> = internal.unbounded

package/src/TRandom.ts

@@ -29,29 +29,29 @@ export interface TRandom {
   /**
    * Returns the next numeric value from the pseudo-random number generator.
    */
-  readonly next: STM.STM<never, never, number>
+  readonly next: STM.STM<number>
   /**
    * Returns the next boolean value from the pseudo-random number generator.
    */
-  readonly nextBoolean: STM.STM<never, never, boolean>
+  readonly nextBoolean: STM.STM<boolean>
   /**
    * Returns the next integer value from the pseudo-random number generator.
    */
-  readonly nextInt: STM.STM<never, never, number>
+  readonly nextInt: STM.STM<number>
   /**
    * Returns the next numeric value in the specified range from the
    * pseudo-random number generator.
    */
-  nextRange(min: number, max: number): STM.STM<never, never, number>
+  nextRange(min: number, max: number): STM.STM<number>
   /**
    * Returns the next integer value in the specified range from the
    * pseudo-random number generator.
    */
-  nextIntBetween(min: number, max: number): STM.STM<never, never, number>
+  nextIntBetween(min: number, max: number): STM.STM<number>
   /**
    * Uses the pseudo-random number generator to shuffle the specified iterable.
    */
-  shuffle<A>(elements: Iterable<A>): STM.STM<never, never, Array<A>>
+  shuffle<A>(elements: Iterable<A>): STM.STM<Array<A>>
 }
 /**
  * @internal
@@ -76,7 +76,7 @@ export const Tag: Context.Tag<TRandom, TRandom> = internal.Tag
  * @since 2.0.0
  * @category context
  */
-export const live: Layer.Layer<never, never, TRandom> = internal.live
+export const live: Layer.Layer<TRandom> = internal.live
 
 /**
  * Returns the next number from the pseudo-random number generator.
@@ -84,7 +84,7 @@ export const live: Layer.Layer<never, never, TRandom> = internal.live
  * @since 2.0.0
  * @category random
  */
-export const next: STM.STM<TRandom, never, number> = internal.next
+export const next: STM.STM<number, never, TRandom> = internal.next
 
 /**
  * Returns the next boolean value from the pseudo-random number generator.
@@ -92,7 +92,7 @@ export const next: STM.STM<TRandom, never, number> = internal.next
  * @since 2.0.0
  * @category random
  */
-export const nextBoolean: STM.STM<TRandom, never, boolean> = internal.nextBoolean
+export const nextBoolean: STM.STM<boolean, never, TRandom> = internal.nextBoolean
 
 /**
  * Returns the next integer from the pseudo-random number generator.
@@ -100,7 +100,7 @@ export const nextBoolean: STM.STM<TRandom, never, boolean> = internal.nextBoolea
  * @since 2.0.0
  * @category random
  */
-export const nextInt: STM.STM<TRandom, never, number> = internal.nextInt
+export const nextInt: STM.STM<number, never, TRandom> = internal.nextInt
 
 /**
  * Returns the next integer in the specified range from the pseudo-random number
@@ -109,7 +109,7 @@ export const nextInt: STM.STM<TRandom, never, number> = internal.nextInt
  * @since 2.0.0
  * @category random
  */
-export const nextIntBetween: (low: number, high: number) => STM.STM<TRandom, never, number> = internal.nextIntBetween
+export const nextIntBetween: (low: number, high: number) => STM.STM<number, never, TRandom> = internal.nextIntBetween
 
 /**
  * Returns the next number in the specified range from the pseudo-random number
@@ -118,7 +118,7 @@ export const nextIntBetween: (low: number, high: number) => STM.STM<TRandom, nev
  * @since 2.0.0
  * @category random
  */
-export const nextRange: (min: number, max: number) => STM.STM<TRandom, never, number> = internal.nextRange
+export const nextRange: (min: number, max: number) => STM.STM<number, never, TRandom> = internal.nextRange
 
 /**
  * Uses the pseudo-random number generator to shuffle the specified iterable.
@@ -126,4 +126,4 @@ export const nextRange: (min: number, max: number) => STM.STM<TRandom, never, nu
  * @since 2.0.0
  * @category random
  */
-export const shuffle: <A>(elements: Iterable<A>) => STM.STM<TRandom, never, Array<A>> = internal.shuffle
+export const shuffle: <A>(elements: Iterable<A>) => STM.STM<Array<A>, never, TRandom> = internal.shuffle