Simplify module trait by combining produce/consume event methods into a single run method that runs in the module's own thread and can produce and/or consume events. Introduce an Envelope struct that encapsulates event + to/from so we can (eventually) tag every event and also limit where events are sent (e.g. you can have a specific module configured to talk or listen only to a certain other module).

src/modules/discord.rs

@@ -8,7 +8,7 @@ use toml::Table;
 use event;
 
 use std::sync::Arc;
-use std::sync::mpsc::Sender;
+use std::sync::mpsc::{Sender, Receiver};
 
 use {MessageSender, Message, User, Channel};
 
@@ -52,7 +52,7 @@ impl MessageSender for DiscordMessageSender {
 }
 
 impl Module for DiscordModule {
-    fn produce_events<'a>(&'a self, sender: Sender<Arc<event::Event>>) {
+    fn run (&self, sender: Sender<event::Envelope>, _: Receiver<Arc<event::Envelope>>) {
         let discord = Arc::new(Discord::from_bot_token(&self.token[..]).expect("Discord module: Login failed"));
         let (mut connection, _) = discord.connect().expect("Discord module: Connection failed");
 
@@ -86,7 +86,7 @@ impl Module for DiscordModule {
                         channel: Some(channel)
                     };
 
-                    match sender.send(Arc::new(event::Event::Message { message: message })) {
+                    match sender.send(event::Envelope::new(event::Event::Message { message: message })) {
                         Err(err) => error!("Error sending message event: {:?}", err),
                         Ok(_) => {}
                     }

src/modules/echo.rs

@@ -2,10 +2,10 @@ use modules::Module;
 use toml::Table;
 
 use std::sync::Arc;
-use std::sync::mpsc::Receiver;
+use std::sync::mpsc::{Sender, Receiver};
 
 use helpers::command::split_command;
-use event::Event;
+use event::{Event, Envelope};
 
 pub struct EchoModule {
     prefix: String
@@ -24,11 +24,11 @@ impl EchoModule {
 }
 
 impl Module for EchoModule {
-    fn consume_events (&self, receiver: Receiver<Arc<Event>>) {
+    fn run(&self, _: Sender<Envelope>, receiver: Receiver<Arc<Envelope>>) {
         loop {
             match receiver.recv() {
-                Ok(event) => {
-                    match *event {
+                Ok(envelope) => {
+                    match *envelope.event {
                         Event::Message { ref message } => {
                             debug!("Received message... {:?}", message.content);
                             match split_command(&message.content) {

src/modules/echobox.rs

@@ -2,10 +2,10 @@ use modules::Module;
 use toml::Table;
 
 use std::sync::Arc;
-use std::sync::mpsc::Receiver;
+use std::sync::mpsc::{Sender, Receiver};
 
 use helpers::command::split_command;
-use event::Event;
+use event::{Event, Envelope};
 use echobox::Echobox;
 
 pub struct EchoboxModule {
@@ -31,13 +31,13 @@ impl EchoboxModule {
 }
 
 impl Module for EchoboxModule {
-    fn consume_events (&self, receiver: Receiver<Arc<Event>>) {
+    fn run(&self, _: Sender<Envelope>, receiver: Receiver<Arc<Envelope>>) {
         let echobox = Echobox::with_file(&self.file).unwrap();
 
         loop {
             match receiver.recv() {
-                Ok(event) => {
-                    match *event {
+                Ok(envelope) => {
+                    match *envelope.event {
                         Event::Message { ref message } => {
                             debug!("Received message... {:?}", message.content);
                             match split_command(&message.content) {

src/modules/lua.rs

@@ -6,7 +6,7 @@ pub struct LuaModule {
 }
 
 impl LuaModule {
-    pub fn new (configuration: &Table) -> Box<Module> {
+    pub fn new (_: &Table) -> Box<Module> {
         Box::new(LuaModule {})
     }
 }

src/modules/mod.rs

@@ -9,13 +9,12 @@ pub mod echobox;
 pub mod loader;
 
 use Tenquestionmarks;
-use event::Event;
+use event::Envelope;
 
 use std::sync::Arc;
 use std::sync::mpsc::{Sender, Receiver};
 
 pub trait Module : Sync {
-    fn register (&self, tenquestionmarks: &Tenquestionmarks) {}
-    fn consume_events (&self, receiver: Receiver<Arc<Event>>) {}
-    fn produce_events<'a>(&'a self, sender: Sender<Arc<Event>>) {}
+    fn register (&self, _: &Tenquestionmarks) {}
+    fn run (&self, _: Sender<Envelope>, _: Receiver<Arc<Envelope>>) {}
 }

src/modules/pvn.rs

@@ -2,13 +2,12 @@ use modules::Module;
 use toml::Table;
 
 use std::sync::Arc;
-use std::sync::mpsc::Receiver;
-use event::Event;
+use std::sync::mpsc::{Sender, Receiver};
+use event::{Event, Envelope};
 
-use {Message, Channel, User};
+use Message;
 use helpers::command::split_command;
 
-use pvn::Error;
 use pvn::Fighter;
 use pvn::pirates::{Pirate, Pirates};
 use pvn::ninjas::{Ninja, Ninjas};
@@ -16,7 +15,7 @@ use pvn::ninjas::{Ninja, Ninjas};
 pub struct PvnModule {}
 
 impl PvnModule {
-    pub fn new (configuration: &Table) -> Box<Module> {
+    pub fn new (_: &Table) -> Box<Module> {
         Box::new(PvnModule {})
     }
 }
@@ -133,18 +132,10 @@ impl PirateVsNinja {
             }
         }
     }
-
-    fn get_pirate (&mut self, name: &str) -> Result<&Pirate, Error> {
-        self.pirates.get(name)
-    }
-
-    fn get_ninja (&mut self, name: &str) -> Result<&Ninja, Error> {
-        self.ninjas.get(name)
-    }
 }
 
 impl Module for PvnModule {
-    fn consume_events (&self, receiver: Receiver<Arc<Event>>) {
+    fn run(&self, _: Sender<Envelope>, receiver: Receiver<Arc<Envelope>>) {
         let mut pvn = PirateVsNinja {
             pirates: Pirates::new(),
             ninjas: Ninjas::new()
@@ -152,8 +143,8 @@ impl Module for PvnModule {
 
         loop {
             match receiver.recv() {
-                Ok(event) => {
-                    match *event {
+                Ok(envelope) => {
+                    match *envelope.event {
                         Event::Message { ref message } => {
                             let command = split_command(&message.content);
                             debug!("Received message... {:?}", &message.content);

src/modules/random.rs

@@ -2,10 +2,10 @@ use modules::Module;
 use toml::Table;
 
 use std::sync::Arc;
-use std::sync::mpsc::Receiver;
+use std::sync::mpsc::{Sender, Receiver};
 
 use helpers::command::split_command;
-use event::Event;
+use event::{Event, Envelope};
 use rand;
 
 pub struct RandomModule {
@@ -35,13 +35,13 @@ impl RandomModule {
 }
 
 impl Module for RandomModule {
-    fn consume_events (&self, receiver: Receiver<Arc<Event>>) {
+    fn run(&self, _: Sender<Envelope>, receiver: Receiver<Arc<Envelope>>) {
         let mut rng = rand::thread_rng();
 
         loop {
             match receiver.recv() {
-                Ok(event) => {
-                    match *event {
+                Ok(envelope) => {
+                    match *envelope.event {
                         Event::Message { ref message } => {
                             debug!("Received message... {:?}", message.content);
                             match split_command(&message.content) {

src/modules/stdin.rs

@@ -6,8 +6,8 @@ use toml::Table;
 use {MessageSender, Message, User};
 
 use std::sync::Arc;
-use std::sync::mpsc::Sender;
-use event::Event;
+use std::sync::mpsc::{Sender, Receiver};
+use event::{Event, Envelope};
 
 pub struct StdinModule {}
 
@@ -23,17 +23,17 @@ impl MessageSender for StdinMessageSender {
 }
 
 impl StdinModule {
-    pub fn new (configuration: &Table) -> Box<Module> {
+    pub fn new (_: &Table) -> Box<Module> {
         Box::new(StdinModule {})
     }
 }
 
 impl Module for StdinModule {
-    fn produce_events<'a>(&'a self, sender: Sender<Arc<Event>>) {
+    fn run(&self, sender: Sender<Envelope>, _: Receiver<Arc<Envelope>>) {
         loop {
             let mut input = String::new();
             match io::stdin().read_line(&mut input) {
-                Ok(n) => {
+                Ok(_) => {
                     let message = Message {
                         author: User {
                             name: String::from("Dave"),
@@ -45,7 +45,7 @@ impl Module for StdinModule {
                         channel: None
                     };
 
-                    match sender.send(Arc::new(Event::Message { message: message })) {
+                    match sender.send(Envelope::new(Event::Message { message: message })) {
                         Err(err) => error!("Error sending message event: {:?}", err),
                         Ok(_) => {}
                     }