Rust

Resources

• http://xion.io/post/code/rust-iter-patterns.html
• https://deterministic.space/rust-cli-tips.htm
• https://manishearth.github.io/blog/2018/01/10/whats-tokio-and-async-io-all-about/
• https://saghm.github.io/five-rust-things/

Optimization: use RUSTFLAGS="-C target-cpu=native" to take advantage of CPU special features.

(via http://vfoley.xyz/rust-compilation-tip/)

For local rust/std documentation, do rustup doc.

Little tricks

Run tests with stdout output:

cargo test -- --nocapture

To run tests with logging enabled (eg, with env_logger), make sure you add env_logger::init() to the test function itself.

map() and Result Ergonomics

.collect() has some magical features! In addition to turning an iterator of Item into Vec<Item>, it will turn an iterator of Result<Item> into Result<Vec<Item>>. This makes it really useful for the end of functions.

This is particularly useful for resolving some categories of “error handling in map closures”: you can use ? in the map closure as long as you wrap the happy path with Ok() and call collect on the outside. Eg:

let list: Vec<Item> = junk
    .iter()
    .map(|thing| Ok(Item {
        a: thing.a,
        b: fixup(thing.widget)?,
    }))
    .collect::Result<Vec<Item>>()?;

What about when map over an Option? Eg:

let toy = Shiny {
    a: 123,
    b: component.map(|v| paint(v).expect("paint to succeed"),
};

Should use match in this case:

let toy = Shiny {
    a: 123,
    b: match component {
        None => None,
        Some(v) => Some(paint(v)?),
    },
};