effect 2.2.5 → 2.3.1

package/src/internal/queue.ts

@@ -71,9 +71,9 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
     /** @internal */
     readonly queue: 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 */
@@ -89,7 +89,7 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
     return this.queue.capacity()
   }
 
-  get size(): Effect.Effect<never, never, number> {
+  get size(): Effect.Effect<number> {
     return core.suspend(() => core.catchAll(this.unsafeSize(), () => core.interrupt))
   }
 
@@ -104,17 +104,17 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
     )
   }
 
-  get isEmpty(): Effect.Effect<never, never, boolean> {
+  get isEmpty(): Effect.Effect<boolean> {
     return core.map(this.size, (size) => size <= 0)
   }
 
-  get isFull(): Effect.Effect<never, never, boolean> {
+  get isFull(): Effect.Effect<boolean> {
     return core.map(this.size, (size) => size >= this.capacity())
   }
 
-  get shutdown(): Effect.Effect<never, never, void> {
+  get shutdown(): Effect.Effect<void> {
     return core.uninterruptible(
-      core.withFiberRuntime<never, never, void>((state) => {
+      core.withFiberRuntime((state) => {
         pipe(this.shutdownFlag, MutableRef.set(true))
         return pipe(
           fiberRuntime.forEachConcurrentDiscard(
@@ -131,11 +131,11 @@ class QueueImpl<in out A> implements Queue.Queue<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)
   }
 
@@ -171,7 +171,7 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
     return succeeded
   }
 
-  offer(value: A): Effect.Effect<never, never, boolean> {
+  offer(value: A): Effect.Effect<boolean> {
     return core.suspend(() => {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
@@ -203,7 +203,7 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
     })
   }
 
-  offerAll(iterable: Iterable<A>): Effect.Effect<never, never, boolean> {
+  offerAll(iterable: Iterable<A>): Effect.Effect<boolean> {
     return core.suspend(() => {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
@@ -230,8 +230,8 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
     })
   }
 
-  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
       }
@@ -244,7 +244,7 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
         // - Try to take again in case a value was added since
         // - Wait for the deferred to be completed
         // - Clean up resources in case of interruption
-        const deferred = core.deferredUnsafeMake<never, A>(state.id())
+        const deferred = core.deferredUnsafeMake<A>(state.id())
         return pipe(
           core.suspend(() => {
             pipe(this.takers, MutableQueue.offer(deferred))
@@ -261,7 +261,7 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
     })
   }
 
-  get takeAll(): Effect.Effect<never, never, Chunk.Chunk<A>> {
+  get takeAll(): Effect.Effect<Chunk.Chunk<A>> {
     return core.suspend(() => {
       return MutableRef.get(this.shutdownFlag)
         ? core.interrupt
@@ -273,7 +273,7 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
     })
   }
 
-  takeUpTo(max: number): Effect.Effect<never, never, Chunk.Chunk<A>> {
+  takeUpTo(max: number): Effect.Effect<Chunk.Chunk<A>> {
     return core.suspend(() =>
       MutableRef.get(this.shutdownFlag)
         ? core.interrupt
@@ -285,7 +285,7 @@ class QueueImpl<in out A> implements Queue.Queue<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,
@@ -303,7 +303,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)
   }
@@ -345,28 +345,28 @@ export const isEnqueue = (u: unknown): u is Queue.Enqueue<unknown> => hasPropert
 export const isDequeue = (u: unknown): u is Queue.Dequeue<unknown> => hasProperty(u, DequeueTypeId)
 
 /** @internal */
-export const bounded = <A>(requestedCapacity: number): Effect.Effect<never, never, Queue.Queue<A>> =>
+export const bounded = <A>(requestedCapacity: number): Effect.Effect<Queue.Queue<A>> =>
   pipe(
     core.sync(() => MutableQueue.bounded<A>(requestedCapacity)),
     core.flatMap((queue) => make(backingQueueFromMutableQueue(queue), backPressureStrategy()))
   )
 
 /** @internal */
-export const dropping = <A>(requestedCapacity: number): Effect.Effect<never, never, Queue.Queue<A>> =>
+export const dropping = <A>(requestedCapacity: number): Effect.Effect<Queue.Queue<A>> =>
   pipe(
     core.sync(() => MutableQueue.bounded<A>(requestedCapacity)),
     core.flatMap((queue) => make(backingQueueFromMutableQueue(queue), droppingStrategy()))
   )
 
 /** @internal */
-export const sliding = <A>(requestedCapacity: number): Effect.Effect<never, never, Queue.Queue<A>> =>
+export const sliding = <A>(requestedCapacity: number): Effect.Effect<Queue.Queue<A>> =>
   pipe(
     core.sync(() => MutableQueue.bounded<A>(requestedCapacity)),
     core.flatMap((queue) => make(backingQueueFromMutableQueue(queue), slidingStrategy()))
   )
 
 /** @internal */
-export const unbounded = <A>(): Effect.Effect<never, never, Queue.Queue<A>> =>
+export const unbounded = <A>(): Effect.Effect<Queue.Queue<A>> =>
   pipe(
     core.sync(() => MutableQueue.unbounded<A>()),
     core.flatMap((queue) => make(backingQueueFromMutableQueue(queue), droppingStrategy()))
@@ -375,8 +375,8 @@ export const unbounded = <A>(): Effect.Effect<never, never, Queue.Queue<A>> =>
 /** @internal */
 const unsafeMake = <A>(
   queue: Queue.BackingQueue<A>,
-  takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>,
-  shutdownHook: Deferred.Deferred<never, void>,
+  takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>,
+  shutdownHook: Deferred.Deferred<void>,
   shutdownFlag: MutableRef.MutableRef<boolean>,
   strategy: Queue.Strategy<A>
 ): Queue.Queue<A> => {
@@ -387,9 +387,9 @@ const unsafeMake = <A>(
 export const make = <A>(
   queue: Queue.BackingQueue<A>,
   strategy: Queue.Strategy<A>
-): Effect.Effect<never, never, Queue.Queue<A>> =>
+): Effect.Effect<Queue.Queue<A>> =>
   pipe(
-    core.deferredMake<never, void>(),
+    core.deferredMake<void>(),
     core.map((deferred) =>
       unsafeMake(
         queue,
@@ -433,32 +433,27 @@ export const backingQueueFromMutableQueue = <A>(mutable: MutableQueue.MutableQue
 export const capacity = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): number => self.capacity()
 
 /** @internal */
-export const size = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<never, never, number> => self.size
+export const size = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<number> => self.size
 
 /** @internal */
-export const isFull = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<never, never, boolean> =>
-  self.isFull
+export const isFull = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<boolean> => self.isFull
 
 /** @internal */
-export const isEmpty = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<never, never, boolean> =>
-  self.isEmpty
+export const isEmpty = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<boolean> => self.isEmpty
 
 /** @internal */
-export const isShutdown = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<never, never, boolean> =>
-  self.isShutdown
+export const isShutdown = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<boolean> => self.isShutdown
 
 /** @internal */
-export const awaitShutdown = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<never, never, void> =>
-  self.awaitShutdown
+export const awaitShutdown = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<void> => self.awaitShutdown
 
 /** @internal */
-export const shutdown = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<never, never, void> =>
-  self.shutdown
+export const shutdown = <A>(self: Queue.Dequeue<A> | Queue.Enqueue<A>): Effect.Effect<void> => self.shutdown
 
 /** @internal */
 export const offer = dual<
-  <A>(value: A) => (self: Queue.Enqueue<A>) => Effect.Effect<never, never, boolean>,
-  <A>(self: Queue.Enqueue<A>, value: A) => Effect.Effect<never, never, boolean>
+  <A>(value: A) => (self: Queue.Enqueue<A>) => Effect.Effect<boolean>,
+  <A>(self: Queue.Enqueue<A>, value: A) => Effect.Effect<boolean>
 >(2, (self, value) => self.offer(value))
 
 /** @internal */
@@ -471,39 +466,39 @@ export const unsafeOffer = dual<
 export const offerAll = dual<
   <A>(
     iterable: Iterable<A>
-  ) => (self: Queue.Enqueue<A>) => Effect.Effect<never, never, boolean>,
+  ) => (self: Queue.Enqueue<A>) => Effect.Effect<boolean>,
   <A>(
     self: Queue.Enqueue<A>,
     iterable: Iterable<A>
-  ) => Effect.Effect<never, never, boolean>
+  ) => Effect.Effect<boolean>
 >(2, (self, iterable) => self.offerAll(iterable))
 
 /** @internal */
-export const poll = <A>(self: Queue.Dequeue<A>): Effect.Effect<never, never, Option.Option<A>> =>
+export const poll = <A>(self: Queue.Dequeue<A>): Effect.Effect<Option.Option<A>> =>
   core.map(self.takeUpTo(1), Chunk.head)
 
 /** @internal */
-export const take = <A>(self: Queue.Dequeue<A>): Effect.Effect<never, never, A> => self.take
+export const take = <A>(self: Queue.Dequeue<A>): Effect.Effect<A> => self.take
 
 /** @internal */
-export const takeAll = <A>(self: Queue.Dequeue<A>): Effect.Effect<never, never, Chunk.Chunk<A>> => self.takeAll
+export const takeAll = <A>(self: Queue.Dequeue<A>): Effect.Effect<Chunk.Chunk<A>> => self.takeAll
 
 /** @internal */
 export const takeUpTo = dual<
-  (max: number) => <A>(self: Queue.Dequeue<A>) => Effect.Effect<never, never, Chunk.Chunk<A>>,
-  <A>(self: Queue.Dequeue<A>, max: number) => Effect.Effect<never, never, Chunk.Chunk<A>>
+  (max: number) => <A>(self: Queue.Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>>,
+  <A>(self: Queue.Dequeue<A>, max: number) => Effect.Effect<Chunk.Chunk<A>>
 >(2, (self, max) => self.takeUpTo(max))
 
 /** @internal */
 export const takeBetween = dual<
-  (min: number, max: number) => <A>(self: Queue.Dequeue<A>) => Effect.Effect<never, never, Chunk.Chunk<A>>,
-  <A>(self: Queue.Dequeue<A>, min: number, max: number) => Effect.Effect<never, never, Chunk.Chunk<A>>
+  (min: number, max: number) => <A>(self: Queue.Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>>,
+  <A>(self: Queue.Dequeue<A>, min: number, max: number) => Effect.Effect<Chunk.Chunk<A>>
 >(3, (self, min, max) => self.takeBetween(min, max))
 
 /** @internal */
 export const takeN = dual<
-  (n: number) => <A>(self: Queue.Dequeue<A>) => Effect.Effect<never, never, Chunk.Chunk<A>>,
-  <A>(self: Queue.Dequeue<A>, n: number) => Effect.Effect<never, never, Chunk.Chunk<A>>
+  (n: number) => <A>(self: Queue.Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>>,
+  <A>(self: Queue.Dequeue<A>, n: number) => Effect.Effect<Chunk.Chunk<A>>
 >(2, (self, n) => self.takeBetween(n, n))
 
 // -----------------------------------------------------------------------------
@@ -523,13 +518,13 @@ export const slidingStrategy = <A>(): Queue.Strategy<A> => new SlidingStrategy()
 class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
   readonly [QueueStrategyTypeId] = queueStrategyVariance
 
-  readonly putters = MutableQueue.unbounded<readonly [A, Deferred.Deferred<never, boolean>, boolean]>()
+  readonly putters = MutableQueue.unbounded<readonly [A, Deferred.Deferred<boolean>, boolean]>()
 
   surplusSize(): number {
     return MutableQueue.length(this.putters)
   }
 
-  onCompleteTakersWithEmptyQueue(takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>): void {
+  onCompleteTakersWithEmptyQueue(takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>): void {
     while (!MutableQueue.isEmpty(this.putters) && !MutableQueue.isEmpty(takers)) {
       const taker = MutableQueue.poll(takers, void 0)!
       const putter = MutableQueue.poll(this.putters, void 0)!
@@ -540,7 +535,7 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
     }
   }
 
-  get shutdown(): Effect.Effect<never, never, void> {
+  get shutdown(): Effect.Effect<void> {
     return pipe(
       core.fiberId,
       core.flatMap((fiberId) =>
@@ -568,11 +563,11 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
   handleSurplus(
     iterable: Iterable<A>,
     queue: 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> {
-    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(iterable, deferred)
@@ -587,7 +582,7 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
 
   unsafeOnQueueEmptySpace(
     queue: Queue.BackingQueue<A>,
-    takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+    takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   ): void {
     let keepPolling = true
     while (keepPolling && (queue.capacity() === Number.POSITIVE_INFINITY || queue.length() < queue.capacity())) {
@@ -606,7 +601,7 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
     }
   }
 
-  unsafeOffer(iterable: Iterable<A>, deferred: Deferred.Deferred<never, boolean>): void {
+  unsafeOffer(iterable: Iterable<A>, deferred: Deferred.Deferred<boolean>): void {
     const stuff = Array.from(iterable)
     for (let i = 0; i < stuff.length; i++) {
       const value = stuff[i]
@@ -618,7 +613,7 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
     }
   }
 
-  unsafeRemove(deferred: Deferred.Deferred<never, boolean>): void {
+  unsafeRemove(deferred: Deferred.Deferred<boolean>): void {
     unsafeOfferAll(
       this.putters,
       pipe(unsafePollAll(this.putters), Chunk.filter(([, _]) => _ !== deferred))
@@ -634,7 +629,7 @@ class DroppingStrategy<in out A> implements Queue.Strategy<A> {
     return 0
   }
 
-  get shutdown(): Effect.Effect<never, never, void> {
+  get shutdown(): Effect.Effect<void> {
     return core.unit
   }
 
@@ -644,15 +639,15 @@ class DroppingStrategy<in out A> implements Queue.Strategy<A> {
   handleSurplus(
     _iterable: Iterable<A>,
     _queue: 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> {
     return core.succeed(false)
   }
 
   unsafeOnQueueEmptySpace(
     _queue: Queue.BackingQueue<A>,
-    _takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+    _takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   ): void {
     //
   }
@@ -666,7 +661,7 @@ class SlidingStrategy<in out A> implements Queue.Strategy<A> {
     return 0
   }
 
-  get shutdown(): Effect.Effect<never, never, void> {
+  get shutdown(): Effect.Effect<void> {
     return core.unit
   }
 
@@ -676,9 +671,9 @@ class SlidingStrategy<in out A> implements Queue.Strategy<A> {
   handleSurplus(
     iterable: Iterable<A>,
     queue: 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> {
     return core.sync(() => {
       this.unsafeOffer(queue, iterable)
       unsafeCompleteTakers(this, queue, takers)
@@ -688,7 +683,7 @@ class SlidingStrategy<in out A> implements Queue.Strategy<A> {
 
   unsafeOnQueueEmptySpace(
     _queue: Queue.BackingQueue<A>,
-    _takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+    _takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
   ): void {
     //
   }
@@ -709,7 +704,7 @@ class SlidingStrategy<in out A> implements Queue.Strategy<A> {
 }
 
 /** @internal */
-const unsafeCompleteDeferred = <A>(deferred: Deferred.Deferred<never, A>, a: A): void => {
+const unsafeCompleteDeferred = <A>(deferred: Deferred.Deferred<A>, a: A): void => {
   return core.deferredUnsafeDone(deferred, core.succeed(a))
 }
 
@@ -740,7 +735,7 @@ export const unsafeRemove = <A>(queue: MutableQueue.MutableQueue<A>, a: A): void
 export const unsafeCompleteTakers = <A>(
   strategy: Queue.Strategy<A>,
   queue: Queue.BackingQueue<A>,
-  takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+  takers: MutableQueue.MutableQueue<Deferred.Deferred<A>>
 ): void => {
   // Check both a taker and an item are in the queue, starting with the taker
   let keepPolling = true

package/src/internal/random.ts

@@ -15,7 +15,7 @@ export const RandomTypeId: Random.RandomTypeId = Symbol.for(
 ) as Random.RandomTypeId
 
 /** @internal */
-export const randomTag: Context.Tag<Random.Random, Random.Random> = Context.Tag(RandomTypeId)
+export const randomTag: Context.Tag<Random.Random, Random.Random> = Context.GenericTag("effect/Random")
 /** @internal */
 class RandomImpl implements Random.Random {
   readonly [RandomTypeId]: Random.RandomTypeId = RandomTypeId
@@ -26,35 +26,35 @@ class RandomImpl implements Random.Random {
     this.PRNG = new PCGRandom.PCGRandom(seed)
   }
 
-  get next(): Effect.Effect<never, never, number> {
+  get next(): Effect.Effect<number> {
     return core.sync(() => this.PRNG.number())
   }
 
-  get nextBoolean(): Effect.Effect<never, never, boolean> {
+  get nextBoolean(): Effect.Effect<boolean> {
     return core.map(this.next, (n) => n > 0.5)
   }
 
-  get nextInt(): Effect.Effect<never, never, number> {
+  get nextInt(): Effect.Effect<number> {
     return core.sync(() => this.PRNG.integer(Number.MAX_SAFE_INTEGER))
   }
 
-  nextRange(min: number, max: number): Effect.Effect<never, never, number> {
+  nextRange(min: number, max: number): Effect.Effect<number> {
     return core.map(this.next, (n) => (max - min) * n + min)
   }
 
-  nextIntBetween(min: number, max: number): Effect.Effect<never, never, number> {
+  nextIntBetween(min: number, max: number): Effect.Effect<number> {
     return core.sync(() => this.PRNG.integer(max - min) + min)
   }
 
-  shuffle<A>(elements: Iterable<A>): Effect.Effect<never, never, Chunk.Chunk<A>> {
+  shuffle<A>(elements: Iterable<A>): Effect.Effect<Chunk.Chunk<A>> {
     return shuffleWith(elements, (n) => this.nextIntBetween(0, n))
   }
 }
 
 const shuffleWith = <A>(
   elements: Iterable<A>,
-  nextIntBounded: (n: number) => Effect.Effect<never, never, number>
-): Effect.Effect<never, never, Chunk.Chunk<A>> => {
+  nextIntBounded: (n: number) => Effect.Effect<number>
+): Effect.Effect<Chunk.Chunk<A>> => {
   return core.suspend(() =>
     pipe(
       core.sync(() => Array.from(elements)),

package/src/internal/rateLimiter.ts

@@ -0,0 +1,30 @@
+import type { DurationInput } from "../Duration.js"
+import * as Effect from "../Effect.js"
+import type { RateLimiter } from "../RateLimiter.js"
+import type { Scope } from "../Scope.js"
+import * as SynchronizedRef from "../SynchronizedRef.js"
+
+/** @internal */
+export const make = (limit: number, window: DurationInput): Effect.Effect<
+  RateLimiter,
+  never,
+  Scope
+> =>
+  Effect.gen(function*(_) {
+    const scope = yield* _(Effect.scope)
+    const semaphore = yield* _(Effect.makeSemaphore(limit))
+    const ref = yield* _(SynchronizedRef.make(false))
+    const reset = SynchronizedRef.updateEffect(
+      ref,
+      (running) =>
+        running ? Effect.succeed(true) : Effect.sleep(window).pipe(
+          Effect.zipRight(SynchronizedRef.set(ref, false)),
+          Effect.zipRight(semaphore.releaseAll),
+          Effect.forkIn(scope),
+          Effect.interruptible,
+          Effect.as(true)
+        )
+    )
+    const take = Effect.zipRight(semaphore.take(1), reset)
+    return (effect) => Effect.zipRight(take, effect)
+  })

package/src/internal/ref.ts

@@ -18,7 +18,7 @@ export const refVariance = {
 class RefImpl<in out A> implements Ref.Ref<A> {
   readonly [RefTypeId] = refVariance
   constructor(readonly ref: MutableRef.MutableRef<A>) {}
-  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> {
+  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B> {
     return core.sync(() => {
       const current = MutableRef.get(this.ref)
       const [b, a] = f(current)
@@ -37,33 +37,33 @@ class RefImpl<in out A> implements Ref.Ref<A> {
 export const unsafeMake = <A>(value: A): Ref.Ref<A> => new RefImpl(MutableRef.make(value))
 
 /** @internal */
-export const make = <A>(value: A): Effect.Effect<never, never, Ref.Ref<A>> => core.sync(() => unsafeMake(value))
+export const make = <A>(value: A): Effect.Effect<Ref.Ref<A>> => core.sync(() => unsafeMake(value))
 
 /** @internal */
 export const get = <A>(self: Ref.Ref<A>) => self.modify((a) => [a, a])
 
 /** @internal */
 export const set = dual<
-  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<never, never, void>,
-  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<never, never, void>
+  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<void>,
+  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<void>
 >(2, <A>(self: Ref.Ref<A>, value: A) => self.modify((): [void, A] => [void 0, value]))
 
 /** @internal */
 export const getAndSet = dual<
-  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<never, never, A>,
-  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<never, never, A>
+  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<A>,
+  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<A>
 >(2, <A>(self: Ref.Ref<A>, value: A) => self.modify((a): [A, A] => [a, value]))
 
 /** @internal */
 export const getAndUpdate = dual<
-  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<never, never, A>,
-  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<never, never, A>
+  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<A>,
+  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<A>
 >(2, <A>(self: Ref.Ref<A>, f: (a: A) => A) => self.modify((a): [A, A] => [a, f(a)]))
 
 /** @internal */
 export const getAndUpdateSome = dual<
-  <A>(pf: (a: A) => Option.Option<A>) => (self: Ref.Ref<A>) => Effect.Effect<never, never, A>,
-  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) => Effect.Effect<never, never, A>
+  <A>(pf: (a: A) => Option.Option<A>) => (self: Ref.Ref<A>) => Effect.Effect<A>,
+  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) => Effect.Effect<A>
 >(2, <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) =>
   self.modify((value): [A, A] => {
     const option = pf(value)
@@ -79,14 +79,14 @@ export const getAndUpdateSome = dual<
 
 /** @internal */
 export const setAndGet = dual<
-  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<never, never, A>,
-  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<never, never, A>
+  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<A>,
+  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<A>
 >(2, <A>(self: Ref.Ref<A>, value: A) => self.modify((): [A, A] => [value, value]))
 
 /** @internal */
 export const modify = dual<
-  <A, B>(f: (a: A) => readonly [B, A]) => (self: Ref.Ref<A>) => Effect.Effect<never, never, B>,
-  <A, B>(self: Ref.Ref<A>, f: (a: A) => readonly [B, A]) => Effect.Effect<never, never, B>
+  <A, B>(f: (a: A) => readonly [B, A]) => (self: Ref.Ref<A>) => Effect.Effect<B>,
+  <A, B>(self: Ref.Ref<A>, f: (a: A) => readonly [B, A]) => Effect.Effect<B>
 >(2, (self, f) => self.modify(f))
 
 /** @internal */
@@ -94,12 +94,12 @@ export const modifySome = dual<
   <B, A>(
     fallback: B,
     pf: (a: A) => Option.Option<readonly [B, A]>
-  ) => (self: Ref.Ref<A>) => Effect.Effect<never, never, B>,
+  ) => (self: Ref.Ref<A>) => Effect.Effect<B>,
   <A, B>(
     self: Ref.Ref<A>,
     fallback: B,
     pf: (a: A) => Option.Option<readonly [B, A]>
-  ) => Effect.Effect<never, never, B>
+  ) => Effect.Effect<B>
 >(3, (self, fallback, pf) =>
   self.modify((value) => {
     const option = pf(value)
@@ -115,14 +115,14 @@ export const modifySome = dual<
 
 /** @internal */
 export const update = dual<
-  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<never, never, void>,
-  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<never, never, void>
+  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<void>,
+  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<void>
 >(2, <A>(self: Ref.Ref<A>, f: (a: A) => A) => self.modify((a): [void, A] => [void 0, f(a)]))
 
 /** @internal */
 export const updateAndGet = dual<
-  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<never, never, A>,
-  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<never, never, A>
+  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<A>,
+  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<A>
 >(2, <A>(self: Ref.Ref<A>, f: (a: A) => A) =>
   self.modify((a): [A, A] => {
     const result = f(a)
@@ -131,8 +131,8 @@ export const updateAndGet = dual<
 
 /** @internal */
 export const updateSome = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: Ref.Ref<A>) => Effect.Effect<never, never, void>,
-  <A>(self: Ref.Ref<A>, f: (a: A) => Option.Option<A>) => Effect.Effect<never, never, void>
+  <A>(f: (a: A) => Option.Option<A>) => (self: Ref.Ref<A>) => Effect.Effect<void>,
+  <A>(self: Ref.Ref<A>, f: (a: A) => Option.Option<A>) => Effect.Effect<void>
 >(2, <A>(self: Ref.Ref<A>, f: (a: A) => Option.Option<A>) =>
   self.modify(
     (a): [void, A] => [
@@ -146,8 +146,8 @@ export const updateSome = dual<
 
 /** @internal */
 export const updateSomeAndGet = dual<
-  <A>(pf: (a: A) => Option.Option<A>) => (self: Ref.Ref<A>) => Effect.Effect<never, never, A>,
-  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) => Effect.Effect<never, never, A>
+  <A>(pf: (a: A) => Option.Option<A>) => (self: Ref.Ref<A>) => Effect.Effect<A>,
+  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) => Effect.Effect<A>
 >(2, <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) =>
   self.modify((value): [A, A] => {
     const option = pf(value)