<A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<
ScopedRef<A>,
E,
Scope.Scope | R
>Creates a new ScopedRef from an effect that acquires the initial value.
When to use
Use when creating a ScopedRef whose initial value requires acquiring
resources that must be released.
constructorsmake
Source effect/ScopedRef.ts:7514 lines
export const const fromAcquire: <A, E, R>(
acquire: Effect.Effect<A, E, R>
) => Effect.Effect<
ScopedRef<A>,
E,
Scope.Scope | R
>
Creates a new ScopedRef from an effect that acquires the initial value.
When to use
Use when creating a ScopedRef whose initial value requires acquiring
resources that must be released.
fromAcquire: <function (type parameter) A in <A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<ScopedRef<A>, E, Scope.Scope | R>A, function (type parameter) E in <A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<ScopedRef<A>, E, Scope.Scope | R>E, function (type parameter) R in <A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<ScopedRef<A>, E, Scope.Scope | R>R>(
acquire: Effect.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;
}
import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<function (type parameter) A in <A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<ScopedRef<A>, E, Scope.Scope | R>A, function (type parameter) E in <A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<ScopedRef<A>, E, Scope.Scope | R>E, function (type parameter) R in <A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<ScopedRef<A>, E, Scope.Scope | R>R>
) => import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<interface ScopedRef<in out A>A ScopedRef is a reference whose value is associated with resources,
which must be released properly. You can both get the current value of any
ScopedRef, as well as set it to a new value (which may require new
resources). The reference itself takes care of properly releasing resources
for the old value whenever a new value is obtained.
When to use
Use when an application needs to keep a current resource-backed value and
later replace it with another acquired value while ensuring the previous
value is released.
ScopedRef<function (type parameter) A in <A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<ScopedRef<A>, E, Scope.Scope | R>A>, function (type parameter) E in <A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<ScopedRef<A>, E, Scope.Scope | R>E, import ScopeScope.type Scope.Scope = /*unresolved*/ anyScope | function (type parameter) R in <A, E, R>(acquire: Effect.Effect<A, E, R>): Effect.Effect<ScopedRef<A>, E, Scope.Scope | R>R> = import EffectEffect.fnUntraced(function*<function (type parameter) A in <A, E, R>(acquire: Effect.Effect<A, E, R>): Generator<any, ScopedRef<any>, any>A, function (type parameter) E in <A, E, R>(acquire: Effect.Effect<A, E, R>): Generator<any, ScopedRef<any>, any>E, function (type parameter) R in <A, E, R>(acquire: Effect.Effect<A, E, R>): Generator<any, ScopedRef<any>, any>R>(
acquire: Effect.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;
}
import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<function (type parameter) A in <A, E, R>(acquire: Effect.Effect<A, E, R>): Generator<any, ScopedRef<any>, any>A, function (type parameter) E in <A, E, R>(acquire: Effect.Effect<A, E, R>): Generator<any, ScopedRef<any>, any>E, function (type parameter) R in <A, E, R>(acquire: Effect.Effect<A, E, R>): Generator<any, ScopedRef<any>, any>R>
) {
const const scope: Scope.Closeableconst scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
import ScopeScope.makeUnsafe()
const const value: anyvalue = yield* acquire: Effect.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;
}
import ScopeScope.provide(const scope: Scope.Closeableconst scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
import EffectEffect.tapCause((cause: Cause<NoInfer<E>>(parameter) cause: {
reasons: ReadonlyArray<Reason<E>>;
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 ScopeScope.close(const scope: Scope.Closeableconst scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
import ExitExit.failCause(cause: Cause<NoInfer<E>>(parameter) cause: {
reasons: ReadonlyArray<Reason<E>>;
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;
}
const self: ScopedRef<A>const self: {
backing: Synchronized.SynchronizedRef<readonly [Scope.Closeable, A]>;
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; <…;
}
const makeUnsafe: <A>(
scope: Scope.Closeable,
value: A
) => ScopedRef<A>
const scope: Scope.Closeableconst scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
const value: anyvalue)
yield* import EffectEffect.addFinalizer((exit: Exit.Exit<unknown, unknown>exit) => import ScopeScope.close(const self: ScopedRef<A>const self: {
backing: Synchronized.SynchronizedRef<readonly [Scope.Closeable, A]>;
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; <…;
}
ScopedRef<any>.backing: Synchronized.SynchronizedRef<readonly [Scope.Closeable, A]>(property) ScopedRef<any>.backing: {
backing: Ref.Ref<A>;
semaphore: Semaphore.Semaphore;
ref: MutableRef.MutableRef<A>;
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; <…;
}
SynchronizedRef<readonly [Scope.Closeable, any]>.backing: Ref.Ref<A>(property) SynchronizedRef<readonly [Scope.Closeable, any]>.backing: {
ref: MutableRef.MutableRef<A>;
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; <…;
}
exit: Exit.Exit<unknown, unknown>exit))
return const self: ScopedRef<A>const self: {
backing: Synchronized.SynchronizedRef<readonly [Scope.Closeable, A]>;
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; <…;
}
import EffectEffect.uninterruptible)Referenced by 1 symbols