Method get

packages/effect/src/internal/scopedCache.ts:260–306

(key: Key)

  }

  get(key: Key): Effect.Effect<Value, Error, Scope.Scope> {
    return pipe(
      this.lookupValueOf(key),
      effect.memoize,
      core.flatMap((lookupValue) =>
        core.suspend(() => {
          let k: cache_.MapKey<Key> | undefined = undefined
          let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
          if (value === undefined) {
            k = cache_.makeMapKey(key)
            if (MutableHashMap.has(this.cacheState.map, key)) {
              value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
            } else {
              MutableHashMap.set(this.cacheState.map, key, pending(k, lookupValue))
            }
          }
          if (value === undefined) {
            this.trackMiss()
            return core.zipRight(
              this.ensureMapSizeNotExceeded(k!),
              lookupValue
            )
          }

          return core.map(
            this.resolveMapValue(value),
            core.flatMap(Option.match({
              onNone: () => {
                const val = value as Complete<Key, Value, Error>
                const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
                if (Equal.equals(current, value)) {
                  MutableHashMap.remove(this.cacheState.map, key)
                }
                return pipe(
                  this.ensureMapSizeNotExceeded(val.key),
                  core.zipRight(releaseOwner(val)),
                  core.zipRight(this.get(key))
                )
              },
              onSome: core.succeed
            }))
          )
        })
      ),
      core.flatten
    )
  }

  invalidate(key: Key): Effect.Effect<void> {
    return core.suspend(() => {