alternate implementation using Box<MessageSender> and clone

src/event/mod.rs

@@ -1,8 +1,8 @@
 use {Channel, User};
 
 #[derive(Clone)]
-pub enum Event<'a> {
-    Message { sender: User<'a>, channel: Option<Channel<'a>>, content: String },
-    Join { channel: Channel<'a> },
-    Quit { channel: Channel<'a> }
+pub enum Event {
+    Message { sender: User, channel: Option<Channel>, content: String },
+    Join { channel: Channel },
+    Quit { channel: Channel }
 }

src/lib.rs

@@ -79,27 +79,38 @@ impl Tenquestionmarks {
 }
 
 #[derive(Clone)]
-pub struct Channel<'a> {
+pub struct Channel {
     name: String,
     description: String,
     topic: String,
-    send_function: &'a Fn(&Channel, &str)
+    sender: Box<MessageSender>
 }
 
-impl<'a> Channel<'a> {
+impl Channel {
     pub fn send (&self, message: &str) {
-        (self.send_function)(self, message);
+        self.sender.send_message(message);
     }
 }
 
 #[derive(Clone)]
-pub struct User<'a> {
+pub struct User {
     name: String,
-    send_function: &'a Fn(&User, &str)
+    sender: Box<MessageSender>
 }
 
-impl<'a> User<'a> {
+impl User {
     pub fn send (&self, message: &str) {
-        (self.send_function)(self, message);
+        self.sender.send_message(message);
+    }
+}
+
+pub trait MessageSender : Sync + Send {
+    fn box_clone (&self) -> Box<MessageSender>;
+    fn send_message (&self, message: &str) {}
+}
+
+impl Clone for Box<MessageSender> {
+    fn clone (&self) -> Box<MessageSender> {
+        self.box_clone()
     }
 }

src/plugins/discord.rs

@@ -8,6 +8,7 @@ use toml::Table;
 use event;
 use std::sync::mpsc::Sender;
 
+use MessageSender;
 use User;
 use Channel;
 
@@ -29,6 +30,21 @@ impl DiscordPlugin {
     }
 }
 
+#[derive(Clone)]
+pub struct DiscordMessageSender {
+    name: String
+}
+
+impl MessageSender for DiscordMessageSender {
+    fn box_clone (&self) -> Box<MessageSender> {
+        Box::new((*self).clone())
+    }
+
+    fn send_message (&self, message: &str) {
+        println!("send to {:?}: {:?}", self.name, message);
+    }
+}
+
 impl Plugin for DiscordPlugin {
     fn produce_events<'a>(&'a self, sender: Sender<event::Event>) {
         let discord = Discord::from_bot_token(&self.token[..]).expect("Login failed");
@@ -36,10 +52,10 @@ impl Plugin for DiscordPlugin {
         loop {
             match connection.recv_event() {
                 Ok(Event::MessageCreate(message)) => {
-                    let author = User {
+                    /*let author = User {
                         name: message.author.name,
-                        send_function: &(|user: &User, message: &str| {
-                            println!("Send to {:?}: {:?}", user.name, message);
+                        sender: &(DiscordMessageSender {
+                            name: message.author.name
                         })
                     };
 
@@ -47,12 +63,12 @@ impl Plugin for DiscordPlugin {
                         name: String::from("channel"),
                         description: String::from(""),
                         topic: String::from(""),
-                        send_function: &(|channel: &Channel, message: &str| {
-                            println!("Send to {:?}: {:?}", channel.name, message);
+                        sender: &(DiscordMessageSender {
+                            name: String::from("channel")
                         })
                     };
 
-                    sender.send(event::Event::Message { sender: author, content: message.content, channel: Option::Some(channel) });
+                    sender.send(event::Event::Message { sender: author, content: message.content, channel: Option::Some(channel) });*/
                 }
     			Ok(_) => {}
     			Err(discord::Error::Closed(code, body)) => {

src/plugins/stdin.rs

@@ -4,12 +4,28 @@ use plugins::Plugin;
 use toml::Table;
 
 use User;
+use MessageSender;
 
 use std::sync::mpsc::Sender;
 use event::Event;
 
 pub struct StdinPlugin {}
 
+#[derive(Clone)]
+pub struct StdinMessageSender {
+    name: String
+}
+
+impl MessageSender for StdinMessageSender {
+    fn box_clone (&self) -> Box<MessageSender> {
+        Box::new((*self).clone())
+    }
+
+    fn send_message (&self, message: &str) {
+        println!("send to {:?}: {:?}", self.name, message);
+    }
+}
+
 impl StdinPlugin {
     pub fn new (configuration: &Table) -> Box<Plugin> {
         Box::new(StdinPlugin {})
@@ -20,8 +36,8 @@ impl Plugin for StdinPlugin {
     fn produce_events<'a>(&'a self, sender: Sender<Event>) {
         let user = User {
             name: String::from("Dave"),
-            send_function: &(|user: &User, message: &str| {
-                println!("Send to {:?}: {:?}", user.name, message);
+            sender: Box::new(StdinMessageSender {
+                name: String::from("Dave")
             })
         };