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

package/src/RuntimeFlags.ts

@@ -0,0 +1,336 @@
+/**
+ * @since 2.0.0
+ */
+
+import type * as Differ from "./Differ"
+import * as circular from "./internal/layer/circular"
+import * as internal from "./internal/runtimeFlags"
+import type * as Layer from "./Layer"
+import type * as RuntimeFlagsPatch from "./RuntimeFlagsPatch"
+
+/**
+ * Represents a set of `RuntimeFlag`s. `RuntimeFlag`s affect the operation of
+ * the Effect runtime system. They are exposed to application-level code because
+ * they affect the behavior and performance of application code.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export type RuntimeFlags = number & {
+  readonly RuntimeFlags: unique symbol
+}
+
+/**
+ * Represents a flag that can be set to enable or disable a particular feature
+ * of the Effect runtime.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export type RuntimeFlag = number & {
+  readonly RuntimeFlag: unique symbol
+}
+
+/**
+ * No runtime flags.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const None: RuntimeFlag = internal.None
+
+/**
+ * The interruption flag determines whether or not the Effect runtime system will
+ * interrupt a fiber.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Interruption: RuntimeFlag = internal.Interruption
+
+/**
+ * The op supervision flag determines whether or not the Effect runtime system
+ * will supervise all operations of the Effect runtime. Use of this flag will
+ * negatively impact performance, but is required for some operations, such as
+ * profiling.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const OpSupervision: RuntimeFlag = internal.OpSupervision
+
+/**
+ * The runtime metrics flag determines whether or not the Effect runtime system
+ * will collect metrics about the Effect runtime. Use of this flag will have a
+ * very small negative impact on performance, but generates very helpful
+ * operational insight into running Effect applications that can be exported to
+ * Prometheus or other tools via Effect Metrics.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const RuntimeMetrics: RuntimeFlag = internal.RuntimeMetrics
+
+/**
+ * The wind down flag determines whether the Effect runtime system will execute
+ * effects in wind-down mode. In wind-down mode, even if interruption is
+ * enabled and a fiber has been interrupted, the fiber will continue its
+ * execution uninterrupted.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const WindDown: RuntimeFlag = internal.WindDown
+
+/**
+ * The cooperative yielding flag determines whether the Effect runtime will
+ * yield to another fiber.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const CooperativeYielding: RuntimeFlag = internal.CooperativeYielding
+
+/**
+ * Returns `true` if the `CooperativeYielding` `RuntimeFlag` is enabled, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const cooperativeYielding: (self: RuntimeFlags) => boolean = internal.cooperativeYielding
+
+/**
+ * Creates a `RuntimeFlagsPatch` which describes the difference between `self`
+ * and `that`.
+ *
+ * @since 2.0.0
+ * @category diffing
+ */
+export const diff: {
+  (that: RuntimeFlags): (self: RuntimeFlags) => RuntimeFlagsPatch.RuntimeFlagsPatch
+  (self: RuntimeFlags, that: RuntimeFlags): RuntimeFlagsPatch.RuntimeFlagsPatch
+} = internal.diff
+
+/**
+ * Constructs a differ that knows how to diff `RuntimeFlags` values.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const differ: Differ.Differ<RuntimeFlags, RuntimeFlagsPatch.RuntimeFlagsPatch> = internal.differ
+
+/**
+ * Disables the specified `RuntimeFlag`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const disable: {
+  (flag: RuntimeFlag): (self: RuntimeFlags) => RuntimeFlags
+  (self: RuntimeFlags, flag: RuntimeFlag): RuntimeFlags
+} = internal.disable
+
+/**
+ * Disables all of the `RuntimeFlag`s in the specified set of `RuntimeFlags`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const disableAll: {
+  (flags: RuntimeFlags): (self: RuntimeFlags) => RuntimeFlags
+  (self: RuntimeFlags, flags: RuntimeFlags): RuntimeFlags
+} = internal.disableAll
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const disableCooperativeYielding: Layer.Layer<never, never, never> = circular.disableCooperativeYielding
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const disableInterruption: Layer.Layer<never, never, never> = circular.disableInterruption
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const disableOpSupervision: Layer.Layer<never, never, never> = circular.disableOpSupervision
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const disableRuntimeMetrics: Layer.Layer<never, never, never> = circular.disableRuntimeMetrics
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const disableWindDown: Layer.Layer<never, never, never> = circular.disableWindDown
+
+/**
+ * Enables the specified `RuntimeFlag`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const enable: {
+  (flag: RuntimeFlag): (self: RuntimeFlags) => RuntimeFlags
+  (self: RuntimeFlags, flag: RuntimeFlag): RuntimeFlags
+} = internal.enable
+
+/**
+ * Enables all of the `RuntimeFlag`s in the specified set of `RuntimeFlags`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const enableAll: {
+  (flags: RuntimeFlags): (self: RuntimeFlags) => RuntimeFlags
+  (self: RuntimeFlags, flags: RuntimeFlags): RuntimeFlags
+} = internal.enableAll
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const enableCooperativeYielding: Layer.Layer<never, never, never> = circular.enableCooperativeYielding
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const enableInterruption: Layer.Layer<never, never, never> = circular.enableInterruption
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const enableOpSupervision: Layer.Layer<never, never, never> = circular.enableOpSupervision
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const enableRuntimeMetrics: Layer.Layer<never, never, never> = circular.enableRuntimeMetrics
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const enableWindDown: Layer.Layer<never, never, never> = circular.enableWindDown
+
+/**
+ * Returns true only if the `Interruption` flag is **enabled** and the
+ * `WindDown` flag is **disabled**.
+ *
+ * A fiber is said to be interruptible if interruption is enabled and the fiber
+ * is not in its wind-down phase, in which it takes care of cleanup activities
+ * related to fiber shutdown.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const interruptible: (self: RuntimeFlags) => boolean = internal.interruptible
+
+/**
+ * Returns `true` if the `Interruption` `RuntimeFlag` is enabled, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const interruption: (self: RuntimeFlags) => boolean = internal.interruption
+
+/**
+ * Returns `true` if the specified `RuntimeFlag` is enabled, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const isEnabled: {
+  (flag: RuntimeFlag): (self: RuntimeFlags) => boolean
+  (self: RuntimeFlags, flag: RuntimeFlag): boolean
+} = internal.isEnabled
+
+/**
+ * Returns `true` if the specified `RuntimeFlag` is disabled, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const isDisabled: {
+  (flag: RuntimeFlag): (self: RuntimeFlags) => boolean
+  (self: RuntimeFlags, flag: RuntimeFlag): boolean
+} = internal.isDisabled
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (...flags: ReadonlyArray<RuntimeFlag>) => RuntimeFlags = internal.make
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const none: RuntimeFlags = internal.none
+
+/**
+ * Returns `true` if the `OpSupervision` `RuntimeFlag` is enabled, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const opSupervision: (self: RuntimeFlags) => boolean = internal.opSupervision
+
+/**
+ * Patches a set of `RuntimeFlag`s with a `RuntimeFlagsPatch`, returning the
+ * patched set of `RuntimeFlag`s.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const patch: {
+  (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): (self: RuntimeFlags) => RuntimeFlags
+  (self: RuntimeFlags, patch: RuntimeFlagsPatch.RuntimeFlagsPatch): RuntimeFlags
+} = internal.patch
+
+/**
+ * Converts the provided `RuntimeFlags` into a `string`.
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export const render: (self: RuntimeFlags) => string = internal.render
+
+/**
+ * Returns `true` if the `RuntimeMetrics` `RuntimeFlag` is enabled, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const runtimeMetrics: (self: RuntimeFlags) => boolean = internal.runtimeMetrics
+
+/**
+ * Converts the provided `RuntimeFlags` into a `ReadonlySet<number>`.
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export const toSet: (self: RuntimeFlags) => ReadonlySet<RuntimeFlag> = internal.toSet
+
+/**
+ * Returns `true` if the `WindDown` `RuntimeFlag` is enabled, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const windDown: (self: RuntimeFlags) => boolean = internal.windDown

package/src/RuntimeFlagsPatch.ts

@@ -0,0 +1,183 @@
+/**
+ * @since 2.0.0
+ */
+import * as runtimeFlags from "./internal/runtimeFlags"
+import * as internal from "./internal/runtimeFlagsPatch"
+import type * as RuntimeFlags from "./RuntimeFlags"
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type RuntimeFlagsPatch = number & {
+  readonly RuntimeFlagsPatch: unique symbol
+}
+
+/**
+ * The empty `RuntimeFlagsPatch`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty: RuntimeFlagsPatch = internal.empty
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (active: number, enabled: number) => RuntimeFlagsPatch = internal.make
+
+/**
+ * Creates a `RuntimeFlagsPatch` describing enabling the provided `RuntimeFlag`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const enable: (flag: RuntimeFlags.RuntimeFlag) => RuntimeFlagsPatch = internal.enable
+
+/**
+ * Creates a `RuntimeFlagsPatch` describing disabling the provided `RuntimeFlag`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const disable: (flag: RuntimeFlags.RuntimeFlag) => RuntimeFlagsPatch = internal.disable
+
+/**
+ * Returns `true` if the specified `RuntimeFlagsPatch` is empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isEmpty: (patch: RuntimeFlagsPatch) => boolean = internal.isEmpty
+
+/**
+ * Returns `true` if the `RuntimeFlagsPatch` describes the specified
+ * `RuntimeFlag` as active.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const isActive: {
+  (flag: RuntimeFlagsPatch): (self: RuntimeFlagsPatch) => boolean
+  (self: RuntimeFlagsPatch, flag: RuntimeFlagsPatch): boolean
+} = internal.isActive
+
+/**
+ * Returns `true` if the `RuntimeFlagsPatch` describes the specified
+ * `RuntimeFlag` as enabled.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const isEnabled: {
+  (flag: RuntimeFlags.RuntimeFlag): (self: RuntimeFlagsPatch) => boolean
+  (self: RuntimeFlagsPatch, flag: RuntimeFlags.RuntimeFlag): boolean
+} = internal.isEnabled
+
+/**
+ * Returns `true` if the `RuntimeFlagsPatch` describes the specified
+ * `RuntimeFlag` as disabled.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const isDisabled: {
+  (flag: RuntimeFlags.RuntimeFlag): (self: RuntimeFlagsPatch) => boolean
+  (self: RuntimeFlagsPatch, flag: RuntimeFlags.RuntimeFlag): boolean
+} = internal.isDisabled
+
+/**
+ * Returns `true` if the `RuntimeFlagsPatch` includes the specified
+ * `RuntimeFlag`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const includes: {
+  (flag: RuntimeFlagsPatch): (self: RuntimeFlagsPatch) => boolean
+  (self: RuntimeFlagsPatch, flag: RuntimeFlagsPatch): boolean
+} = internal.isActive
+
+/**
+ * Creates a `RuntimeFlagsPatch` describing the application of the `self` patch,
+ * followed by `that` patch.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const andThen: {
+  (that: RuntimeFlagsPatch): (self: RuntimeFlagsPatch) => RuntimeFlagsPatch
+  (self: RuntimeFlagsPatch, that: RuntimeFlagsPatch): RuntimeFlagsPatch
+} = internal.andThen
+
+/**
+ * Creates a `RuntimeFlagsPatch` describing application of both the `self` patch
+ * and `that` patch.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const both: {
+  (that: RuntimeFlagsPatch): (self: RuntimeFlagsPatch) => RuntimeFlagsPatch
+  (self: RuntimeFlagsPatch, that: RuntimeFlagsPatch): RuntimeFlagsPatch
+} = internal.both
+
+/**
+ * Creates a `RuntimeFlagsPatch` describing application of either the `self`
+ * patch or `that` patch.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const either: {
+  (that: RuntimeFlagsPatch): (self: RuntimeFlagsPatch) => RuntimeFlagsPatch
+  (self: RuntimeFlagsPatch, that: RuntimeFlagsPatch): RuntimeFlagsPatch
+} = internal.either
+
+/**
+ * Creates a `RuntimeFlagsPatch` which describes exclusion of the specified
+ * `RuntimeFlag` from the set of `RuntimeFlags`.
+ *
+ * @category utils
+ * @since 2.0.0
+ */
+export const exclude: {
+  (flag: RuntimeFlags.RuntimeFlag): (self: RuntimeFlagsPatch) => RuntimeFlagsPatch
+  (self: RuntimeFlagsPatch, flag: RuntimeFlags.RuntimeFlag): RuntimeFlagsPatch
+} = internal.exclude
+
+/**
+ * Creates a `RuntimeFlagsPatch` which describes the inverse of the patch
+ * specified by the provided `RuntimeFlagsPatch`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const inverse: (patch: RuntimeFlagsPatch) => RuntimeFlagsPatch = internal.inverse
+
+/**
+ * Returns a `ReadonlySet<number>` containing the `RuntimeFlags` described as
+ * enabled by the specified `RuntimeFlagsPatch`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const enabledSet: (self: RuntimeFlagsPatch) => ReadonlySet<RuntimeFlags.RuntimeFlag> = runtimeFlags.enabledSet
+
+/**
+ * Returns a `ReadonlySet<number>` containing the `RuntimeFlags` described as
+ * disabled by the specified `RuntimeFlagsPatch`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const disabledSet: (self: RuntimeFlagsPatch) => ReadonlySet<RuntimeFlags.RuntimeFlag> = runtimeFlags.disabledSet
+
+/**
+ * Renders the provided `RuntimeFlagsPatch` to a string.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const render: (self: RuntimeFlagsPatch) => string = runtimeFlags.renderPatch