<A>(self: Ref<A>): AGets the current value of the Ref synchronously (unsafe version).
When to use
Use when you need immediate synchronous access and can guarantee that
reading the Ref outside of Effect is safe.
Gotchas
Prefer Ref.get for Effect-wrapped access in Effect programs.
Example (Reading a ref unsafely)
import { Ref } from "effect"
// Create a ref directly
const counter = Ref.makeUnsafe(42)
// Get the value synchronously
const value = Ref.getUnsafe(counter)
console.log(value) // 42
// Note: This is unsafe and should be used carefully
// Prefer Ref.get for Effect-wrapped accessexport const const getUnsafe: <A>(self: Ref<A>) => AGets the current value of the Ref synchronously (unsafe version).
When to use
Use when you need immediate synchronous access and can guarantee that
reading the Ref outside of Effect is safe.
Gotchas
Prefer Ref.get for Effect-wrapped access in Effect programs.
Example (Reading a ref unsafely)
import { Ref } from "effect"
// Create a ref directly
const counter = Ref.makeUnsafe(42)
// Get the value synchronously
const value = Ref.getUnsafe(counter)
console.log(value) // 42
// Note: This is unsafe and should be used carefully
// Prefer Ref.get for Effect-wrapped access
getUnsafe = <function (type parameter) A in <A>(self: Ref<A>): AA>(self: Ref<A>(parameter) self: {
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; <…;
}
interface Ref<in out A>A mutable reference that provides atomic read, write, and update operations.
When to use
Use to keep shared mutable state that is read and updated inside Effect
programs.
Details
A Ref is a thread-safe mutable reference type for shared state. It supports
simple read and write operations as well as atomic transformations.
Example (Reading and updating a ref)
import { Effect, Ref } from "effect"
const program = Effect.gen(function*() {
// Create a ref with initial value
const counter = yield* Ref.make(0)
// Read the current value
const value = yield* Ref.get(counter)
console.log(value) // 0
// Update the value atomically
yield* Ref.update(counter, (n) => n + 1)
// Read the updated value
const newValue = yield* Ref.get(counter)
console.log(newValue) // 1
})
The Ref namespace containing type definitions and utilities.
When to use
Use when referring to type members nested under the Ref namespace.
Ref<function (type parameter) A in <A>(self: Ref<A>): AA>): function (type parameter) A in <A>(self: Ref<A>): AA => self: Ref<A>(parameter) self: {
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; <…;
}
Ref<in out A>.ref: MutableRef.MutableRef<A>(property) Ref<in out A>.ref: {
current: T;
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;
}