Class Latch

packages/effect/src/internal/effect.ts:5523–5606

const succeedFalse = succeed(false)

class Latch implements _Latch.Latch {
  waiters: Array<(_: Effect.Effect<void>) => void> = []
  scheduled: Array<(_: Effect.Effect<void>) => void> | undefined = undefined
  private _isOpen: boolean

  constructor(isOpen: boolean) {
    this._isOpen = isOpen
  }

  private scheduleUnsafe(fiber: Fiber.Fiber<unknown, unknown>) {
    if (this.waiters.length === 0) {
      return succeedTrue
    }
    if (this.scheduled === undefined) {
      this.scheduled = this.waiters
      fiber.currentDispatcher.scheduleTask(this.flushScheduled, 0)
    } else {
      for (let i = 0; i < this.waiters.length; i++) {
        this.scheduled.push(this.waiters[i])
      }
    }
    this.waiters = []
    return succeedTrue
  }
  private flushScheduled = () => {
    if (this.scheduled === undefined) return
    const waiters = this.scheduled
    this.scheduled = undefined
    for (let i = 0; i < waiters.length; i++) {
      waiters[i](exitVoid)
    }
  }
  private flushWaiters() {
    // swap both arrays out before any resume runs: a resumed waiter can
    // reentrantly close the latch and register new waiters, which must not
    // be drained by this flush
    const waiters = this.waiters
    this.waiters = []
    this.flushScheduled()
    for (let i = 0; i < waiters.length; i++) {
      waiters[i](exitVoid)
    }
  }

  open = withFiber<boolean>((fiber) => {
    if (this._isOpen) return succeedFalse
    this._isOpen = true
    return this.scheduleUnsafe(fiber)
  })
  release = withFiber<boolean>((fiber) => this._isOpen ? succeedFalse : this.scheduleUnsafe(fiber))
  openUnsafe() {
    if (this._isOpen) return false
    this._isOpen = true
    this.flushWaiters()
    return true
  }
  await = callback<void>((resume) => {
    if (this._isOpen) {