effect 2.2.5 → 2.3.0

package/src/Pool.ts

@@ -1,7 +1,6 @@
 /**
  * @since 2.0.0
  */
-import type * as Data from "./Data.js"
 import type * as Duration from "./Duration.js"
 import type * as Effect from "./Effect.js"
 import * as internal from "./internal/pool.js"
@@ -22,27 +21,27 @@ export const PoolTypeId: unique symbol = internal.PoolTypeId
 export type PoolTypeId = typeof PoolTypeId
 
 /**
- * A `Pool<E, A>` is a pool of items of type `A`, each of which may be
+ * A `Pool<A, E>` is a pool of items of type `A`, each of which may be
  * associated with the acquisition and release of resources. An attempt to get
  * an item `A` from a pool may fail with an error of type `E`.
  *
  * @since 2.0.0
  * @category models
  */
-export interface Pool<out E, in out A> extends Data.Case, Pool.Variance<E, A>, Pipeable {
+export interface Pool<in out A, out E = never> extends Pool.Variance<A, E>, Pipeable {
   /**
    * Retrieves an item from the pool in a scoped effect. Note that if
    * acquisition fails, then the returned effect will fail for that same reason.
    * Retrying a failed acquisition attempt will repeat the acquisition attempt.
    */
-  readonly get: Effect.Effect<Scope.Scope, E, A>
+  readonly get: Effect.Effect<A, E, Scope.Scope>
 
   /**
    * Invalidates the specified item. This will cause the pool to eventually
    * reallocate the item, although this reallocation may occur lazily rather
    * than eagerly.
    */
-  invalidate(item: A): Effect.Effect<never, never, void>
+  invalidate(item: A): Effect.Effect<void>
 }
 
 /**
@@ -53,10 +52,10 @@ export declare namespace Pool {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<out E, in out A> {
+  export interface Variance<in out A, out E> {
     readonly [PoolTypeId]: {
-      readonly _E: Types.Covariant<E>
       readonly _A: Types.Invariant<A>
+      readonly _E: Types.Covariant<E>
     }
   }
 }
@@ -78,12 +77,12 @@ export const isPool: (u: unknown) => u is Pool<unknown, unknown> = internal.isPo
  * @since 2.0.0
  * @category constructors
  */
-export const make: <R, E, A>(
+export const make: <A, E, R>(
   options: {
-    readonly acquire: Effect.Effect<R, E, A>
+    readonly acquire: Effect.Effect<A, E, R>
     readonly size: number
   }
-) => Effect.Effect<Scope.Scope | R, never, Pool<E, A>> = internal.make
+) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R> = internal.make
 
 /**
  * Makes a new pool with the specified minimum and maximum sizes and time to
@@ -116,12 +115,12 @@ export const make: <R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWithTTL: <R, E, A>(options: {
-  readonly acquire: Effect.Effect<R, E, A>
+export const makeWithTTL: <A, E, R>(options: {
+  readonly acquire: Effect.Effect<A, E, R>
   readonly min: number
   readonly max: number
   readonly timeToLive: Duration.DurationInput
-}) => Effect.Effect<Scope.Scope | R, never, Pool<E, A>> = internal.makeWithTTL
+}) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R> = internal.makeWithTTL
 
 /**
  * Retrieves an item from the pool in a scoped effect. Note that if
@@ -131,7 +130,7 @@ export const makeWithTTL: <R, E, A>(options: {
  * @since 2.0.0
  * @category getters
  */
-export const get: <E, A>(self: Pool<E, A>) => Effect.Effect<Scope.Scope, E, A> = internal.get
+export const get: <A, E>(self: Pool<A, E>) => Effect.Effect<A, E, Scope.Scope> = internal.get
 
 /**
  * Invalidates the specified item. This will cause the pool to eventually
@@ -142,6 +141,6 @@ export const get: <E, A>(self: Pool<E, A>) => Effect.Effect<Scope.Scope, E, A> =
  * @category combinators
  */
 export const invalidate: {
-  <A>(value: A): <E>(self: Pool<E, A>) => Effect.Effect<Scope.Scope, never, void>
-  <E, A>(self: Pool<E, A>, value: A): Effect.Effect<Scope.Scope, never, void>
+  <A>(value: A): <E>(self: Pool<A, E>) => Effect.Effect<void, never, Scope.Scope>
+  <A, E>(self: Pool<A, E>, value: A): Effect.Effect<void, never, Scope.Scope>
 } = internal.invalidate

package/src/PubSub.ts

@@ -20,20 +20,20 @@ export interface PubSub<in out A> extends Queue.Enqueue<A>, Pipeable {
    * Publishes a message to the `PubSub`, returning whether the message was published
    * to the `PubSub`.
    */
-  publish(value: A): Effect.Effect<never, never, boolean>
+  publish(value: A): Effect.Effect<boolean>
 
   /**
    * Publishes all of the specified messages to the `PubSub`, returning whether they
    * were published to the `PubSub`.
    */
-  publishAll(elements: Iterable<A>): Effect.Effect<never, never, boolean>
+  publishAll(elements: Iterable<A>): Effect.Effect<boolean>
 
   /**
    * Subscribes to receive messages from the `PubSub`. The resulting subscription can
    * be evaluated multiple times within the scope to take a message from the `PubSub`
    * each time.
    */
-  readonly subscribe: Effect.Effect<Scope.Scope, never, Queue.Dequeue<A>>
+  readonly subscribe: Effect.Effect<Queue.Dequeue<A>, never, Scope.Scope>
 }
 
 /**
@@ -46,7 +46,7 @@ export interface PubSub<in out A> extends Queue.Enqueue<A>, Pipeable {
  * @since 2.0.0
  * @category constructors
  */
-export const bounded: <A>(requestedCapacity: number) => Effect.Effect<never, never, PubSub<A>> = internal.bounded
+export const bounded: <A>(requestedCapacity: number) => Effect.Effect<PubSub<A>> = internal.bounded
 
 /**
  * Creates a bounded `PubSub` with the dropping strategy. The `PubSub` will drop new
@@ -57,7 +57,7 @@ export const bounded: <A>(requestedCapacity: number) => Effect.Effect<never, nev
  * @since 2.0.0
  * @category constructors
  */
-export const dropping: <A>(requestedCapacity: number) => Effect.Effect<never, never, PubSub<A>> = internal.dropping
+export const dropping: <A>(requestedCapacity: number) => Effect.Effect<PubSub<A>> = internal.dropping
 
 /**
  * Creates a bounded `PubSub` with the sliding strategy. The `PubSub` will add new
@@ -68,7 +68,7 @@ export const dropping: <A>(requestedCapacity: number) => Effect.Effect<never, ne
  * @since 2.0.0
  * @category constructors
  */
-export const sliding: <A>(requestedCapacity: number) => Effect.Effect<never, never, PubSub<A>> = internal.sliding
+export const sliding: <A>(requestedCapacity: number) => Effect.Effect<PubSub<A>> = internal.sliding
 
 /**
  * Creates an unbounded `PubSub`.
@@ -76,7 +76,7 @@ export const sliding: <A>(requestedCapacity: number) => Effect.Effect<never, nev
  * @since 2.0.0
  * @category constructors
  */
-export const unbounded: <A>() => Effect.Effect<never, never, PubSub<A>> = internal.unbounded
+export const unbounded: <A>() => Effect.Effect<PubSub<A>> = internal.unbounded
 
 /**
  *  Returns the number of elements the queue can hold.
@@ -94,7 +94,7 @@ export const capacity: <A>(self: PubSub<A>) => number = internal.capacity
  * @since 2.0.0
  * @category getters
  */
-export const size: <A>(self: PubSub<A>) => Effect.Effect<never, never, number> = internal.size
+export const size: <A>(self: PubSub<A>) => Effect.Effect<number> = internal.size
 
 /**
  * Returns `true` if the `Queue` contains at least one element, `false`
@@ -103,7 +103,7 @@ export const size: <A>(self: PubSub<A>) => Effect.Effect<never, never, number> =
  * @since 2.0.0
  * @category getters
  */
-export const isFull: <A>(self: PubSub<A>) => Effect.Effect<never, never, boolean> = internal.isFull
+export const isFull: <A>(self: PubSub<A>) => Effect.Effect<boolean> = internal.isFull
 
 /**
  * Returns `true` if the `Queue` contains zero elements, `false` otherwise.
@@ -111,7 +111,7 @@ export const isFull: <A>(self: PubSub<A>) => Effect.Effect<never, never, boolean
  * @since 2.0.0
  * @category getters
  */
-export const isEmpty: <A>(self: PubSub<A>) => Effect.Effect<never, never, boolean> = internal.isEmpty
+export const isEmpty: <A>(self: PubSub<A>) => Effect.Effect<boolean> = internal.isEmpty
 
 /**
  * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
@@ -120,7 +120,7 @@ export const isEmpty: <A>(self: PubSub<A>) => Effect.Effect<never, never, boolea
  * @since 2.0.0
  * @category utils
  */
-export const shutdown: <A>(self: PubSub<A>) => Effect.Effect<never, never, void> = internal.shutdown
+export const shutdown: <A>(self: PubSub<A>) => Effect.Effect<void> = internal.shutdown
 
 /**
  * Returns `true` if `shutdown` has been called, otherwise returns `false`.
@@ -128,7 +128,7 @@ export const shutdown: <A>(self: PubSub<A>) => Effect.Effect<never, never, void>
  * @since 2.0.0
  * @category getters
  */
-export const isShutdown: <A>(self: PubSub<A>) => Effect.Effect<never, never, boolean> = internal.isShutdown
+export const isShutdown: <A>(self: PubSub<A>) => Effect.Effect<boolean> = internal.isShutdown
 
 /**
  * Waits until the queue is shutdown. The `Effect` returned by this method will
@@ -138,7 +138,7 @@ export const isShutdown: <A>(self: PubSub<A>) => Effect.Effect<never, never, boo
  * @since 2.0.0
  * @category utils
  */
-export const awaitShutdown: <A>(self: PubSub<A>) => Effect.Effect<never, never, void> = internal.awaitShutdown
+export const awaitShutdown: <A>(self: PubSub<A>) => Effect.Effect<void> = internal.awaitShutdown
 
 /**
  * Publishes a message to the `PubSub`, returning whether the message was published
@@ -148,8 +148,8 @@ export const awaitShutdown: <A>(self: PubSub<A>) => Effect.Effect<never, never,
  * @category utils
  */
 export const publish: {
-  <A>(value: A): (self: PubSub<A>) => Effect.Effect<never, never, boolean>
-  <A>(self: PubSub<A>, value: A): Effect.Effect<never, never, boolean>
+  <A>(value: A): (self: PubSub<A>) => Effect.Effect<boolean>
+  <A>(self: PubSub<A>, value: A): Effect.Effect<boolean>
 } = internal.publish
 
 /**
@@ -160,8 +160,8 @@ export const publish: {
  * @category utils
  */
 export const publishAll: {
-  <A>(elements: Iterable<A>): (self: PubSub<A>) => Effect.Effect<never, never, boolean>
-  <A>(self: PubSub<A>, elements: Iterable<A>): Effect.Effect<never, never, boolean>
+  <A>(elements: Iterable<A>): (self: PubSub<A>) => Effect.Effect<boolean>
+  <A>(self: PubSub<A>, elements: Iterable<A>): Effect.Effect<boolean>
 } = internal.publishAll
 
 /**
@@ -172,4 +172,4 @@ export const publishAll: {
  * @since 2.0.0
  * @category utils
  */
-export const subscribe: <A>(self: PubSub<A>) => Effect.Effect<Scope.Scope, never, Queue.Dequeue<A>> = internal.subscribe
+export const subscribe: <A>(self: PubSub<A>) => Effect.Effect<Queue.Dequeue<A>, never, Scope.Scope> = internal.subscribe

package/src/Queue.ts

@@ -67,9 +67,9 @@ export interface Queue<in out A> extends Enqueue<A>, Dequeue<A>, Pipeable {
   /** @internal */
   readonly queue: BackingQueue<A>
   /** @internal */
-  readonly takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+  readonly takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   /** @internal */
-  readonly shutdownHook: Deferred.Deferred<never, void>
+  readonly shutdownHook: Deferred.Deferred<void>
   /** @internal */
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   /** @internal */
@@ -84,7 +84,7 @@ export interface Enqueue<in A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipe
   /**
    * Places one value in the queue.
    */
-  offer(value: A): Effect.Effect<never, never, boolean>
+  offer(value: A): Effect.Effect<boolean>
 
   /**
    * Places one value in the queue when possible without needing the fiber runtime.
@@ -106,7 +106,7 @@ export interface Enqueue<in A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipe
    * For Dropping Queue: 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>): Effect.Effect<never, never, boolean>
+  offerAll(iterable: Iterable<A>): Effect.Effect<boolean>
 }
 
 /**
@@ -118,25 +118,25 @@ export interface Dequeue<out A> extends Queue.DequeueVariance<A>, BaseQueue, Pip
    * 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: Effect.Effect<never, never, A>
+  readonly take: Effect.Effect<A>
 
   /**
    * Takes all the values in the queue and returns the values. If the queue is
    * empty returns an empty collection.
    */
-  readonly takeAll: Effect.Effect<never, never, Chunk.Chunk<A>>
+  readonly takeAll: Effect.Effect<Chunk.Chunk<A>>
 
   /**
    * Takes up to max number of values from the queue.
    */
-  takeUpTo(max: number): Effect.Effect<never, never, Chunk.Chunk<A>>
+  takeUpTo(max: number): Effect.Effect<Chunk.Chunk<A>>
 
   /**
    * Takes a number of elements from the queue between the specified minimum and
    * maximum. If there are fewer than the minimum number of elements available,
    * suspends until at least the minimum number of elements have been collected.
    */
-  takeBetween(min: number, max: number): Effect.Effect<never, never, Chunk.Chunk<A>>
+  takeBetween(min: number, max: number): Effect.Effect<Chunk.Chunk<A>>
 }
 
 /**
@@ -161,7 +161,7 @@ export interface BaseQueue {
    * in the queue. This may be negative if fibers are suspended waiting for
    * elements to be added to the queue.
    */
-  readonly size: Effect.Effect<never, never, number>
+  readonly size: Effect.Effect<number>
 
   /**
    * Retrieves the size of the queue, which is equal to the number of elements
@@ -174,30 +174,30 @@ export interface BaseQueue {
    * Returns `true` if the `Queue` contains at least one element, `false`
    * otherwise.
    */
-  readonly isFull: Effect.Effect<never, never, boolean>
+  readonly isFull: Effect.Effect<boolean>
 
   /**
    * Returns `true` if the `Queue` contains zero elements, `false` otherwise.
    */
-  readonly isEmpty: Effect.Effect<never, never, boolean>
+  readonly isEmpty: Effect.Effect<boolean>
 
   /**
    * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
    * to `offer*` and `take*` will be interrupted immediately.
    */
-  readonly shutdown: Effect.Effect<never, never, void>
+  readonly shutdown: Effect.Effect<void>
 
   /**
    * Returns `true` if `shutdown` has been called, otherwise returns `false`.
    */
-  readonly isShutdown: Effect.Effect<never, never, boolean>
+  readonly isShutdown: Effect.Effect<boolean>
 
   /**
    * Waits until the queue is shutdown. The `Effect` returned by this method will
    * not resume until the queue has been shutdown. If the queue is already
    * shutdown, the `Effect` will resume right away.
    */
-  readonly awaitShutdown: Effect.Effect<never, never, void>
+  readonly awaitShutdown: Effect.Effect<void>
 }
 
 /**
@@ -215,7 +215,7 @@ export interface Strategy<in out A> extends Queue.StrategyVariance<A> {
    * Determines how the `Queue.Strategy` should shut down when the `Queue` is
    * shut down.
    */
