effect 4.0.0-beta.31 → 4.0.0-beta.32

package/src/Semaphore.ts

@@ -1,10 +1,12 @@
 /**
  * @since 2.0.0
  */
-import * as Effect from "./Effect.ts"
+import type * as Effect from "./Effect.ts"
+import type { Fiber } from "./Fiber.ts"
+import { dual } from "./Function.ts"
+import * as core from "./internal/core.ts"
 import * as internal from "./internal/effect.ts"
-import * as MutableHashMap from "./MutableHashMap.ts"
-import * as Option from "./Option.ts"
+import type * as Option from "./Option.ts"
 
 /**
  * @category models
@@ -27,7 +29,7 @@ export interface Semaphore {
   /**
    * Adjusts the number of permits available in the semaphore.
    */
-  resize(permits: number): Effect.Effect<void>
+  resize(this: Semaphore, permits: number): Effect.Effect<void>
 
   /**
    * Runs an effect with the given number of permits and releases the permits
@@ -40,7 +42,7 @@ export interface Semaphore {
    * If insufficient permits are available, the function will wait until they
    * are released by other tasks.
    */
-  withPermits(permits: number): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  withPermits(this: Semaphore, permits: number): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 
   /**
    * Runs an effect with the given number of permits and releases the permits
@@ -53,7 +55,7 @@ export interface Semaphore {
    * If insufficient permits are available, the function will wait until they
    * are released by other tasks.
    */
