I have no idea if this is actually idiomatic Rust, but I tried to keep it as close as possible to the spirit of the Rust book as I could.

Lines 15-22, you could just let stream = connection.unwrap(), it does essentially what you do explicitly (panic on Err).

I’m guessing that this is because the stream we got is the result of the iteration, and we already took ownership on that value?

Pretty much. handle_client takes a TcpStream by value, and Incoming yields "owned" TcpStream, so the TcpStream object is straight moved into the closure.

If handle_client took an &mut TcpStream instead (which it can), the closure would would only capture a reference and rustc would complain that the reference could outlive the referenced value. This could be fixed by creating a move closure (just add the move keyword before the parameters list) which would capture the context by value and thus move the TcpStream back into the closure.

As I understand it, it might be done with composing this, but I tried using and_then, or_else, map and map_error and wasn’t really able to come up with something that would actually work.

This case isn't really great for error-chaining as you don't really care about the errors themselves but want to convert a "success case" into an error. It would probably be simpler if handle_client returned a Result and the closure eventually handled that, then handle_client could become this:

```rust fn handle_client(mut stream: TcpStream) -> io::Result<()> { let mut buffer = [0; 16]; try!(stream.write("Hello from Rust".as_bytes()));

loop {
    let read = try!(stream.read(&mut buffer));
    if read == 0 {
        return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "End of stream"));
    }
    try!(stream.write(&buffer[0..read]));
}

} ~~~

Damn sorry about the previous comment ending abruptly, I tried previewing and hit "post comment" instead, here's the missing bit:

If you wanted to use chaining you'd have to generate a "fake" error on read = 0 (as above) or convert the "Err" case to some universal value (e.g. ()) or — the simplest — convert your Results to Options since it's basically just a flag to end iteration:

loop {
    if stream.read(&mut buffer).ok().and_then(|read| {
        if read != 0 {
            Some(read)
        } else {
            None
        }
    }).and_then(|read| {
        stream.write(&buffer[0..read]).ok()
    }).is_none() { break; }
}

I've been following your blog for a while now, and I enjoy it. Are you going to be blog about rust a lot now? If so I will probably have to learn a new language to keep up :)

for async I/O, tokio on top of mio crates would definitely be the libraries recommended for what you're targeting. Nice to see more and more people diving into rust.

Hi, nice post about Rust.

Regarding your uncertainty about your code being idiomatic Rust or not, you could simply transform the loop statement and the contained blocks into a nice while-let loop:

while let Ok(read) = stream.read(&mut buffer) {
    if read == 0 {
        break;
    }
    if let Err(_) = stream.write(&buffer[0..read]) {
        break;
    }
}