-  readonly shutdown: Effect.Effect<never, never, void>
+  readonly shutdown: Effect.Effect<void>
 
   /**
    * Determines the behavior of the `Queue.Strategy` when there are surplus
@@ -225,16 +225,16 @@ export interface Strategy<in out A> extends Queue.StrategyVariance<A> {
   handleSurplus(
     iterable: Iterable<A>,
     queue: BackingQueue<A>,
-    takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>,
+    takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>,
     isShutdown: MutableRef.MutableRef<boolean>
-  ): Effect.Effect<never, never, boolean>
+  ): Effect.Effect<boolean>
 
   /**
    * It is called when the backing queue is empty but there are some
    * takers that can be completed
    */
   onCompleteTakersWithEmptyQueue(
-    takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+    takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   ): void
 
   /**
@@ -243,7 +243,7 @@ export interface Strategy<in out A> extends Queue.StrategyVariance<A> {
    */
   unsafeOnQueueEmptySpace(
     queue: BackingQueue<A>,
-    takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+    takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   ): void
 }
 
@@ -377,8 +377,7 @@ export const slidingStrategy: <A>() => Strategy<A> = internal.slidingStrategy
  * @since 2.0.0
  * @category constructors
  */
-export const make: <A>(queue: BackingQueue<A>, strategy: Strategy<A>) => Effect.Effect<never, never, Queue<A>> =
-  internal.make
+export const make: <A>(queue: BackingQueue<A>, strategy: Strategy<A>) => Effect.Effect<Queue<A>> = internal.make
 
 /**
  * Makes a new bounded `Queue`. When the capacity of the queue is reached, any
@@ -392,7 +391,7 @@ export const make: <A>(queue: BackingQueue<A>, strategy: Strategy<A>) => Effect.
  * @since 2.0.0
  * @category constructors
  */
