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

package/src/ScheduleDecision.ts

@@ -0,0 +1,62 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/schedule/decision.js"
+import type * as Interval from "./ScheduleInterval.js"
+import type * as Intervals from "./ScheduleIntervals.js"
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type ScheduleDecision = Continue | Done
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Continue {
+  readonly _tag: "Continue"
+  readonly intervals: Intervals.Intervals
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Done {
+  readonly _tag: "Done"
+}
+
+const _continue = internal._continue
+export {
+  /**
+   * @since 2.0.0
+   * @category constructors
+   */
+  _continue as continue
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const continueWith: (interval: Interval.Interval) => ScheduleDecision = internal.continueWith
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const done: ScheduleDecision = internal.done
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isContinue: (self: ScheduleDecision) => self is Continue = internal.isContinue
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isDone: (self: ScheduleDecision) => self is Done = internal.isDone

package/src/ScheduleInterval.ts

@@ -0,0 +1,151 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Duration from "./Duration.js"
+import * as internal from "./internal/schedule/interval.js"
+import type * as Option from "./Option.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const IntervalTypeId: unique symbol = internal.IntervalTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type IntervalTypeId = typeof IntervalTypeId
+
+/**
+ * An `Interval` represents an interval of time. Intervals can encompass all
+ * time, or no time at all.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Interval {
+  readonly [IntervalTypeId]: IntervalTypeId
+  readonly startMillis: number
+  readonly endMillis: number
+}
+
+/**
+ * Constructs a new interval from the two specified endpoints. If the start
+ * endpoint greater than the end endpoint, then a zero size interval will be
+ * returned.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (startMillis: number, endMillis: number) => Interval = internal.make
+
+/**
+ * An `Interval` of zero-width.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty: Interval = internal.empty
+
+/**
+ * Returns `true` if this `Interval` is less than `that` interval, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category ordering
+ */
+export const lessThan: {
+  (that: Interval): (self: Interval) => boolean
+  (self: Interval, that: Interval): boolean
+} = internal.lessThan
+
+/**
+ * Returns the minimum of two `Interval`s.
+ *
+ * @since 2.0.0
+ * @category ordering
+ */
+export const min: {
+  (that: Interval): (self: Interval) => Interval
+  (self: Interval, that: Interval): Interval
+} = internal.min
+
+/**
+ * Returns the maximum of two `Interval`s.
+ *
+ * @since 2.0.0
+ * @category ordering
+ */
+export const max: {
+  (that: Interval): (self: Interval) => Interval
+  (self: Interval, that: Interval): Interval
+} = internal.max
+
+/**
+ * Returns `true` if the specified `Interval` is empty, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category ordering
+ */
+export const isEmpty: (self: Interval) => boolean = internal.isEmpty
+
+/**
+ * Returns `true` if the specified `Interval` is non-empty, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category ordering
+ */
+export const isNonEmpty: (self: Interval) => boolean = internal.isNonEmpty
+
+/**
+ * Computes a new `Interval` which is the intersection of this `Interval` and
+ * that `Interval`.
+ *
+ * @since 2.0.0
+ * @category ordering
+ */
+export const intersect: {
+  (that: Interval): (self: Interval) => Interval
+  (self: Interval, that: Interval): Interval
+} = internal.intersect
+
+/**
+ * Calculates the size of the `Interval` as the `Duration` from the start of the
+ * interval to the end of the interval.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const size: (self: Interval) => Duration.Duration = internal.size
+
+/**
+ * Computes a new `Interval` which is the union of this `Interval` and that
+ * `Interval` as a `Some`, otherwise returns `None` if the two intervals cannot
+ * form a union.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const union: {
+  (that: Interval): (self: Interval) => Option.Option<Interval>
+  (self: Interval, that: Interval): Option.Option<Interval>
+} = internal.union
+
+/**
+ * Construct an `Interval` that includes all time equal to and after the
+ * specified start time.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const after: (startMilliseconds: number) => Interval = internal.after
+
+/**
+ * Construct an `Interval` that includes all time equal to and before the
+ * specified end time.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const before: (endMilliseconds: number) => Interval = internal.before

package/src/ScheduleIntervals.ts

@@ -0,0 +1,122 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Check from "./Chunk.js"
+import * as internal from "./internal/schedule/intervals.js"
+import type * as Interval from "./ScheduleInterval.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const IntervalsTypeId: unique symbol = internal.IntervalsTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type IntervalsTypeId = typeof IntervalsTypeId
+
+/**
+ * An `Intervals` represents a list of several `Interval`s.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Intervals {
+  readonly [IntervalsTypeId]: IntervalsTypeId
+  readonly intervals: Check.Chunk<Interval.Interval>
+}
+
+/**
+ * Creates a new `Intervals` from a `List` of `Interval`s.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (intervals: Check.Chunk<Interval.Interval>) => Intervals = internal.make
+
+/**
+ * Constructs an empty list of `Interval`s.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty: Intervals = internal.empty
+
+/**
+ * Creates `Intervals` from the specified `Iterable<Interval>`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable: (intervals: Iterable<Interval.Interval>) => Intervals = internal.fromIterable
+
+/**
+ * Computes the union of this `Intervals` and  that `Intervals`
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const union: {
+  (that: Intervals): (self: Intervals) => Intervals
+  (self: Intervals, that: Intervals): Intervals
+} = internal.union
+
+/**
+ * Produces the intersection of this `Intervals` and that `Intervals`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const intersect: {
+  (that: Intervals): (self: Intervals) => Intervals
+  (self: Intervals, that: Intervals): Intervals
+} = internal.intersect
+
+/**
+ * The start of the earliest interval in the specified `Intervals`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const start: (self: Intervals) => number = internal.start
+
+/**
+ * The end of the latest interval in the specified `Intervals`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const end: (self: Intervals) => number = internal.end
+
+/**
+ * Returns `true` if the start of this `Intervals` is before the start of that
+ * `Intervals`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category ordering
+ */
+export const lessThan: {
+  (that: Intervals): (self: Intervals) => boolean
+  (self: Intervals, that: Intervals): boolean
+} = internal.lessThan
+
+/**
+ * Returns `true` if this `Intervals` is non-empty, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isNonEmpty: (self: Intervals) => boolean = internal.isNonEmpty
+
+/**
+ * Returns the maximum of the two `Intervals` (i.e. which has the latest start).
+ *
+ * @since 2.0.0
+ * @category ordering
+ */
+export const max: {
+  (that: Intervals): (self: Intervals) => Intervals
+  (self: Intervals, that: Intervals): Intervals
+} = internal.max

package/src/Scheduler.ts

@@ -0,0 +1,353 @@
+/**
+ * @since 2.0.0
+ */
+
+import type { Effect } from "./Effect.js"
+import type { RuntimeFiber } from "./Fiber.js"
+import type { FiberRef } from "./FiberRef.js"
+import { dual } from "./Function.js"
+import { globalValue } from "./GlobalValue.js"
+import * as core from "./internal/core.js"
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type Task = () => void
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Scheduler {
+  shouldYield(fiber: RuntimeFiber<unknown, unknown>): number | false
+  scheduleTask(task: Task, priority: number): void
+}
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export class PriorityBuckets<in out T = Task> {
+  /**
+   * @since 2.0.0
+   */
+  public buckets: Array<[number, Array<T>]> = []
+  /**
+   * @since 2.0.0
+   */
+  scheduleTask(task: T, priority: number) {
+    const length = this.buckets.length
+    let bucket: [number, Array<T>] | undefined = undefined
+    let index = 0
+    for (; index < length; index++) {
+      if (this.buckets[index][0] <= priority) {
+        bucket = this.buckets[index]
+      } else {
+        break
+      }
+    }
+    if (bucket && bucket[0] === priority) {
+      bucket[1].push(task)
+    } else if (index === length) {
+      this.buckets.push([priority, [task]])
+    } else {
+      this.buckets.splice(index, 0, [priority, [task]])
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export class MixedScheduler implements Scheduler {
+  /**
+   * @since 2.0.0
+   */
+  running = false
+  /**
+   * @since 2.0.0
+   */
+  tasks = new PriorityBuckets()
+
+  constructor(
+    /**
+     * @since 2.0.0
+     */
+    readonly maxNextTickBeforeTimer: number
+  ) {}
+
+  /**
+   * @since 2.0.0
+   */
+  private starveInternal(depth: number) {
+    const tasks = this.tasks.buckets
+    this.tasks.buckets = []
+    for (const [_, toRun] of tasks) {
+      for (let i = 0; i < toRun.length; i++) {
+        toRun[i]()
+      }
+    }
+    if (this.tasks.buckets.length === 0) {
+      this.running = false
+    } else {
+      this.starve(depth)
+    }
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  private starve(depth = 0) {
+    if (depth >= this.maxNextTickBeforeTimer) {
+      setTimeout(() => this.starveInternal(0), 0)
+    } else {
+      Promise.resolve(void 0).then(() => this.starveInternal(depth + 1))
+    }
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  shouldYield(fiber: RuntimeFiber<unknown, unknown>): number | false {
+    return fiber.currentOpCount > fiber.getFiberRef(core.currentMaxOpsBeforeYield)
+      ? fiber.getFiberRef(core.currentSchedulingPriority)
+      : false
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  scheduleTask(task: Task, priority: number) {
+    this.tasks.scheduleTask(task, priority)
+    if (!this.running) {
+      this.running = true
+      this.starve()
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category schedulers
+ */
+export const defaultScheduler: Scheduler = globalValue(
+  Symbol.for("effect/Scheduler/defaultScheduler"),
+  () => new MixedScheduler(2048)
+)
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export class SyncScheduler implements Scheduler {
+  /**
+   * @since 2.0.0
+   */
+  tasks = new PriorityBuckets()
+
+  /**
+   * @since 2.0.0
+   */
+  deferred = false
+
+  /**
+   * @since 2.0.0
+   */
+  scheduleTask(task: Task, priority: number) {
+    if (this.deferred) {
+      defaultScheduler.scheduleTask(task, priority)
+    } else {
+      this.tasks.scheduleTask(task, priority)
+    }
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  shouldYield(fiber: RuntimeFiber<unknown, unknown>): number | false {
+    return fiber.currentOpCount > fiber.getFiberRef(core.currentMaxOpsBeforeYield)
+      ? fiber.getFiberRef(core.currentSchedulingPriority)
+      : false
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  flush() {
+    while (this.tasks.buckets.length > 0) {
+      const tasks = this.tasks.buckets
+      this.tasks.buckets = []
+      for (const [_, toRun] of tasks) {
+        for (let i = 0; i < toRun.length; i++) {
+          toRun[i]()
+        }
+      }
+    }
+    this.deferred = true
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export class ControlledScheduler implements Scheduler {
+  /**
+   * @since 2.0.0
+   */
+  tasks = new PriorityBuckets()
+
+  /**
+   * @since 2.0.0
+   */
+  deferred = false
+
+  /**
+   * @since 2.0.0
+   */
+  scheduleTask(task: Task, priority: number) {
+    if (this.deferred) {
+      defaultScheduler.scheduleTask(task, priority)
+    } else {
+      this.tasks.scheduleTask(task, priority)
+    }
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  shouldYield(fiber: RuntimeFiber<unknown, unknown>): number | false {
+    return fiber.currentOpCount > fiber.getFiberRef(core.currentMaxOpsBeforeYield)
+      ? fiber.getFiberRef(core.currentSchedulingPriority)
+      : false
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  step() {
+    const tasks = this.tasks.buckets
+    this.tasks.buckets = []
+    for (const [_, toRun] of tasks) {
+      for (let i = 0; i < toRun.length; i++) {
+        toRun[i]()
+      }
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeMatrix = (...record: Array<[number, Scheduler]>): Scheduler => {
+  const index = record.sort(([p0], [p1]) => p0 < p1 ? -1 : p0 > p1 ? 1 : 0)
+  return {
+    shouldYield(fiber) {
+      for (const scheduler of record) {
+        const priority = scheduler[1].shouldYield(fiber)
+        if (priority !== false) {
+          return priority
+        }
+      }
+      return false
+    },
+    scheduleTask(task, priority) {
+      let scheduler: Scheduler | undefined = undefined
+      for (const i of index) {
+        if (priority >= i[0]) {
+          scheduler = i[1]
+        } else {
+          return (scheduler ?? defaultScheduler).scheduleTask(task, priority)
+        }
+      }
+      return (scheduler ?? defaultScheduler).scheduleTask(task, priority)
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category utilities
+ */
+export const defaultShouldYield: Scheduler["shouldYield"] = (fiber) => {
+  return fiber.currentOpCount > fiber.getFiberRef(core.currentMaxOpsBeforeYield)
+    ? fiber.getFiberRef(core.currentSchedulingPriority)
+    : false
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = (
+  scheduleTask: Scheduler["scheduleTask"],
+  shouldYield: Scheduler["shouldYield"] = defaultShouldYield
+): Scheduler => ({
+  scheduleTask,
+  shouldYield
+})
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeBatched = (
+  callback: (runBatch: () => void) => void,
+  shouldYield: Scheduler["shouldYield"] = defaultShouldYield
+) => {
+  let running = false
+  const tasks = new PriorityBuckets()
+  const starveInternal = () => {
+    const tasksToRun = tasks.buckets
+    tasks.buckets = []
+    for (const [_, toRun] of tasksToRun) {
+      for (let i = 0; i < toRun.length; i++) {
+        toRun[i]()
+      }
+    }
+    if (tasks.buckets.length === 0) {
+      running = false
+    } else {
+      starve()
+    }
+  }
+
+  const starve = () => callback(starveInternal)
+
+  return make((task, priority) => {
+    tasks.scheduleTask(task, priority)
+    if (!running) {
+      running = true
+      starve()
+    }
+  }, shouldYield)
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const timer = (ms: number, shouldYield: Scheduler["shouldYield"] = defaultShouldYield) =>
+  make((task) => setTimeout(task, ms), shouldYield)
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const timerBatched = (ms: number, shouldYield: Scheduler["shouldYield"] = defaultShouldYield) =>
+  makeBatched((task) => setTimeout(task, ms), shouldYield)
+
+/** @internal */
+export const currentScheduler: FiberRef<Scheduler> = globalValue(
+  Symbol.for("effect/FiberRef/currentScheduler"),
+  () => core.fiberRefUnsafeMake(defaultScheduler)
+)
+
+/** @internal */
+export const withScheduler = dual<
+  (scheduler: Scheduler) => <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>,
+  <A, E, R>(self: Effect<A, E, R>, scheduler: Scheduler) => Effect<A, E, R>
+>(2, (self, scheduler) => core.fiberRefLocally(self, currentScheduler, scheduler))