Function take

packages/effect/src/PartitionedSemaphore.ts:86–132

(key: K, permits: number)

  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) => {