Function getOrCreatePool

packages/effect/src/internal/keyedPool.ts:110–175

(key: K)

    ]),
    core.map(([context, fiberId, map, scope]) => {
      const getOrCreatePool = (key: K): Effect.Effect<Pool.Pool<A, E>> =>
        core.suspend(() => {
          let value: MapValue<A, E> | undefined = Option.getOrUndefined(HashMap.get(MutableRef.get(map), key))
          if (value === undefined) {
            return core.uninterruptibleMask((restore) => {
              const deferred = core.deferredUnsafeMake<Pool.Pool<A, E>>(fiberId)
              value = new Pending(deferred)
              let previous: MapValue<A, E> | undefined = undefined
              if (HashMap.has(MutableRef.get(map), key)) {
                previous = Option.getOrUndefined(HashMap.get(MutableRef.get(map), key))
              } else {
                MutableRef.update(map, HashMap.set(key, value as MapValue<A, E>))
              }
              if (previous === undefined) {
                return pipe(
                  restore(
                    fiberRuntime.scopeExtend(
                      pool.makeWithTTL({
                        acquire: core.provideContext(get(key), context),
                        min: min(key),
                        max: max(key),
                        timeToLive: Option.getOrElse(timeToLive(key), () => Duration.infinity)
                      }),
                      scope
                    )
                  ),
                  core.matchCauseEffect({
                    onFailure: (cause) => {
                      const current = Option.getOrUndefined(HashMap.get(MutableRef.get(map), key))
                      if (Equal.equals(current, value)) {
                        MutableRef.update(map, HashMap.remove(key))
                      }
                      return core.zipRight(
                        core.deferredFailCause(deferred, cause),
                        core.failCause(cause)
                      )
                    },
                    onSuccess: (pool) => {
                      MutableRef.update(map, HashMap.set(key, new Complete(pool) as MapValue<A, E>))
                      return core.as(
                        core.deferredSucceed(deferred, pool),
                        pool
                      )
                    }
                  })
                )
              }
              switch (previous._tag) {
                case "Complete": {
                  return core.succeed(previous.pool)
                }
                case "Pending": {
                  return restore(core.deferredAwait(previous.deferred))
                }
              }
            })
          }
          switch (value._tag) {