ActorRunnable

A Swift protocol that batches multiple actor operations into a single suspension point — eliminating interleaving race conditions and reducing scheduling overhead.

Inspired by this Point-Free tweet about reducing await proliferation on actors.

The Problem

Each await on an actor is a suspension point. Between suspension points, other tasks can interleave and mutate actor state:

// 3 suspension points — state can change between each await
let token = await session.token        // ← another task can run here
let expires = await session.expiresAt  // ← and here
let active = await session.isRefreshing

The Solution

protocol ActorRunnable: Actor {
    func run<T: Sendable>(_ body: @Sendable (isolated Self) throws -> T) rethrows -> T
}

Conform any actor, then batch reads/writes into a single await:

actor SessionManager: ActorRunnable {
    var token: String?
    var expiresAt: Date?
    var isRefreshing = false
}

// 1 suspension point — atomic access, no interleaving
let snapshot = await session.run { iso in
    (iso.token, iso.expiresAt, iso.isRefreshing)
}

Performance

Benchmarked with ContinuousClock on Apple Silicon (Swift 6, Swift Testing):

Scenario	Individual (10 awaits/iter)	Batched (2 awaits/iter)	Speedup
Sequential — 10k iterations	6.2 ms	4.1 ms	1.5×
Concurrent — 50 tasks × 200 iterations	25.2 ms	10.1 ms	2.5×

Under contention the speedup grows because each suspension point is a scheduling event where other tasks compete for the actor's executor.

The primary benefit is correctness, not speed — run guarantees atomic access to actor state within the closure. No interleaving, no race conditions.

Usage

1. Add ActorRunnable.swift to your project
2. Conform your actor: actor MyStore: ActorRunnable { ... }
3. Use await store.run { iso in ... } instead of multiple await calls

Requires Swift 6.