Search documentation

Search by topic, API name, or import path.

GitHub ↗

variable / @typed/fx/Fx

ensuring

Runs a finalizer with no typed error after the Fx run ends for any reason.

Package version
2.0.0-beta.7
Category
Resource lifetime
Since
1.0.0

Follow one execution

Run close after completion, failure, or interruption; output completion waits for cleanup.

Fx timelineensuring(close)ensuring
Operatorensuring(close)
Read this diagram

Follow each lane from left to right. Events stacked vertically share a tick; the green cursor marks the current time across every lane.

  • A value
    The text inside the pill is the emitted value.
  • Work starts
    The raised chevron starts an inner run (^ in the source).
  • The run returns
    The vertical bar ends this lane’s run.
  • A cause is delivered
    The exclamation mark belongs to this lane.
  • Work is interrupted
    The cross marks cancellation of this run.
  • Current time
    The line and diamond move together across all lanes.
  • Happening now
    A highlighted event is at the current tick.
  • Still ahead
    Muted, dashed values have not happened yet.
  • Time continues
    The lane’s arrow is not a return marker. An empty stretch can be quiet work that is still running.

Illustrated ticks start at 0. At 1×, one illustrated tick takes one second; captions specify real durations when timing matters. A cause or interruption belongs to its lane, and other work may continue. Scroll horizontally to inspect the rest of a long timeline.

The finalizer runs exactly once after normal completion, failure, defect, or interruption of the source run and follows Effect’s ensuring finalization semantics. Its never typed-error channel does not make it incapable of defecting or being interrupted: a finalizer defect can fail a successful run or combine with the source Cause. Its services are required for the subscription.

Source implementation · Learn the surrounding model

Compare all Fx timelines →

Import

import { ensuring } from "@typed/fx/Fx";

Signatures

export declare const ensuring: {
    <R2>(finalizer: Effect.Effect<void, never, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>;
    <A, E, R, R2>(self: Fx<A, E, R>, finalizer: Effect.Effect<void, never, R2>): Fx<A, E, R | R2>;
};

Why

Resources sometimes belong to the subscription as a whole rather than to individual values. ensuring attaches unconditional teardown without changing the source’s success or typed-error channels.

Ownership and lifetime

The finalizer runs exactly once after normal completion, failure, defect, or interruption of the source run and follows Effect’s ensuring finalization semantics. Its never typed-error channel does not make it incapable of defecting or being interrupted: a finalizer defect can fail a successful run or combine with the source Cause. Its services are required for the subscription.

Examples

import { Effect } from "effect"
import { ensuring } from "@typed/fx/Fx"
import { succeed } from "@typed/fx/Fx"

const observed = ensuring(succeed("ready"), Effect.log("subscription closed"))
A `never` typed-error channel can still contain a defect
```ts
import { Effect } from "effect"
import { ensuring } from "@typed/fx/Fx"
import { succeed } from "@typed/fx/Fx"

const defectiveFinalizer = ensuring(succeed("ready"), Effect.die("close failed"))
```

Other public imports

These import paths expose the same declaration. Each page retains its own public name and signature.

Source