Add a map to Request and Response (#151)

For ease of use, it's nice to be able to map using a closure from
one type to another. This adds that ability to both the
`Request` and `Response` objects.

src/request.rs

@@ -638,6 +638,27 @@ impl<T> Request<T> {
     pub fn into_parts(self) -> (Parts, T) {
         (self.head, self.body)
     }
+
+    /// Consumes the request returning a new request with body mapped to the
+    /// return type of the passed in function.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::*;
+    /// let request = Request::builder().body("some string").unwrap();
+    /// let mapped_request: Request<&[u8]> = request.map(|b| {
+    ///   assert_eq!(b, "some string");
+    ///   b.as_bytes()
+    /// });
+    /// assert_eq!(mapped_request.body(), &"some string".as_bytes());
+    /// ```
+    #[inline]
+    pub fn map<F, U>(self, f: F) -> Request<U>
+        where F: FnOnce(T) -> U
+    {
+        Request { body: f(self.body), head: self.head }
+    }
 }
 
 impl<T: Default> Default for Request<T> {
@@ -906,3 +927,18 @@ impl Default for Builder {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_can_map_a_body_from_one_type_to_another() {
+        let request= Request::builder().body("some string").unwrap();
+        let mapped_request = request.map(|s| {
+            assert_eq!(s, "some string");
+            123u32
+        });
+        assert_eq!(mapped_request.body(), &123u32);
+    }
+}

src/response.rs

@@ -439,6 +439,27 @@ impl<T> Response<T> {
     pub fn into_parts(self) -> (Parts, T) {
         (self.head, self.body)
     }
+
+    /// Consumes the response returning a new response with body mapped to the
+    /// return type of the passed in function.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::*;
+    /// let response = Response::builder().body("some string").unwrap();
+    /// let mapped_response: Response<&[u8]> = response.map(|b| {
+    ///   assert_eq!(b, "some string");
+    ///   b.as_bytes()
+    /// });
+    /// assert_eq!(mapped_response.body(), &"some string".as_bytes());
+    /// ```
+    #[inline]
+    pub fn map<F, U>(self, f: F) -> Response<U>
+        where F: FnOnce(T) -> U
+    {
+        Response { body: f(self.body), head: self.head }
+    }
 }
 
 impl<T: Default> Default for Response<T> {
@@ -676,3 +697,18 @@ impl Default for Builder {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_can_map_a_body_from_one_type_to_another() {
+        let response = Response::builder().body("some string").unwrap();
+        let mapped_response = response.map(|s| {
+            assert_eq!(s, "some string");
+            123u32
+        });
+        assert_eq!(mapped_response.body(), &123u32);
+    }
+}