Latch

A Latch is a synchronization tool that works like a gate, letting fibers wait until the latch is opened before they continue. The latch can be either open or closed:

• When closed, fibers that reach the latch wait until it opens.
• When open, fibers pass through immediately.

Once opened, a latch typically stays open, although you can close it again if needed

Imagine an application that processes requests only after completing an initial setup (like loading configuration data or establishing a database connection). You can create a latch in a closed state while the setup is happening. Any incoming requests, represented as fibers, would wait at the latch until it opens. Once the setup is finished, you call latch.open so the requests can proceed.

The Latch Interface

A Latch includes several operations that let you control and observe its state:

Creating a Latch

Use the Effect.makeLatch function to create a latch in an open or closed state by passing a boolean. The default is false, which means it starts closed.

Example (Creating and Using a Latch)

In this example, the latch starts closed. A fiber logs “open sesame” only when the latch is open. After waiting for one second, the latch is opened, releasing the fiber:

1
import { Console, Effect } from "effect"
2

3
// A generator function that demonstrates latch usage
4
const program = Effect.gen(function* () {
5
  // Create a latch, starting in the closed state
6
  const latch = yield* Effect.makeLatch()
7

8
  // Fork a fiber that logs "open sesame" only when the latch is open
9
  const fiber = yield* Console.log("open sesame").pipe(
10
    latch.whenOpen, // Waits for the latch to open
11
    Effect.fork, // Fork the effect into a new fiber
12
  )
13

14
  // Wait for 1 second
15
  yield* Effect.sleep("1 second")
16

17
  // Open the latch, releasing the fiber
18
  yield* latch.open
19

20
  // Wait for the forked fiber to finish
21
  yield* fiber.await
22
})
23

24
Effect.runFork(program)
25
// Output: open sesame (after 1 second)

Latch vs Semaphore

A latch is good when you have a one-time event or condition that determines whether fibers can proceed. For example, you might use a latch to block all fibers until a setup step is finished, and then open the latch so everyone can continue.

A semaphore with one lock (often called a binary semaphore or a mutex) is usually for mutual exclusion: it ensures that only one fiber at a time accesses a shared resource or section of code. Once a fiber acquires the lock, no other fiber can enter the protected area until the lock is released.

In short:

• Use a latch if you’re gating a set of fibers on a specific event (“Wait here until this becomes true”).
• Use a semaphore (with one lock) if you need to ensure only one fiber at a time is in a critical section or using a shared resource.