Remove `on_` prefix to EventHandler tymethods

It was voted that the `on_` prefix is unnecessary, so these have been
dropped.

14 files changed, 131 insertions, 131 deletions

diff --git a/src/builder/create_embed.rs b/src/builder/create_embed.rs
index 733a091..46d9873 100644
--- a/src/builder/create_embed.rs
+++ b/src/builder/create_embed.rs
@@ -208,7 +208,7 @@ impl CreateEmbed {
     /// #
     /// struct Handler;
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, _: Context, msg: Message) {
+    ///     fn message(&self, _: Context, msg: Message) {
     ///         if msg.content == "~embed" {
     ///             let _ = msg.channel_id.send_message(|m| m
     ///              .embed(|e| e
@@ -231,7 +231,7 @@ impl CreateEmbed {
     /// #
     /// struct Handler;
     /// impl EventHandler for Handler {
-    ///     fn on_guild_member_addition(&self, _: Context, guild_id: GuildId, member: Member) {
+    ///     fn guild_member_addition(&self, _: Context, guild_id: GuildId, member: Member) {
     ///         use serenity::client::CACHE;
     ///         let cache = CACHE.read();
     ///
diff --git a/src/builder/create_invite.rs b/src/builder/create_invite.rs
index 87c4988..d4e0c25 100644
--- a/src/builder/create_invite.rs
+++ b/src/builder/create_invite.rs
@@ -19,7 +19,7 @@ use internal::prelude::*;
 /// struct Handler;
 ///
 /// impl EventHandler for Handler {
-///     fn on_message(&self, _: Context, msg: Message) {
+///     fn message(&self, _: Context, msg: Message) {
 ///         use serenity::client::CACHE;
 ///         if msg.content == "!createinvite" {
 ///             let channel = match CACHE.read().guild_channel(msg.channel_id) {
diff --git a/src/builder/edit_profile.rs b/src/builder/edit_profile.rs
index 648bfbf..48e09cd 100644
--- a/src/builder/edit_profile.rs
+++ b/src/builder/edit_profile.rs
@@ -25,7 +25,7 @@ impl EditProfile {
     /// #
     /// # struct Handler;
     /// # impl EventHandler for Handler {
-    ///    # fn on_message(&self, context: Context, _: Message) {
+    ///    # fn message(&self, context: Context, _: Message) {
     ///         use serenity::utils;
     ///
     ///         // assuming a `context` has been bound
diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index 238ca97..f9beaee 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -178,7 +178,7 @@ impl Cache {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_ready(&self, ctx: Context, _: Ready) {
+    ///     fn ready(&self, ctx: Context, _: Ready) {
     ///          // Wait some time for guilds to be received.
     ///         //
     ///         // You should keep track of this in a better fashion by tracking how
@@ -261,7 +261,7 @@ impl Cache {
     ///
     /// struct Handler;
     /// impl EventHandler for Handler {
-    ///     fn on_ready(&self, _: Context, _: Ready) {
+    ///     fn ready(&self, _: Context, _: Ready) {
     ///         println!("Guilds in the Cache: {:?}", CACHE.read().all_guilds());
     ///     }
     /// }
@@ -369,7 +369,7 @@ impl Cache {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, ctx: Context, message: Message) {
+    ///     fn message(&self, ctx: Context, message: Message) {
     ///         let cache = CACHE.read();
     ///
     ///         let channel = match cache.guild_channel(message.channel_id) {
diff --git a/src/client/context.rs b/src/client/context.rs
index e27c134..261c8ff 100644
--- a/src/client/context.rs
+++ b/src/client/context.rs
@@ -71,7 +71,7 @@ impl Context {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, ctx: Context, msg: Message) {
+    ///     fn message(&self, ctx: Context, msg: Message) {
     ///         if msg.content == "!changename" {
     ///             ctx.edit_profile(|e| e.username("Edward Elric"));
     ///         }
@@ -122,7 +122,7 @@ impl Context {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, ctx: Context, msg: Message) {
+    ///     fn message(&self, ctx: Context, msg: Message) {
     ///         if msg.content == "!online" {
     ///             ctx.online();
     ///         }
@@ -151,7 +151,7 @@ impl Context {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, ctx: Context, msg: Message) {
+    ///     fn message(&self, ctx: Context, msg: Message) {
     ///         if msg.content == "!idle" {
     ///             ctx.idle();
     ///         }
@@ -180,7 +180,7 @@ impl Context {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, ctx: Context, msg: Message) {
+    ///     fn message(&self, ctx: Context, msg: Message) {
     ///         if msg.content == "!dnd" {
     ///             ctx.dnd();
     ///         }
@@ -210,7 +210,7 @@ impl Context {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_ready(&self, ctx: Context, _: Ready) {
+    ///     fn ready(&self, ctx: Context, _: Ready) {
     ///         ctx.invisible();
     ///     }
     /// }
@@ -241,7 +241,7 @@ impl Context {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_resume(&self, ctx: Context, _: ResumedEvent) {
+    ///     fn resume(&self, ctx: Context, _: ResumedEvent) {
     ///         ctx.reset_presence();
     ///     }
     /// }
@@ -272,7 +272,7 @@ impl Context {
     ///
     /// struct Handler;
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, ctx: Context, msg: Message) {
+    ///     fn message(&self, ctx: Context, msg: Message) {
     ///         let args = msg.content.splitn(2, ' ').collect::<Vec<&str>>();
     ///
     ///         if args.len() < 2 || *unsafe { args.get_unchecked(0) } != "~setgame" {
@@ -312,7 +312,7 @@ impl Context {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_ready(&self, ctx: Context, _: Ready) {
+    ///     fn ready(&self, ctx: Context, _: Ready) {
     ///         ctx.set_game_name("test");
     ///     }
     /// }
@@ -351,7 +351,7 @@ impl Context {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_ready(&self, ctx: Context, _: Ready) {
+    ///     fn ready(&self, ctx: Context, _: Ready) {
     ///         use serenity::model::OnlineStatus;
     ///
     ///         ctx.set_presence(None, OnlineStatus::Idle);
@@ -370,7 +370,7 @@ impl Context {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_ready(&self, context: Context, _: Ready) {
+    ///     fn ready(&self, context: Context, _: Ready) {
     ///         use serenity::model::{Game, OnlineStatus};
     ///
     ///         let game = Game::playing("Heroes of the Storm");
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index c296b70..827875e 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -87,7 +87,7 @@ fn dispatch_message<H>(
         message.transform_content();
     }
 
-    event_handler.on_message(context, message);
+    event_handler.message(context, message);
 }
 
 #[allow(cyclomatic_complexity, unused_assignments, unused_mut)]
@@ -120,14 +120,14 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             // So in short, only exists to reduce unnecessary clutter.
             match event.channel {
                 Channel::Private(channel) => {
-                    event_handler.on_private_channel_create(context, channel);
+                    event_handler.private_channel_create(context, channel);
                 },
                 Channel::Group(_) => {},
                 Channel::Guild(channel) => {
-                    event_handler.on_channel_create(context, channel);
+                    event_handler.channel_create(context, channel);
                 },
                 Channel::Category(channel) => {
-                    event_handler.on_category_create(context, channel);
+                    event_handler.category_create(context, channel);
                 },
             }
         },
@@ -139,31 +139,31 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             match event.channel {
                 Channel::Private(_) | Channel::Group(_) => {},
                 Channel::Guild(channel) => {
-                    event_handler.on_channel_delete(context, channel);
+                    event_handler.channel_delete(context, channel);
                 },
                 Channel::Category(channel) => {
-                    event_handler.on_category_delete(context, channel);
+                    event_handler.category_delete(context, channel);
                 },
             }
         },
         Event::ChannelPinsUpdate(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_channel_pins_update(context, event);
+            event_handler.channel_pins_update(context, event);
         },
         Event::ChannelRecipientAdd(mut event) => {
             update!(event);
 
             let context = context(conn, data);
 
-            event_handler.on_channel_recipient_addition(context, event.channel_id, event.user);
+            event_handler.channel_recipient_addition(context, event.channel_id, event.user);
         },
         Event::ChannelRecipientRemove(mut event) => {
             update!(event);
 
             let context = context(conn, data);
 
-            event_handler.on_channel_recipient_removal(context, event.channel_id, event.user);
+            event_handler.channel_recipient_removal(context, event.channel_id, event.user);
         },
         Event::ChannelUpdate(mut event) => {
             update!(event);
@@ -172,20 +172,20 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             feature_cache! {{
                 let before = CACHE.read().channel(event.channel.id());
-                event_handler.on_channel_update(context, before, event.channel);
+                event_handler.channel_update(context, before, event.channel);
             } else {
-                event_handler.on_channel_update(context, event.channel);
+                event_handler.channel_update(context, event.channel);
             }}
         },
         Event::GuildBanAdd(mut event) => {
             let context = context(conn, data);
 
-                event_handler.on_guild_ban_addition(context, event.guild_id, event.user);
+                event_handler.guild_ban_addition(context, event.guild_id, event.user);
         },
         Event::GuildBanRemove(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_guild_ban_removal(context, event.guild_id, event.user);
+            event_handler.guild_ban_removal(context, event.guild_id, event.user);
         },
         Event::GuildCreate(mut event) => {
             #[cfg(feature = "cache")]
@@ -212,16 +212,16 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
                         .map(|(&id, _)| id)
                         .collect::<Vec<GuildId>>();
 
-                    event_handler.on_cached(context, guild_amount);
+                    event_handler.cached(context, guild_amount);
                 }
             }
 
             let context = context(conn, data);
 
             feature_cache! {{
-                event_handler.on_guild_create(context, event.guild, _is_new);
+                event_handler.guild_create(context, event.guild, _is_new);
             } else {
-                event_handler.on_guild_create(context, event.guild);
+                event_handler.guild_create(context, event.guild);
             }}
         },
         Event::GuildDelete(mut event) => {
@@ -229,9 +229,9 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             let context = context(conn, data);
 
             feature_cache! {{
-                event_handler.on_guild_delete(context, event.guild, _full);
+                event_handler.guild_delete(context, event.guild, _full);
             } else {
-                event_handler.on_guild_delete(context, event.guild);
+                event_handler.guild_delete(context, event.guild);
             }}
         },
         Event::GuildEmojisUpdate(mut event) => {
@@ -239,28 +239,28 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let context = context(conn, data);
 
-            event_handler.on_guild_emojis_update(context, event.guild_id, event.emojis);
+            event_handler.guild_emojis_update(context, event.guild_id, event.emojis);
         },
         Event::GuildIntegrationsUpdate(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_guild_integrations_update(context, event.guild_id);
+            event_handler.guild_integrations_update(context, event.guild_id);
         },
         Event::GuildMemberAdd(mut event) => {
             update!(event);
 
             let context = context(conn, data);
 
-            event_handler.on_guild_member_addition(context, event.guild_id, event.member);
+            event_handler.guild_member_addition(context, event.guild_id, event.member);
         },
         Event::GuildMemberRemove(mut event) => {
             let _member = update!(event);
             let context = context(conn, data);
 
             feature_cache! {{
-                event_handler.on_guild_member_removal(context, event.guild_id, event.user, _member);
+                event_handler.guild_member_removal(context, event.guild_id, event.user, _member);
             } else {
-                event_handler.on_guild_member_removal(context, event.guild_id, event.user);
+                event_handler.guild_member_removal(context, event.guild_id, event.user);
             }}
         },
         Event::GuildMemberUpdate(mut event) => {
@@ -276,9 +276,9 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
                     .unwrap()
                     .clone();
 
-                event_handler.on_guild_member_update(context, _before, after);
+                event_handler.guild_member_update(context, _before, after);
             } else {
-                event_handler.on_guild_member_update(context, event);
+                event_handler.guild_member_update(context, event);
             }}
         },
         Event::GuildMembersChunk(mut event) => {
@@ -286,23 +286,23 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let context = context(conn, data);
 
-            event_handler.on_guild_members_chunk(context, event.guild_id, event.members);
+            event_handler.guild_members_chunk(context, event.guild_id, event.members);
         },
         Event::GuildRoleCreate(mut event) => {
             update!(event);
 
             let context = context(conn, data);
 
-            event_handler.on_guild_role_create(context, event.guild_id, event.role);
+            event_handler.guild_role_create(context, event.guild_id, event.role);
         },
         Event::GuildRoleDelete(mut event) => {
             let _role = update!(event);
             let context = context(conn, data);
 
             feature_cache! {{
-                event_handler.on_guild_role_delete(context, event.guild_id, event.role_id, _role);
+                event_handler.guild_role_delete(context, event.guild_id, event.role_id, _role);
             } else {
-                event_handler.on_guild_role_delete(context, event.guild_id, event.role_id);
+                event_handler.guild_role_delete(context, event.guild_id, event.role_id);
             }}
         },
         Event::GuildRoleUpdate(mut event) => {
@@ -310,9 +310,9 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             let context = context(conn, data);
 
             feature_cache! {{
-                event_handler.on_guild_role_update(context, event.guild_id, _before, event.role);
+                event_handler.guild_role_update(context, event.guild_id, _before, event.role);
             } else {
-                event_handler.on_guild_role_update(context, event.guild_id, event.role);
+                event_handler.guild_role_update(context, event.guild_id, event.role);
             }}
         },
         Event::GuildUnavailable(mut event) => {
@@ -320,7 +320,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let context = context(conn, data);
 
-            event_handler.on_guild_unavailable(context, event.guild_id);
+            event_handler.guild_unavailable(context, event.guild_id);
         },
         Event::GuildUpdate(mut event) => {
             update!(event);
@@ -333,9 +333,9 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
                     .get(&event.guild.id)
                     .cloned();
 
-                event_handler.on_guild_update(context, before, event.guild);
+                event_handler.guild_update(context, before, event.guild);
             } else {
-                event_handler.on_guild_update(context, event.guild);
+                event_handler.guild_update(context, event.guild);
             }}
         },
         // Already handled by the framework check macro
@@ -343,46 +343,46 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
         Event::MessageDeleteBulk(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_message_delete_bulk(context, event.channel_id, event.ids);
+            event_handler.message_delete_bulk(context, event.channel_id, event.ids);
         },
         Event::MessageDelete(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_message_delete(context, event.channel_id, event.message_id);
+            event_handler.message_delete(context, event.channel_id, event.message_id);
         },
         Event::MessageUpdate(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_message_update(context, event);
+            event_handler.message_update(context, event);
         },
         Event::PresencesReplace(mut event) => {
             update!(event);
 
             let context = context(conn, data);
 
-            event_handler.on_presence_replace(context, event.presences);
+            event_handler.presence_replace(context, event.presences);
         },
         Event::PresenceUpdate(mut event) => {
             update!(event);
 
             let context = context(conn, data);
 
-            event_handler.on_presence_update(context, event);
+            event_handler.presence_update(context, event);
         },
         Event::ReactionAdd(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_reaction_add(context, event.reaction);
+            event_handler.reaction_add(context, event.reaction);
         },
         Event::ReactionRemove(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_reaction_remove(context, event.reaction);
+            event_handler.reaction_remove(context, event.reaction);
         },
         Event::ReactionRemoveAll(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_reaction_remove_all(context, event.channel_id, event.message_id);
+            event_handler.reaction_remove_all(context, event.channel_id, event.message_id);
         },
         Event::Ready(mut event) => {
             update!(event);
@@ -395,56 +395,56 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
                         .map(move |_| {
                             let context = context(conn, data);
 
-                            event_handler.on_ready(context, event.ready);
+                            event_handler.ready(context, event.ready);
                         });
                 } else {
                     let context = context(conn, data);
 
-                    event_handler.on_ready(context, event.ready);
+                    event_handler.ready(context, event.ready);
                 }
             }
         },
         Event::Resumed(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_resume(context, event);
+            event_handler.resume(context, event);
         },
         Event::TypingStart(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_typing_start(context, event);
+            event_handler.typing_start(context, event);
         },
         Event::Unknown(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_unknown(context, event.kind, event.value);
+            event_handler.unknown(context, event.kind, event.value);
         },
         Event::UserUpdate(mut event) => {
             let _before = update!(event);
             let context = context(conn, data);
 
             feature_cache! {{
-                event_handler.on_user_update(context, _before.unwrap(), event.current_user);
+                event_handler.user_update(context, _before.unwrap(), event.current_user);
             } else {
-                event_handler.on_user_update(context, event.current_user);
+                event_handler.user_update(context, event.current_user);
             }}
         },
         Event::VoiceServerUpdate(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_voice_server_update(context, event);
+            event_handler.voice_server_update(context, event);
         },
         Event::VoiceStateUpdate(mut event) => {
             update!(event);
 
             let context = context(conn, data);
 
-            event_handler.on_voice_state_update(context, event.guild_id, event.voice_state);
+            event_handler.voice_state_update(context, event.guild_id, event.voice_state);
         },
         Event::WebhookUpdate(mut event) => {
             let context = context(conn, data);
 
-            event_handler.on_webhook_update(context, event.guild_id, event.channel_id);
+            event_handler.webhook_update(context, event.guild_id, event.channel_id);
         },
     }
 }
diff --git a/src/client/event_handler.rs b/src/client/event_handler.rs
index 0c618c2..5c2f131 100644
--- a/src/client/event_handler.rs
+++ b/src/client/event_handler.rs
@@ -8,73 +8,73 @@ use model::*;
 
 pub trait EventHandler {
     #[cfg(feature = "cache")]
-    fn on_cached(&self, _: Context, _: Vec<GuildId>) {}
-    fn on_channel_create(&self, _: Context, _: Arc<RwLock<GuildChannel>>) {}
-    fn on_category_create(&self, _: Context, _: Arc<RwLock<ChannelCategory>>) {}
-    fn on_category_delete(&self, _: Context, _: Arc<RwLock<ChannelCategory>>) {}
-    fn on_private_channel_create(&self, _: Context, _: Arc<RwLock<PrivateChannel>>) {}
-    fn on_channel_delete(&self, _: Context, _: Arc<RwLock<GuildChannel>>) {}
-    fn on_channel_pins_update(&self, _: Context, _: ChannelPinsUpdateEvent) {}
-    fn on_channel_recipient_addition(&self, _: Context, _: ChannelId, _: User) {}
-    fn on_channel_recipient_removal(&self, _: Context, _: ChannelId, _: User) {}
+    fn cached(&self, _: Context, _: Vec<GuildId>) {}
+    fn channel_create(&self, _: Context, _: Arc<RwLock<GuildChannel>>) {}
+    fn category_create(&self, _: Context, _: Arc<RwLock<ChannelCategory>>) {}
+    fn category_delete(&self, _: Context, _: Arc<RwLock<ChannelCategory>>) {}
+    fn private_channel_create(&self, _: Context, _: Arc<RwLock<PrivateChannel>>) {}
+    fn channel_delete(&self, _: Context, _: Arc<RwLock<GuildChannel>>) {}
+    fn channel_pins_update(&self, _: Context, _: ChannelPinsUpdateEvent) {}
+    fn channel_recipient_addition(&self, _: Context, _: ChannelId, _: User) {}
+    fn channel_recipient_removal(&self, _: Context, _: ChannelId, _: User) {}
     #[cfg(feature = "cache")]
-    fn on_channel_update(&self, _: Context, _: Option<Channel>, _: Channel) {}
+    fn channel_update(&self, _: Context, _: Option<Channel>, _: Channel) {}
     #[cfg(not(feature = "cache"))]
-    fn on_channel_update(&self, _: Context, _: Channel) {}
-    fn on_guild_ban_addition(&self, _: Context, _: GuildId, _: User) {}
-    fn on_guild_ban_removal(&self, _: Context, _: GuildId, _: User) {}
+    fn channel_update(&self, _: Context, _: Channel) {}
+    fn guild_ban_addition(&self, _: Context, _: GuildId, _: User) {}
+    fn guild_ban_removal(&self, _: Context, _: GuildId, _: User) {}
     #[cfg(feature = "cache")]
-    fn on_guild_create(&self, _: Context, _: Guild, _: bool) {}
+    fn guild_create(&self, _: Context, _: Guild, _: bool) {}
     #[cfg(not(feature = "cache"))]
-    fn on_guild_create(&self, _: Context, _: Guild) {}
+    fn guild_create(&self, _: Context, _: Guild) {}
     #[cfg(feature = "cache")]
-    fn on_guild_delete(&self, _: Context, _: PartialGuild, _: Option<Arc<RwLock<Guild>>>) {}
+    fn guild_delete(&self, _: Context, _: PartialGuild, _: Option<Arc<RwLock<Guild>>>) {}
     #[cfg(not(feature = "cache"))]
-    fn on_guild_delete(&self, _: Context, _: PartialGuild) {}
-    fn on_guild_emojis_update(&self, _: Context, _: GuildId, _: HashMap<EmojiId, Emoji>) {}
-    fn on_guild_integrations_update(&self, _: Context, _: GuildId) {}
-    fn on_guild_member_addition(&self, _: Context, _: GuildId, _: Member) {}
+    fn guild_delete(&self, _: Context, _: PartialGuild) {}
+    fn guild_emojis_update(&self, _: Context, _: GuildId, _: HashMap<EmojiId, Emoji>) {}
+    fn guild_integrations_update(&self, _: Context, _: GuildId) {}
+    fn guild_member_addition(&self, _: Context, _: GuildId, _: Member) {}
     #[cfg(feature = "cache")]
-    fn on_guild_member_removal(&self, _: Context, _: GuildId, _: User, _: Option<Member>) {}
+    fn guild_member_removal(&self, _: Context, _: GuildId, _: User, _: Option<Member>) {}
     #[cfg(not(feature = "cache"))]
-    fn on_guild_member_removal(&self, _: Context, _: GuildId, _: User) {}
+    fn guild_member_removal(&self, _: Context, _: GuildId, _: User) {}
     #[cfg(feature = "cache")]
-    fn on_guild_member_update(&self, _: Context, _: Option<Member>, _: Member) {}
+    fn guild_member_update(&self, _: Context, _: Option<Member>, _: Member) {}
     #[cfg(not(feature = "cache"))]
-    fn on_guild_member_update(&self, _: Context, _: GuildMemberUpdateEvent) {}
-    fn on_guild_members_chunk(&self, _: Context, _: GuildId, _: HashMap<UserId, Member>) {}
-    fn on_guild_role_create(&self, _: Context, _: GuildId, _: Role) {}
+    fn guild_member_update(&self, _: Context, _: GuildMemberUpdateEvent) {}
+    fn guild_members_chunk(&self, _: Context, _: GuildId, _: HashMap<UserId, Member>) {}
+    fn guild_role_create(&self, _: Context, _: GuildId, _: Role) {}
     #[cfg(feature = "cache")]
-    fn on_guild_role_delete(&self, _: Context, _: GuildId, _: RoleId, _: Option<Role>) {}
+    fn guild_role_delete(&self, _: Context, _: GuildId, _: RoleId, _: Option<Role>) {}
     #[cfg(not(feature = "cache"))]
-    fn on_guild_role_delete(&self, _: Context, _: GuildId, _: RoleId) {}
+    fn guild_role_delete(&self, _: Context, _: GuildId, _: RoleId) {}
     #[cfg(feature = "cache")]
-    fn on_guild_role_update(&self, _: Context, _: GuildId, _: Option<Role>, _: Role) {}
+    fn guild_role_update(&self, _: Context, _: GuildId, _: Option<Role>, _: Role) {}
     #[cfg(not(feature = "cache"))]
-    fn on_guild_role_update(&self, _: Context, _: GuildId, _: Role) {}
-    fn on_guild_unavailable(&self, _: Context, _: GuildId) {}
+    fn guild_role_update(&self, _: Context, _: GuildId, _: Role) {}
+    fn guild_unavailable(&self, _: Context, _: GuildId) {}
     #[cfg(feature = "cache")]
-    fn on_guild_update(&self, _: Context, _: Option<Arc<RwLock<Guild>>>, _: PartialGuild) {}
+    fn guild_update(&self, _: Context, _: Option<Arc<RwLock<Guild>>>, _: PartialGuild) {}
     #[cfg(not(feature = "cache"))]
-    fn on_guild_update(&self, _: Context, _: PartialGuild) {}
-    fn on_message(&self, _: Context, _: Message) {}
-    fn on_message_delete(&self, _: Context, _: ChannelId, _: MessageId) {}
-    fn on_message_delete_bulk(&self, _: Context, _: ChannelId, _: Vec<MessageId>) {}
-    fn on_reaction_add(&self, _: Context, _: Reaction) {}
-    fn on_reaction_remove(&self, _: Context, _: Reaction) {}
-    fn on_reaction_remove_all(&self, _: Context, _: ChannelId, _: MessageId) {}
-    fn on_message_update(&self, _: Context, _: MessageUpdateEvent) {}
-    fn on_presence_replace(&self, _: Context, _: Vec<Presence>) {}
-    fn on_presence_update(&self, _: Context, _: PresenceUpdateEvent) {}
-    fn on_ready(&self, _: Context, _: Ready) {}
-    fn on_resume(&self, _: Context, _: ResumedEvent) {}
-    fn on_typing_start(&self, _: Context, _: TypingStartEvent) {}
-    fn on_unknown(&self, _: Context, _: String, _: Value) {}
+    fn guild_update(&self, _: Context, _: PartialGuild) {}
+    fn message(&self, _: Context, _: Message) {}
+    fn message_delete(&self, _: Context, _: ChannelId, _: MessageId) {}
+    fn message_delete_bulk(&self, _: Context, _: ChannelId, _: Vec<MessageId>) {}
+    fn reaction_add(&self, _: Context, _: Reaction) {}
+    fn reaction_remove(&self, _: Context, _: Reaction) {}
+    fn reaction_remove_all(&self, _: Context, _: ChannelId, _: MessageId) {}
+    fn message_update(&self, _: Context, _: MessageUpdateEvent) {}
+    fn presence_replace(&self, _: Context, _: Vec<Presence>) {}
+    fn presence_update(&self, _: Context, _: PresenceUpdateEvent) {}
+    fn ready(&self, _: Context, _: Ready) {}
+    fn resume(&self, _: Context, _: ResumedEvent) {}
+    fn typing_start(&self, _: Context, _: TypingStartEvent) {}
+    fn unknown(&self, _: Context, _: String, _: Value) {}
     #[cfg(feature = "cache")]
-    fn on_user_update(&self, _: Context, _: CurrentUser, _: CurrentUser) {}
+    fn user_update(&self, _: Context, _: CurrentUser, _: CurrentUser) {}
     #[cfg(not(feature = "cache"))]
-    fn on_user_update(&self, _: Context, _: CurrentUser) {}
-    fn on_voice_server_update(&self, _: Context, _: VoiceServerUpdateEvent) {}
-    fn on_voice_state_update(&self, _: Context, _: Option<GuildId>, _: VoiceState) {}
-    fn on_webhook_update(&self, _: Context, _: GuildId, _: ChannelId) {}
+    fn user_update(&self, _: Context, _: CurrentUser) {}
+    fn voice_server_update(&self, _: Context, _: VoiceServerUpdateEvent) {}
+    fn voice_state_update(&self, _: Context, _: Option<GuildId>, _: VoiceState) {}
+    fn webhook_update(&self, _: Context, _: GuildId, _: ChannelId) {}
 }
diff --git a/src/gateway/shard.rs b/src/gateway/shard.rs
index a13dade..d7ffb59 100644
--- a/src/gateway/shard.rs
+++ b/src/gateway/shard.rs
@@ -610,7 +610,7 @@ impl Shard {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, ctx: Context, msg: Message) {
+    ///     fn message(&self, ctx: Context, msg: Message) {
     ///         if msg.content == "~ping" {
     ///             if let Some(latency) = ctx.shard.lock().latency() {
     ///                 let s = format!("{}.{}s", latency.as_secs(), latency.subsec_nanos());
diff --git a/src/model/channel/attachment.rs b/src/model/channel/attachment.rs
index eac513f..4d72f58 100644
--- a/src/model/channel/attachment.rs
+++ b/src/model/channel/attachment.rs
@@ -54,7 +54,7 @@ impl Attachment {
     ///
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, _: Context, message: Message) {
+    ///     fn message(&self, _: Context, message: Message) {
     ///         for attachment in message.attachments {
     ///             let content = match attachment.download() {
     ///                 Ok(content) => content,
@@ -86,7 +86,7 @@ impl Attachment {
     ///         }
     ///     }
     ///
-    ///     fn on_ready(&self, _: Context, ready: Ready) {
+    ///     fn ready(&self, _: Context, ready: Ready) {
     ///         println!("{} is connected!", ready.user.name);
     ///     }
     /// }
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index 90bb926..dacbfac 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -431,7 +431,7 @@ impl GuildChannel {
     /// use serenity::CACHE;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, _: Context, msg: Message) {
+    ///     fn message(&self, _: Context, msg: Message) {
     ///         let channel = match CACHE.read().guild_channel(msg.channel_id) {
     ///             Some(channel) => channel,
     ///             None => return,
@@ -459,7 +459,7 @@ impl GuildChannel {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, _: Context, msg: Message) {
+    ///     fn message(&self, _: Context, msg: Message) {
     ///         let channel = match CACHE.read().guild_channel(msg.channel_id) {
     ///             Some(channel) => channel,
     ///             None => return,
diff --git a/src/model/error.rs b/src/model/error.rs
index fa24272..a66095a 100644
--- a/src/model/error.rs
+++ b/src/model/error.rs
@@ -27,7 +27,7 @@ use super::Permissions;
 /// struct Handler;
 ///
 /// impl EventHandler for Handler {
-///     fn on_guild_ban_removal(&self, context: Context, guild_id: GuildId, user: User) {
+///     fn guild_ban_removal(&self, context: Context, guild_id: GuildId, user: User) {
 ///         // If the user has an even discriminator, don't re-ban them.
 ///         if user.discriminator % 2 == 0 {
 ///             return;
diff --git a/src/model/guild/mod.rs b/src/model/guild/mod.rs
index 90938d9..a90445a 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -1286,7 +1286,7 @@ impl Guild {
     /// use serenity::CACHE;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, _: Context, msg: Message) {
+    ///     fn message(&self, _: Context, msg: Message) {
     ///         if let Some(arc) = msg.guild_id().unwrap().find() {
     ///             if let Some(role) = arc.read().role_by_name("role_name") {
     ///                 println!("{:?}", role);
diff --git a/src/model/guild/partial_guild.rs b/src/model/guild/partial_guild.rs
index 6a8717d..bdfcbe0 100644
--- a/src/model/guild/partial_guild.rs
+++ b/src/model/guild/partial_guild.rs
@@ -456,7 +456,7 @@ impl PartialGuild {
     /// use serenity::CACHE;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, _: Context, msg: Message) {
+    ///     fn message(&self, _: Context, msg: Message) {
     ///         if let Some(role) =
     ///            msg.guild_id().unwrap().get().unwrap().role_by_name("role_name") {
     ///             println!("Obtained role's reference: {:?}", role);
diff --git a/src/model/user.rs b/src/model/user.rs
index d01eb88..0d8388d 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -414,7 +414,7 @@ impl User {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, _: Context, msg: Message) {
+    ///     fn message(&self, _: Context, msg: Message) {
     ///         if msg.content == "~help" {
     ///             let cache = CACHE.read();
     ///
@@ -610,7 +610,7 @@ impl User {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, _: Context, _: Message) {
+    ///     fn message(&self, _: Context, _: Message) {
     ///         // normal message handling here
     ///     }
     /// }
@@ -681,7 +681,7 @@ impl User {
     /// struct Handler;
     ///
     /// impl EventHandler for Handler {
-    ///     fn on_message(&self, _: Context, msg: Message) {
+    ///     fn message(&self, _: Context, msg: Message) {
     ///         if msg.content == "!mytag" {
     ///             let content = MessageBuilder::new()
     ///                 .push("Your tag is ")