<A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>
readonly idleTimeToLive?: Duration.Input | undefined
}): Effect.Effect<RcRef<A, E>, never, R | Scope>Creates an RcRef from an acquire effect.
When to use
Use to create a lazily acquired, reference-counted resource from an acquire effect.
Details
The resource is acquired lazily on the first get and shared by subsequent
gets while it remains cached. Each get adds a reference to the current
Scope. When the last reference is released, the resource is closed
immediately by default, or after idleTimeToLive when that option is
provided.
Example (Creating a reference-counted resource)
import { Effect, RcRef } from "effect"
Effect.gen(function*() {
const ref = yield* RcRef.make({
acquire: Effect.acquireRelease(
Effect.succeed("foo"),
() => Effect.log("release foo")
)
})
// will only acquire the resource once, and release it
// when the scope is closed
yield* RcRef.get(ref).pipe(
Effect.andThen(RcRef.get(ref)),
Effect.scoped
)
})export const const make: <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>
readonly idleTimeToLive?:
| Duration.Input
| undefined
}) => Effect.Effect<RcRef<A, E>, never, R | Scope>
Creates an RcRef from an acquire effect.
When to use
Use to create a lazily acquired, reference-counted resource from an acquire
effect.
Details
The resource is acquired lazily on the first get and shared by subsequent
gets while it remains cached. Each get adds a reference to the current
Scope. When the last reference is released, the resource is closed
immediately by default, or after idleTimeToLive when that option is
provided.
Example (Creating a reference-counted resource)
import { Effect, RcRef } from "effect"
Effect.gen(function*() {
const ref = yield* RcRef.make({
acquire: Effect.acquireRelease(
Effect.succeed("foo"),
() => Effect.log("release foo")
)
})
// will only acquire the resource once, and release it
// when the scope is closed
yield* RcRef.get(ref).pipe(
Effect.andThen(RcRef.get(ref)),
Effect.scoped
)
})
make: <function (type parameter) A in <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>;
readonly idleTimeToLive?: Duration.Input | undefined;
}): Effect.Effect<RcRef<A, E>, never, R | Scope>
function (type parameter) E in <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>;
readonly idleTimeToLive?: Duration.Input | undefined;
}): Effect.Effect<RcRef<A, E>, never, R | Scope>
function (type parameter) R in <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>;
readonly idleTimeToLive?: Duration.Input | undefined;
}): Effect.Effect<RcRef<A, E>, never, R | Scope>
options: {
readonly acquire: Effect.Effect<A, E, R>
readonly idleTimeToLive?:
| Duration.Input
| undefined
}
acquire: Effect.Effect<A, E, R>(property) 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;
}
import EffectEffect.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, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>;
readonly idleTimeToLive?: Duration.Input | undefined;
}): Effect.Effect<RcRef<A, E>, never, R | Scope>
function (type parameter) E in <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>;
readonly idleTimeToLive?: Duration.Input | undefined;
}): Effect.Effect<RcRef<A, E>, never, R | Scope>
function (type parameter) R in <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>;
readonly idleTimeToLive?: Duration.Input | undefined;
}): Effect.Effect<RcRef<A, E>, never, R | Scope>
idleTimeToLive?: Duration.Input | undefinedWhen the reference count reaches zero, the resource will be released
after this duration.
idleTimeToLive?: import DurationDuration.type Input =
| number
| bigint
| Duration.Duration
| readonly [seconds: number, nanos: number]
| `${number} nano`
| `${number} nanos`
| `${number} micro`
| `${number} micros`
| `${number} milli`
| `${number} millis`
| `${number} second`
| `${number} seconds`
| `${number} minute`
| `${number} minutes`
| `${number} hour`
| `${number} hours`
| `${number} day`
| `${number} days`
| `${number} week`
| `${number} weeks`
| "Infinity"
| "-Infinity"
| Duration.DurationObject
Valid input types that can be converted to a Duration.
When to use
Use when an API should accept any value that Effect can convert into a
Duration, including existing durations, millisecond numbers, nanosecond
bigints, high-resolution tuples, duration strings, infinity strings, or
duration objects.
Details
String inputs accept values like "10 seconds", "500 millis",
"Infinity", and "-Infinity". Finite fractional values that are
normalized to nanoseconds are rounded to the nearest nanosecond, with ties
away from zero.
Input | undefined
}
) => import EffectEffect.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<interface RcRef<out A, out E = never>A reference counted reference that manages resource lifecycle.
When to use
Use to share a scoped resource across active users with reference-counted
acquisition and release.
Details
An RcRef wraps a resource that can be acquired and released multiple times.
The resource is lazily acquired on the first call to get and automatically
released when the last reference is released.
Example (Sharing a lazily acquired resource)
import { Effect, RcRef } from "effect"
// Create an RcRef for a database connection
const createConnectionRef = (connectionString: string) =>
RcRef.make({
acquire: Effect.acquireRelease(
Effect.succeed(`Connected to ${connectionString}`),
(connection) => Effect.log(`Closing connection: ${connection}`)
)
})
// Use the RcRef in multiple operations
const program = Effect.gen(function*() {
const connectionRef = yield* createConnectionRef("postgres://localhost")
// Multiple gets will share the same connection
const connection1 = yield* RcRef.get(connectionRef)
const connection2 = yield* RcRef.get(connectionRef)
return [connection1, connection2]
})
Namespace containing type-level members associated with RcRef.
Example (Referencing namespace types)
import type { RcRef } from "effect"
// Use RcRef namespace types
type MyRcRef = RcRef.RcRef<string, Error>
type MyVariance = RcRef.RcRef.Variance<string, Error>
RcRef<function (type parameter) A in <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>;
readonly idleTimeToLive?: Duration.Input | undefined;
}): Effect.Effect<RcRef<A, E>, never, R | Scope>
function (type parameter) E in <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>;
readonly idleTimeToLive?: Duration.Input | undefined;
}): Effect.Effect<RcRef<A, E>, never, R | Scope>
function (type parameter) R in <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>;
readonly idleTimeToLive?: Duration.Input | undefined;
}): Effect.Effect<RcRef<A, E>, never, R | Scope>
import internalinternal.const make: <A, E, R>(options: {
readonly acquire: Effect.Effect<A, E, R>
readonly idleTimeToLive?:
| Duration.Input
| undefined
}) => Effect.Effect<RcRef<A, E>, never, R | Scope>