-export const bounded: <A>(requestedCapacity: number) => Effect.Effect<never, never, Queue<A>> = internal.bounded
+export const bounded: <A>(requestedCapacity: number) => Effect.Effect<Queue<A>> = internal.bounded
 
 /**
  * Makes a new bounded `Queue` with the dropping strategy.
@@ -407,7 +406,7 @@ export const bounded: <A>(requestedCapacity: number) => Effect.Effect<never, nev
  * @since 2.0.0
  * @category constructors
  */
-export const dropping: <A>(requestedCapacity: number) => Effect.Effect<never, never, Queue<A>> = internal.dropping
+export const dropping: <A>(requestedCapacity: number) => Effect.Effect<Queue<A>> = internal.dropping
 
 /**
  * Makes a new bounded `Queue` with the sliding strategy.
@@ -422,7 +421,7 @@ export const dropping: <A>(requestedCapacity: number) => Effect.Effect<never, ne
  * @since 2.0.0
  * @category constructors
  */
-export const sliding: <A>(requestedCapacity: number) => Effect.Effect<never, never, Queue<A>> = internal.sliding
+export const sliding: <A>(requestedCapacity: number) => Effect.Effect<Queue<A>> = internal.sliding
 
 /**
  * Creates a new unbounded `Queue`.
@@ -430,7 +429,7 @@ export const sliding: <A>(requestedCapacity: number) => Effect.Effect<never, nev
  * @since 2.0.0
  * @category constructors
  */