-  withPermit<A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+  withPermit<A, E, R>(this: Semaphore, self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
 
   /**
    * Runs an effect only if the specified number of permits are immediately
@@ -67,6 +69,7 @@ export interface Semaphore {
    * the result is `Option.none`.
    */
   withPermitsIfAvailable(
+    this: Semaphore,
     permits: number
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, R>
 
@@ -75,18 +78,18 @@ export interface Semaphore {
    * available permits, suspending the task if they are not yet available.
    * Concurrent pending `take` calls are processed in a first-in, first-out manner.
    */
-  take(permits: number): Effect.Effect<number>
+  take(this: Semaphore, permits: number): Effect.Effect<number>
 
   /**
    * Releases the specified number of permits and returns the resulting
    * available permits.
    */
-  release(permits: number): Effect.Effect<number>
+  release(this: Semaphore, permits: number): Effect.Effect<number>
 
   /**
    * Releases all permits held by this semaphore and returns the resulting available permits.
    */
-  releaseAll: Effect.Effect<number>
+  readonly releaseAll: Effect.Effect<number>
 }
 
 /**
@@ -126,7 +129,113 @@ export interface Semaphore {
  * @since 2.0.0
  * @category constructors
  */
-export const makeUnsafe: (permits: number) => Semaphore = internal.makeSemaphoreUnsafe
+export const makeUnsafe = (permits: number): Semaphore => new SemaphoreImpl(permits)
+
+class SemaphoreImpl implements Semaphore {
+  public waiters = new Set<() => void>()
+  public taken = 0
+  public permits: number
+
+  constructor(permits: number) {
+    this.permits = permits
+  }
+
+  get free() {
+    return this.permits - this.taken
+  }
+
+  take(n: number): Effect.Effect<number> {
+    const take: Effect.Effect<number> = internal.suspend(() => {
+      if (this.free < n) {
+        return internal.callback((resume) => {
+          if (this.free >= n) return resume(take)
+          const observer = () => {
+            if (this.free < n) return
+            this.waiters.delete(observer)
+            resume(take)
+          }
+          this.waiters.add(observer)
+          return internal.sync(() => {
+            this.waiters.delete(observer)
+          })
+        })
+      }
+      this.taken += n
+      return internal.succeed(n)
+    })
+    return take
+  }
+
+  updateTakenUnsafe(fiber: Fiber<any, any>, f: (n: number) => number): number {
+    this.taken = f(this.taken)
+    if (this.waiters.size > 0) {
+      fiber.currentDispatcher.scheduleTask(() => {
+        const iter = this.waiters.values()
+        let item = iter.next()
+        while (item.done === false && this.free > 0) {
+          item.value()
+          item = iter.next()
+        }
+      }, 0)
+    }
+    return this.free
+  }
+
+  updateTaken(f: (n: number) => number): Effect.Effect<number> {
+    return core.withFiber((fiber) => internal.succeed(this.updateTakenUnsafe(fiber, f)))
+  }
+
+  resize(permits: number) {
+    return core.withFiber((fiber) => {
+      this.permits = permits
+      if (this.free < 0) return internal.void
+      this.updateTakenUnsafe(fiber, (taken) => taken)
+      return internal.void
+    })
+  }
+
+  release(n: number): Effect.Effect<number> {
+    return this.updateTaken((taken) => taken - n)
+  }
+
+  get releaseAll(): Effect.Effect<number> {
+    return this.updateTaken((_) => 0)
+  }
+
+  withPermits(n: number) {
+    return <A, E, R>(self: Effect.Effect<A, E, R>) =>
+      internal.uninterruptibleMask((restore) =>
+        internal.flatMap(
+          restore(this.take(n)),
+          (permits) =>
+            internal.onExitPrimitive(
+              restore(self),
+              () => {
+                this.updateTakenUnsafe(internal.getCurrentFiber()!, (taken) => taken - permits)
+                return undefined
+              },
+              true
+            )
+        )
+      )
+  }
+
+  get withPermit(): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> {
+    return this.withPermits(1)
+  }
+
+  withPermitsIfAvailable(n: number) {
+    return <A, E, R>(self: Effect.Effect<A, E, R>) =>
+      internal.uninterruptibleMask((restore) => {
+        if (this.free < n) return internal.succeedNone
+        this.taken += n
+        return internal.onExitPrimitive(restore(internal.asSome(self)), () => {
+          this.updateTakenUnsafe(internal.getCurrentFiber()!, (taken) => taken - n)
+          return undefined
+        }, true)
+      })
+  }
+}
 
 /**
  * Creates a new Semaphore.
@@ -161,196 +270,175 @@ export const makeUnsafe: (permits: number) => Semaphore = internal.makeSemaphore
  * @since 2.0.0
  * @category constructors
  */
-export const make: (permits: number) => Effect.Effect<Semaphore> = internal.makeSemaphore
-
-// -----------------------------------------------------------------------------
-// Partitioned
-// -----------------------------------------------------------------------------
+export const make = (permits: number): Effect.Effect<Semaphore> => internal.sync(() => new SemaphoreImpl(permits))
 
 /**
- * @since 3.19.4
- * @category models
+ * Adjusts the number of permits available in the semaphore.
+ *
+ * @since 4.0.0
+ * @category combinators
  */
-export const PartitionedTypeId: PartitionedTypeId = "~effect/PartitionedSemaphore"
+export const resize: {
+  /**
+   * Adjusts the number of permits available in the semaphore.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (permits: number): (self: Semaphore) => Effect.Effect<void>
+  /**
+   * Adjusts the number of permits available in the semaphore.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Semaphore, permits: number): Effect.Effect<void>
+} = dual(2, (self: Semaphore, permits: number) => self.resize(permits))
 
 /**
- * @since 3.19.4
- * @category models
+ * Runs an effect with the given number of permits and releases the permits when
+ * the effect completes.
+ *
+ * @since 4.0.0
+ * @category combinators
  */
-export type PartitionedTypeId = "~effect/PartitionedSemaphore"
+export const withPermits: {
+  /**
+   * Runs an effect with the given number of permits and releases the permits when
+   * the effect completes.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Semaphore, permits: number): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  /**
+   * Runs an effect with the given number of permits and releases the permits when
+   * the effect completes.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  <A, E, R>(self: Semaphore, permits: number, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+} = ((self: Semaphore, permits: number, effect?: Effect.Effect<any, any, any>) => {
+  const withPermits = self.withPermits(permits)
+  return effect ? withPermits(effect) : withPermits
+}) as any
 
 /**
- * A `Partitioned` semaphore controls access to a shared permit pool while
- * tracking waiters by partition key.
- *
- * Waiting permits are distributed across partitions in round-robin order.
- *
- * **Previously Known As**
- *
- * This API replaces the following from Effect 3.x:
- *
- * - `PartitionedSemaphore.PartitionedSemaphore`
+ * Runs an effect with a single permit and releases the permit when the effect
+ * completes.
  *
- * @since 3.19.4
- * @category models
+ * @since 4.0.0
+ * @category combinators
  */
-export interface Partitioned<in K> {
-  readonly [PartitionedTypeId]: PartitionedTypeId
-  readonly withPermits: (
-    key: K,
-    permits: number
-  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-}
+export const withPermit: {
+  /**
+   * Runs an effect with a single permit and releases the permit when the effect
+   * completes.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Semaphore): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  /**
+   * Runs an effect with a single permit and releases the permit when the effect
+   * completes.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  <A, E, R>(self: Semaphore, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+} = ((self: Semaphore, effect?: Effect.Effect<any, any, any>) => {
+  if (!effect) return self.withPermit
+  return self.withPermit(effect)
+}) as any
 
 /**
- * Creates a `Partitioned` semaphore unsafely.
+ * Runs an effect only if the specified number of permits are immediately
+ * available.
  *
- * **Previously Known As**
- *
- * This API replaces the following from Effect 3.x:
- *
- * - `PartitionedSemaphore.makeUnsafe`
- *
- * @since 3.19.4
- * @category constructors
+ * @since 4.0.0
+ * @category combinators
  */
-export const makePartitionedUnsafe = <K = unknown>(options: {
-  readonly permits: number
-}): Partitioned<K> => {
-  const maxPermits = Math.max(0, options.permits)
-
-  if (!Number.isFinite(maxPermits)) {
-    return {
-      [PartitionedTypeId]: PartitionedTypeId,
-      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.callback<void>((resume) => {
-      if (maxPermits < permits) {
-        resume(Effect.never)
-        return
-      }
-
-      if (totalPermits >= permits) {
-        totalPermits -= permits
-        resume(Effect.void)
-        return
-      }
-
-      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)
-        }
-      }
-
-      const 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): void => {
-    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 waiter = state.value[1].values().next().value
-      if (waiter === undefined) {
-        continue
-      }
-
-      waiter.permits -= 1
-      waitingPermits -= 1
-
-      if (waiter.permits === 0) {
-        waiter.resume()
-      }
-
-      permits -= 1
-    }
-  }
-
-  return {
-    [PartitionedTypeId]: PartitionedTypeId,
-    withPermits: (key, permits) => {
-      const takePermits = take(key, permits)
-      return (effect) =>
-        Effect.uninterruptibleMask((restore) =>
-          Effect.flatMap(
-            restore(takePermits),
-            () => Effect.ensuring(restore(effect), Effect.sync(() => releaseUnsafe(permits)))
-          )
-        )
-    }
-  }
-}
+export const withPermitsIfAvailable: {
+  /**
+   * Runs an effect only if the specified number of permits are immediately
+   * available.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Semaphore, permits: number): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, R>
+  /**
+   * Runs an effect only if the specified number of permits are immediately
+   * available.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  <A, E, R>(self: Semaphore, permits: number, effect: Effect.Effect<A, E, R>): Effect.Effect<Option.Option<A>, E, R>
+} = ((self: Semaphore, permits: number, effect?: Effect.Effect<any, any, any>) => {
+  const withPermits = self.withPermitsIfAvailable(permits)
+  return effect ? withPermits(effect) : withPermits
+}) as any
 
 /**
- * Creates a `Partitioned` semaphore.
+ * Acquires the specified number of permits and returns the resulting available
+ * permits, suspending the task if they are not yet available.
  *
- * **Previously Known As**
- *
- * This API replaces the following from Effect 3.x:
+ * @since 4.0.0
+ * @category combinators
+ */
+export const take: {
+  /**
+   * Acquires the specified number of permits and returns the resulting available
+   * permits, suspending the task if they are not yet available.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (permits: number): (self: Semaphore) => Effect.Effect<number>
+  /**
+   * Acquires the specified number of permits and returns the resulting available
+   * permits, suspending the task if they are not yet available.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Semaphore, permits: number): Effect.Effect<number>
+} = dual(2, (self: Semaphore, permits: number) => self.take(permits))
+
+/**
+ * Releases the specified number of permits and returns the resulting available
+ * permits.
  *
- * - `PartitionedSemaphore.make`
+ * @since 4.0.0
+ * @category combinators
+ */
+export const release: {
+  /**
+   * Releases the specified number of permits and returns the resulting available
+   * permits.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (permits: number): (self: Semaphore) => Effect.Effect<number>
+  /**
+   * Releases the specified number of permits and returns the resulting available
+   * permits.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Semaphore, permits: number): Effect.Effect<number>
+} = dual(2, (self: Semaphore, permits: number) => self.release(permits))
+
+/**
+ * Releases all permits held by this semaphore and returns the resulting
+ * available permits.
  *
- * @since 3.19.4
- * @category constructors
+ * @since 4.0.0
+ * @category combinators
  */
-export const makePartitioned = <K = unknown>(options: {
-  readonly permits: number
-}): Effect.Effect<Partitioned<K>> => Effect.sync(() => makePartitionedUnsafe<K>(options))
+export const releaseAll = (self: Semaphore): Effect.Effect<number> => self.releaseAll

package/src/ServiceMap.ts

@@ -446,6 +446,7 @@ export interface ServiceMap<in Services> extends Equal.Equal, Pipeable, Inspecta
     readonly _Services: Types.Contravariant<Services>
   }
   readonly mapUnsafe: ReadonlyMap<string, any>
+  mutable: boolean
 }
 
 /**
@@ -467,10 +468,11 @@ export interface ServiceMap<in Services> extends Equal.Equal, Pipeable, Inspecta
 export const makeUnsafe = <Services = never>(mapUnsafe: ReadonlyMap<string, any>): ServiceMap<Services> => {
   const self = Object.create(Proto)
   self.mapUnsafe = mapUnsafe
+  self.mutable = false
   return self
 }
 
-const Proto: Omit<ServiceMap<never>, "mapUnsafe"> = {
+const Proto: Omit<ServiceMap<never>, "mapUnsafe" | "mutable"> = {
   ...PipeInspectableProto,
   [TypeId]: {
     _Services: (_: never) => _
@@ -676,11 +678,10 @@ export const add: {
   self: ServiceMap<Services>,
   key: Key<I, S>,
   service: Types.NoInfer<S>
-): ServiceMap<Services | I> => {
-  const map = new Map(self.mapUnsafe)
-  map.set(key.key, service)
-  return makeUnsafe(map)
-})
+): ServiceMap<Services | I> =>
+  withMapUnsafe(self, (map) => {
+    map.set(key.key, service)
+  }))
 
 /**
  * @since 4.0.0
@@ -705,15 +706,14 @@ export const addOrOmit: {
   self: ServiceMap<Services>,
   key: Key<I, S>,
   service: Option.Option<Types.NoInfer<S>>
-): ServiceMap<Services | I> => {
-  const map = new Map(self.mapUnsafe)
-  if (service._tag === "None") {
-    map.delete(key.key)
-  } else {
-    map.set(key.key, service.value)
-  }
-  return makeUnsafe(map)
-})
+): ServiceMap<Services | I> =>
+  withMapUnsafe(self, (map) => {
+    if (service._tag === "None") {
+      map.delete(key.key)
+    } else {
+      map.set(key.key, service.value)
+    }
+  }))
 
 /**
  * Get a service from the context that corresponds to the given key, or
@@ -1253,9 +1253,9 @@ export const merge: {
 } = dual(2, <Services, R1>(self: ServiceMap<Services>, that: ServiceMap<R1>): ServiceMap<Services | R1> => {
   if (self.mapUnsafe.size === 0) return that as any
   if (that.mapUnsafe.size === 0) return self as any
-  const map = new Map(self.mapUnsafe)
-  that.mapUnsafe.forEach((value, key) => map.set(key, value))
-  return makeUnsafe(map)
+  return withMapUnsafe(self, (map) => {
+    that.mapUnsafe.forEach((value, key) => map.set(key, value))
+  })
 })
 
 /**
@@ -1333,16 +1333,14 @@ export const mergeAll = <T extends Array<unknown>>(
 export const pick = <S extends ReadonlyArray<Key<any, any>>>(
   ...services: S
 ) =>
-<Services>(self: ServiceMap<Services>): ServiceMap<Services & Service.Identifier<S[number]>> => {
-  const map = new Map<string, any>()
-  const keySet = new Set(services.map((key) => key.key))
-  self.mapUnsafe.forEach((value, key) => {
-    if (keySet.has(key)) {
-      map.set(key, value)
-    }
+<Services>(self: ServiceMap<Services>): ServiceMap<Services & Service.Identifier<S[number]>> =>
+  withMapUnsafe(self, (map) => {
+    const keySet = new Set(services.map((key) => key.key))
+    map.forEach((_, key) => {
+      if (keySet.has(key)) return
+      map.delete(key)
+    })
   })
-  return makeUnsafe(map)
-}
 
 /**
  * @example
@@ -1373,11 +1371,65 @@ export const pick = <S extends ReadonlyArray<Key<any, any>>>(
 export const omit = <S extends ReadonlyArray<Key<any, any>>>(
   ...keys: S
 ) =>
-<Services>(self: ServiceMap<Services>): ServiceMap<Exclude<Services, Service.Identifier<S[number]>>> => {
-  const map = new Map(self.mapUnsafe)
-  for (let i = 0; i < keys.length; i++) {
-    map.delete(keys[i].key)
+<Services>(self: ServiceMap<Services>): ServiceMap<Exclude<Services, Service.Identifier<S[number]>>> =>
+  withMapUnsafe(self, (map) => {
+    for (let i = 0; i < keys.length; i++) {
+      map.delete(keys[i].key)
+    }
+  })
+
+/**
+ * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+ * of the underlying map when multiple mutations are needed.
+ *
+ * @since 4.0.0
+ * @category Utils
+ */
+export const mutate: {
+  /**
+   * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+   * of the underlying map when multiple mutations are needed.
+   *
+   * @since 4.0.0
+   * @category Utils
+   */
+  <Services, B>(f: (serviceMap: ServiceMap<Services>) => ServiceMap<B>): <Services>(self: ServiceMap<Services>) => ServiceMap<B>
+  /**
+   * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+   * of the underlying map when multiple mutations are needed.
+   *
+   * @since 4.0.0
+   * @category Utils
+   */
+  <Services, B>(
+    self: ServiceMap<Services>,
+    f: (serviceMap: ServiceMap<Services>) => ServiceMap<B>
+  ): ServiceMap<B>
+} = dual(
+  2,
+  <Services, B>(self: ServiceMap<Services>, f: (serviceMap: ServiceMap<Services>) => ServiceMap<B>): ServiceMap<B> => {
+    const next = makeUnsafe</**
+     * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+     * of the underlying map when multiple mutations are needed.
+     *
+     * @since 4.0.0
+     * @category Utils
+     */
+    Services>(new Map(self.mapUnsafe))
+    next.mutable = true
+    const result = f(next)
+    result.mutable = false
+    return result
   }
+)
+
+const withMapUnsafe = <Services, B>(self: ServiceMap<Services>, f: (map: Map<string, any>) => void): ServiceMap<B> => {
+  if (self.mutable) {
+    f(self.mapUnsafe as any)
+    return self as any
+  }
+  const map = new Map(self.mapUnsafe)
+  f(map)
   return makeUnsafe(map)
 }