effect 2.0.0-next.44 → 2.0.0-next.46

package/src/internal/runtime.ts

@@ -0,0 +1,348 @@
+import type * as Cause from "../Cause"
+import * as Context from "../Context"
+import type * as Effect from "../Effect"
+import * as Exit from "../Exit"
+import * as Fiber from "../Fiber"
+import * as FiberId from "../FiberId"
+import type * as FiberRef from "../FiberRef"
+import * as FiberRefs from "../FiberRefs"
+import { pipe } from "../Function"
+import { NodeInspectSymbol, toString } from "../Inspectable"
+import { NoSuchElementException } from "../internal/cause"
+import * as InternalCause from "../internal/cause"
+import * as core from "../internal/core"
+import * as FiberRuntime from "../internal/fiberRuntime"
+import * as fiberScope from "../internal/fiberScope"
+import * as OpCodes from "../internal/opCodes/effect"
+import * as runtimeFlags from "../internal/runtimeFlags"
+import * as _supervisor from "../internal/supervisor"
+import * as Option from "../Option"
+import { pipeArguments } from "../Pipeable"
+import * as Predicate from "../Predicate"
+import type * as Runtime from "../Runtime"
+import type * as RuntimeFlags from "../RuntimeFlags"
+import * as _scheduler from "../Scheduler"
+
+/** @internal */
+export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
+<E, A>(
+  self: Effect.Effect<R, E, A>,
+  options?: Runtime.RunForkOptions
+): Fiber.RuntimeFiber<E, A> => {
+  const fiberId = FiberId.unsafeMake()
+  const effect = self
+
+  let fiberRefs = FiberRefs.updatedAs(runtime.fiberRefs, {
+    fiberId,
+    fiberRef: core.currentContext,
+    value: runtime.context as Context.Context<never>
+  })
+
+  if (options?.scheduler) {
+    fiberRefs = FiberRefs.updatedAs(fiberRefs, {
+      fiberId,
+      fiberRef: _scheduler.currentScheduler,
+      value: options.scheduler
+    })
+  }
+
+  if (options?.updateRefs) {
+    fiberRefs = options.updateRefs(fiberRefs, fiberId)
+  }
+
+  const fiberRuntime: FiberRuntime.FiberRuntime<E, A> = new FiberRuntime.FiberRuntime<E, A>(
+    fiberId,
+    FiberRefs.forkAs(fiberRefs, fiberId),
+    runtime.runtimeFlags
+  )
+
+  const supervisor = fiberRuntime._supervisor
+
+  // we can compare by reference here as _supervisor.none is wrapped with globalValue
+  if (supervisor !== _supervisor.none) {
+    supervisor.onStart(runtime.context, effect, Option.none(), fiberRuntime)
+
+    fiberRuntime.addObserver((exit) => supervisor.onEnd(exit, fiberRuntime))
+  }
+
+  fiberScope.globalScope.add(runtime.runtimeFlags, fiberRuntime)
+
+  fiberRuntime.start(effect)
+
+  return fiberRuntime
+}
+
+/** @internal */
+export const unsafeRunCallback = <R>(runtime: Runtime.Runtime<R>) =>
+<E, A>(
+  effect: Effect.Effect<R, E, A>,
+  onExit?: (exit: Exit.Exit<E, A>) => void
+): (fiberId?: FiberId.FiberId, onExit?: (exit: Exit.Exit<E, A>) => void) => void => {
+  const fiberRuntime = unsafeFork(runtime)(effect)
+
+  if (onExit) {
+    fiberRuntime.addObserver((exit) => {
+      onExit(exit)
+    })
+  }
+
+  return (id, onExitInterrupt) =>
+    unsafeRunCallback(runtime)(
+      pipe(fiberRuntime, Fiber.interruptAs(id ?? FiberId.none)),
+      onExitInterrupt ?
+        (exit) => onExitInterrupt(Exit.flatten(exit)) :
+        void 0
+    )
+}
+
+/** @internal */
+export const unsafeRunSync = <R>(runtime: Runtime.Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>): A => {
+  const result = unsafeRunSyncExit(runtime)(effect)
+  if (result._tag === "Failure") {
+    throw fiberFailure(result.i0)
+  } else {
+    return result.i0
+  }
+}
+
+/** @internal */
+const asyncFiberException = <E, A>(fiber: Fiber.RuntimeFiber<E, A>): Runtime.AsyncFiberException<E, A> => {
+  const limit = Error.stackTraceLimit
+  Error.stackTraceLimit = 0
+  const error = (new Error()) as any
+  Error.stackTraceLimit = limit
+  const message =
+    `Fiber #${fiber.id().id} cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work`
+  const _tag = "AsyncFiberException"
+  Object.defineProperties(error, {
+    _tag: {
+      value: _tag
+    },
+    fiber: {
+      value: fiber
+    },
+    message: {
+      value: message
+    },
+    name: {
+      value: _tag
+    },
+    toString: {
+      get() {
+        return () => message
+      }
+    },
+    [NodeInspectSymbol]: {
+      get() {
+        return () => message
+      }
+    }
+  })
+  return error
+}
+
+/** @internal */
+export const isAsyncFiberException = (u: unknown): u is Runtime.AsyncFiberException<unknown, unknown> =>
+  Predicate.isTagged(u, "AsyncFiberException") && "fiber" in u
+
+/** @internal */
+export const FiberFailureId: Runtime.FiberFailureId = Symbol.for("effect/Runtime/FiberFailure") as any
+/** @internal */
+export const FiberFailureCauseId: Runtime.FiberFailureCauseId = Symbol.for(
+  "effect/Runtime/FiberFailure/Cause"
+) as any
+
+type Mutable<A> = {
+  -readonly [k in keyof A]: A[k]
+}
+
+/** @internal */
+export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure => {
+  const limit = Error.stackTraceLimit
+  Error.stackTraceLimit = 0
+  const error = (new Error()) as Mutable<Runtime.FiberFailure>
+  Error.stackTraceLimit = limit
+  const prettyErrors = InternalCause.prettyErrors(cause)
+  if (prettyErrors.length > 0) {
+    const head = prettyErrors[0]
+    error.name = head.message.split(":")[0]
+    error.message = head.message.substring(error.name.length + 2)
+    error.stack = `${error.name}: ${error.message}\n${head.stack}`
+  }
+  error[FiberFailureId] = FiberFailureId
+  error[FiberFailureCauseId] = cause
+  error.toJSON = () => {
+    return {
+      _id: "FiberFailure",
+      cause: cause.toJSON()
+    }
+  }
+  error.toString = () => {
+    return toString(error.toJSON())
+  }
+  error[NodeInspectSymbol] = () => {
+    return error.toJSON()
+  }
+  return error
+}
+
+/** @internal */
+export const isFiberFailure = (u: unknown): u is Runtime.FiberFailure =>
+  typeof u === "object" && u !== null && FiberFailureId in u
+
+const fastPath = <R, E, A>(effect: Effect.Effect<R, E, A>): Exit.Exit<E, A> | undefined => {
+  const op = effect as core.Primitive
+  switch (op._op) {
+    case "Failure":
+    case "Success": {
+      // @ts-expect-error
+      return op
+    }
+    case "Left": {
+      return core.exitFail(op.left)
+    }
+    case "Right": {
+      return core.exitSucceed(op.right)
+    }
+    case "Some": {
+      return core.exitSucceed(op.value)
+    }
+    case "None": {
+      // @ts-expect-error
+      return core.exitFail(NoSuchElementException())
+    }
+  }
+}
+
+/** @internal */
+export const unsafeRunSyncExit =
+  <R>(runtime: Runtime.Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>): Exit.Exit<E, A> => {
+    const op = fastPath(effect)
+    if (op) {
+      return op
+    }
+    const scheduler = new _scheduler.SyncScheduler()
+    const fiberRuntime = unsafeFork(runtime)(effect, { scheduler })
+    scheduler.flush()
+    const result = fiberRuntime.unsafePoll()
+    if (result) {
+      return result
+    }
+    throw asyncFiberException(fiberRuntime)
+  }
+
+/** @internal */
+export const unsafeRunPromise =
+  <R>(runtime: Runtime.Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>): Promise<A> =>
+    unsafeRunPromiseExit(runtime)(effect).then((result) => {
+      switch (result._tag) {
+        case OpCodes.OP_SUCCESS: {
+          return result.i0
+        }
+        case OpCodes.OP_FAILURE: {
+          throw fiberFailure(result.i0)
+        }
+      }
+    })
+
+/** @internal */
+export const unsafeRunPromiseExit =
+  <R>(runtime: Runtime.Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>): Promise<Exit.Exit<E, A>> =>
+    new Promise((resolve) => {
+      const op = fastPath(effect)
+      if (op) {
+        resolve(op)
+      }
+      unsafeFork(runtime)(effect).addObserver((exit) => {
+        resolve(exit)
+      })
+    })
+
+/** @internal */
+export class RuntimeImpl<R> implements Runtime.Runtime<R> {
+  constructor(
+    readonly context: Context.Context<R>,
+    readonly runtimeFlags: RuntimeFlags.RuntimeFlags,
+    readonly fiberRefs: FiberRefs.FiberRefs
+  ) {}
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const make = <R>(
+  options: {
+    readonly context: Context.Context<R>
+    readonly runtimeFlags: RuntimeFlags.RuntimeFlags
+    readonly fiberRefs: FiberRefs.FiberRefs
+  }
+): Runtime.Runtime<R> => new RuntimeImpl(options.context, options.runtimeFlags, options.fiberRefs)
+
+/** @internal */
+export const runtime = <R>(): Effect.Effect<R, never, Runtime.Runtime<R>> =>
+  core.withFiberRuntime<R, never, RuntimeImpl<R>>((state, status) =>
+    core.succeed(
+      new RuntimeImpl<R>(
+        state.getFiberRef(core.currentContext as unknown as FiberRef.FiberRef<Context.Context<R>>),
+        status.runtimeFlags,
+        state.getFiberRefs()
+      )
+    )
+  )
+
+/** @internal */
+export const defaultRuntimeFlags: RuntimeFlags.RuntimeFlags = runtimeFlags.make(
+  runtimeFlags.Interruption,
+  runtimeFlags.CooperativeYielding,
+  runtimeFlags.RuntimeMetrics
+)
+
+/** @internal */
+export const defaultRuntime = make({
+  context: Context.empty(),
+  runtimeFlags: defaultRuntimeFlags,
+  fiberRefs: FiberRefs.empty()
+})
+
+/** @internal */
+export const unsafeRunEffect = unsafeRunCallback(defaultRuntime)
+
+/** @internal */
+export const unsafeForkEffect = unsafeFork(defaultRuntime)
+
+/** @internal */
+export const unsafeRunPromiseEffect = unsafeRunPromise(defaultRuntime)
+
+/** @internal */
+export const unsafeRunPromiseExitEffect = unsafeRunPromiseExit(defaultRuntime)
+
+/** @internal */
+export const unsafeRunSyncEffect = unsafeRunSync(defaultRuntime)
+
+/** @internal */
+export const unsafeRunSyncExitEffect = unsafeRunSyncExit(defaultRuntime)
+
+// circular with Effect
+
+/** @internal */
+export const asyncEffect = <R, E, A, R2, E2, X>(
+  register: (callback: (_: Effect.Effect<R, E, A>) => void) => Effect.Effect<R2, E2, X>
+): Effect.Effect<R | R2, E | E2, A> =>
+  core.flatMap(
+    core.deferredMake<E | E2, A>(),
+    (deferred) =>
+      core.flatMap(runtime<R | R2>(), (runtime) =>
+        core.uninterruptibleMask((restore) =>
+          core.zipRight(
+            FiberRuntime.fork(restore(
+              core.catchAllCause(
+                register((cb) => unsafeRunCallback(runtime)(core.intoDeferred(cb, deferred))),
+                (cause) => core.deferredFailCause(deferred, cause)
+              )
+            )),
+            restore(core.deferredAwait(deferred))
+          )
+        ))
+  )

package/src/internal/runtimeFlags.ts

@@ -0,0 +1,176 @@
+import * as Differ from "../Differ"
+import { dual } from "../Function"
+import * as runtimeFlagsPatch from "../internal/runtimeFlagsPatch"
+import type * as RuntimeFlags from "../RuntimeFlags"
+import type * as RuntimeFlagsPatch from "../RuntimeFlagsPatch"
+
+/** @internal */
+export const None: RuntimeFlags.RuntimeFlag = 0 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const Interruption: RuntimeFlags.RuntimeFlag = 1 << 0 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const OpSupervision: RuntimeFlags.RuntimeFlag = 1 << 1 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const RuntimeMetrics: RuntimeFlags.RuntimeFlag = 1 << 2 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const WindDown: RuntimeFlags.RuntimeFlag = 1 << 4 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const CooperativeYielding: RuntimeFlags.RuntimeFlag = 1 << 5 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const allFlags: ReadonlyArray<RuntimeFlags.RuntimeFlag> = [
+  None,
+  Interruption,
+  OpSupervision,
+  RuntimeMetrics,
+  WindDown,
+  CooperativeYielding
+]
+
+const print = (flag: RuntimeFlags.RuntimeFlag) => {
+  switch (flag) {
+    case CooperativeYielding: {
+      return "CooperativeYielding"
+    }
+    case WindDown: {
+      return "WindDown"
+    }
+    case RuntimeMetrics: {
+      return "RuntimeMetrics"
+    }
+    case OpSupervision: {
+      return "OpSupervision"
+    }
+    case Interruption: {
+      return "Interruption"
+    }
+    case None: {
+      return "None"
+    }
+  }
+}
+
+/** @internal */
+export const cooperativeYielding = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, CooperativeYielding)
+
+/** @internal */
+export const disable = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, flag: RuntimeFlags.RuntimeFlag) => RuntimeFlags.RuntimeFlags
+>(2, (self, flag) => (self & ~flag) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const disableAll = dual<
+  (flags: RuntimeFlags.RuntimeFlags) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, flags: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags
+>(2, (self, flags) => (self & ~flags) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const enable = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, flag: RuntimeFlags.RuntimeFlag) => RuntimeFlags.RuntimeFlags
+>(2, (self, flag) => (self | flag) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const enableAll = dual<
+  (flags: RuntimeFlags.RuntimeFlags) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, flags: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags
+>(2, (self, flags) => (self | flags) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const interruptible = (self: RuntimeFlags.RuntimeFlags): boolean => interruption(self) && !windDown(self)
+
+/** @internal */
+export const interruption = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, Interruption)
+
+/** @internal */
+export const isDisabled = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlags.RuntimeFlags) => boolean,
+  (self: RuntimeFlags.RuntimeFlags, flag: RuntimeFlags.RuntimeFlag) => boolean
+>(2, (self, flag) => !isEnabled(self, flag))
+
+/** @internal */
+export const isEnabled = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlags.RuntimeFlags) => boolean,
+  (self: RuntimeFlags.RuntimeFlags, flag: RuntimeFlags.RuntimeFlag) => boolean
+>(2, (self, flag) => (self & flag) !== 0)
+
+/** @internal */
+export const make = (...flags: ReadonlyArray<RuntimeFlags.RuntimeFlag>): RuntimeFlags.RuntimeFlags =>
+  flags.reduce((a, b) => a | b, 0) as RuntimeFlags.RuntimeFlags
+
+/** @internal */
+export const none: RuntimeFlags.RuntimeFlags = make(None)
+
+/** @internal */
+export const opSupervision = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, OpSupervision)
+
+/** @internal */
+export const render = (self: RuntimeFlags.RuntimeFlags): string => {
+  const active: Array<string> = []
+  allFlags.forEach((flag) => {
+    if (isEnabled(self, flag)) {
+      active.push(`${print(flag)}`)
+    }
+  })
+  return `RuntimeFlags(${active.join(", ")})`
+}
+
+/** @internal */
+export const runtimeMetrics = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, RuntimeMetrics)
+
+/** @internal */
+export const toSet = (self: RuntimeFlags.RuntimeFlags): ReadonlySet<RuntimeFlags.RuntimeFlag> =>
+  new Set(allFlags.filter((flag) => isEnabled(self, flag)))
+
+export const windDown = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, WindDown)
+
+// circular with RuntimeFlagsPatch
+
+/** @internal */
+export const enabledSet = (self: RuntimeFlagsPatch.RuntimeFlagsPatch): ReadonlySet<RuntimeFlags.RuntimeFlag> =>
+  toSet((runtimeFlagsPatch.active(self) & runtimeFlagsPatch.enabled(self)) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const disabledSet = (self: RuntimeFlagsPatch.RuntimeFlagsPatch): ReadonlySet<RuntimeFlags.RuntimeFlag> =>
+  toSet((runtimeFlagsPatch.active(self) & ~runtimeFlagsPatch.enabled(self)) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const diff = dual<
+  (that: RuntimeFlags.RuntimeFlags) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (self: RuntimeFlags.RuntimeFlags, that: RuntimeFlags.RuntimeFlags) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, that) => runtimeFlagsPatch.make(self ^ that, that))
+
+/** @internal */
+export const patch = dual<
+  (patch: RuntimeFlagsPatch.RuntimeFlagsPatch) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, patch: RuntimeFlagsPatch.RuntimeFlagsPatch) => RuntimeFlags.RuntimeFlags
+>(2, (self, patch) =>
+  (
+    (self & (runtimeFlagsPatch.invert(runtimeFlagsPatch.active(patch)) | runtimeFlagsPatch.enabled(patch))) |
+    (runtimeFlagsPatch.active(patch) & runtimeFlagsPatch.enabled(patch))
+  ) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const renderPatch = (self: RuntimeFlagsPatch.RuntimeFlagsPatch): string => {
+  const enabled = Array.from(enabledSet(self))
+    .map((flag) => print(flag))
+    .join(", ")
+  const disabled = Array.from(disabledSet(self))
+    .map((flag) => print(flag))
+    .join(", ")
+  return `RuntimeFlagsPatch(enabled = (${enabled}), disabled = (${disabled}))`
+}
+
+/** @internal */
+export const differ: Differ.Differ<RuntimeFlags.RuntimeFlags, RuntimeFlagsPatch.RuntimeFlagsPatch> = Differ.make({
+  empty: runtimeFlagsPatch.empty,
+  diff: (oldValue, newValue) => diff(oldValue, newValue),
+  combine: (first, second) => runtimeFlagsPatch.andThen(second)(first),
+  patch: (_patch, oldValue) => patch(oldValue, _patch)
+})

package/src/internal/runtimeFlagsPatch.ts

@@ -0,0 +1,103 @@
+import { dual } from "../Function"
+import type * as RuntimeFlags from "../RuntimeFlags"
+import type * as RuntimeFlagsPatch from "../RuntimeFlagsPatch"
+
+/** @internal */
+const BIT_MASK = 0xff
+
+/** @internal */
+const BIT_SHIFT = 0x08
+
+/** @internal */
+export const active = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): number => patch & BIT_MASK
+
+/** @internal */
+export const enabled = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): number => (patch >> BIT_SHIFT) & BIT_MASK
+
+/** @internal */
+export const make = (active: number, enabled: number): RuntimeFlagsPatch.RuntimeFlagsPatch =>
+  (((active) & BIT_MASK) + (((enabled & active) & BIT_MASK) << BIT_SHIFT)) as RuntimeFlagsPatch.RuntimeFlagsPatch
+
+/** @internal */
+export const empty = make(0, 0)
+
+/** @internal */
+export const enable = (flag: RuntimeFlags.RuntimeFlag): RuntimeFlagsPatch.RuntimeFlagsPatch => make(flag, flag)
+
+/** @internal */
+export const disable = (flag: RuntimeFlags.RuntimeFlag): RuntimeFlagsPatch.RuntimeFlagsPatch => make(flag, 0)
+
+/** @internal */
+export const isEmpty = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): boolean => patch === 0
+
+/** @internal */
+export const isActive = dual<
+  (flag: RuntimeFlagsPatch.RuntimeFlagsPatch) => (self: RuntimeFlagsPatch.RuntimeFlagsPatch) => boolean,
+  (self: RuntimeFlagsPatch.RuntimeFlagsPatch, flag: RuntimeFlagsPatch.RuntimeFlagsPatch) => boolean
+>(2, (self, flag) => (active(self) & flag) !== 0)
+
+/** @internal */
+export const isEnabled = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlagsPatch.RuntimeFlagsPatch) => boolean,
+  (self: RuntimeFlagsPatch.RuntimeFlagsPatch, flag: RuntimeFlags.RuntimeFlag) => boolean
+>(2, (self, flag) => (enabled(self) & flag) !== 0)
+
+/** @internal */
+export const isDisabled = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlagsPatch.RuntimeFlagsPatch) => boolean,
+  (self: RuntimeFlagsPatch.RuntimeFlagsPatch, flag: RuntimeFlags.RuntimeFlag) => boolean
+>(2, (self, flag) => ((active(self) & flag) !== 0) && ((enabled(self) & flag) === 0))
+
+/** @internal */
+export const exclude = dual<
+  (
+    flag: RuntimeFlags.RuntimeFlag
+  ) => (self: RuntimeFlagsPatch.RuntimeFlagsPatch) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (self: RuntimeFlagsPatch.RuntimeFlagsPatch, flag: RuntimeFlags.RuntimeFlag) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, flag) => make(active(self) & ~flag, enabled(self)))
+
+/** @internal */
+export const both = dual<
+  (
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch,
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, that) => make(active(self) | active(that), enabled(self) & enabled(that)))
+
+/** @internal */
+export const either = dual<
+  (
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch,
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, that) => make(active(self) | active(that), enabled(self) | enabled(that)))
+
+/** @internal */
+export const andThen = dual<
+  (
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch,
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, that) => (self | that) as RuntimeFlagsPatch.RuntimeFlagsPatch)
+
+/** @internal */
+export const inverse = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): RuntimeFlagsPatch.RuntimeFlagsPatch =>
+  make(enabled(patch), invert(active(patch)))
+
+/** @internal */
+export const invert = (n: number): number => (~n >>> 0) & BIT_MASK

