<A extends AsyncDisposable | Disposable, E, R>(
acquire: Effect<A, E, R>
): Effect<A, E, R | Scope>Acquires a scoped resource that implements JavaScript disposal protocols.
When to use
Use when you work with JavaScript Disposable or AsyncDisposable resources
that should be closed with the surrounding scope.
Details
The resource is automatically disposed when the surrounding Scope is closed, using Symbol.dispose for synchronous disposables or Symbol.asyncDispose for asynchronous disposables.
This is similar to acquireRelease, but uses the standard
JavaScript disposal protocol instead of requiring an explicit release
function. It works with JavaScript Disposable and AsyncDisposable
resources.
Example (Acquiring a disposable resource)
import sqlite from "node:sqlite";
import { Effect } from "effect"
const program = Effect.scoped(
Effect.gen(function* () {
// acquire database connection
// database will be closed when the scope is closed
const db = yield* Effect.acquireDisposable(
Effect.sync(() => new sqlite.DatabaseSync(":memory:"))
)
const row = db.prepare("SELECT 1 AS value").get()
yield* Effect.log(row) // { value: 1 }
})
)export const const acquireDisposable: <
A extends AsyncDisposable | Disposable,
E,
R
>(
acquire: Effect<A, E, R>
) => Effect<A, E, R | Scope>
Acquires a scoped resource that implements JavaScript disposal protocols.
When to use
Use when you work with JavaScript Disposable or AsyncDisposable resources
that should be closed with the surrounding scope.
Details
The resource is automatically disposed when the surrounding
Scope
is closed, using
Symbol.dispose
for
synchronous disposables or
Symbol.asyncDispose
for asynchronous
disposables.
This is similar to
acquireRelease
, but uses the standard
JavaScript disposal protocol instead of requiring an explicit release
function. It works with JavaScript Disposable and AsyncDisposable
resources.
Example (Acquiring a disposable resource)
import sqlite from "node:sqlite";
import { Effect } from "effect"
const program = Effect.scoped(
Effect.gen(function* () {
// acquire database connection
// database will be closed when the scope is closed
const db = yield* Effect.acquireDisposable(
Effect.sync(() => new sqlite.DatabaseSync(":memory:"))
)
const row = db.prepare("SELECT 1 AS value").get()
yield* Effect.log(row) // { value: 1 }
})
)
acquireDisposable: <function (type parameter) A in <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>): Effect<A, E, R | Scope>A extends AsyncDisposable | Disposable, function (type parameter) E in <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>): Effect<A, E, R | Scope>E, function (type parameter) R in <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>): Effect<A, E, R | Scope>R>(
acquire: Effect<A, E, R>(parameter) acquire: {
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; <…;
toString: () => string;
toJSON: () => unknown;
}
acquire: interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>): Effect<A, E, R | Scope>A, function (type parameter) E in <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>): Effect<A, E, R | Scope>E, function (type parameter) R in <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>): Effect<A, E, R | Scope>R>
) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>): Effect<A, E, R | Scope>A, function (type parameter) E in <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>): Effect<A, E, R | Scope>E, function (type parameter) R in <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>): Effect<A, E, R | Scope>R | Scope> = import internalinternal.const acquireDisposable: <
A extends AsyncDisposable | Disposable,
E,
R
>(
acquire: Effect.Effect<A, E, R>
) => Effect.Effect<A, E, R | Scope.Scope>
acquireDisposable