@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/stm/tPubSub.ts

@@ -0,0 +1,551 @@
+import * as RA from "../../Array.js"
+import * as Effect from "../../Effect.js"
+import { dual, identity, pipe } from "../../Function.js"
+import * as HashSet from "../../HashSet.js"
+import * as Option from "../../Option.js"
+import type * as Scope from "../../Scope.js"
+import type * as STM from "../../STM.js"
+import type * as TPubSub from "../../TPubSub.js"
+import type * as TQueue from "../../TQueue.js"
+import type * as TRef from "../../TRef.js"
+import * as core from "./core.js"
+import * as OpCodes from "./opCodes/strategy.js"
+import * as stm from "./stm.js"
+import * as tQueue from "./tQueue.js"
+import * as tRef from "./tRef.js"
+
+/** @internal */
+const TPubSubSymbolKey = "effect/TPubSub"
+
+/** @internal */
+export const TPubSubTypeId: TPubSub.TPubSubTypeId = Symbol.for(TPubSubSymbolKey) as TPubSub.TPubSubTypeId
+
+const AbsentValue = Symbol.for("effect/TPubSub/AbsentValue")
+type AbsentValue = typeof AbsentValue
+
+/** @internal */
+export interface Node<in out A> {
+  readonly head: A | AbsentValue
+  readonly subscribers: number
+  readonly tail: TRef.TRef<Node<A> | undefined>
+}
+
+/** @internal */
+export const makeNode = <A>(
+  head: A | AbsentValue,
+  subscribers: number,
+  tail: TRef.TRef<Node<A> | undefined>
+): Node<A> => ({
+  head,
+  subscribers,
+  tail
+})
+
+/** @internal */
+class TPubSubImpl<in out A> implements TPubSub.TPubSub<A> {
+  readonly [TPubSubTypeId] = {
+    _A: (_: any) => _
+  }
+  readonly [tQueue.TEnqueueTypeId] = tQueue.tEnqueueVariance
+  constructor(
+    readonly pubsubSize: TRef.TRef<number>,
+    readonly publisherHead: TRef.TRef<TRef.TRef<Node<A> | undefined>>,
+    readonly publisherTail: TRef.TRef<TRef.TRef<Node<A> | undefined> | undefined>,
+    readonly requestedCapacity: number,
+    readonly strategy: tQueue.TQueueStrategy,
+    readonly subscriberCount: TRef.TRef<number>,
+    readonly subscribers: TRef.TRef<HashSet.HashSet<TRef.TRef<TRef.TRef<Node<A>> | undefined>>>
+  ) {}
+
+  isShutdown: STM.STM<boolean> = core.effect<never, boolean>((journal) => {
+    const currentPublisherTail = tRef.unsafeGet(this.publisherTail, journal)
+    return currentPublisherTail === undefined
+  })
+
+  awaitShutdown: STM.STM<void> = core.flatMap(
+    this.isShutdown,
+    (isShutdown) => isShutdown ? stm.void : core.retry
+  )
+
+  capacity(): number {
+    return this.requestedCapacity
+  }
+
+  size: STM.STM<number> = core.withSTMRuntime((runtime) => {
+    const currentPublisherTail = tRef.unsafeGet(this.publisherTail, runtime.journal)
+    if (currentPublisherTail === undefined) {
+      return core.interruptAs(runtime.fiberId)
+    }
+    return core.succeed(tRef.unsafeGet(this.pubsubSize, runtime.journal))
+  })
+
+  isEmpty: STM.STM<boolean> = core.map(this.size, (size) => size === 0)
+
+  isFull: STM.STM<boolean> = core.map(this.size, (size) => size === this.capacity())
+
+  offer(value: A): STM.STM<boolean> {
+    return core.withSTMRuntime((runtime) => {
+      const currentPublisherTail = tRef.unsafeGet(this.publisherTail, runtime.journal)
+      if (currentPublisherTail === undefined) {
+        return core.interruptAs(runtime.fiberId)
+      }
+      const currentSubscriberCount = tRef.unsafeGet(this.subscriberCount, runtime.journal)
+      if (currentSubscriberCount === 0) {
+        return core.succeed(true)
+      }
+      const currentPubSubSize = tRef.unsafeGet(this.pubsubSize, runtime.journal)
+      if (currentPubSubSize < this.requestedCapacity) {
+        const updatedPublisherTail: TRef.TRef<Node<A> | undefined> = new tRef.TRefImpl<Node<A> | undefined>(void 0)
+        const updatedNode = makeNode(value, currentSubscriberCount, updatedPublisherTail)
+        tRef.unsafeSet<Node<A> | undefined>(currentPublisherTail, updatedNode, runtime.journal)
+        tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(
+          this.publisherTail,
+          updatedPublisherTail,
+          runtime.journal
+        )
+        tRef.unsafeSet(this.pubsubSize, currentPubSubSize + 1, runtime.journal)
+        return core.succeed(true)
+      }
+      switch (this.strategy._tag) {
+        case OpCodes.OP_BACKPRESSURE_STRATEGY: {
+          return core.retry
+        }
+        case OpCodes.OP_DROPPING_STRATEGY: {
+          return core.succeed(false)
+        }
+        case OpCodes.OP_SLIDING_STRATEGY: {
+          if (this.requestedCapacity > 0) {
+            let currentPublisherHead: TRef.TRef<Node<A> | undefined> = tRef.unsafeGet(
+              this.publisherHead,
+              runtime.journal
+            )
+            let loop = true
+            while (loop) {
+              const node = tRef.unsafeGet(currentPublisherHead, runtime.journal)
+              if (node === undefined) {
+                return core.retry
+              }
+              const head = node.head
+              const tail = node.tail
+              if (head !== AbsentValue) {
+                const updatedNode = makeNode<A>(AbsentValue, node.subscribers, node.tail as any)
+                tRef.unsafeSet<Node<A> | undefined>(
+                  currentPublisherHead as any,
+                  updatedNode as any,
+                  runtime.journal
+                )
+                tRef.unsafeSet(this.publisherHead, tail, runtime.journal)
+                loop = false
+              } else {
+                currentPublisherHead = tail
+              }
+            }
+          }
+          const updatedPublisherTail: TRef.TRef<Node<A> | undefined> = new tRef.TRefImpl<Node<A> | undefined>(void 0)
+          const updatedNode = makeNode(value, currentSubscriberCount, updatedPublisherTail)
+          tRef.unsafeSet<Node<A> | undefined>(currentPublisherTail, updatedNode, runtime.journal)
+          tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(
+            this.publisherTail,
+            updatedPublisherTail,
+            runtime.journal
+          )
+          return core.succeed(true)
+        }
+      }
+    })
+  }
+
+  offerAll(iterable: Iterable<A>): STM.STM<boolean> {
+    return core.map(
+      stm.forEach(iterable, (a) => this.offer(a)),
+      RA.every(identity)
+    )
+  }
+
+  shutdown: STM.STM<void> = core.effect<never, void>((journal) => {
+    const currentPublisherTail = tRef.unsafeGet(this.publisherTail, journal)
+    if (currentPublisherTail !== undefined) {
+      tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(this.publisherTail, void 0, journal)
+      const currentSubscribers = tRef.unsafeGet(this.subscribers, journal)
+      HashSet.forEach(currentSubscribers, (subscriber) => {
+        tRef.unsafeSet<TRef.TRef<Node<A>> | undefined>(subscriber, void 0, journal)
+      })
+      tRef.unsafeSet(this.subscribers, HashSet.empty<TRef.TRef<TRef.TRef<Node<A>> | undefined>>(), journal)
+    }
+  })
+}
+
+/** @internal */
+class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
+  readonly [TPubSubTypeId]: TPubSub.TPubSubTypeId = TPubSubTypeId
+  readonly [tQueue.TDequeueTypeId] = tQueue.tDequeueVariance
+  constructor(
+    readonly pubsubSize: TRef.TRef<number>,
+    readonly publisherHead: TRef.TRef<TRef.TRef<Node<A> | undefined>>,
+    readonly requestedCapacity: number,
+    readonly subscriberHead: TRef.TRef<TRef.TRef<Node<A> | undefined> | undefined>,
+    readonly subscriberCount: TRef.TRef<number>,
+    readonly subscribers: TRef.TRef<HashSet.HashSet<TRef.TRef<TRef.TRef<Node<A>> | undefined>>>
+  ) {}
+
+  isShutdown: STM.STM<boolean> = core.effect<never, boolean>((journal) => {
+    const currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, journal)
+    return currentSubscriberHead === undefined
+  })
+
+  awaitShutdown: STM.STM<void> = core.flatMap(
+    this.isShutdown,
+    (isShutdown) => isShutdown ? stm.void : core.retry
+  )
+
+  capacity(): number {
+    return this.requestedCapacity
+  }
+
+  size: STM.STM<number> = core.withSTMRuntime((runtime) => {
+    let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
+    if (currentSubscriberHead === undefined) {
+      return core.interruptAs(runtime.fiberId)
+    }
+    let loop = true
+    let size = 0
+    while (loop) {
+      const node = tRef.unsafeGet(currentSubscriberHead, runtime.journal)
+      if (node === undefined) {
+        loop = false
+      } else {
+        const head = node.head
+        const tail: TRef.TRef<Node<A> | undefined> = node.tail
+        if (head !== AbsentValue) {
+          size = size + 1
+          if (size >= Number.MAX_SAFE_INTEGER) {
+            loop = false
+          }
+        }
+        currentSubscriberHead = tail
+      }
+    }
+    return core.succeed(size)
+  })
+
+  isEmpty: STM.STM<boolean> = core.map(this.size, (size) => size === 0)
+
+  isFull: STM.STM<boolean> = core.map(this.size, (size) => size === this.capacity())
+
+  peek: STM.STM<A> = core.withSTMRuntime((runtime) => {
+    let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
+    if (currentSubscriberHead === undefined) {
+      return core.interruptAs(runtime.fiberId)
+    }
+    let value: A | AbsentValue = AbsentValue
+    let loop = true
+    while (loop) {
+      const node = tRef.unsafeGet(currentSubscriberHead, runtime.journal)
+      if (node === undefined) {
+        return core.retry
+      }
+      const head = node.head
+      const tail: TRef.TRef<Node<A> | undefined> = node.tail
+      if (head !== AbsentValue) {
+        value = head
+        loop = false
+      } else {
+        currentSubscriberHead = tail
+      }
+    }
+    return core.succeed(value as A)
+  })
+
+  peekOption: STM.STM<Option.Option<A>> = core.withSTMRuntime((runtime) => {
+    let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
+    if (currentSubscriberHead === undefined) {
+      return core.interruptAs(runtime.fiberId)
+    }
+    let value: Option.Option<A> = Option.none()
+    let loop = true
+    while (loop) {
+      const node = tRef.unsafeGet(currentSubscriberHead, runtime.journal)
+      if (node === undefined) {
+        value = Option.none()
+        loop = false
+      } else {
+        const head = node.head
+        const tail: TRef.TRef<Node<A> | undefined> = node.tail
+        if (head !== AbsentValue) {
+          value = Option.some(head)
+          loop = false
+        } else {
+          currentSubscriberHead = tail
+        }
+      }
+    }
+    return core.succeed(value)
+  })
+
+  shutdown: STM.STM<void> = core.effect<never, void>((journal) => {
+    let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, journal)
+    if (currentSubscriberHead !== undefined) {
+      tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(this.subscriberHead, void 0, journal)
+      let loop = true
+      while (loop) {
+        const node = tRef.unsafeGet(currentSubscriberHead, journal)
+        if (node === undefined) {
+          loop = false
+        } else {
+          const head = node.head
+          const tail: TRef.TRef<Node<A> | undefined> = node.tail
+          if (head !== AbsentValue) {
+            const subscribers = node.subscribers
+            if (subscribers === 1) {
+              const size = tRef.unsafeGet(this.pubsubSize, journal)
+              const updatedNode = makeNode<A>(AbsentValue, 0, tail)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, journal)
+              tRef.unsafeSet(this.publisherHead, tail as any, journal)
+              tRef.unsafeSet(this.pubsubSize, size - 1, journal)
+            } else {
+              const updatedNode = makeNode(head, subscribers - 1, tail)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, journal)
+            }
+          }
+          currentSubscriberHead = tail
+        }
+      }
+      const currentSubscriberCount = tRef.unsafeGet(this.subscriberCount, journal)
+      tRef.unsafeSet(this.subscriberCount, currentSubscriberCount - 1, journal)
+      tRef.unsafeSet(
+        this.subscribers,
+        HashSet.remove(
+          tRef.unsafeGet(this.subscribers, journal),
+          this.subscriberHead as any
+        ),
+        journal
+      )
+    }
+  })
+
+  take: STM.STM<A> = core.withSTMRuntime((runtime) => {
+    let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
+    if (currentSubscriberHead === undefined) {
+      return core.interruptAs(runtime.fiberId)
+    }
+    let value: A | AbsentValue = AbsentValue
+    let loop = true
+    while (loop) {
+      const node = tRef.unsafeGet(currentSubscriberHead, runtime.journal)
+      if (node === undefined) {
+        return core.retry
+      }
+      const head = node.head
+      const tail: TRef.TRef<Node<A> | undefined> = node.tail
+      if (head !== AbsentValue) {
+        const subscribers = node.subscribers
+        if (subscribers === 1) {
+          const size = tRef.unsafeGet(this.pubsubSize, runtime.journal)
+          const updatedNode = makeNode<A>(AbsentValue, 0, tail)
+          tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+          tRef.unsafeSet(this.publisherHead, tail as any, runtime.journal)
+          tRef.unsafeSet(this.pubsubSize, size - 1, runtime.journal)
+        } else {
+          const updatedNode = makeNode(head, subscribers - 1, tail)
+          tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+        }
+        tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(
+          this.subscriberHead,
+          tail,
+          runtime.journal
+        )
+        value = head
+        loop = false
+      } else {
+        currentSubscriberHead = tail
+      }
+    }
+    return core.succeed(value as A)
+  })
+
+  takeAll: STM.STM<Array<A>> = this.takeUpTo(Number.POSITIVE_INFINITY)
+
+  takeUpTo(max: number): STM.STM<Array<A>> {
+    return core.withSTMRuntime((runtime) => {
+      let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
+      if (currentSubscriberHead === undefined) {
+        return core.interruptAs(runtime.fiberId)
+      }
+      const builder: Array<A> = []
+      let n = 0
+      while (n !== max) {
+        const node = tRef.unsafeGet(currentSubscriberHead, runtime.journal)
+        if (node === undefined) {
+          n = max
+        } else {
+          const head = node.head
+          const tail: TRef.TRef<Node<A> | undefined> = node.tail
+          if (head !== AbsentValue) {
+            const subscribers = node.subscribers
+            if (subscribers === 1) {
+              const size = tRef.unsafeGet(this.pubsubSize, runtime.journal)
+              const updatedNode = makeNode<A>(AbsentValue, 0, tail)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+              tRef.unsafeSet(this.publisherHead, tail as any, runtime.journal)
+              tRef.unsafeSet(this.pubsubSize, size - 1, runtime.journal)
+            } else {
+              const updatedNode = makeNode(head, subscribers - 1, tail)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+            }
+            builder.push(head)
+            n = n + 1
+          }
+          currentSubscriberHead = tail
+        }
+      }
+      tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(
+        this.subscriberHead,
+        currentSubscriberHead,
+        runtime.journal
+      )
+      return core.succeed(builder)
+    })
+  }
+}
+
+/** @internal */
+const makeTPubSub = <A>(
+  requestedCapacity: number,
+  strategy: tQueue.TQueueStrategy
+): STM.STM<TPubSub.TPubSub<A>> =>
+  pipe(
+    stm.all([
+      tRef.make<Node<A> | undefined>(void 0),
+      tRef.make(0)
+    ]),
+    core.flatMap(([empty, pubsubSize]) =>
+      pipe(
+        stm.all([
+          tRef.make(empty),
+          tRef.make(empty),
+          tRef.make(0),
+          tRef.make(HashSet.empty())
+        ]),
+        core.map(([publisherHead, publisherTail, subscriberCount, subscribers]) =>
+          new TPubSubImpl(
+            pubsubSize,
+            publisherHead,
+            publisherTail as any,
+            requestedCapacity,
+            strategy,
+            subscriberCount,
+            subscribers as any
+          )
+        )
+      )
+    )
+  )
+
+const makeSubscription = <A>(
+  pubsubSize: TRef.TRef<number>,
+  publisherHead: TRef.TRef<TRef.TRef<Node<A> | undefined>>,
+  publisherTail: TRef.TRef<TRef.TRef<Node<A> | undefined> | undefined>,
+  requestedCapacity: number,
+  subscriberCount: TRef.TRef<number>,
+  subscribers: TRef.TRef<HashSet.HashSet<TRef.TRef<TRef.TRef<Node<A>> | undefined>>>
+): STM.STM<TQueue.TDequeue<A>> =>
+  pipe(
+    tRef.get(publisherTail),
+    core.flatMap((currentPublisherTail) =>
+      pipe(
+        stm.all([
+          tRef.make(currentPublisherTail),
+          tRef.get(subscriberCount),
+          tRef.get(subscribers)
+        ]),
+        stm.tap(([_, currentSubscriberCount]) =>
+          pipe(
+            subscriberCount,
+            tRef.set(currentSubscriberCount + 1)
+          )
+        ),
+        stm.tap(([subscriberHead, _, currentSubscribers]) =>
+          pipe(
+            subscribers as any,
+            tRef.set(pipe(currentSubscribers as any, HashSet.add(subscriberHead)))
+          )
+        ),
+        core.map(([subscriberHead]) =>
+          new TPubSubSubscriptionImpl(
+            pubsubSize,
+            publisherHead,
+            requestedCapacity,
+            subscriberHead as any,
+            subscriberCount,
+            subscribers
+          )
+        )
+      )
+    )
+  )
+
+/** @internal */
+export const awaitShutdown = <A>(self: TPubSub.TPubSub<A>): STM.STM<void> => self.awaitShutdown
+
+/** @internal */
+export const bounded = <A>(requestedCapacity: number): STM.STM<TPubSub.TPubSub<A>> =>
+  makeTPubSub<A>(requestedCapacity, tQueue.BackPressure)
+
+/** @internal */
+export const capacity = <A>(self: TPubSub.TPubSub<A>): number => self.capacity()
+
+/** @internal */
+export const dropping = <A>(requestedCapacity: number): STM.STM<TPubSub.TPubSub<A>> =>
+  makeTPubSub<A>(requestedCapacity, tQueue.Dropping)
+
+/** @internal */
+export const isEmpty = <A>(self: TPubSub.TPubSub<A>): STM.STM<boolean> => self.isEmpty
+
+/** @internal */
+export const isFull = <A>(self: TPubSub.TPubSub<A>): STM.STM<boolean> => self.isFull
+
+/** @internal */
+export const isShutdown = <A>(self: TPubSub.TPubSub<A>): STM.STM<boolean> => self.isShutdown
+
+/** @internal */
+export const publish = dual<
+  <A>(value: A) => (self: TPubSub.TPubSub<A>) => STM.STM<boolean>,
+  <A>(self: TPubSub.TPubSub<A>, value: A) => STM.STM<boolean>
+>(2, (self, value) => self.offer(value))
+
+/** @internal */
+export const publishAll = dual<
+  <A>(iterable: Iterable<A>) => (self: TPubSub.TPubSub<A>) => STM.STM<boolean>,
+  <A>(self: TPubSub.TPubSub<A>, iterable: Iterable<A>) => STM.STM<boolean>
+>(2, (self, iterable) => self.offerAll(iterable))
+
+/** @internal */
+export const size = <A>(self: TPubSub.TPubSub<A>): STM.STM<number> => self.size
+
+/** @internal */
+export const shutdown = <A>(self: TPubSub.TPubSub<A>): STM.STM<void> => self.shutdown
+
+/** @internal */
+export const sliding = <A>(requestedCapacity: number): STM.STM<TPubSub.TPubSub<A>> =>
+  makeTPubSub<A>(requestedCapacity, tQueue.Sliding)
+
+/** @internal */
+export const subscribe = <A>(self: TPubSub.TPubSub<A>): STM.STM<TQueue.TDequeue<A>> =>
+  makeSubscription(
+    self.pubsubSize,
+    self.publisherHead,
+    self.publisherTail,
+    self.requestedCapacity,
+    self.subscriberCount,
+    self.subscribers
+  )
+
+/** @internal */
+export const subscribeScoped = <A>(self: TPubSub.TPubSub<A>): Effect.Effect<TQueue.TDequeue<A>, never, Scope.Scope> =>
+  Effect.acquireRelease(
+    subscribe(self),
+    (dequeue) => tQueue.shutdown(dequeue)
+  )
+
+/** @internal */
+export const unbounded = <A>(): STM.STM<TPubSub.TPubSub<A>> => makeTPubSub<A>(Number.MAX_SAFE_INTEGER, tQueue.Dropping)