Slightly improve performance of builders

Builders would keep a `serde_json::Map<String, Value>`, which would
require re-creating owned strings for the same parameter multiple times
in some cases, depending on builder defaults and keying strategies.

This commit uses a `std::collections::HashMap<&'static str, Value>`
internally, and moves over values to a `serde_json::Map<String, Value>`
when it comes time to sending them to the appropriate `http` module
function.

This saves the number of heap-allocated string creations on most
builders, with specific performance increase on `builder::CreateMessage`
and `builder::CreateEmbed` & co.

10 files changed, 77 insertions, 62 deletions

diff --git a/src/model/channel/channel_category.rs b/src/model/channel/channel_category.rs
index f567cee..73c50a7 100644
--- a/src/model/channel/channel_category.rs
+++ b/src/model/channel/channel_category.rs
@@ -93,20 +93,14 @@ impl ChannelCategory {
             }
         }
 
-        let mut map = Map::new();
-        map.insert("name".to_string(), Value::String(self.name.clone()));
-        map.insert(
-            "position".to_string(),
-            Value::Number(Number::from(self.position)),
-        );
-        map.insert(
-            "type".to_string(),
-            Value::String(self.kind.name().to_string()),
-        );
+        let mut map = HashMap::new();
+        map.insert("name", Value::String(self.name.clone()));
+        map.insert("position", Value::Number(Number::from(self.position)));
+        map.insert("type", Value::String(self.kind.name().to_string()));
 
-        let edited = f(EditChannel(map)).0;
+        let map = serenity_utils::hashmap_to_json_map(f(EditChannel(map)).0);
 
