@clayroach/effect 3.19.14-source-capture.7 → 3.19.14-source-capture.8

package/src/internal/stm/tPubSub.ts

@@ -1,551 +0,0 @@
-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)