Message Passing

Command Message

Route Enum Variants

Message passing often starts with an enum that names the commands a receiver understands.

Program

Play the program to choose a command kind and route it through one message handler.

kind
command_message_enum.rs
Replay: real traced execution (multi-file project)
fn main() {
    let kind = 1;
    let message = make_message(kind);
    let result = handle(message);
    println!("{result}");
}

enum Message {
    Start(&'static str),
    Stop(&'static str),
    Ping,
}

fn make_message(kind: i32) -> Message {
    match kind {
        1 => Message::Start("worker"),
        2 => Message::Stop("worker"),
        _ => Message::Ping,
    }
}

fn handle(message: Message) -> String {
    match message {
        Message::Start(name) => format!("start:{name}"),
        Message::Stop(name) => format!("stop:{name}"),
        Message::Ping => "pong".to_string(),
    }
}

fn main() {
    let kind = 2;
    let message = make_message(kind);
    let result = handle(message);
    println!("{result}");
}

enum Message {
    Start(&'static str),
    Stop(&'static str),
    Ping,
}

fn make_message(kind: i32) -> Message {
    match kind {
        1 => Message::Start("worker"),
        2 => Message::Stop("worker"),
        _ => Message::Ping,
    }
}

fn handle(message: Message) -> String {
    match message {
        Message::Start(name) => format!("start:{name}"),
        Message::Stop(name) => format!("stop:{name}"),
        Message::Ping => "pong".to_string(),
    }
}

fn main() {
    let kind = 3;
    let message = make_message(kind);
    let result = handle(message);
    println!("{result}");
}

enum Message {
    Start(&'static str),
    Stop(&'static str),
    Ping,
}

fn make_message(kind: i32) -> Message {
    match kind {
        1 => Message::Start("worker"),
        2 => Message::Stop("worker"),
        _ => Message::Ping,
    }
}

fn handle(message: Message) -> String {
    match message {
        Message::Start(name) => format!("start:{name}"),
        Message::Stop(name) => format!("stop:{name}"),
        Message::Ping => "pong".to_string(),
    }
}

  1. kind ← 1

    1fn main() {2    let kin→ 1d = 1; //@kind=1, 2, 33    let message = make_message(kin1d);4    let result = handle(message);

  2. message ← (empty)

    2let kind = 1; //@kind=1, 2, 33let messag→ (empty)e = make_message(kin1d);4let result = handle(messag(empty)e);5println!("{result}");

  3. result ← "start:worker"

    3    let message = make_message(kind);4    let resul→ "start:worker"t = handle(messag(empty)e);5    println!("{result}");6}
    outputstart:worker

  1. kind ← 2

    1fn main() {2    let kin→ 2d = 2;3    let message = make_message(kin2d);4    let result = handle(message);

  2. message ← (empty)

    2let kind = 2;3let messag→ (empty)e = make_message(kin2d);4let result = handle(messag(empty)e);5println!("{result}");

  3. result ← "stop:worker"

    3    let message = make_message(kind);4    let resul→ "stop:worker"t = handle(messag(empty)e);5    println!("{result}");6}
    outputstop:worker

  1. kind ← 3

    1fn main() {2    let kin→ 3d = 3;3    let message = make_message(kin3d);4    let result = handle(message);

  2. message ← (empty)

    2let kind = 3;3let messag→ (empty)e = make_message(kin3d);4let result = handle(messag(empty)e);5println!("{result}");

  3. result ← "pong"

    3    let message = make_message(kind);4    let resul→ "pong"t = handle(messag(empty)e);5    println!("{result}");6}
    outputpong
message enum `Message` defines the command shapes that can be sent.
routing `handle` matches each message variant and chooses the receiver behavior.
payload The `Start` and `Stop` variants carry the worker name as message data.