ManagedRuntime

Creates a ManagedRuntime from a layer.

When to use

Use to create a reusable runtime from a Layer for application entry points or integration code that runs many effects without rebuilding services.

Details

The layer is built lazily on first use and its context is cached for subsequent runs. Resources acquired by the layer are owned by the runtime and are released when dispose or disposeEffect is run. options.memoMap can be used to share layer memoization with other layer builds.

Gotchas

Dispose the runtime when it is no longer needed. A runtime cannot be reused after disposal.

See

• ManagedRuntime for the returned runtime interface
• Layer.MemoMap for shared layer memoization
• Layer.build for lower-level scoped layer construction

declare function make<R, ER>(layer: Layer<R, ER, never>, options?: {
  readonly memoMap?: MemoMap;
}): ManagedRuntime<R, ER>

import { Context, Effect, Layer, ManagedRuntime } from "effect"

const notifications: Array<string> = []

class Notifications extends Context.Service<Notifications, {
  readonly notify: (message: string) => Effect.Effect<void>
}>()("Notifications") {
  static readonly layer = Layer.succeed(this)({
    notify: Effect.fn("Notifications.notify")((message) =>
      Effect.sync(() => notifications.push(message))
    )
  })
}

const runtime = ManagedRuntime.make(Notifications.layer)

const program = Effect.flatMap(
  Notifications,
  (_) => _.notify("Hello, world!")
).pipe(Effect.ensuring(runtime.disposeEffect))

await runtime.runPromise(program)
notifications // => ["Hello, world!"]

Checks whether the provided argument is a ManagedRuntime.

When to use

Use to narrow an unknown value before treating it as a ManagedRuntime.

Details

The guard checks the internal ManagedRuntime marker property. It does not build the layer or inspect the runtime's services.

Gotchas

Disposed runtimes still carry the marker, so this guard does not prove the runtime is still usable.

See

• make for creating managed runtimes this guard recognizes

declare function isManagedRuntime(input: unknown): input is ManagedRuntime<unknown, unknown>

A runtime built from a layer that can execute effects requiring that layer's services.

When to use

Use as the reusable runtime value returned by make when application entry points or integration code need to run many effects against the same layer-built services.

Details

The runtime builds and caches its service context and owns the scope for resources acquired by the layer.

Gotchas

Dispose the runtime with dispose or disposeEffect when it is no longer needed.

See

• make for constructing a managed runtime from a layer
• Layer.build for lower-level scoped layer construction

interface ManagedRuntime<in R, out ER> {
  readonly [asyncDispose]: () => Promise<void>;
  readonly "~effect/ManagedRuntime": "~effect/ManagedRuntime";
  cachedContext: Context<R> | undefined;
  readonly context: () => Promise<Context<R>>;
  readonly contextEffect: Effect<Context<R>, ER>;
  readonly dispose: () => Promise<void>;
  readonly disposeEffect: Effect<void, never, never>;
  readonly memoMap: MemoMap;
  readonly runCallback: <A, E>(effect: Effect<A, E, R>, options?: RunOptions & {
    readonly onExit: (exit: Exit<A, ER | E>) => void;
  }) => (interruptor?: number) => void;
  readonly runFork: <A, E>(self: Effect<A, E, R>, options?: RunOptions) => Fiber<A, ER | E>;
  readonly runPromise: <A, E>(effect: Effect<A, E, R>, options?: RunOptions) => Promise<A>;
  readonly runPromiseExit: <A, E>(effect: Effect<A, E, R>, options?: RunOptions) => Promise<Exit<A, ER | E>>;
  readonly runSync: <A, E>(effect: Effect<A, E, R>) => A;
  readonly runSyncExit: <A, E>(effect: Effect<A, E, R>) => Exit<A, ER | E>;
  readonly scope: Closeable;
}

Type helpers associated with ManagedRuntime.

When to use

Use to reference type-level helpers for extracting managed runtime services and layer errors.