MixedSchedulerProvides a scheduler implementation that batches queued tasks and dispatches them by priority.
When to use
Use when you need the default runtime scheduler directly, including a scheduler that batches queued work by priority and preserves FIFO order within each priority.
Details
MixedScheduler supports synchronous and asynchronous execution modes, uses
operation counts to decide when fibers should yield, and is the default
scheduler implementation.
export class class MixedSchedulerclass MixedScheduler {
executionMode: "sync" | "async";
setImmediate: (f: () => void) => () => void;
shouldYield: (fiber: Fiber.Fiber<unknown, unknown>) => boolean;
makeDispatcher: () => MixedSchedulerDispatcher;
}
Provides a scheduler implementation that batches queued tasks and dispatches them by
priority.
When to use
Use when you need the default runtime scheduler directly, including a
scheduler that batches queued work by priority and preserves FIFO order within
each priority.
Details
MixedScheduler supports synchronous and asynchronous execution modes, uses
operation counts to decide when fibers should yield, and is the default
scheduler implementation.
MixedScheduler implements Scheduler {
readonly MixedScheduler.executionMode: "sync" | "async"executionMode: "sync" | "async"
readonly MixedScheduler.setImmediate: (f: () => void) => () => voidsetImmediate: (f: () => voidf: () => void) => () => void
constructor(
executionMode: "sync" | "async"executionMode: "sync" | "async" = "async",
setImmediateFn: (f: () => void) => () => voidsetImmediateFn: (f: () => voidf: () => void) => () => void = const setImmediate: (
f: () => void
) => () => void
MixedScheduler.executionMode: "sync" | "async"executionMode = executionMode: "sync" | "async"executionMode
this.MixedScheduler.setImmediate: (f: () => void) => () => voidsetImmediate = setImmediateFn: (f: () => void) => () => voidsetImmediateFn
}
/**
* Returns whether the fiber has reached its operation budget and should yield.
*
* **When to use**
*
* Use to decide whether a fiber should yield after consuming its current
* operation budget.
*
* @since 2.0.0
*/
MixedScheduler.shouldYield(fiber: Fiber.Fiber<unknown, unknown>): booleanReturns whether the fiber has reached its operation budget and should yield.
When to use
Use to decide whether a fiber should yield after consuming its current
operation budget.
shouldYield(fiber: Fiber.Fiber<unknown, unknown>(parameter) fiber: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import FiberFiber.type Fiber.Fiber = /*unresolved*/ anyFiber<unknown, unknown>) {
return fiber: Fiber.Fiber<unknown, unknown>(parameter) fiber: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
fiber: Fiber.Fiber<unknown, unknown>(parameter) fiber: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
MixedScheduler.makeDispatcher(): MixedSchedulerDispatcherCreates a dispatcher that schedules work through this scheduler.
When to use
Use when you need a standalone dispatcher from a scheduler instance, for
example in tests that enqueue tasks and then flush them deterministically.
makeDispatcher() {
return new constructor MixedSchedulerDispatcher(setImmediateFn?: (f: () => void) => () => void): MixedSchedulerDispatcherMixedSchedulerDispatcher(this.MixedScheduler.setImmediate: (f: () => void) => () => voidsetImmediate)
}
}