I guess it depends where you come from, coming from C Rust feels very elegant. I miss Option a lot when I go back to writing C, for instance.

Maybe if you write your code first and then modify it to get through the borrow checker it just means you're not yet familiar enough with the language's pattern (and given how young and unstable it is at the moment, I doubt anybody can pretend to know idiomatic rust at that point). Maybe if you took ownership constraints while designing your application you would end up with more elegant code? It definitely adds a cognitive load though, that's for sure.

As for the "match", "is_ok" and "unwrap" noise, it used to be a problem in my code as well but since refutable lets have been added to the language it's not really a problem anymore. For instance in my code I used to have:

    match map::in_range(addr, map::ZERO_PAGE) {
        Some(off) => {
            // Do stuff with off
        }
        _        => (),
    }

Or:

    let off = map::in_range(addr, map::ZERO_PAGE);

    if off.is_some() {
        let off = off.unwrap();
        // Do stuff with off
    }

None of which is elegant or nice looking. With refutable lets I can write that:

    if let Some(off) = map::in_range(addr, map::ZERO_PAGE) {
        // Do stuff with off
    }

For is_ok I use the try! macro which is admittedly a bit hackish but works well in practice. In the end I never use unwrap()/is_ok() outside of test code where I don't want to do proper error handling and let the runtime panic if something goes wrong.