proposed async io for hyper

pipe.rs

fn handle(req: Request, res: Response) {
  // assuming `POST /echo`
  req.pipe(res).on_error(|err| error!("pipe error: {}", err));
}

read.rs

fn handle(req: Request, _res: Response) {
  req.read(move |result| {
    Ok((data, req)) => {
      println!("read: {}", from_utf8(data));
      // not necessarily eof yet
    },
    Err(e) => {
      println!("req read error: {}", e);
    }
  });
}

read_and_write.rs

fn handle(req: Request, res: Response) {
  let mut buf = vec![];
  req.stream(move |result| {
    Ok(Some(bytes)) => buf.extend(bytes),
    Ok(None) => {
      res.write_all(buf, |result| if let Err(e) = result {
        println!("write_all err: {}", e); 
      });
    },
    Err(e) => println!("stream err: {}", e)
  });
}

stream.rs

fn handle(req: Request, res: Response) {
  req.stream(move |result| {
    match result {
      Ok(Some(bytes)) => println!("read: {}", from_utf8(bytes).unwrap_or("")),
      Ok(None) => println!("eof"),
      Err(e) => println!("read error: {}", e)
    }
  })
}

write.rs

fn handle(req: Request, res: Response) {
  res.write(move |transport| {
    use std::io::Write;
    try!(transport.write("Hello World"));
  });
}

write_all.rs

fn handle(req: Request, res: Response) {
  res.write_all("Hello World!", |result| {
    match result {
      Ok(response) => println!("write_all completed"),
      Err(e) => println!("write_all error: {}", e)
    }
  });
}