(self: TxSemaphore): Effect.Effect<void, never, Scope.Scope>Acquires a single permit from the semaphore in a scoped manner. The permit will be automatically released when the scope is closed, even if effects within the scope fail or are interrupted.
When to use
Use to acquire one transactional permit for the lifetime of the current scope.
Details
The permit acquisition and release operations use atomic semantics to ensure proper resource management with Effect's scoped operations.
Example (Acquiring a scoped permit)
import { Console, Effect, TxSemaphore } from "effect"
const program = Effect.gen(function*() {
const semaphore = yield* TxSemaphore.make(3)
yield* Effect.scoped(
Effect.gen(function*() {
// Acquire permit for the duration of this scope
yield* TxSemaphore.withPermitScoped(semaphore)
yield* Console.log("Permit acquired for scope")
// Do work within the scope
yield* Effect.sleep("500 millis")
yield* Console.log("Work completed")
// Permit will be automatically released when scope closes
})
)
yield* Console.log("Scope closed, permit released")
})export const const withPermitScoped: (
self: TxSemaphore
) => Effect.Effect<void, never, Scope.Scope>
Acquires a single permit from the semaphore in a scoped manner. The permit
will be automatically released when the scope is closed, even if effects
within the scope fail or are interrupted.
When to use
Use to acquire one transactional permit for the lifetime of the current
scope.
Details
The permit acquisition and release operations use atomic semantics to ensure
proper resource management with Effect's scoped operations.
Example (Acquiring a scoped permit)
import { Console, Effect, TxSemaphore } from "effect"
const program = Effect.gen(function*() {
const semaphore = yield* TxSemaphore.make(3)
yield* Effect.scoped(
Effect.gen(function*() {
// Acquire permit for the duration of this scope
yield* TxSemaphore.withPermitScoped(semaphore)
yield* Console.log("Permit acquired for scope")
// Do work within the scope
yield* Effect.sleep("500 millis")
yield* Console.log("Work completed")
// Permit will be automatically released when scope closes
})
)
yield* Console.log("Scope closed, permit released")
})
withPermitScoped = (self: TxSemaphore(parameter) self: {
permitsRef: TxRef.TxRef<number>;
capacity: number;
toString: () => string;
toJSON: () => unknown;
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.type Effect.Effect = /*unresolved*/ anyEffect<void, never, import ScopeScope.type Scope.Scope = /*unresolved*/ anyScope> =>
import EffectEffect.acquireRelease(
const acquire: (
self: TxSemaphore
) => Effect.Effect<void>
Acquires a single permit from the semaphore. If no permits are available,
the effect will block until one becomes available.
When to use
Use to manually acquire one permit transactionally, waiting until one is
available.
Example (Acquiring a permit)
import { Console, Effect, TxSemaphore } from "effect"
const program = Effect.gen(function*() {
const semaphore = yield* TxSemaphore.make(2)
yield* Console.log("Acquiring first permit...")
yield* TxSemaphore.acquire(semaphore)
yield* Console.log("First permit acquired")
yield* Console.log("Acquiring second permit...")
yield* TxSemaphore.acquire(semaphore)
yield* Console.log("Second permit acquired")
const available = yield* TxSemaphore.available(semaphore)
yield* Console.log(`Available permits: ${available}`) // 0
})
acquire(self: TxSemaphore(parameter) self: {
permitsRef: TxRef.TxRef<number>;
capacity: number;
toString: () => string;
toJSON: () => unknown;
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 release: (
self: TxSemaphore
) => Effect.Effect<void>
Releases one permit back to the semaphore, making it available for
acquisition.
When to use
Use to manually return one permit after a transactional acquire.
Details
If the semaphore is already at capacity, this operation leaves the permit
count unchanged.
Example (Releasing a permit)
import { Console, Effect, TxSemaphore } from "effect"
const program = Effect.gen(function*() {
const semaphore = yield* TxSemaphore.make(2)
// Acquire a permit
yield* TxSemaphore.acquire(semaphore)
let available = yield* TxSemaphore.available(semaphore)
yield* Console.log(`After acquire: ${available}`) // 1
// Release the permit
yield* TxSemaphore.release(semaphore)
available = yield* TxSemaphore.available(semaphore)
yield* Console.log(`After release: ${available}`) // 2
})
release(self: TxSemaphore(parameter) self: {
permitsRef: TxRef.TxRef<number>;
capacity: number;
toString: () => string;
toJSON: () => unknown;
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; <…;
}