-        http::edit_channel(self.id.0, &edited).map(|channel| {
+        http::edit_channel(self.id.0, &map).map(|channel| {
             let GuildChannel {
                 id,
                 category_id,
diff --git a/src/model/channel/channel_id.rs b/src/model/channel/channel_id.rs
index 4034fb9..3bed660 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -11,6 +11,8 @@ use builder::{CreateMessage, EditChannel, GetMessages};
 use CACHE;
 #[cfg(feature = "model")]
 use http::{self, AttachmentType};
+#[cfg(feature = "model")]
+use utils;
 
 #[cfg(feature = "model")]
 impl ChannelId {
@@ -185,7 +187,9 @@ impl ChannelId {
     /// [Manage Channel]: permissions/constant.MANAGE_CHANNELS.html
     #[inline]
     pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildChannel> {
-        http::edit_channel(self.0, &f(EditChannel::default()).0)
+        let map = utils::hashmap_to_json_map(f(EditChannel::default()).0);
+
+        http::edit_channel(self.0, &map)
     }
 
     /// Edits a [`Message`] in the channel given its Id.
@@ -209,9 +213,9 @@ impl ChannelId {
     /// [`the limit`]: ../builder/struct.CreateMessage.html#method.content
     pub fn edit_message<F, M>(&self, message_id: M, f: F) -> Result<Message>
         where F: FnOnce(CreateMessage) -> CreateMessage, M: Into<MessageId> {
-        let map = f(CreateMessage::default()).0;
+        let msg = f(CreateMessage::default());
 
-        if let Some(content) = map.get("content") {
+        if let Some(content) = msg.0.get("content") {
             if let Value::String(ref content) = *content {
                 if let Some(length_over) = Message::overflow_length(content) {
                     return Err(Error::Model(ModelError::MessageTooLong(length_over)));
@@ -219,6 +223,8 @@ impl ChannelId {
             }
         }
 
+        let map = utils::hashmap_to_json_map(msg.0);
+
         http::edit_message(self.0, message_id.into().0, &Value::Object(map))
     }
 
@@ -441,9 +447,9 @@ impl ChannelId {
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     pub fn send_files<'a, F, T, It: IntoIterator<Item=T>>(&self, files: It, f: F) -> Result<Message>
         where F: FnOnce(CreateMessage) -> CreateMessage, T: Into<AttachmentType<'a>> {
-        let mut map = f(CreateMessage::default()).0;
+        let mut msg = f(CreateMessage::default());
 
-        if let Some(content) = map.get("content") {
+        if let Some(content) = msg.0.get("content") {
             if let Value::String(ref content) = *content {
                 if let Some(length_over) = Message::overflow_length(content) {
                     return Err(Error::Model(ModelError::MessageTooLong(length_over)));
@@ -451,7 +457,8 @@ impl ChannelId {
             }
         }
 
-        let _ = map.remove("embed");
+        let _ = msg.0.remove("embed");
+        let map = utils::hashmap_to_json_map(msg.0);
 
         http::send_files(self.0, files, map)
     }
@@ -477,14 +484,15 @@ impl ChannelId {
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     pub fn send_message<F>(&self, f: F) -> Result<Message>
         where F: FnOnce(CreateMessage) -> CreateMessage {
-        let CreateMessage(map, reactions) = f(CreateMessage::default());
+        let msg = f(CreateMessage::default());
+        let map = utils::hashmap_to_json_map(msg.0);
 
         Message::check_content_length(&map)?;
         Message::check_embed_length(&map)?;
 
         let message = http::send_message(self.0, &Value::Object(map))?;
 
-        if let Some(reactions) = reactions {
+        if let Some(reactions) = msg.1 {
             for reaction in reactions {
                 self.create_reaction(message.id, reaction)?;
             }
diff --git a/src/model/channel/embed.rs b/src/model/channel/embed.rs
index 435f706..74c503d 100644
--- a/src/model/channel/embed.rs
+++ b/src/model/channel/embed.rs
@@ -4,6 +4,8 @@ use utils::Colour;
 use internal::prelude::*;
 #[cfg(feature = "model")]
 use builder::CreateEmbed;
+#[cfg(feature = "model")]
+use utils;
 
 /// Represents a rich embed which allows using richer markdown, multiple fields
 /// and more. This was heavily inspired by [slack's attachments].
@@ -89,7 +91,9 @@ impl Embed {
     #[inline]
     pub fn fake<F>(f: F) -> Value
         where F: FnOnce(CreateEmbed) -> CreateEmbed {
-        Value::Object(f(CreateEmbed::default()).0)
+        let map = utils::hashmap_to_json_map(f(CreateEmbed::default()).0);
+
+        Value::Object(map)
     }
 }
 
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index cc74b9d..90bb926 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -116,7 +116,9 @@ impl GuildChannel {
             }
         }
 
-        http::create_invite(self.id.0, &f(CreateInvite::default()).0)
+        let map = serenity_utils::hashmap_to_json_map(f(CreateInvite::default()).0);
+
+        http::create_invite(self.id.0, &map)
     }
 
     /// Creates a [permission overwrite][`PermissionOverwrite`] for either a
@@ -312,18 +314,12 @@ impl GuildChannel {
             }
         }
 
-        let mut map = Map::new();
-        map.insert("name".to_string(), Value::String(self.name.clone()));
-        map.insert(
-            "position".to_string(),
-            Value::Number(Number::from(self.position)),
-        );
-        map.insert(
-            "type".to_string(),
-            Value::String(self.kind.name().to_string()),
-        );
-
-        let edited = f(EditChannel(map)).0;
+        let mut map = HashMap::new();
+        map.insert("name", Value::String(self.name.clone()));
+        map.insert("position", Value::Number(Number::from(self.position)));
+        map.insert("type", Value::String(self.kind.name().to_string()));
+
+        let edited = serenity_utils::hashmap_to_json_map(f(EditChannel(map)).0);
 
         match http::edit_channel(self.id.0, &edited) {
             Ok(channel) => {
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 0e939b2..b5864fc 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -14,6 +14,8 @@ use constants;
 use CACHE;
 #[cfg(feature = "model")]
 use http;
+#[cfg(feature = "model")]
+use utils as serenity_utils;
 
 /// A representation of a message over a guild's text channel, a group, or a
 /// private channel.
@@ -230,7 +232,7 @@ impl Message {
             builder = builder.tts(true);
         }
 
-        let map = f(builder).0;
+        let map = serenity_utils::hashmap_to_json_map(f(builder).0);
 
         match http::edit_message(self.channel_id.0, self.id.0, &Value::Object(map)) {
             Ok(edited) => {
diff --git a/src/model/guild/guild_id.rs b/src/model/guild/guild_id.rs
index efda6a8..2771fc8 100644
--- a/src/model/guild/guild_id.rs
+++ b/src/model/guild/guild_id.rs
@@ -5,11 +5,11 @@ use CACHE;
 #[cfg(feature = "model")]
 use builder::{EditGuild, EditMember, EditRole};
 #[cfg(feature = "model")]
-use http;
-#[cfg(feature = "model")]
 use internal::prelude::*;
 #[cfg(feature = "model")]
 use model::guild::BanOptions;
+#[cfg(feature = "model")]
+use {http, utils};
 
 #[cfg(feature = "model")]
 impl GuildId {
@@ -168,7 +168,9 @@ impl GuildId {
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[inline]
     pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role> {
-        http::create_role(self.0, &f(EditRole::default()).0)
+        let map = utils::hashmap_to_json_map(f(EditRole::default()).0);
+
+        http::create_role(self.0, &map)
     }
 
     /// Deletes the current guild if the current account is the owner of the
@@ -229,7 +231,9 @@ impl GuildId {
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
     pub fn edit<F: FnOnce(EditGuild) -> EditGuild>(&mut self, f: F) -> Result<PartialGuild> {
-        http::edit_guild(self.0, &f(EditGuild::default()).0)
+        let map = utils::hashmap_to_json_map(f(EditGuild::default()).0);
+
+        http::edit_guild(self.0, &map)
     }
 
     /// Edits an [`Emoji`]'s name in the guild.
@@ -266,7 +270,9 @@ impl GuildId {
     #[inline]
     pub fn edit_member<F, U>(&self, user_id: U, f: F) -> Result<()>
         where F: FnOnce(EditMember) -> EditMember, U: Into<UserId> {
-        http::edit_member(self.0, user_id.into().0, &f(EditMember::default()).0)
+        let map = utils::hashmap_to_json_map(f(EditMember::default()).0);
+
+        http::edit_member(self.0, user_id.into().0, &map)
     }
 
     /// Edits the current user's nickname for the guild.
@@ -300,7 +306,9 @@ impl GuildId {
     #[inline]
     pub fn edit_role<F, R>(&self, role_id: R, f: F) -> Result<Role>
         where F: FnOnce(EditRole) -> EditRole, R: Into<RoleId> {
-        http::edit_role(self.0, role_id.into().0, &f(EditRole::default()).0)
+        let map = utils::hashmap_to_json_map(f(EditRole::default()).0);
+
+        http::edit_role(self.0, role_id.into().0, &map)
     }
 
     /// Search the cache for the guild.
diff --git a/src/model/guild/member.rs b/src/model/guild/member.rs
index 90dca58..7420faa 100644
--- a/src/model/guild/member.rs
+++ b/src/model/guild/member.rs
@@ -6,15 +6,13 @@ use model::*;
 #[cfg(feature = "model")]
 use std::borrow::Cow;
 #[cfg(all(feature = "cache", feature = "model"))]
-use CACHE;
-#[cfg(all(feature = "cache", feature = "model"))]
 use internal::prelude::*;
-#[cfg(all(feature = "cache", feature = "model"))]
-use http;
 #[cfg(all(feature = "builder", feature = "cache", feature = "model"))]
 use builder::EditMember;
 #[cfg(all(feature = "cache", feature = "model", feature = "utils"))]
 use utils::Colour;
+#[cfg(all(feature = "cache", feature = "model"))]
+use {CACHE, http, utils};
 
 pub trait BanOptions {
     fn dmd(&self) -> u8 { 0 }
@@ -109,7 +107,8 @@ impl Member {
     pub fn add_roles(&mut self, role_ids: &[RoleId]) -> Result<()> {
         self.roles.extend_from_slice(role_ids);
 
-        let map = EditMember::default().roles(&self.roles).0;
+        let builder = EditMember::default().roles(&self.roles);
+        let map = utils::hashmap_to_json_map(builder.0);
 
         match http::edit_member(self.guild_id.0, self.user.read().id.0, &map) {
             Ok(()) => Ok(()),
@@ -227,7 +226,7 @@ impl Member {
     /// [`EditMember`]: ../builder/struct.EditMember.html
     #[cfg(feature = "cache")]
     pub fn edit<F: FnOnce(EditMember) -> EditMember>(&self, f: F) -> Result<()> {
-        let map = f(EditMember::default()).0;
+        let map = utils::hashmap_to_json_map(f(EditMember::default()).0);
 
         http::edit_member(self.guild_id.0, self.user.read().id.0, &map)
     }
@@ -361,7 +360,8 @@ impl Member {
     pub fn remove_roles(&mut self, role_ids: &[RoleId]) -> Result<()> {
         self.roles.retain(|r| !role_ids.contains(r));
 
-        let map = EditMember::default().roles(&self.roles).0;
+        let builder = EditMember::default().roles(&self.roles);
+        let map = utils::hashmap_to_json_map(builder.0);
 
         match http::edit_member(self.guild_id.0, self.user.read().id.0, &map) {
             Ok(()) => Ok(()),
diff --git a/src/model/invite.rs b/src/model/invite.rs
index b4f326c..8ef848c 100644
--- a/src/model/invite.rs
+++ b/src/model/invite.rs
@@ -6,9 +6,9 @@ use super::{Permissions, utils as model_utils};
 #[cfg(feature = "model")]
 use builder::CreateInvite;
 #[cfg(feature = "model")]
-use http;
-#[cfg(feature = "model")]
 use internal::prelude::*;
+#[cfg(feature = "model")]
+use {http, utils};
 
 /// Information about an invite code.
 ///
@@ -73,7 +73,9 @@ impl Invite {
             }
         }
 
-        http::create_invite(channel_id.0, &f(CreateInvite::default()).0)
+        let map = utils::hashmap_to_json_map(f(CreateInvite::default()).0);
+
+        http::create_invite(channel_id.0, &map)
     }
 
     /// Deletes the invite.
diff --git a/src/model/user.rs b/src/model/user.rs
index bf5ee36..d01eb88 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -21,6 +21,8 @@ use builder::{CreateMessage, EditProfile};
 use CACHE;
 #[cfg(feature = "model")]
 use http::{self, GuildPagination};
+#[cfg(feature = "model")]
+use utils;
 
 /// Information about the current user.
 #[derive(Clone, Default, Debug, Deserialize)]
@@ -86,14 +88,16 @@ impl CurrentUser {
     /// ```
     pub fn edit<F>(&mut self, f: F) -> Result<()>
         where F: FnOnce(EditProfile) -> EditProfile {
-        let mut map = Map::new();
-        map.insert("username".to_string(), Value::String(self.name.clone()));
+        let mut map = HashMap::new();
+        map.insert("username", Value::String(self.name.clone()));
 
         if let Some(email) = self.email.as_ref() {
-            map.insert("email".to_string(), Value::String(email.clone()));
+            map.insert("email", Value::String(email.clone()));
         }
 
-        match http::edit_profile(&f(EditProfile(map)).0) {
+        let map = utils::hashmap_to_json_map(f(EditProfile(map)).0);
+
+        match http::edit_profile(&map) {
             Ok(new) => {
                 let _ = mem::replace(self, new);
 
diff --git a/src/model/webhook.rs b/src/model/webhook.rs
index c8ae1b0..e00d018 100644
--- a/src/model/webhook.rs
+++ b/src/model/webhook.rs
@@ -7,7 +7,7 @@ use builder::ExecuteWebhook;
 #[cfg(feature = "model")]
 use internal::prelude::*;
 #[cfg(feature = "model")]
-use http;
+use {http, utils};
 
 /// A representation of a webhook, which is a low-effort way to post messages to
 /// channels. They do not necessarily require a bot user or authentication to
@@ -183,12 +183,9 @@ impl Webhook {
                                                                 wait: bool,
                                                                 f: F)
                                                                 -> Result<Option<Message>> {
-        http::execute_webhook(
-            self.id.0,
-            &self.token,
-            wait,
-            &f(ExecuteWebhook::default()).0,
-        )
+        let map = utils::hashmap_to_json_map(f(ExecuteWebhook::default()).0);
+
+        http::execute_webhook(self.id.0, &self.token, wait, &map)
     }
 
     /// Retrieves the latest information about the webhook, editing the