hyperium · Twey · May 4, 2017
diff --git a/benches/end_to_end.rs b/benches/end_to_end.rs
@@ -33,7 +33,7 @@ fn get_one_at_a_time(b: &mut test::Bencher) {
     b.bytes = 160 * 2 + PHRASE.len() as u64;
     b.iter(move || {
         let work = client.get(url.clone()).and_then(|res| {
-            res.body().for_each(|_chunk| {
+            res.into_body().unwrap_or_default().for_each(|_chunk| {
                 Ok(())
             })
         });
@@ -61,7 +61,7 @@ fn post_one_at_a_time(b: &mut test::Bencher) {
         req.set_body(post);
 
         let work = client.request(req).and_then(|res| {
-            res.body().for_each(|_chunk| {
+            res.into_body().unwrap_or_default().for_each(|_chunk| {
                 Ok(())
             })
         });
@@ -85,7 +85,7 @@ impl Service for Hello {
             server::Response::new()
                 .with_header(ContentLength(PHRASE.len() as u64))
                 .with_header(ContentType::plaintext())
-                .with_body(PHRASE)
+                .with_body(Some(PHRASE.into()))
         )
     }
 

diff --git a/examples/client.rs b/examples/client.rs
@@ -38,7 +38,7 @@ fn main() {
         println!("Response: {}", res.status());
         println!("Headers: \n{}", res.headers());
 
-        res.body().for_each(|chunk| {
+        res.into_body().unwrap_or_default().for_each(|chunk| {
             io::stdout().write_all(&chunk).map_err(From::from)
         })
     }).map(|_| {

diff --git a/examples/hello.rs b/examples/hello.rs
@@ -24,7 +24,7 @@ impl Service for Hello {
             Response::new()
                 .with_header(ContentLength(PHRASE.len() as u64))
                 .with_header(ContentType::plaintext())
-                .with_body(PHRASE)
+                .with_body(Some(PHRASE.into()))
         )
     }
 

diff --git a/examples/server.rs b/examples/server.rs
@@ -25,14 +25,14 @@ impl Service for Echo {
             (&Get, "/") | (&Get, "/echo") => {
                 Response::new()
                     .with_header(ContentLength(INDEX.len() as u64))
-                    .with_body(INDEX)
+                    .with_body(Some(INDEX.into()))
             },
             (&Post, "/echo") => {
                 let mut res = Response::new();
                 if let Some(len) = req.headers().get::<ContentLength>() {
                     res.headers_mut().set(len.clone());
                 }
-                res.with_body(req.body())
+                res.with_body(Some(req.body()))
             },
             _ => {
                 Response::new()

diff --git a/src/http/request.rs b/src/http/request.rs
@@ -8,6 +8,7 @@ use version::HttpVersion;
 use std::net::SocketAddr;
 
 /// A client request to a remote server.
+#[derive(Clone)]
 pub struct Request<B = Body> {
     method: Method,
     uri: Uri,

diff --git a/src/http/response.rs b/src/http/response.rs
@@ -6,20 +6,29 @@ use status::StatusCode;
 use version::HttpVersion;
 
 /// A response for a client request to a remote server.
-pub struct Response<B = Body> {
+#[derive(Clone)]
+pub struct Response<B = Option<Body>> {
     version: HttpVersion,
     headers: Headers,
     status: StatusCode,
     raw_status: RawStatus,
-    body: Option<B>,
+    body: B,
 }
 
-impl<B> Response<B> {
+impl Response {
     /// Constructs a default response
     #[inline]
-    pub fn new() -> Response<B> {
+    pub fn new() -> Response {
         Response::default()
     }
+}
+
+impl<B> Response<B> {
+    /// Constructs a default response with a given body
+    #[inline]
+    pub fn new_with_body(body: B) -> Response<B> {
+        Response::<()>::default().with_body(body)
+    }
 
     /// Get the HTTP version of this response.
     #[inline]
@@ -80,40 +89,77 @@ impl<B> Response<B> {
     /// Set the body.
     #[inline]
     pub fn set_body<T: Into<B>>(&mut self, body: T) {
-        self.body = Some(body.into());
+        self.body = body.into();
     }
 
     /// Set the body and move the Response.
     ///
     /// Useful for the "builder-style" pattern.
     #[inline]
-    pub fn with_body<T: Into<B>>(mut self, body: T) -> Self {
-        self.set_body(body);
-        self
+    pub fn with_body<B_>(self, body: B_) -> Response<B_> {
+        let Response {
+            version: version_,
+            headers: headers_,
+            status: status_,
+            raw_status: raw_status_,
+            ..
+        } = self;
+
+        Response {
+            version: version_,
+            headers: headers_,
+            status: status_,
+            raw_status: raw_status_,
+            body: body,
+        }
+    }
+
+    /// Get a reference to the body.
+    pub fn body(&self) -> &B { &self.body }
+
+    /// Get a mutable reference to the body.
+    pub fn body_mut(&mut self) -> &mut B { &mut self.body }
+
+    /// Take the body, moving it out of the Response.
+    #[inline]
+    pub fn take_body(self) -> (B, Response<()>) {
+        let Response {
+            version: version_,
+            headers: headers_,
+            status: status_,
+            raw_status: raw_status_,
+            body: body_,
+        } = self;
+
+        (body_, Response {
+            version: version_,
+            headers: headers_,
+            status: status_,
+            raw_status: raw_status_,
+            body: (),
+        })
     }
-}
 
-impl Response<Body> {
-    /// Take the `Body` of this response.
+    /// Take the body of this response.
     #[inline]
-    pub fn body(self) -> Body {
-        self.body.unwrap_or_default()
+    pub fn into_body(self) -> B {
+        self.body
     }
 }
 
-impl<B> Default for Response<B> {
+impl<B: Default> Default for Response<B> {
     fn default() -> Response<B> {
         Response::<B> {
             version: Default::default(),
             headers: Default::default(),
             status: Default::default(),
             raw_status: Default::default(),
-            body: None,
+            body: Default::default(),
         }
     }
 }
 
-impl fmt::Debug for Response {
+impl<B> fmt::Debug for Response<B> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("Response")
             .field("status", &self.status)
@@ -125,13 +171,14 @@ impl fmt::Debug for Response {
 
 /// Constructs a response using a received ResponseHead and optional body
 #[inline]
-pub fn from_wire<B>(incoming: ResponseHead, body: Option<B>) -> Response<B> {
+pub fn from_wire<B: Default>(incoming: ResponseHead, body: Option<B>)
+                             -> Response<Option<B>> {
     let status = incoming.status();
     trace!("Response::new");
     debug!("version={:?}, status={:?}", incoming.version, status);
     debug!("headers={:?}", incoming.headers);
 
-    Response::<B> {
+    Response {
         status: status,
         version: incoming.version,
         headers: incoming.headers,
@@ -142,7 +189,7 @@ pub fn from_wire<B>(incoming: ResponseHead, body: Option<B>) -> Response<B> {
 
 /// Splits this response into a MessageHead<StatusCode> and its body
 #[inline]
-pub fn split<B>(res: Response<B>) -> (MessageHead<StatusCode>, Option<B>) {
+pub fn split<B>(res: Response<B>) -> (MessageHead<StatusCode>, B) {
     let head = MessageHead::<StatusCode> {
         version: res.version,
         headers: res.headers,

diff --git a/src/lib.rs b/src/lib.rs
diff --git a/src/server/mod.rs b/src/server/mod.rs
@@ -86,7 +86,7 @@ impl<B: AsRef<[u8]> + 'static> Http<B> {
     /// The returned `Server` contains one method, `run`, which is used to
     /// actually run the server.
     pub fn bind<S, Bd>(&self, addr: &SocketAddr, new_service: S) -> ::Result<Server<S, Bd>>
-        where S: NewService<Request = Request, Response = Response<Bd>, Error = ::Error> +
+        where S: NewService<Request = Request, Response = Response<Option<Bd>>, Error = ::Error> +
                     Send + Sync + 'static,
               Bd: Stream<Item=B, Error=::Error>,
     {
@@ -122,7 +122,7 @@ impl<B: AsRef<[u8]> + 'static> Http<B> {
                                  io: I,
                                  remote_addr: SocketAddr,
                                  service: S)
-        where S: Service<Request = Request, Response = Response<Bd>, Error = ::Error> + 'static,
+        where S: Service<Request = Request, Response = Response<Option<Bd>>, Error = ::Error> + 'static,
               Bd: Stream<Item=B, Error=::Error> + 'static,
               I: AsyncRead + AsyncWrite + 'static,
     {
@@ -287,11 +287,11 @@ impl From<Message<__ProtoRequest, http::TokioBody>> for Request {
     }
 }
 
-impl<B> Into<Message<__ProtoResponse, B>> for Response<B> {
-    fn into(self) -> Message<__ProtoResponse, B> {
+impl<B_, B: Into<Option<B_>>> Into<Message<__ProtoResponse, B_>> for Response<B> {
+    fn into(self) -> Message<__ProtoResponse, B_> {
         let (head, body) = response::split(self);
-        if let Some(body) = body {
-            Message::WithBody(__ProtoResponse(head), body.into())
+        if let Some(body) = body.into() {
+            Message::WithBody(__ProtoResponse(head), body)
         } else {
             Message::WithoutBody(__ProtoResponse(head))
         }
@@ -306,14 +306,14 @@ struct HttpService<T> {
 type ResponseHead = http::MessageHead<::StatusCode>;
 
 impl<T, B> Service for HttpService<T>
-    where T: Service<Request=Request, Response=Response<B>, Error=::Error>,
+    where T: Service<Request=Request, Response=Response<Option<B>>, Error=::Error>,
           B: Stream<Error=::Error>,
           B::Item: AsRef<[u8]>,
 {
     type Request = Message<__ProtoRequest, http::TokioBody>;
     type Response = Message<__ProtoResponse, B>;
     type Error = ::Error;
-    type Future = Map<T::Future, fn(Response<B>) -> Message<__ProtoResponse, B>>;
+    type Future = Map<T::Future, fn(Response<Option<B>>) -> Message<__ProtoResponse, B>>;
 
     fn call(&self, message: Self::Request) -> Self::Future {
         let (head, body) = match message {
@@ -326,7 +326,7 @@ impl<T, B> Service for HttpService<T>
 }
 
 impl<S, B> Server<S, B>
-    where S: NewService<Request = Request, Response = Response<B>, Error = ::Error>
+    where S: NewService<Request = Request, Response = Response<Option<B>>, Error = ::Error>
                 + Send + Sync + 'static,
           B: Stream<Error=::Error> + 'static,
           B::Item: AsRef<[u8]>,

diff --git a/tests/server.rs b/tests/server.rs
@@ -128,7 +128,7 @@ impl Service for TestService {
                         *res.headers_mut() = headers;
                     },
                     Reply::Body(body) => {
-                        res.set_body(body);
+                        res.set_body(Some(body.into()));
                     },
                 }
             }