fixup! Add on approach overview toward actors

design/thin-edge-actors-design.md

@@ -246,6 +246,15 @@ impl A {
     peer.say("that").await;
   }
 }
+
+struct B { state: u64 }
+
+impl B {
+  pub async fn say(&mut self, arg: &str) {
+    self.state += 1;
+    println!("{}: {}", self.state, arg);
+  }
+}
 ```
 
 Moving to an actor model introduces two ideas:
@@ -255,7 +264,7 @@ Moving to an actor model introduces two ideas:
   * the peers clone the channel sender and send messages for processing.
 
 ```rust
-struct ActorA { state: AState, messages: Receiver<AMessage>, peer: Sender<BMessage> }
+struct ActorA { state: u64, messages: Receiver<AMessage>, peer: Sender<BMessage> }
 
 #[derive(Clone, Debug)]
 enum AMessage {
@@ -272,14 +281,34 @@ impl A {
           self.state += 1;
 
           // send messages to self.peer, triggering asynchronous operations
-          let _ = self.peer.send("this").await;
+          let _ = self.peer.send(BMessage::Say("this".to_string())).await;
         }
         DoThat(arg) => {
           // update self.state
           self.state += 1;
 
           // send messages to self.peer, triggering asynchronous operations
-          let _ = self.peer.send("that").await;
+          let _ = self.peer.send(BMessage::Say("that".to_string())).await;
+        }
+      }
+    }
+  }
+}
+
+struct ActorB { state: u64, messages: Receiver<BMessage> }
+
+#[derive(Clone, Debug)]
+enum BMessage {
+  Say(String),
+}
+
+impl B {
+  pub async fn run(mut self) {
+    while let Some(message) = self.messages.recv().await {
+      match message {
+        Say(arg) => {
+          self.state += 1;
+          println!("{}: {}", self.state, &arg);
         }
       }
     }
@@ -339,6 +368,38 @@ impl A {
     self.peer.say("that").await;
   }
 }
+
+struct ActorHandlerB {
+  sender: Sender<BMessage>
+}
+
+impl ActorHandlerB {
+  pub async fn say(&mut self, arg: &str) {
+    let _ = self.sender.send(BMessage::Say(arg.to_string())).await;
+  }
+}
+
+struct ActorB { state: u64, messages: Receiver<BMessage> }
+
+#[derive(Clone, Debug)]
+enum BMessage {
+  Say(String),
+}
+
+impl B {
+  pub async fn run(mut self) {
+    while let Some(message) = self.messages.recv().await {
+      match message {
+        Say(arg) => self.say(arg),
+      }
+    }
+  }
+
+  async fn say(&mut self, arg: String) {
+    self.state += 1;
+    println!("{}: {}", self.state, &arg);
+  }
+}
 ```
 
 These three variants of the same example highlight several points.