package/src/internal/schedule/decision.ts

@@ -0,0 +1,47 @@
+import * as Chunk from "../../Chunk"
+import type * as ScheduleDecision from "../../ScheduleDecision"
+import type * as Interval from "../../ScheduleInterval"
+import * as Intervals from "../../ScheduleIntervals"
+
+/** @internal */
+export const OP_CONTINUE = "Continue" as const
+
+/** @internal */
+export type OP_CONTINUE = typeof OP_CONTINUE
+
+/** @internal */
+export const OP_DONE = "Done" as const
+
+/** @internal */
+export type OP_DONE = typeof OP_DONE
+
+/** @internal */
+export const _continue = (intervals: Intervals.Intervals): ScheduleDecision.ScheduleDecision => {
+  return {
+    _tag: OP_CONTINUE,
+    intervals
+  }
+}
+
+/** @internal */
+export const continueWith = (interval: Interval.Interval): ScheduleDecision.ScheduleDecision => {
+  return {
+    _tag: OP_CONTINUE,
+    intervals: Intervals.make(Chunk.of(interval))
+  }
+}
+
+/** @internal */
+export const done: ScheduleDecision.ScheduleDecision = {
+  _tag: OP_DONE
+}
+
+/** @internal */
+export const isContinue = (self: ScheduleDecision.ScheduleDecision): self is ScheduleDecision.Continue => {
+  return self._tag === OP_CONTINUE
+}
+
+/** @internal */
+export const isDone = (self: ScheduleDecision.ScheduleDecision): self is ScheduleDecision.Done => {
+  return self._tag === OP_DONE
+}