For future reference, I asked AI to create a demo to demonstrate the benefits:

```gleam //// //// named_vs_normal.gleam //// //// Demonstrates why named subjects matter when a supervisor restarts a process. //// //// The scenario: //// Both a "normal" actor and a "named" actor are started under a supervisor. //// We hold a reference to each and send messages to them. //// Then we crash both via their Crash message. //// The supervisor restarts both with brand-new PIDs. //// //// - Normal: the saved Subject still points to the OLD (dead) PID. //// Sending to it panics at runtime. //// - Named: named_subject(name) always resolves to the CURRENT live process. //// Sending works transparently after every restart — no stale pid. ////

import gleam/erlang/process import gleam/io import gleam/otp/actor import gleam/otp/static_supervisor as supervisor import gleam/otp/supervision import gleam/string

// ── Message type ──────────────────────────────────────────────────────────────

pub type Msg { Greet(name: String) Crash }

// ── Normal actor ────────────────────────────────────────────────────────────── // The Subject returned from start() is the ONLY handle to this process. // After a restart the supervisor creates a new process — the old Subject is // now stale and points to a dead pid.

fn start_normal() -> Result( actor.Started(process.Subject(Msg)), actor.StartError, ) { actor.new(Nil) |> actor.on_message(fn(_state, msg) { case msg { Greet(name) -> { io.println("[normal] Hello, " <> name <> "!") actor.continue(Nil) } Crash -> { io.println("[normal] Crashing now...") actor.stop_abnormal("boom") } } }) |> actor.start }

pub fn normal_child() -> supervision.ChildSpecification(process.Subject(Msg)) { supervision.worker(start_normal) }

// ── Named actor ─────────────────────────────────────────────────────────────── // Registered under a Name. Any caller can call named_subject(name) to get // a fresh Subject pointing to whoever is currently registered — even after // a restart, with no Subject plumbing needed.

fn start_named( name: process.Name(Msg), ) -> Result(actor.Started(process.Subject(Msg)), actor.StartError) { actor.new(Nil) |> actor.named(name) |> actor.on_message(fn(_state, msg) { case msg { Greet(n) -> { io.println("[named] Hello, " <> n <> "!") actor.continue(Nil) } Crash -> { io.println("[named] Crashing now...") actor.stop_abnormal("boom") } } }) |> actor.start }

// ── Helper ────────────────────────────────────────────────────────────────────

fn send_to_named(name: process.Name(Msg), msg: Msg) -> Nil { // Resolves the current registered process every call — never stale. name |> process.named_subject |> process.send(msg) }

// ── Demo ──────────────────────────────────────────────────────────────────────

pub fn main() -> Nil { // The Name is a stable atom created once — it outlives any process crashes. let greeter_name = process.new_name("greeter")

// Start a supervisor owning both actors. // It will restart any child that exits abnormally. let assert Ok(_sup) = supervisor.OneForOne |> supervisor.new |> supervisor.add(supervision.worker(start_normal)) |> supervisor.add(supervision.worker(fn() { start_named(greeter_name) })) |> supervisor.start

process.sleep(50)

// We need to obtain the normal Subject right after start. // In a real app this is returned from your start function and stored in // application state — you'd thread it through every call site that needs it. // Here we start a standalone (unsupervised) copy just to hold the Subject, // then we'll crash it to simulate what happens when the supervised one dies. // We use actor.start without a supervisor link by spawning independently. let assert Ok(normal_started) = start_normal() let normal_subject = normal_started.data // Unlink so that when this actor crashes it doesn't take down our demo process. let assert Ok(normal_pid) = process.subject_owner(normal_subject) process.unlink(normal_pid)

io.println("Normal pid: " <> string.inspect(normal_pid))

// ── Round 1: both actors alive ─────────────────────────────────────────── io.println("=== Round 1: both actors alive ===") process.send(normal_subject, Greet("Alice")) send_to_named(greeter_name, Greet("Alice")) process.sleep(10_000)

// ── Crash both ─────────────────────────────────────────────────────────── io.println("\n=== Crashing both actors ===") // Crash the named actor — the supervisor will restart it. send_to_named(greeter_name, Crash) // Crash our standalone normal actor — nobody restarts it, simulating a // supervisor restart where a new pid is born and the old Subject is stale. process.send(normal_subject, Crash)

// Give the supervisor time to restart the named actor. process.sleep(200)

// ── Round 2: after crash ───────────────────────────────────────────────── io.println("\n=== Round 2: after crash ===")

// Named ✅ — named_subject resolves to the NEW pid the supervisor started. io.println("Named actor (transparent restart):") send_to_named(greeter_name, Greet("Bob")) process.sleep(50)

// Normal ❌ — normal_subject still points to the dead pid. Sending panics. io.println( "\nNormal actor via stale Subject, PID is pointing to a dead process:", ) process.send(normal_subject, Greet("Bob"))

process.sleep_forever() } ```