-export const unbounded: <A>() => Effect.Effect<never, never, Queue<A>> = internal.unbounded
+export const unbounded: <A>() => Effect.Effect<Queue<A>> = internal.unbounded
 
 /**
  * Returns the number of elements the queue can hold.
@@ -448,7 +447,7 @@ export const capacity: <A>(self: Dequeue<A> | Enqueue<A>) => number = internal.c
  * @since 2.0.0
  * @category getters
  */
-export const size: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never, never, number> = internal.size
+export const size: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<number> = internal.size
 
 /**
  * Returns `true` if the `Queue` contains zero elements, `false` otherwise.
@@ -456,7 +455,7 @@ export const size: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never, ne
  * @since 2.0.0
  * @category getters
  */
-export const isEmpty: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never, never, boolean> = internal.isEmpty
+export const isEmpty: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<boolean> = internal.isEmpty
 
 /**
  * Returns `true` if the `Queue` contains at least one element, `false`
@@ -465,7 +464,7 @@ export const isEmpty: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never,
  * @since 2.0.0
  * @category getters
  */
-export const isFull: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never, never, boolean> = internal.isFull
+export const isFull: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<boolean> = internal.isFull
 
 /**
  * Returns `true` if `shutdown` has been called, otherwise returns `false`.
@@ -473,8 +472,7 @@ export const isFull: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never,
  * @since 2.0.0
  * @category getters
  */
