effect 3.4.9 → 3.5.0

package/src/internal/rcMap.ts

@@ -0,0 +1,213 @@
+import type * as Cause from "../Cause.js"
+import * as Context from "../Context.js"
+import type * as Deferred from "../Deferred.js"
+import * as Duration from "../Duration.js"
+import type { Effect } from "../Effect.js"
+import type { RuntimeFiber } from "../Fiber.js"
+import { dual, identity } from "../Function.js"
+import * as MutableHashMap from "../MutableHashMap.js"
+import { pipeArguments } from "../Pipeable.js"
+import type * as RcMap from "../RcMap.js"
+import type * as Scope from "../Scope.js"
+import * as coreEffect from "./core-effect.js"
+import * as core from "./core.js"
+import * as circular from "./effect/circular.js"
+import * as fiberRuntime from "./fiberRuntime.js"
+
+/** @internal */
+export const TypeId: RcMap.TypeId = Symbol.for("effect/RcMap") as RcMap.TypeId
+
+type State<K, A, E> = State.Open<K, A, E> | State.Closed
+
+declare namespace State {
+  interface Open<K, A, E> {
+    readonly _tag: "Open"
+    readonly map: MutableHashMap.MutableHashMap<K, Entry<A, E>>
+  }
+
+  interface Closed {
+    readonly _tag: "Closed"
+  }
+
+  interface Entry<A, E> {
+    readonly deferred: Deferred.Deferred<A, E>
+    readonly scope: Scope.CloseableScope
+    fiber: RuntimeFiber<void, never> | undefined
+    refCount: number
+  }
+}
+
+const variance: RcMap.RcMap.Variance<any, any, any> = {
+  _K: identity,
+  _A: identity,
+  _E: identity
+}
+
+class RcMapImpl<K, A, E> implements RcMap.RcMap<K, A, E> {
+  readonly [TypeId]: RcMap.RcMap.Variance<K, A, E>
+
+  state: State<K, A, E> = {
+    _tag: "Open",
+    map: MutableHashMap.empty()
+  }
+  readonly semaphore = circular.unsafeMakeSemaphore(1)
+
+  constructor(
+    readonly lookup: (key: K) => Effect<A, E, Scope.Scope>,
+    readonly context: Context.Context<never>,
+    readonly scope: Scope.Scope,
+    readonly idleTimeToLive: Duration.Duration | undefined,
+    readonly capacity: number
+  ) {
+    this[TypeId] = variance
+  }
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const make: {
+  <K, A, E, R>(options: {
+    readonly lookup: (key: K) => Effect<A, E, R>
+    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly capacity?: undefined
+  }): Effect<RcMap.RcMap<K, A, E>, never, Scope.Scope | R>
+  <K, A, E, R>(options: {
+    readonly lookup: (key: K) => Effect<A, E, R>
+    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly capacity: number
+  }): Effect<RcMap.RcMap<K, A, E | Cause.ExceededCapacityException>, never, Scope.Scope | R>
+} = <K, A, E, R>(options: {
+  readonly lookup: (key: K) => Effect<A, E, R>
+  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly capacity?: number | undefined
+}) =>
+  core.withFiberRuntime<RcMap.RcMap<K, A, E>, never, R | Scope.Scope>((fiber) => {
+    const context = fiber.getFiberRef(core.currentContext) as Context.Context<R | Scope.Scope>
+    const scope = Context.get(context, fiberRuntime.scopeTag)
+    const self = new RcMapImpl<K, A, E>(
+      options.lookup as any,
+      context,
+      scope,
+      options.idleTimeToLive ? Duration.decode(options.idleTimeToLive) : undefined,
+      Math.max(options.capacity ?? Number.POSITIVE_INFINITY, 0)
+    )
+    return core.as(
+      scope.addFinalizer(() =>
+        core.suspend(() => {
+          if (self.state._tag === "Closed") {
+            return core.void
+          }
+          const map = self.state.map
+          self.state = { _tag: "Closed" }
+          return core.forEachSequentialDiscard(
+            map,
+            ([, entry]) => core.scopeClose(entry.scope, core.exitVoid)
+          ).pipe(
+            core.tap(() => {
+              MutableHashMap.clear(map)
+            }),
+            self.semaphore.withPermits(1)
+          )
+        })
+      ),
+      self
+    )
+  })
+
+/** @internal */
+export const get: {
+  <K>(key: K): <A, E>(self: RcMap.RcMap<K, A, E>) => Effect<A, E, Scope.Scope>
+  <K, A, E>(self: RcMap.RcMap<K, A, E>, key: K): Effect<A, E, Scope.Scope>
+} = dual(
+  2,
+  <K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K): Effect<A, E, Scope.Scope> => {
+    const self = self_ as RcMapImpl<K, A, E>
+    return core.uninterruptibleMask((restore) =>
+      core.suspend(() => {
+        if (self.state._tag === "Closed") {
+          return core.interrupt
+        }
+        const state = self.state
+        const o = MutableHashMap.get(state.map, key)
+        if (o._tag === "Some") {
+          const entry = o.value
+          entry.refCount++
+          return entry.fiber
+            ? core.as(core.interruptFiber(entry.fiber), entry)
+            : core.succeed(entry)
+        } else if (Number.isFinite(self.capacity) && MutableHashMap.size(self.state.map) >= self.capacity) {
+          return core.fail(
+            new core.ExceededCapacityException(`RcMap attempted to exceed capacity of ${self.capacity}`)
+          ) as Effect<never>
+        }
+        const acquire = self.lookup(key)
+        return fiberRuntime.scopeMake().pipe(
+          coreEffect.bindTo("scope"),
+          coreEffect.bind("deferred", () => core.deferredMake<A, E>()),
+          core.tap(({ deferred, scope }) =>
+            restore(core.fiberRefLocally(
+              acquire as Effect<A, E>,
+              core.currentContext,
+              Context.add(self.context, fiberRuntime.scopeTag, scope)
+            )).pipe(
+              core.exit,
+              core.flatMap((exit) => core.deferredDone(deferred, exit)),
+              circular.forkIn(scope)
+            )
+          ),
+          core.map(({ deferred, scope }) => {
+            const entry: State.Entry<A, E> = {
+              deferred,
+              scope,
+              fiber: undefined,
+              refCount: 1
+            }
+            MutableHashMap.set(state.map, key, entry)
+            return entry
+          })
+        )
+      }).pipe(
+        self.semaphore.withPermits(1),
+        coreEffect.bindTo("entry"),
+        coreEffect.bind("scope", () => fiberRuntime.scopeTag),
+        core.tap(({ entry, scope }) =>
+          scope.addFinalizer(() =>
+            core.suspend(() => {
+              entry.refCount--
+              if (entry.refCount > 0) {
+                return core.void
+              } else if (self.idleTimeToLive === undefined) {
+                if (self.state._tag === "Open") {
+                  MutableHashMap.remove(self.state.map, key)
+                }
+                return core.scopeClose(entry.scope, core.exitVoid)
+              }
+              return coreEffect.sleep(self.idleTimeToLive).pipe(
+                core.interruptible,
+                core.zipRight(core.suspend(() => {
+                  if (self.state._tag === "Open" && entry.refCount === 0) {
+                    MutableHashMap.remove(self.state.map, key)
+                    return core.scopeClose(entry.scope, core.exitVoid)
+                  }
+                  return core.void
+                })),
+                fiberRuntime.ensuring(core.sync(() => {
+                  entry.fiber = undefined
+                })),
+                circular.forkIn(self.scope),
+                core.tap((fiber) => {
+                  entry.fiber = fiber
+                }),
+                self.semaphore.withPermits(1)
+              )
+            })
+          )
+        ),
+        core.flatMap(({ entry }) => restore(core.deferredAwait(entry.deferred)))
+      )
+    )
+  }
+)

