effect 4.0.0-beta.30 → 4.0.0-beta.32

package/src/internal/dateTime.ts

@@ -9,11 +9,11 @@ import type { LazyArg } from "../Function.ts"
 import { dual } from "../Function.ts"
 import * as Hash from "../Hash.ts"
 import * as Inspectable from "../Inspectable.ts"
+import * as Option from "../Option.ts"
 import * as order from "../Order.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import * as Predicate from "../Predicate.ts"
 import type { Mutable } from "../Types.ts"
-import * as UndefinedOr from "../UndefinedOr.ts"
 import * as effect from "./effect.ts"
 
 /** @internal */
@@ -39,10 +39,10 @@ const ProtoUtc = {
   ...Proto,
   _tag: "Utc",
   [Hash.symbol](this: DateTime.Utc) {
-    return Hash.number(this.epochMillis)
+    return Hash.number(this.epochMilliseconds)
   },
   [Equal.symbol](this: DateTime.Utc, that: unknown) {
-    return isDateTime(that) && that._tag === "Utc" && this.epochMillis === that.epochMillis
+    return isDateTime(that) && that._tag === "Utc" && this.epochMilliseconds === that.epochMilliseconds
   },
   toString(this: DateTime.Utc) {
     return `DateTime.Utc(${toDateUtc(this).toJSON()})`
@@ -53,10 +53,10 @@ const ProtoZoned = {
   ...Proto,
   _tag: "Zoned",
   [Hash.symbol](this: DateTime.Zoned) {
-    return Hash.combine(Hash.number(this.epochMillis))(Hash.hash(this.zone))
+    return Hash.combine(Hash.number(this.epochMilliseconds))(Hash.hash(this.zone))
   },
   [Equal.symbol](this: DateTime.Zoned, that: unknown) {
-    return isDateTime(that) && that._tag === "Zoned" && this.epochMillis === that.epochMillis &&
+    return isDateTime(that) && that._tag === "Zoned" && this.epochMilliseconds === that.epochMilliseconds &&
       Equal.equals(this.zone, that.zone)
   },
   toString(this: DateTime.Zoned) {
@@ -120,7 +120,7 @@ export const makeZonedProto = (
   partsUtc?: DateTime.DateTime.PartsWithWeekday
 ): DateTime.Zoned => {
   const self = Object.create(ProtoZoned)
-  self.epochMillis = epochMillis
+  self.epochMilliseconds = epochMillis
   self.zone = zone
   Object.defineProperty(self, "partsUtc", {
     value: partsUtc,
@@ -169,11 +169,13 @@ export const isZoned = (self: DateTime.DateTime): self is DateTime.Zoned => self
 // =============================================================================
 
 /** @internal */
-export const Equivalence: Equ.Equivalence<DateTime.DateTime> = Equ.make((a, b) => a.epochMillis === b.epochMillis)
+export const Equivalence: Equ.Equivalence<DateTime.DateTime> = Equ.make((a, b) =>
+  a.epochMilliseconds === b.epochMilliseconds
+)
 
 /** @internal */
 export const Order: order.Order<DateTime.DateTime> = order.make((self, that) =>
-  self.epochMillis < that.epochMillis ? -1 : self.epochMillis > that.epochMillis ? 1 : 0
+  self.epochMilliseconds < that.epochMilliseconds ? -1 : self.epochMilliseconds > that.epochMilliseconds ? 1 : 0
 )
 
 /** @internal */
@@ -193,7 +195,7 @@ export const clamp: {
 
 const makeUtc = (epochMillis: number): DateTime.Utc => {
   const self = Object.create(ProtoUtc)
-  self.epochMillis = epochMillis
+  self.epochMilliseconds = epochMillis
   Object.defineProperty(self, "partsUtc", {
     value: undefined,
     enumerable: false,
@@ -218,6 +220,9 @@ export const makeUnsafe = <A extends DateTime.DateTime.Input>(input: A): DateTim
   } else if (input instanceof Date) {
     return fromDateUnsafe(input) as DateTime.DateTime.PreserveZone<A>
   } else if (typeof input === "object") {
+    if ("epochMilliseconds" in input) {
+      return makeUtc(input.epochMilliseconds) as DateTime.DateTime.PreserveZone<A>
+    }
     const date = new Date(0)
     setPartsDate(date, input)
     return fromDateUnsafe(date) as DateTime.DateTime.PreserveZone<A>
@@ -238,32 +243,36 @@ export const makeZonedUnsafe = (input: DateTime.DateTime.Input, options?: {
   readonly adjustForTimeZone?: boolean | undefined
   readonly disambiguation?: DateTime.Disambiguation | undefined
 }): DateTime.Zoned => {
-  if (options?.timeZone === undefined && isDateTime(input) && isZoned(input)) {
+  let timeZoneOption = options?.timeZone
+  if (timeZoneOption === undefined && isDateTime(input) && isZoned(input)) {
     return input
   }
   const self = makeUnsafe(input)
-  if (self.epochMillis < minEpochMillis || self.epochMillis > maxEpochMillis) {
-    throw new RangeError(`Epoch millis out of range: ${self.epochMillis}`)
+  if (self.epochMilliseconds < minEpochMillis || self.epochMilliseconds > maxEpochMillis) {
+    throw new RangeError(`Epoch millis out of range: ${self.epochMilliseconds}`)
+  }
+  if (timeZoneOption === undefined && typeof input === "object" && "timeZoneId" in input) {
+    timeZoneOption = input.timeZoneId
   }
   let zone: DateTime.TimeZone
-  if (options?.timeZone === undefined) {
-    const offset = new Date(self.epochMillis).getTimezoneOffset() * -60 * 1000
+  if (timeZoneOption === undefined) {
+    const offset = new Date(self.epochMilliseconds).getTimezoneOffset() * -60 * 1000
     zone = zoneMakeOffset(offset)
-  } else if (isTimeZone(options?.timeZone)) {
-    zone = options.timeZone
-  } else if (typeof options?.timeZone === "number") {
-    zone = zoneMakeOffset(options.timeZone)
+  } else if (isTimeZone(timeZoneOption)) {
+    zone = timeZoneOption
+  } else if (typeof timeZoneOption === "number") {
+    zone = zoneMakeOffset(timeZoneOption)
   } else {
-    const parsedZone = zoneFromString(options.timeZone)
-    if (parsedZone === undefined) {
-      throw new IllegalArgumentError(`Invalid time zone: ${options.timeZone}`)
+    const parsedZone = zoneFromString(timeZoneOption)
+    if (Option.isNone(parsedZone)) {
+      throw new IllegalArgumentError(`Invalid time zone: ${timeZoneOption}`)
     }
-    zone = parsedZone
+    zone = parsedZone.value
   }
   if (options?.adjustForTimeZone !== true) {
-    return makeZonedProto(self.epochMillis, zone, self.partsUtc)
+    return makeZonedProto(self.epochMilliseconds, zone, self.partsUtc)
   }
-  return makeZonedFromAdjusted(self.epochMillis, zone, options?.disambiguation ?? "compatible")
+  return makeZonedFromAdjusted(self.epochMilliseconds, zone, options?.disambiguation ?? "compatible")
 }
 
 /** @internal */
@@ -274,20 +283,20 @@ export const makeZoned: (
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: DateTime.Disambiguation | undefined
   }
-) => DateTime.Zoned | undefined = UndefinedOr.liftThrowable(makeZonedUnsafe)
+) => Option.Option<DateTime.Zoned> = Option.liftThrowable(makeZonedUnsafe)
 
 /** @internal */
-export const make: <A extends DateTime.DateTime.Input>(input: A) => DateTime.DateTime.PreserveZone<A> | undefined =
-  UndefinedOr.liftThrowable(makeUnsafe)
+export const make: <A extends DateTime.DateTime.Input>(input: A) => Option.Option<DateTime.DateTime.PreserveZone<A>> =
+  Option.liftThrowable(makeUnsafe)
 
 const zonedStringRegExp = /^(.{17,35})\[(.+)\]$/
 
 /** @internal */
-export const makeZonedFromString = (input: string): DateTime.Zoned | undefined => {
+export const makeZonedFromString = (input: string): Option.Option<DateTime.Zoned> => {
   const match = zonedStringRegExp.exec(input)
   if (match === null) {
     const offset = parseOffset(input)
-    return offset !== null ? makeZoned(input, { timeZone: offset }) : undefined
+    return offset !== null ? makeZoned(input, { timeZone: offset }) : Option.none()
   }
   const [, isoString, timeZone] = match
   return makeZoned(isoString, { timeZone })
@@ -307,7 +316,7 @@ export const nowUnsafe: LazyArg<DateTime.Utc> = () => makeUtc(Date.now())
 // =============================================================================
 
 /** @internal */
-export const toUtc = (self: DateTime.DateTime): DateTime.Utc => makeUtc(self.epochMillis)
+export const toUtc = (self: DateTime.DateTime): DateTime.Utc => makeUtc(self.epochMilliseconds)
 
 /** @internal */
 export const setZone: {
@@ -324,8 +333,8 @@ export const setZone: {
   readonly disambiguation?: DateTime.Disambiguation | undefined
 }): DateTime.Zoned =>
   options?.adjustForTimeZone === true
-    ? makeZonedFromAdjusted(self.epochMillis, zone, options?.disambiguation ?? "compatible")
-    : makeZonedProto(self.epochMillis, zone, self.partsUtc))
+    ? makeZonedFromAdjusted(self.epochMilliseconds, zone, options?.disambiguation ?? "compatible")
+    : makeZonedProto(self.epochMilliseconds, zone, self.partsUtc))
 
 /** @internal */
 export const setZoneOffset: {
@@ -393,7 +402,7 @@ export const zoneMakeOffset = (offset: number): DateTime.TimeZone.Offset => {
 }
 
 /** @internal */
-export const zoneMakeNamed: (zoneId: string) => DateTime.TimeZone.Named | undefined = UndefinedOr.liftThrowable(
+export const zoneMakeNamed: (zoneId: string) => Option.Option<DateTime.TimeZone.Named> = Option.liftThrowable(
   zoneMakeNamedUnsafe
 )
 
@@ -411,10 +420,10 @@ export const zoneMakeLocal = (): DateTime.TimeZone.Named =>
 const offsetZoneRegExp = /^(?:GMT|[+-])/
 
 /** @internal */
-export const zoneFromString = (zone: string): DateTime.TimeZone | undefined => {
+export const zoneFromString = (zone: string): Option.Option<DateTime.TimeZone> => {
   if (offsetZoneRegExp.test(zone)) {
     const offset = parseOffset(zone)
-    return offset === null ? undefined : zoneMakeOffset(offset)
+    return offset === null ? Option.none() : Option.some(zoneMakeOffset(offset))
   }
   return zoneMakeNamed(zone)
 }
@@ -432,17 +441,17 @@ export const setZoneNamed: {
   (zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: DateTime.Disambiguation | undefined
-  }): (self: DateTime.DateTime) => DateTime.Zoned | undefined
+  }): (self: DateTime.DateTime) => Option.Option<DateTime.Zoned>
   (self: DateTime.DateTime, zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: DateTime.Disambiguation | undefined
-  }): DateTime.Zoned | undefined
+  }): Option.Option<DateTime.Zoned>
 } = dual(
   isDateTimeArgs,
   (self: DateTime.DateTime, zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: DateTime.Disambiguation | undefined
-  }): DateTime.Zoned | undefined => UndefinedOr.map(zoneMakeNamed(zoneId), (zone) => setZone(self, zone, options))
+  }): Option.Option<DateTime.Zoned> => Option.map(zoneMakeNamed(zoneId), (zone) => setZone(self, zone, options))
 )
 
 /** @internal */
@@ -533,18 +542,18 @@ export const isPastUnsafe = (self: DateTime.DateTime): boolean => isGreaterThan(
 // =============================================================================
 
 /** @internal */
-export const toDateUtc = (self: DateTime.DateTime): Date => new Date(self.epochMillis)
+export const toDateUtc = (self: DateTime.DateTime): Date => new Date(self.epochMilliseconds)
 
 /** @internal */
 export const toDate = (self: DateTime.DateTime): Date => {
   if (self._tag === "Utc") {
-    return new Date(self.epochMillis)
+    return new Date(self.epochMilliseconds)
   } else if (self.zone._tag === "Offset") {
-    return new Date(self.epochMillis + self.zone.offset)
-  } else if (self.adjustedEpochMillis !== undefined) {
-    return new Date(self.adjustedEpochMillis)
+    return new Date(self.epochMilliseconds + self.zone.offset)
+  } else if (self.adjustedEpochMilliseconds !== undefined) {
+    return new Date(self.adjustedEpochMilliseconds)
   }
-  const parts = self.zone.format.formatToParts(self.epochMillis).filter((_) => _.type !== "literal")
+  const parts = self.zone.format.formatToParts(self.epochMilliseconds).filter((_) => _.type !== "literal")
   const date = new Date(0)
   date.setUTCFullYear(
     Number(parts[2].value),
@@ -557,7 +566,7 @@ export const toDate = (self: DateTime.DateTime): Date => {
     Number(parts[5].value),
     Number(parts[6].value)
   )
-  self.adjustedEpochMillis = date.getTime()
+  self.adjustedEpochMilliseconds = date.getTime()
   return date
 }
 
@@ -582,7 +591,7 @@ const offsetToString = (offset: number): string => {
 export const zonedOffsetIso = (self: DateTime.Zoned): string => offsetToString(zonedOffset(self))
 
 /** @internal */
-export const toEpochMillis = (self: DateTime.DateTime): number => self.epochMillis
+export const toEpochMillis = (self: DateTime.DateTime): number => self.epochMilliseconds
 
 /** @internal */
 export const removeTime = (self: DateTime.DateTime): DateTime.Utc =>
@@ -596,10 +605,10 @@ export const removeTime = (self: DateTime.DateTime): DateTime.Utc =>
 // =============================================================================
 
 const dateToParts = (date: Date): DateTime.DateTime.PartsWithWeekday => ({
-  millis: date.getUTCMilliseconds(),
-  seconds: date.getUTCSeconds(),
-  minutes: date.getUTCMinutes(),
-  hours: date.getUTCHours(),
+  millisecond: date.getUTCMilliseconds(),
+  second: date.getUTCSeconds(),
+  minute: date.getUTCMinutes(),
+  hour: date.getUTCHours(),
   day: date.getUTCDate(),
   weekDay: date.getUTCDay(),
   month: date.getUTCMonth() + 1,
@@ -652,17 +661,17 @@ const setPartsDate = (date: Date, parts: Partial<DateTime.DateTime.PartsWithWeek
     const diff = parts.weekDay - date.getUTCDay()
     date.setUTCDate(date.getUTCDate() + diff)
   }
-  if (parts.hours !== undefined) {
-    date.setUTCHours(parts.hours)
+  if (parts.hour !== undefined) {
+    date.setUTCHours(parts.hour)
   }
-  if (parts.minutes !== undefined) {
-    date.setUTCMinutes(parts.minutes)
+  if (parts.minute !== undefined) {
+    date.setUTCMinutes(parts.minute)
   }
-  if (parts.seconds !== undefined) {
-    date.setUTCSeconds(parts.seconds)
+  if (parts.second !== undefined) {
+    date.setUTCSeconds(parts.second)
   }
-  if (parts.millis !== undefined) {
-    date.setUTCMilliseconds(parts.millis)
+  if (parts.millisecond !== undefined) {
+    date.setUTCMilliseconds(parts.millisecond)
   }
 }
 
@@ -925,8 +934,8 @@ export const add: {
   2,
   (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime =>
     mutate(self, (date) => {
-      if (parts.millis) {
-        addMillis(date, parts.millis)
+      if (parts.milliseconds) {
+        addMillis(date, parts.milliseconds)
       }
       if (parts.seconds) {
         addMillis(date, parts.seconds * 1000)
@@ -1100,7 +1109,7 @@ export const nearest: {
   readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
 }): DateTime.DateTime =>
   mutate(self, (date) => {
-    if (part === "milli") return
+    if (part === "millisecond") return
     const millis = date.getTime()
     const start = new Date(millis)
     startOfDate(start, part, options)
@@ -1157,7 +1166,7 @@ export const format: {
     return new Intl.DateTimeFormat(options?.locale, {
       timeZone: self._tag === "Utc" ? "UTC" : intlTimeZone(self.zone),
       ...options
-    }).format(self.epochMillis)
+    }).format(self.epochMilliseconds)
   } catch {
     return new Intl.DateTimeFormat(options?.locale, {
       timeZone: "UTC",
@@ -1190,7 +1199,7 @@ export const formatLocal: {
       readonly locale?: Intl.LocalesArgument
     }
     | undefined
-): string => new Intl.DateTimeFormat(options?.locale, options).format(self.epochMillis))
+): string => new Intl.DateTimeFormat(options?.locale, options).format(self.epochMilliseconds))
 
 /** @internal */
 export const formatUtc: {
@@ -1220,13 +1229,13 @@ export const formatUtc: {
   new Intl.DateTimeFormat(options?.locale, {
     ...options,
     timeZone: "UTC"
-  }).format(self.epochMillis))
+  }).format(self.epochMilliseconds))
 
 /** @internal */
 export const formatIntl: {
   (format: Intl.DateTimeFormat): (self: DateTime.DateTime) => string
   (self: DateTime.DateTime, format: Intl.DateTimeFormat): string
-} = dual(2, (self: DateTime.DateTime, format: Intl.DateTimeFormat): string => format.format(self.epochMillis))
+} = dual(2, (self: DateTime.DateTime, format: Intl.DateTimeFormat): string => format.format(self.epochMilliseconds))
 
 /** @internal */
 export const formatIso = (self: DateTime.DateTime): string => toDateUtc(self).toISOString()

package/src/internal/effect.ts

@@ -540,6 +540,11 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   maxOpsBeforeYield!: number
   currentPreventYield!: boolean
 
+  _dispatcher: Scheduler.SchedulerDispatcher | undefined = undefined
+  get currentDispatcher(): Scheduler.SchedulerDispatcher {
+    return this._dispatcher ??= this.currentScheduler.makeDispatcher()
+  }
+
   getRef<X>(ref: ServiceMap.Reference<X>): X {
     return ServiceMap.getReferenceUnsafe(this.services, ref)
   }
@@ -675,7 +680,11 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   }
   setServices(services: ServiceMap.ServiceMap<never>): void {
     this.services = services
-    this.currentScheduler = this.getRef(Scheduler.Scheduler)
+    const scheduler = this.getRef(Scheduler.Scheduler)
+    if (scheduler !== this.currentScheduler) {
+      this.currentScheduler = scheduler
+      this._dispatcher = undefined
+    }
     this.currentSpan = services.mapUnsafe.get(Tracer.ParentSpanKey)
     this.currentLogLevel = this.getRef(CurrentLogLevel)
     this.minimumLogLevel = this.getRef(MinimumLogLevel)
@@ -903,7 +912,7 @@ export const yieldNowWith: (priority?: number) => Effect.Effect<void> = makePrim
   op: "Yield",
   [evaluate](fiber) {
     let resumed = false
-    fiber.currentScheduler.scheduleTask(() => {
+    fiber.currentDispatcher.scheduleTask(() => {
       if (resumed) return
       fiber.evaluate(exitVoid as any)
     }, this[args] ?? 0)
@@ -4849,7 +4858,7 @@ export const forkUnsafe = <FA, FE, A, E, R>(
   if (immediate) {
     child.evaluate(effect as any)
   } else {
-    parent.currentScheduler.scheduleTask(() => child.evaluate(effect as any), 0)
+    parent.currentDispatcher.scheduleTask(() => child.evaluate(effect as any), 0)
   }
   if (!daemon && !child._exit) {
     parent.children().add(child)
@@ -4990,10 +4999,8 @@ export const runForkWith = <R>(services: ServiceMap.ServiceMap<R>) =>
   effect: Effect.Effect<A, E, R>,
   options?: Effect.RunOptions | undefined
 ): Fiber.Fiber<A, E> => {
-  const scheduler = options?.scheduler ||
-    (!services.mapUnsafe.has(Scheduler.Scheduler.key) && new Scheduler.MixedScheduler())
   const fiber = new FiberImpl<A, E>(
-    scheduler ? ServiceMap.add(services, Scheduler.Scheduler, scheduler) : services,
+    options?.scheduler ? ServiceMap.add(services, Scheduler.Scheduler, options.scheduler) : services,
     options?.uninterruptible !== true
   )
   fiber.evaluate(effect as any)
@@ -5113,7 +5120,7 @@ export const runSyncExitWith = <R>(services: ServiceMap.ServiceMap<R>) => {
     if (effectIsExit(effect)) return effect
     const scheduler = new Scheduler.MixedScheduler("sync")
     const fiber = runFork(effect, { scheduler })
-    scheduler.flush()
+    fiber.currentDispatcher?.flush()
     return (fiber as FiberImpl<A, E>)._exit ?? exitDie(fiber)
   }
 }
@@ -5136,108 +5143,6 @@ export const runSyncWith = <R>(services: ServiceMap.ServiceMap<R>) => {
 /** @internal */
 export const runSync: <A, E>(effect: Effect.Effect<A, E>) => A = runSyncWith(ServiceMap.empty())
 
-// ----------------------------------------------------------------------------
-// Semaphore
-// ----------------------------------------------------------------------------
-
-/** @internal */
-class Semaphore {
-  public waiters = new Set<() => void>()
-  public taken = 0
-  public permits: number
-
-  constructor(permits: number) {
-    this.permits = permits
-  }
-
-  get free() {
-    return this.permits - this.taken
-  }
-
-  readonly take = (n: number): Effect.Effect<number> => {
-    const take: Effect.Effect<number> = suspend(() => {
-      if (this.free < n) {
-        return callback((resume) => {
-          if (this.free >= n) return resume(take)
-          const observer = () => {
-            if (this.free < n) return
-            this.waiters.delete(observer)
-            resume(take)
-          }
-          this.waiters.add(observer)
-          return sync(() => {
-            this.waiters.delete(observer)
-          })
-        })
-      }
-      this.taken += n
-      return succeed(n)
-    })
-    return take
-  }
-
-  updateTakenUnsafe(fiber: Fiber.Fiber<any, any>, f: (n: number) => number): Effect.Effect<number> {
-    this.taken = f(this.taken)
-    if (this.waiters.size > 0) {
-      fiber.currentScheduler.scheduleTask(() => {
-        const iter = this.waiters.values()
-        let item = iter.next()
-        while (item.done === false && this.free > 0) {
-          item.value()
-          item = iter.next()
-        }
-      }, 0)
-    }
-    return succeed(this.free)
-  }
-
-  updateTaken(f: (n: number) => number): Effect.Effect<number> {
-    return withFiber((fiber) => this.updateTakenUnsafe(fiber, f))
-  }
-
-  readonly resize = (permits: number) =>
-    asVoid(
-      withFiber((fiber) => {
-        this.permits = permits
-        if (this.free < 0) {
-          return void_
-        }
-        return this.updateTakenUnsafe(fiber, (taken) => taken)
-      })
-    )
-
-  readonly release = (n: number): Effect.Effect<number> => this.updateTaken((taken) => taken - n)
-
-  readonly releaseAll: Effect.Effect<number> = this.updateTaken((_) => 0)
-
-  readonly withPermits = (n: number) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    uninterruptibleMask((restore) =>
-      flatMap(
-        restore(this.take(n)),
-        (permits) => onExitPrimitive(restore(self), () => this.release(permits), true)
-      )
-    )
-
-  readonly withPermit = this.withPermits(1)
-
-  readonly withPermitsIfAvailable = (n: number) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    uninterruptibleMask((restore) =>
-      suspend(() => {
-        if (this.free < n) {
-          return succeedNone
-        }
-        this.taken += n
-        return ensuring(restore(asSome(self)), this.release(n))
-      })
-    )
-}
-
-/** @internal */
-export const makeSemaphoreUnsafe = (permits: number): Semaphore => new Semaphore(permits)
-
-/** @internal */
-export const makeSemaphore = (permits: number) => sync(() => makeSemaphoreUnsafe(permits))
-
 const succeedTrue = succeed(true)
 const succeedFalse = succeed(false)
 
@@ -5255,7 +5160,7 @@ class Latch implements _Latch.Latch {
       return succeedTrue
     }
     this.scheduled = true
-    fiber.currentScheduler.scheduleTask(this.flushWaiters, 0)
+    fiber.currentDispatcher.scheduleTask(this.flushWaiters, 0)
     return succeedTrue
   }
   private flushWaiters = () => {
@@ -5297,7 +5202,7 @@ class Latch implements _Latch.Latch {
     return true
   }
   close = sync(() => this.closeUnsafe())
-  whenOpen = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => andThen(this.await, self)
+  whenOpen = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => flatMap(this.await, () => self)
 }
 
 /** @internal */
@@ -5360,16 +5265,15 @@ const NoopSpanProto: Omit<Tracer.Span, "parent" | "name" | "annotations" | "leve
 /** @internal */
 export const noopSpan = (options: {
   readonly name: string
-  readonly parent: Tracer.AnySpan | undefined
+  readonly parent: Option.Option<Tracer.AnySpan>
   readonly annotations: ServiceMap.ServiceMap<never>
 }): Tracer.Span => Object.assign(Object.create(NoopSpanProto), options)
 
-const filterDisablePropagation = (span: Tracer.AnySpan | undefined): Tracer.AnySpan | undefined => {
-  if (span) {
-    return ServiceMap.get(span.annotations, Tracer.DisablePropagation)
-      ? span._tag === "Span" ? filterDisablePropagation(span.parent) : undefined
-      : span
-  }
+const filterDisablePropagation = (span: Tracer.AnySpan | undefined): Option.Option<Tracer.AnySpan> => {
+  if (!span) return Option.none()
+  return ServiceMap.get(span.annotations, Tracer.DisablePropagation)
+    ? span._tag === "Span" ? filterDisablePropagation(Option.getOrUndefined(span.parent)) : Option.none()
+    : Option.some(span)
 }
 
 /** @internal */
@@ -5380,7 +5284,11 @@ export const makeSpanUnsafe = <XA, XE>(
 ) => {
   const disablePropagation = !fiber.getRef(TracerEnabled) ||
     (options?.annotations && ServiceMap.get(options.annotations, Tracer.DisablePropagation))
-  const parent = options?.parent ?? (options?.root ? undefined : filterDisablePropagation(fiber.currentSpan))
+  const parent = options?.parent !== undefined
+    ? Option.some(options.parent)
+    : options?.root
+    ? Option.none<Tracer.AnySpan>()
+    : filterDisablePropagation(fiber.currentSpan)
 
   let span: Tracer.Span
 
@@ -5413,9 +5321,9 @@ export const makeSpanUnsafe = <XA, XE>(
       links,
       startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : 0n,
       kind: options?.kind ?? "internal",
-      root: options?.root ?? options?.parent === undefined,
+      root: options?.root ?? Option.isNone(parent),
       sampled: options?.sampled ??
-        (parent?.sampled === false
+        (Option.isSome(parent) && parent.value.sampled === false
           ? false
           : !isLogLevelGreaterThan(fiber.getRef(Tracer.MinimumTraceLevel), level))
     })
@@ -6195,7 +6103,7 @@ const prettyLoggerBrowser = (options: {
 export const defaultLogger = loggerMake<unknown, void>(({ cause, date, fiber, logLevel, message }) => {
   const message_ = Array.isArray(message) ? message.slice() : [message]
   if (cause.reasons.length > 0) {
-    message_.unshift(causePretty(cause))
+    message_.push(causePretty(cause))
   }
   const now = date.getTime()
   const spans = fiber.getRef(CurrentLogSpans)

package/src/internal/hashMap.ts

@@ -1271,14 +1271,15 @@ export const filterMap = dual<
 
 /** @internal */
 export const findFirst = dual<
-  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean) => (self: HashMap<K, A>) => [K, A] | undefined,
-  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean) => [K, A] | undefined
+  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean) => (self: HashMap<K, A>) => Option.Option<[K, A]>,
+  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean) => Option.Option<[K, A]>
 >(2, <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean) => {
   for (const [key, value] of self) {
     if (predicate(value, key)) {
-      return [key, value]
+      return Option.some([key, value])
     }
   }
+  return Option.none()
 })
 
 /** @internal */

package/src/internal/option.ts

@@ -45,10 +45,17 @@ const SomeProto = Object.assign(Object.create(CommonProto), {
   }
 })
 
+Object.defineProperty(SomeProto, "valueOrUndefined", {
+  get() {
+    return this.value
+  }
+})
+
 const NoneHash = Hash.hash("None")
 const NoneProto = Object.assign(Object.create(CommonProto), {
   _tag: "None",
   _op: "None",
+  valueOrUndefined: undefined,
   [Equal.symbol]<A>(this: Option.None<A>, that: unknown): boolean {
     return isOption(that) && isNone(that)
   },

package/src/internal/trie.ts

@@ -682,19 +682,19 @@ export const modify = dual<
 
 /** @internal */
 export const longestPrefixOf = dual<
-  (key: string) => <V>(self: TR.Trie<V>) => [string, V] | undefined,
-  <V>(self: TR.Trie<V>, key: string) => [string, V] | undefined
+  (key: string) => <V>(self: TR.Trie<V>) => Option.Option<[string, V]>,
+  <V>(self: TR.Trie<V>, key: string) => Option.Option<[string, V]>
 >(
   2,
-  <V>(self: TR.Trie<V>, key: string): [string, V] | undefined => {
+  <V>(self: TR.Trie<V>, key: string): Option.Option<[string, V]> => {
     let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return undefined
-    let longestPrefixNode: [string, V] | undefined = undefined
+    if (n === undefined || key.length === 0) return Option.none()
+    let longestPrefixNode: Option.Option<[string, V]> = Option.none()
     let cIndex = 0
     while (cIndex < key.length) {
       const c = key[cIndex]
       if (n.value !== undefined) {
-        longestPrefixNode = [key.slice(0, cIndex + 1), n.value]
+        longestPrefixNode = Option.some([key.slice(0, cIndex + 1), n.value])
       }
 
       if (c > n.key) {

package/src/unstable/ai/AiError.ts

@@ -183,7 +183,7 @@ export class NetworkError extends Schema.ErrorClass<NetworkError>(
       description: error.description,
       reason: error._tag,
       request: {
-        hash: error.request.hash,
+        hash: Option.getOrUndefined(error.request.hash),
         headers: redactHeaders(error.request.headers),
         method: error.request.method,
         url: error.request.url,