-export const isShutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never, never, boolean> =
-  internal.isShutdown
+export const isShutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<boolean> = internal.isShutdown
 
 /**
  * Waits until the queue is shutdown. The `Effect` returned by this method will
@@ -484,8 +482,7 @@ export const isShutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<nev
  * @since 2.0.0
  * @category utils
  */
-export const awaitShutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never, never, void> =
-  internal.awaitShutdown
+export const awaitShutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<void> = internal.awaitShutdown
 
 /**
  * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
@@ -494,7 +491,7 @@ export const awaitShutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<
  * @since 2.0.0
  * @category utils
  */
-export const shutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never, never, void> = internal.shutdown
+export const shutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<void> = internal.shutdown
 
 /**
  * Places one value in the queue.
@@ -503,8 +500,8 @@ export const shutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<never
  * @category utils
  */
 export const offer: {
-  <A>(value: A): (self: Enqueue<A>) => Effect.Effect<never, never, boolean>
-  <A>(self: Enqueue<A>, value: A): Effect.Effect<never, never, boolean>
+  <A>(value: A): (self: Enqueue<A>) => Effect.Effect<boolean>
+  <A>(self: Enqueue<A>, value: A): Effect.Effect<boolean>
 } = internal.offer
 
 /**
@@ -537,8 +534,8 @@ export const unsafeOffer: {
  * @category utils
  */
 export const offerAll: {
-  <A>(iterable: Iterable<A>): (self: Enqueue<A>) => Effect.Effect<never, never, boolean>
-  <A>(self: Enqueue<A>, iterable: Iterable<A>): Effect.Effect<never, never, boolean>
+  <A>(iterable: Iterable<A>): (self: Enqueue<A>) => Effect.Effect<boolean>
+  <A>(self: Enqueue<A>, iterable: Iterable<A>): Effect.Effect<boolean>
 } = internal.offerAll
 
 /**
@@ -548,7 +545,7 @@ export const offerAll: {
  * @since 2.0.0
  * @category utils
  */
