effect 3.19.3 → 3.19.5

package/src/PartitionedSemaphore.ts

@@ -0,0 +1,200 @@
+/**
+ * @since 3.19.4
+ * @experimental
+ */
+import * as Effect from "./Effect.js"
+import * as Iterable from "./Iterable.js"
+import * as MutableHashMap from "./MutableHashMap.js"
+import * as Option from "./Option.js"
+
+/**
+ * @since 3.19.4
+ * @category Models
+ * @experimental
+ */
+export const TypeId: TypeId = "~effect/PartitionedSemaphore"
+
+/**
+ * @since 3.19.4
+ * @category Models
+ * @experimental
+ */
+export type TypeId = "~effect/PartitionedSemaphore"
+
+/**
+ * A `PartitionedSemaphore` is a concurrency primitive that can be used to
+ * control concurrent access to a resource across multiple partitions identified
+ * by keys.
+ *
+ * The total number of permits is shared across all partitions, with waiting
+ * permits equally distributed among partitions using a round-robin strategy.
+ *
+ * This is useful when you want to limit the total number of concurrent accesses
+ * to a resource, while still allowing for fair distribution of access across
+ * different partitions.
+ *
+ * @since 3.19.4
+ * @category Models
+ * @experimental
+ */
+export interface PartitionedSemaphore<in K> {
+  readonly [TypeId]: TypeId
+
+  readonly withPermits: (
+    key: K,
+    permits: number
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+}
+
+/**
+ * A `PartitionedSemaphore` is a concurrency primitive that can be used to
+ * control concurrent access to a resource across multiple partitions identified
+ * by keys.
+ *
+ * The total number of permits is shared across all partitions, with waiting
+ * permits equally distributed among partitions using a round-robin strategy.
+ *
+ * This is useful when you want to limit the total number of concurrent accesses
+ * to a resource, while still allowing for fair distribution of access across
+ * different partitions.
+ *
+ * @since 3.19.4
+ * @category Constructors
+ * @experimental
+ */
+export const makeUnsafe = <K = unknown>(options: {
+  readonly permits: number
+}): PartitionedSemaphore<K> => {
+  const maxPermits = Math.max(0, options.permits)
+
+  if (!Number.isFinite(maxPermits)) {
+    return {
+      [TypeId]: TypeId,
+      withPermits: () => (effect) => effect
+    }
+  }
+
+  let totalPermits = maxPermits
+  let waitingPermits = 0
+
+  type Waiter = {
+    permits: number
+    readonly resume: () => void
+  }
+  const partitions = MutableHashMap.empty<K, Set<Waiter>>()
+
+  const take = (key: K, permits: number) =>
+    Effect.async<void>((resume) => {
+      if (maxPermits < permits) {
+        return resume(Effect.never)
+      } else if (totalPermits >= permits) {
+        totalPermits -= permits
+        return resume(Effect.void)
+      }
+
+      const needed = permits - totalPermits
+      const taken = permits - needed
+      if (totalPermits > 0) {
+        totalPermits = 0
+      }
+      waitingPermits += needed
+
+      const waiters = Option.getOrElse(
+        MutableHashMap.get(partitions, key),
+        () => {
+          const set = new Set<Waiter>()
+          MutableHashMap.set(partitions, key, set)
+          return set
+        }
+      )
+
+      const entry: Waiter = {
+        permits: needed,
+        resume() {
+          cleanup()
+          resume(Effect.void)
+        }
+      }
+      function cleanup() {
+        waiters.delete(entry)
+        if (waiters.size === 0) {
+          MutableHashMap.remove(partitions, key)
+        }
+      }
+      waiters.add(entry)
+      return Effect.sync(() => {
+        cleanup()
+        waitingPermits -= entry.permits
+        if (taken > 0) {
+          releaseUnsafe(taken)
+        }
+      })
+    })
+
+  let iterator = partitions[Symbol.iterator]()
+  const releaseUnsafe = (permits: number) => {
+    while (permits > 0) {
+      if (waitingPermits === 0) {
+        totalPermits += permits
+        return
+      }
+
+      let state = iterator.next()
+      if (state.done) {
+        iterator = partitions[Symbol.iterator]()
+        state = iterator.next()
+        if (state.done) return
+      }
+
+      const entry = Iterable.unsafeHead(state.value[1])
+      entry.permits--
+      waitingPermits--
+      if (entry.permits === 0) entry.resume()
+      permits--
+    }
+  }
+
+  return {
+    [TypeId]: TypeId,
+    withPermits: (key, permits) => {
+      const takePermits = take(key, permits)
+      const release: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> = Effect.matchCauseEffect({
+        onFailure(cause) {
+          releaseUnsafe(permits)
+          return Effect.failCause(cause)
+        },
+        onSuccess(value) {
+          releaseUnsafe(permits)
+          return Effect.succeed(value)
+        }
+      })
+      return (effect) =>
+        Effect.uninterruptibleMask((restore) =>
+          Effect.flatMap(
+            restore(takePermits),
+            () => release(restore(effect))
+          )
+        )
+    }
+  }
+}
+
+/**
+ * A `PartitionedSemaphore` is a concurrency primitive that can be used to
+ * control concurrent access to a resource across multiple partitions identified
+ * by keys.
+ *
+ * The total number of permits is shared across all partitions, with waiting
+ * permits equally distributed among partitions using a round-robin strategy.
+ *
+ * This is useful when you want to limit the total number of concurrent accesses
+ * to a resource, while still allowing for fair distribution of access across
+ * different partitions.
+ *
+ * @since 3.19.4
+ * @category Constructors
+ * @experimental
+ */
+export const make = <K = unknown>(options: {
+  readonly permits: number
+}): Effect.Effect<PartitionedSemaphore<K>> => Effect.sync(() => makeUnsafe<K>(options))

package/src/Types.ts

@@ -261,7 +261,7 @@ export type Mutable<T> = {
  */
 export type DeepMutable<T> = T extends ReadonlyMap<infer K, infer V> ? Map<DeepMutable<K>, DeepMutable<V>>
   : T extends ReadonlySet<infer V> ? Set<DeepMutable<V>>
-  : T extends string | number | boolean | bigint | symbol ? T
+  : T extends string | number | boolean | bigint | symbol | Function ? T
   : { -readonly [K in keyof T]: DeepMutable<T[K]> }
 
 /**

package/src/index.ts

@@ -1090,6 +1090,12 @@ export * as Ordering from "./Ordering.js"
  */
 export * as ParseResult from "./ParseResult.js"
 
+/**
+ * @since 3.19.4
+ * @experimental
+ */
+export * as PartitionedSemaphore from "./PartitionedSemaphore.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/fiberRuntime.ts

@@ -194,10 +194,20 @@ const contOpSuccess = {
     cont: core.FromIterator,
     value: unknown
   ) => {
-    const state = internalCall(() => cont.effect_instruction_i0.next(value))
-    if (state.done) return core.exitSucceed(state.value)
-    self.pushStack(cont)
-    return yieldWrapGet(state.value)
+    while (true) {
+      const state = internalCall(() => cont.effect_instruction_i0.next(value))
+      if (state.done) {
+        return core.exitSucceed(state.value)
+      }
+      const primitive = yieldWrapGet(state.value)
+      if (!core.exitIsExit(primitive)) {
+        self.pushStack(cont)
+        return primitive
+      } else if (primitive._tag === "Failure") {
+        return primitive
+      }
+      value = primitive.value
+    }
   }
 }
 

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.19.3"
+let moduleVersion = "3.19.5"
 
 export const getCurrentVersion = () => moduleVersion