effect 3.7.2 → 3.8.0

package/src/internal/mailbox.ts

@@ -0,0 +1,461 @@
+import * as Arr from "../Array.js"
+import type { Cause } from "../Cause.js"
+import { NoSuchElementException } from "../Cause.js"
+import type { Channel } from "../Channel.js"
+import * as Chunk from "../Chunk.js"
+import type { Effect } from "../Effect.js"
+import * as Effectable from "../Effectable.js"
+import type { Exit } from "../Exit.js"
+import { dual } from "../Function.js"
+import * as Inspectable from "../Inspectable.js"
+import * as Iterable from "../Iterable.js"
+import type * as Api from "../Mailbox.js"
+import * as Option from "../Option.js"
+import { pipeArguments } from "../Pipeable.js"
+import { hasProperty } from "../Predicate.js"
+import type { Scheduler } from "../Scheduler.js"
+import type { Stream } from "../Stream.js"
+import * as channel from "./channel.js"
+import * as coreChannel from "./core-stream.js"
+import * as core from "./core.js"
+import * as stream from "./stream.js"
+
+/** @internal */
+export const TypeId: Api.TypeId = Symbol.for("effect/Mailbox") as Api.TypeId
+
+/** @internal */
+export const ReadonlyTypeId: Api.ReadonlyTypeId = Symbol.for("effect/Mailbox/ReadonlyMailbox") as Api.ReadonlyTypeId
+
+/** @internal */
+export const isMailbox = (u: unknown): u is Api.Mailbox<unknown, unknown> => hasProperty(u, TypeId)
+
+/** @internal */
+export const isReadonlyMailbox = (u: unknown): u is Api.ReadonlyMailbox<unknown, unknown> =>
+  hasProperty(u, ReadonlyTypeId)
+
+type MailboxState<A, E> = {
+  readonly _tag: "Open"
+  readonly takers: Set<(_: Effect<void, E>) => void>
+  readonly offers: Set<OfferEntry<A>>
+  readonly awaiters: Set<(_: Effect<void, E>) => void>
+} | {
+  readonly _tag: "Closing"
+  readonly takers: Set<(_: Effect<void, E>) => void>
+  readonly offers: Set<OfferEntry<A>>
+  readonly awaiters: Set<(_: Effect<void, E>) => void>
+  readonly exit: Exit<void, E>
+} | {
+  readonly _tag: "Done"
+  readonly exit: Exit<void, E>
+}
+
+type OfferEntry<A> = {
+  readonly _tag: "Array"
+  readonly remaining: Array<A>
+  offset: number
+  readonly resume: (_: Effect<Chunk.Chunk<A>>) => void
+} | {
+  readonly _tag: "Single"
+  readonly message: A
+  readonly resume: (_: Effect<boolean>) => void
+}
+
+const empty = Chunk.empty()
+const exitEmpty = core.exitSucceed(empty)
+const exitFalse = core.exitSucceed(false)
+const exitTrue = core.exitSucceed(true)
+const constDone = [empty, true] as const
+
+class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk<A>, done: boolean], E>
+  implements Api.Mailbox<A, E>
+{
+  readonly [TypeId]: Api.TypeId = TypeId
+  readonly [ReadonlyTypeId]: Api.ReadonlyTypeId = ReadonlyTypeId
+  private state: MailboxState<A, E> = {
+    _tag: "Open",
+    takers: new Set(),
+    offers: new Set(),
+    awaiters: new Set()
+  }
+  private messages: Array<A> = []
+  private messagesChunk = Chunk.empty<A>()
+  constructor(
+    readonly scheduler: Scheduler,
+    readonly capacity: number
+  ) {
+    super()
+  }
+
+  offer(message: A): Effect<boolean> {
+    return core.suspend(() => {
+      if (this.state._tag !== "Open") {
+        return exitFalse
+      } else if (this.messages.length + this.messagesChunk.length >= this.capacity) {
+        return this.offerRemainingSingle(message)
+      }
+      this.messages.push(message)
+      this.scheduleReleaseTaker()
+      return exitTrue
+    })
+  }
+  unsafeOffer(message: A): boolean {
+    if (this.state._tag !== "Open") {
+      return false
+    } else if (this.messages.length + this.messagesChunk.length >= this.capacity) {
+      return false
+    }
+    this.messages.push(message)
+    this.scheduleReleaseTaker()
+    return true
+  }
+  offerAll(messages: Iterable<A>): Effect<Chunk.Chunk<A>> {
+    return core.suspend(() => {
+      if (this.state._tag !== "Open") {
+        return core.succeed(Chunk.fromIterable(messages))
+      }
+      const remaining = this.unsafeOfferAllArray(messages)
+      if (remaining.length === 0) {
+        return exitEmpty
+      }
+      return this.offerRemainingArray(remaining)
+    })
+  }
+  unsafeOfferAll(messages: Iterable<A>): Chunk.Chunk<A> {
+    return Chunk.unsafeFromArray(this.unsafeOfferAllArray(messages))
+  }
+  unsafeOfferAllArray(messages: Iterable<A>): Array<A> {
+    if (this.state._tag !== "Open") {
+      return Arr.fromIterable(messages)
+    } else if (this.capacity === Number.POSITIVE_INFINITY) {
+      if (this.messages.length > 0) {
+        this.messagesChunk = Chunk.appendAll(this.messagesChunk, Chunk.unsafeFromArray(this.messages))
+      }
+      if (Chunk.isChunk(messages)) {
+        this.messagesChunk = Chunk.appendAll(this.messagesChunk, messages)
+      } else {
+        this.messages = Arr.fromIterable(messages)
+      }
+      this.scheduleReleaseTaker()
+      return []
+    }
+    const free = this.capacity - this.messages.length - this.messagesChunk.length
+    if (free === 0) {
+      return Arr.fromIterable(messages)
+    }
+    const remaining: Array<A> = []
+    let i = 0
+    for (const message of messages) {
+      if (i < free) {
+        this.messages.push(message)
+      } else {
+        remaining.push(message)
+      }
+      i++
+    }
+    this.scheduleReleaseTaker()
+    return remaining
+  }
+  fail(error: E) {
+    return this.done(core.exitFail(error))
+  }
+  failCause(cause: Cause<E>) {
+    return this.done(core.exitFailCause(cause))
+  }
+  unsafeDone(exit: Exit<void, E>): boolean {
+    if (this.state._tag !== "Open") {
+      return false
+    } else if (this.state.offers.size === 0 && this.messages.length === 0 && this.messagesChunk.length === 0) {
+      this.finalize(exit)
+      return true
+    }
+    this.state = { ...this.state, _tag: "Closing", exit }
+    return true
+  }
+  shutdown: Effect<boolean> = core.sync(() => {
+    if (this.state._tag === "Done") {
+      return true
+    }
+    this.messages = []
+    this.messagesChunk = empty
+    const offers = this.state.offers
+    this.finalize(this.state._tag === "Open" ? core.exitVoid : this.state.exit)
+    if (offers.size > 0) {
+      for (const entry of offers) {
+        if (entry._tag === "Single") {
+          entry.resume(exitFalse)
+        } else {
+          entry.resume(core.exitSucceed(Chunk.unsafeFromArray(entry.remaining.slice(entry.offset))))
+        }
+      }
+      offers.clear()
+    }
+    return true
+  })
+  done(exit: Exit<void, E>) {
+    return core.sync(() => this.unsafeDone(exit))
+  }
+  end = this.done(core.exitVoid)
+  clear: Effect<Chunk.Chunk<A>, E> = core.suspend(() => {
+    if (this.state._tag === "Done") {
+      return core.exitAs(this.state.exit, empty)
+    }
+    const messages = this.unsafeTakeAll()
+    this.releaseCapacity()
+    return core.succeed(messages)
+  })
+  takeAll: Effect<readonly [messages: Chunk.Chunk<A>, done: boolean], E> = core.suspend(() => {
+    if (this.state._tag === "Done") {
+      return core.exitAs(this.state.exit, constDone)
+    }
+    const messages = this.unsafeTakeAll()
+    if (messages.length === 0) {
+      return core.zipRight(this.awaitTake, this.takeAll)
+    }
+    return core.succeed([messages, this.releaseCapacity()])
+  })
+  takeN(n: number): Effect<readonly [messages: Chunk.Chunk<A>, done: boolean], E> {
+    return core.suspend(() => {
+      if (this.state._tag === "Done") {
+        return core.exitAs(this.state.exit, constDone)
+      } else if (n <= 0) {
+        return core.succeed([empty, false])
+      }
+      n = Math.min(n, this.capacity)
+      let messages: Chunk.Chunk<A>
+      if (n <= this.messagesChunk.length) {
+        messages = Chunk.take(this.messagesChunk, n)
+        this.messagesChunk = Chunk.drop(this.messagesChunk, n)
+      } else if (n <= this.messages.length + this.messagesChunk.length) {
+        this.messagesChunk = Chunk.appendAll(this.messagesChunk, Chunk.unsafeFromArray(this.messages))
+        this.messages = []
+        messages = Chunk.take(this.messagesChunk, n)
+        this.messagesChunk = Chunk.drop(this.messagesChunk, n)
+      } else {
+        return core.zipRight(this.awaitTake, this.takeN(n))
+      }
+      return core.succeed([messages, this.releaseCapacity()])
+    })
+  }
+  take: Effect<A, E | NoSuchElementException> = core.suspend(() => {
+    if (this.state._tag === "Done") {
+      return core.exitZipRight(this.state.exit, core.exitFail(new NoSuchElementException()))
+    }
+    let message: A
+    if (this.messagesChunk.length > 0) {
+      message = Chunk.unsafeHead(this.messagesChunk)
+      this.messagesChunk = Chunk.drop(this.messagesChunk, 1)
+    } else if (this.messages.length > 0) {
+      message = this.messages[0]
+      this.messagesChunk = Chunk.drop(Chunk.unsafeFromArray(this.messages), 1)
+      this.messages = []
+    } else {
+      return core.zipRight(this.awaitTake, this.take)
+    }
+    this.releaseCapacity()
+    return core.succeed(message)
+  })
+  await: Effect<void, E> = core.unsafeAsync<void, E>((resume) => {
+    if (this.state._tag === "Done") {
+      return resume(this.state.exit)
+    }
+    this.state.awaiters.add(resume)
+    return core.sync(() => {
+      if (this.state._tag !== "Done") {
+        this.state.awaiters.delete(resume)
+      }
+    })
+  })
+  unsafeSize(): Option.Option<number> {
+    const size = this.messages.length + this.messagesChunk.length
+    return this.state._tag === "Done" ? Option.none() : Option.some(size)
+  }
+  size = core.sync(() => this.unsafeSize())
+
+  commit() {
+    return this.takeAll
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+  toJSON() {
+    return {
+      _id: "effect/Mailbox",
+      state: this.state._tag,
+      size: this.unsafeSize().toJSON()
+    }
+  }
+  toString(): string {
+    return Inspectable.format(this)
+  }
+  [Inspectable.NodeInspectSymbol]() {
+    return Inspectable.format(this)
+  }
+
+  private offerRemainingSingle(message: A) {
+    return core.unsafeAsync<boolean>((resume) => {
+      if (this.state._tag !== "Open") {
+        return resume(exitFalse)
+      }
+      const entry: OfferEntry<A> = { _tag: "Single", message, resume }
+      this.state.offers.add(entry)
+      return core.sync(() => {
+        if (this.state._tag === "Open") {
+          this.state.offers.delete(entry)
+        }
+      })
+    })
+  }
+  private offerRemainingArray(remaining: Array<A>) {
+    return core.unsafeAsync<Chunk.Chunk<A>>((resume) => {
+      if (this.state._tag !== "Open") {
+        return resume(core.exitSucceed(Chunk.unsafeFromArray(remaining)))
+      }
+      const entry: OfferEntry<A> = { _tag: "Array", remaining, offset: 0, resume }
+      this.state.offers.add(entry)
+      return core.sync(() => {
+        if (this.state._tag === "Open") {
+          this.state.offers.delete(entry)
+        }
+      })
+    })
+  }
+  private releaseCapacity(): boolean {
+    if (this.state._tag === "Done") {
+      return this.state.exit._tag === "Success"
+    } else if (this.state.offers.size === 0) {
+      if (this.state._tag === "Closing" && this.messages.length === 0 && this.messagesChunk.length === 0) {
+        this.finalize(this.state.exit)
+        return this.state.exit._tag === "Success"
+      }
+      return false
+    }
+    let n = this.capacity - this.messages.length - this.messagesChunk.length
+    for (const entry of this.state.offers) {
+      if (n === 0) return false
+      else if (entry._tag === "Single") {
+        this.messages.push(entry.message)
+        n--
+        entry.resume(exitTrue)
+        this.state.offers.delete(entry)
+      } else {
+        for (; entry.offset < entry.remaining.length; entry.offset++) {
+          if (n === 0) return false
+          this.messages.push(entry.remaining[entry.offset])
+          n--
+        }
+        entry.resume(exitEmpty)
+        this.state.offers.delete(entry)
+      }
+    }
+    return false
+  }
+  private awaitTake = core.unsafeAsync<void, E>((resume) => {
+    if (this.state._tag === "Done") {
+      return resume(this.state.exit)
+    }
+    this.state.takers.add(resume)
+    return core.sync(() => {
+      if (this.state._tag !== "Done") {
+        this.state.takers.delete(resume)
+      }
+    })
+  })
+
+  private scheduleRunning = false
+  private scheduleReleaseTaker() {
+    if (this.scheduleRunning) {
+      return
+    }
+    this.scheduleRunning = true
+    this.scheduler.scheduleTask(this.releaseTaker, 0)
+  }
+  private releaseTaker = () => {
+    this.scheduleRunning = false
+    if (this.state._tag === "Done") {
+      return
+    } else if (this.state.takers.size === 0) {
+      return
+    }
+    const taker = Iterable.unsafeHead(this.state.takers)
+    this.state.takers.delete(taker)
+    taker(core.exitVoid)
+  }
+
+  private unsafeTakeAll() {
+    if (this.messagesChunk.length > 0) {
+      const messages = this.messages.length > 0 ?
+        Chunk.appendAll(this.messagesChunk, Chunk.unsafeFromArray(this.messages)) :
+        this.messagesChunk
+      this.messagesChunk = empty
+      this.messages = []
+      return messages
+    } else if (this.messages.length > 0) {
+      const messages = Chunk.unsafeFromArray(this.messages)
+      this.messages = []
+      return messages
+    }
+    return empty
+  }
+
+  private finalize(exit: Exit<void, E>) {
+    if (this.state._tag === "Done") {
+      return
+    }
+    const openState = this.state
+    this.state = { _tag: "Done", exit }
+    for (const taker of openState.takers) {
+      taker(exit)
+    }
+    openState.takers.clear()
+    for (const awaiter of openState.awaiters) {
+      awaiter(exit)
+    }
+    openState.awaiters.clear()
+  }
+}
+
+/** @internal */
+export const make = <A, E = never>(capacity?: number | undefined): Effect<Api.Mailbox<A, E>> =>
+  core.withFiberRuntime((fiber) =>
+    core.succeed(
+      new MailboxImpl<A, E>(
+        fiber.currentScheduler,
+        capacity ?? Number.POSITIVE_INFINITY
+      )
+    )
+  )
+
+/** @internal */
+export const into: {
+  <A, E>(
+    self: Api.Mailbox<A, E>
+  ): <AX, EX extends E, RX>(effect: Effect<AX, EX, RX>) => Effect<boolean, never, RX>
+  <AX, E, EX extends E, RX, A>(
+    effect: Effect<AX, EX, RX>,
+    self: Api.Mailbox<A, E>
+  ): Effect<boolean, never, RX>
+} = dual(
+  2,
+  <AX, E, EX extends E, RX, A>(
+    effect: Effect<AX, EX, RX>,
+    self: Api.Mailbox<A, E>
+  ): Effect<boolean, never, RX> =>
+    core.uninterruptibleMask((restore) =>
+      core.matchCauseEffect(restore(effect), {
+        onFailure: (cause) => self.failCause(cause),
+        onSuccess: (_) => self.end
+      })
+    )
+)
+
+/** @internal */
+export const toChannel = <A, E>(self: Api.ReadonlyMailbox<A, E>): Channel<Chunk.Chunk<A>, unknown, E> => {
+  const loop: Channel<Chunk.Chunk<A>, unknown, E> = coreChannel.flatMap(self.takeAll, ([messages, done]) =>
+    done
+      ? messages.length === 0 ? coreChannel.void : coreChannel.write(messages)
+      : channel.zipRight(coreChannel.write(messages), loop))
+  return loop
+}
+
+/** @internal */
+export const toStream = <A, E>(self: Api.ReadonlyMailbox<A, E>): Stream<A, E> => stream.fromChannel(toChannel(self))

package/src/internal/managedRuntime.ts

@@ -26,7 +26,7 @@ function provide<R, ER, A, E>(
     (rt) =>
       core.withFiberRuntime((fiber) => {
         fiber.setFiberRefs(rt.fiberRefs)
-        fiber._runtimeFlags = rt.runtimeFlags
+        fiber.currentRuntimeFlags = rt.runtimeFlags
         return core.provideContext(effect, rt.context)
       })
   )

package/src/internal/pubsub.ts

@@ -1,6 +1,7 @@
 import * as Chunk from "../Chunk.js"
 import type * as Deferred from "../Deferred.js"
 import type * as Effect from "../Effect.js"
+import * as Effectable from "../Effectable.js"
 import { dual, pipe } from "../Function.js"
 import * as MutableQueue from "../MutableQueue.js"
 import * as MutableRef from "../MutableRef.js"
@@ -909,7 +910,7 @@ class UnboundedPubSubSubscription<in out A> implements Subscription<A> {
 }
 
 /** @internal */
-class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
+class SubscriptionImpl<in out A> extends Effectable.Class<A> implements Queue.Dequeue<A> {
   [queue.DequeueTypeId] = queue.dequeueVariance
 
   constructor(
@@ -921,7 +922,13 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
     readonly shutdownFlag: MutableRef.MutableRef<boolean>,
     readonly strategy: PubSubStrategy<A>,
     readonly replayWindow: ReplayWindow<A>
-  ) {}
+  ) {
+    super()
+  }
+
+  commit() {
+    return this.take
+  }
 
   pipe() {
     return pipeArguments(this, arguments)

package/src/internal/queue.ts

@@ -2,6 +2,7 @@ import * as Arr from "../Array.js"
 import * as Chunk from "../Chunk.js"
 import type * as Deferred from "../Deferred.js"
 import type * as Effect from "../Effect.js"
+import * as Effectable from "../Effectable.js"
 import { dual, pipe } from "../Function.js"
 import * as MutableQueue from "../MutableQueue.js"
 import * as MutableRef from "../MutableRef.js"
@@ -63,7 +64,7 @@ export const dequeueVariance = {
 }
 
 /** @internal */
-class QueueImpl<in out A> implements Queue.Queue<A> {
+class QueueImpl<in out A> extends Effectable.Class<A> implements Queue.Queue<A> {
   readonly [EnqueueTypeId] = enqueueVariance
   readonly [DequeueTypeId] = dequeueVariance
 
@@ -79,12 +80,17 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
     /** @internal */
     readonly strategy: Queue.Strategy<A>
   ) {
+    super()
   }
 
   pipe() {
     return pipeArguments(this, arguments)
   }
 
+  commit() {
+    return this.take
+  }
+
   capacity(): number {
     return this.queue.capacity()
   }

package/src/internal/rcMap.ts

@@ -211,3 +211,11 @@ export const get: {
     )
   }
 )
+
+/** @internal */
+export const keys = <K, A, E>(self: RcMap.RcMap<K, A, E>): Effect<Array<K>> => {
+  const impl = self as RcMapImpl<K, A, E>
+  return core.suspend(() =>
+    impl.state._tag === "Closed" ? core.interrupt : core.succeed(MutableHashMap.keys(impl.state.map))
+  )
+}

package/src/internal/rcRef.ts

@@ -1,10 +1,11 @@
 import * as Context from "../Context.js"
 import * as Duration from "../Duration.js"
 import type { Effect } from "../Effect.js"
+import * as Effectable from "../Effectable.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 * as Readable from "../Readable.js"
 import type * as Scope from "../Scope.js"
 import * as coreEffect from "./core-effect.js"
 import * as core from "./core.js"
@@ -42,8 +43,9 @@ const variance: RcRef.RcRef.Variance<any, any> = {
   _E: identity
 }
 
-class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
-  readonly [TypeId]: RcRef.RcRef.Variance<A, E>
+class RcRefImpl<A, E> extends Effectable.Class<A, E, Scope.Scope> implements RcRef.RcRef<A, E> {
+  readonly [TypeId]: RcRef.RcRef.Variance<A, E> = variance
+  readonly [Readable.TypeId]: Readable.TypeId = Readable.TypeId
 
   state: State<A> = stateEmpty
   readonly semaphore = circular.unsafeMakeSemaphore(1)
@@ -54,11 +56,13 @@ class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
     readonly scope: Scope.Scope,
     readonly idleTimeToLive: Duration.Duration | undefined
   ) {
-    this[TypeId] = variance
+    super()
+    this.get = get(this)
   }
+  readonly get: Effect<A, E, Scope.Scope>
 
-  pipe() {
-    return pipeArguments(this, arguments)
+  commit() {
+    return this.get
   }
 }
 

package/src/internal/ref.ts

@@ -1,8 +1,8 @@
 import type * as Effect from "../Effect.js"
+import * as Effectable from "../Effectable.js"
 import { dual } from "../Function.js"
 import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
-import { pipeArguments } from "../Pipeable.js"
 import * as Readable from "../Readable.js"
 import type * as Ref from "../Ref.js"
 import * as core from "./core.js"
@@ -16,11 +16,14 @@ export const refVariance = {
   _A: (_: any) => _
 }
 
-class RefImpl<in out A> implements Ref.Ref<A> {
+class RefImpl<in out A> extends Effectable.Class<A> implements Ref.Ref<A> {
+  commit() {
+    return this.get
+  }
   readonly [RefTypeId] = refVariance
-  readonly [Readable.TypeId]: Readable.TypeId
+  readonly [Readable.TypeId]: Readable.TypeId = Readable.TypeId
   constructor(readonly ref: MutableRef.MutableRef<A>) {
-    this[Readable.TypeId] = Readable.TypeId
+    super()
     this.get = core.sync(() => MutableRef.get(this.ref))
   }
   readonly get: Effect.Effect<A>
@@ -34,9 +37,6 @@ class RefImpl<in out A> implements Ref.Ref<A> {
       return b
     })
   }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
 }
 
 /** @internal */

package/src/internal/runtime.ts

@@ -74,7 +74,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
     )
   }
 
-  const supervisor = fiberRuntime._supervisor
+  const supervisor = fiberRuntime.currentSupervisor
 
   // we can compare by reference here as _supervisor.none is wrapped with globalValue
   if (supervisor !== _supervisor.none) {