-export const poll: <A>(self: Dequeue<A>) => Effect.Effect<never, never, Option.Option<A>> = internal.poll
+export const poll: <A>(self: Dequeue<A>) => Effect.Effect<Option.Option<A>> = internal.poll
 
 /**
  * Takes the oldest value in the queue. If the queue is empty, this will return
@@ -557,7 +554,7 @@ export const poll: <A>(self: Dequeue<A>) => Effect.Effect<never, never, Option.O
  * @since 2.0.0
  * @category utils
  */
-export const take: <A>(self: Dequeue<A>) => Effect.Effect<never, never, A> = internal.take
+export const take: <A>(self: Dequeue<A>) => Effect.Effect<A> = internal.take
 
 /**
  * Takes all the values in the queue and returns the values. If the queue is
@@ -566,7 +563,7 @@ export const take: <A>(self: Dequeue<A>) => Effect.Effect<never, never, A> = int
  * @since 2.0.0
  * @category utils
  */
-export const takeAll: <A>(self: Dequeue<A>) => Effect.Effect<never, never, Chunk.Chunk<A>> = internal.takeAll
+export const takeAll: <A>(self: Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>> = internal.takeAll
 
 /**
  * Takes up to max number of values from the queue.
@@ -575,8 +572,8 @@ export const takeAll: <A>(self: Dequeue<A>) => Effect.Effect<never, never, Chunk
  * @category utils
  */
 export const takeUpTo: {
-  (max: number): <A>(self: Dequeue<A>) => Effect.Effect<never, never, Chunk.Chunk<A>>
-  <A>(self: Dequeue<A>, max: number): Effect.Effect<never, never, Chunk.Chunk<A>>
+  (max: number): <A>(self: Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>>
+  <A>(self: Dequeue<A>, max: number): Effect.Effect<Chunk.Chunk<A>>
 } = internal.takeUpTo
 
 /**
@@ -588,8 +585,8 @@ export const takeUpTo: {
  * @category utils
  */
 export const takeBetween: {
-  (min: number, max: number): <A>(self: Dequeue<A>) => Effect.Effect<never, never, Chunk.Chunk<A>>
-  <A>(self: Dequeue<A>, min: number, max: number): Effect.Effect<never, never, Chunk.Chunk<A>>
+  (min: number, max: number): <A>(self: Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>>
+  <A>(self: Dequeue<A>, min: number, max: number): Effect.Effect<Chunk.Chunk<A>>
 } = internal.takeBetween
 
 /**
@@ -601,6 +598,6 @@ export const takeBetween: {
  * @category utils
  */
 export const takeN: {
-  (n: number): <A>(self: Dequeue<A>) => Effect.Effect<never, never, Chunk.Chunk<A>>
-  <A>(self: Dequeue<A>, n: number): Effect.Effect<never, never, Chunk.Chunk<A>>
+  (n: number): <A>(self: Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>>
+  <A>(self: Dequeue<A>, n: number): Effect.Effect<Chunk.Chunk<A>>
 } = internal.takeN

package/src/Random.ts

@@ -27,29 +27,29 @@ export interface Random {
   /**
    * Returns the next numeric value from the pseudo-random number generator.
    */
-  readonly next: Effect.Effect<never, never, number>
+  readonly next: Effect.Effect<number>
   /**
    * Returns the next boolean value from the pseudo-random number generator.
    */
-  readonly nextBoolean: Effect.Effect<never, never, boolean>
+  readonly nextBoolean: Effect.Effect<boolean>
   /**
    * Returns the next integer value from the pseudo-random number generator.
    */
-  readonly nextInt: Effect.Effect<never, never, number>
+  readonly nextInt: Effect.Effect<number>
   /**
    * Returns the next numeric value in the specified range from the
    * pseudo-random number generator.
    */
-  nextRange(min: number, max: number): Effect.Effect<never, never, number>
+  nextRange(min: number, max: number): Effect.Effect<number>
   /**
    * Returns the next integer value in the specified range from the
    * pseudo-random number generator.
    */
-  nextIntBetween(min: number, max: number): Effect.Effect<never, never, number>
+  nextIntBetween(min: number, max: number): Effect.Effect<number>
   /**
    * Uses the pseudo-random number generator to shuffle the specified iterable.
    */
-  shuffle<A>(elements: Iterable<A>): Effect.Effect<never, never, Chunk.Chunk<A>>
+  shuffle<A>(elements: Iterable<A>): Effect.Effect<Chunk.Chunk<A>>
 }
 
 /**
@@ -58,7 +58,7 @@ export interface Random {
  * @since 2.0.0
  * @category constructors
  */
-export const next: Effect.Effect<never, never, number> = defaultServices.next
+export const next: Effect.Effect<number> = defaultServices.next
 
 /**
  * Returns the next integer value from the pseudo-random number generator.
@@ -66,7 +66,7 @@ export const next: Effect.Effect<never, never, number> = defaultServices.next
  * @since 2.0.0
  * @category constructors
  */
-export const nextInt: Effect.Effect<never, never, number> = defaultServices.nextInt
+export const nextInt: Effect.Effect<number> = defaultServices.nextInt
 
 /**
  * Returns the next boolean value from the pseudo-random number generator.
@@ -74,7 +74,7 @@ export const nextInt: Effect.Effect<never, never, number> = defaultServices.next
  * @since 2.0.0
  * @category constructors
  */
-export const nextBoolean: Effect.Effect<never, never, boolean> = defaultServices.nextBoolean
+export const nextBoolean: Effect.Effect<boolean> = defaultServices.nextBoolean
 
 /**
  * Returns the next numeric value in the specified range from the
@@ -83,7 +83,7 @@ export const nextBoolean: Effect.Effect<never, never, boolean> = defaultServices
  * @since 2.0.0
  * @category constructors
  */
-export const nextRange: (min: number, max: number) => Effect.Effect<never, never, number> = defaultServices.nextRange
+export const nextRange: (min: number, max: number) => Effect.Effect<number> = defaultServices.nextRange
 
 /**
  * Returns the next integer value in the specified range from the
@@ -92,8 +92,7 @@ export const nextRange: (min: number, max: number) => Effect.Effect<never, never
  * @since 2.0.0
  * @category constructors
  */
-export const nextIntBetween: (min: number, max: number) => Effect.Effect<never, never, number> =
-  defaultServices.nextIntBetween
+export const nextIntBetween: (min: number, max: number) => Effect.Effect<number> = defaultServices.nextIntBetween
 
 /**
  * Uses the pseudo-random number generator to shuffle the specified iterable.
@@ -101,8 +100,7 @@ export const nextIntBetween: (min: number, max: number) => Effect.Effect<never,
  * @since 2.0.0
  * @category constructors
  */
-export const shuffle: <A>(elements: Iterable<A>) => Effect.Effect<never, never, Chunk.Chunk<A>> =
-  defaultServices.shuffle
+export const shuffle: <A>(elements: Iterable<A>) => Effect.Effect<Chunk.Chunk<A>> = defaultServices.shuffle
 
 /**
  * Retreives the `Random` service from the context and uses it to run the
@@ -111,5 +109,5 @@ export const shuffle: <A>(elements: Iterable<A>) => Effect.Effect<never, never,
  * @since 2.0.0
  * @category constructors
  */
-export const randomWith: <R, E, A>(f: (random: Random) => Effect.Effect<R, E, A>) => Effect.Effect<R, E, A> =
+export const randomWith: <A, E, R>(f: (random: Random) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
   defaultServices.randomWith