package/src/internal/rcRef.ts

@@ -0,0 +1,172 @@
+import * as Context from "../Context.js"
+import * as Duration from "../Duration.js"
+import type { Effect } from "../Effect.js"
+import type { RuntimeFiber } from "../Fiber.js"
+import { identity } from "../Function.js"
+import { pipeArguments } from "../Pipeable.js"
+import type * as RcRef from "../RcRef.js"
+import type * as Scope from "../Scope.js"
+import * as coreEffect from "./core-effect.js"
+import * as core from "./core.js"
+import * as circular from "./effect/circular.js"
+import * as fiberRuntime from "./fiberRuntime.js"
+
+/** @internal */
+export const TypeId: RcRef.TypeId = Symbol.for("effect/RcRef") as RcRef.TypeId
+
+type State<A> = State.Empty | State.Acquired<A> | State.Closed
+
+declare namespace State {
+  interface Empty {
+    readonly _tag: "Empty"
+  }
+
+  interface Acquired<A> {
+    readonly _tag: "Acquired"
+    readonly value: A
+    readonly scope: Scope.CloseableScope
+    fiber: RuntimeFiber<void, never> | undefined
+    refCount: number
+  }
+
+  interface Closed {
+    readonly _tag: "Closed"
+  }
+}
+
+const stateEmpty: State<never> = { _tag: "Empty" }
+const stateClosed: State<never> = { _tag: "Closed" }
+
+const variance: RcRef.RcRef.Variance<any, any> = {
+  _A: identity,
+  _E: identity
+}
+
+class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
+  readonly [TypeId]: RcRef.RcRef.Variance<A, E>
+
+  state: State<A> = stateEmpty
+  readonly semaphore = circular.unsafeMakeSemaphore(1)
+
+  constructor(
+    readonly acquire: Effect<A, E, Scope.Scope>,
+    readonly context: Context.Context<never>,
+    readonly scope: Scope.Scope,
+    readonly idleTimeToLive: Duration.Duration | undefined
+  ) {
+    this[TypeId] = variance
+  }
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const make = <A, E, R>(options: {
+  readonly acquire: Effect<A, E, R>
+  readonly idleTimeToLive?: Duration.DurationInput | undefined
+}) =>
+  core.withFiberRuntime<RcRef.RcRef<A, E>, never, R | Scope.Scope>((fiber) => {
+    const context = fiber.getFiberRef(core.currentContext) as Context.Context<R | Scope.Scope>
+    const scope = Context.get(context, fiberRuntime.scopeTag)
+    const ref = new RcRefImpl<A, E>(
+      options.acquire as Effect<A, E, Scope.Scope>,
+      context,
+      scope,
+      options.idleTimeToLive ? Duration.decode(options.idleTimeToLive) : undefined
+    )
+    return core.as(
+      scope.addFinalizer(() =>
+        ref.semaphore.withPermits(1)(core.suspend(() => {
+          const close = ref.state._tag === "Acquired"
+            ? core.scopeClose(ref.state.scope, core.exitVoid)
+            : core.void
+          ref.state = stateClosed
+          return close
+        }))
+      ),
+      ref
+    )
+  })
+
+/** @internal */
+export const get = <A, E>(
+  self_: RcRef.RcRef<A, E>
+): Effect<A, E, Scope.Scope> => {
+  const self = self_ as RcRefImpl<A, E>
+  return core.uninterruptibleMask((restore) =>
+    core.suspend(() => {
+      switch (self.state._tag) {
+        case "Closed": {
+          return core.interrupt
+        }
+        case "Acquired": {
+          self.state.refCount++
+          return self.state.fiber
+            ? core.as(core.interruptFiber(self.state.fiber), self.state)
+            : core.succeed(self.state)
+        }
+        case "Empty": {
+          return fiberRuntime.scopeMake().pipe(
+            coreEffect.bindTo("scope"),
+            coreEffect.bind("value", ({ scope }) =>
+              restore(core.fiberRefLocally(
+                self.acquire as Effect<A, E>,
+                core.currentContext,
+                Context.add(self.context, fiberRuntime.scopeTag, scope)
+              ))),
+            core.map(({ scope, value }) => {
+              const state: State.Acquired<A> = {
+                _tag: "Acquired",
+                value,
+                scope,
+                fiber: undefined,
+                refCount: 1
+              }
+              self.state = state
+              return state
+            })
+          )
+        }
+      }
+    })
+  ).pipe(
+    self.semaphore.withPermits(1),
+    coreEffect.bindTo("state"),
+    coreEffect.bind("scope", () => fiberRuntime.scopeTag),
+    core.tap(({ scope, state }) =>
+      scope.addFinalizer(() =>
+        core.suspend(() => {
+          state.refCount--
+          if (state.refCount > 0) {
+            return core.void
+          }
+          if (self.idleTimeToLive === undefined) {
+            self.state = stateEmpty
+            return core.scopeClose(state.scope, core.exitVoid)
+          }
+          return coreEffect.sleep(self.idleTimeToLive).pipe(
+            core.interruptible,
+            core.zipRight(core.suspend(() => {
+              if (self.state._tag === "Acquired" && self.state.refCount === 0) {
+                self.state = stateEmpty
+                return core.scopeClose(state.scope, core.exitVoid)
+              }
+              return core.void
+            })),
+            fiberRuntime.ensuring(core.sync(() => {
+              state.fiber = undefined
+            })),
+            circular.forkIn(self.scope),
+            core.tap((fiber) => {
+              state.fiber = fiber
+            }),
+            self.semaphore.withPermits(1)
+          )
+        })
+      )
+    ),
+    core.map(({ state }) => state.value)
+  )
+}