Remove `on_` prefix to EventHandler tymethods

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

3 files changed, 113 insertions, 113 deletions

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) {}
 }