Rust tips @rust@octodon.social

This is the permalink for the full archive of #Rust tips: https://octodon.social/@rust

If you're looking for good #Rustlang crates, use https://lib.rs to search. It has much better ranking algorithm than crates.io.

Compare:

https://crates.io/search?q=option
vs
https://lib.rs/search?q=option

Rustdoc documentation supports embedding external files using include_str!(), like other #Rust expressions.

If you want to reuse your README file for your library's documentation on docs.rs, put this at the top of the src/lib.rs:

#![doc = include_str!("README.md")]

To find unused #rustlang dependencies, compile your program with:

cargo rustc -- -W unused_crate_dependencies

A new #Rust release is next week: https://www.whatrustisit.com

You can see changelogs from the future:
https://releases.rs

In #Rust you can return std::process::ExitCode from main().

It's better than calling std::process::exit(), because it allows the program to run destructors, which may be needed to flush pending I/O or print buffered logs.

https://play.rust-lang.org/?gist=56c6ffb9d0b1206502ca996244bd0242

https://doc.rust-lang.org/stable/std/process/struct.ExitCode.html

The latest #Rust nightly version has an option to build or install crates without downloading the full crates-io index. This can be a big speed boost for Dockerized builds and Continious Integration that doesn't cache .cargo directory.

Try it out:

https://internals.rust-lang.org/t/call-for-testing-cargo-sparse-registry/16862

You can easily pass ownership of #Rustlang objects to C. There's no need to use `Box::into_raw()` or any unsafe trickery. Box is FFI-safe, and can be used as a return type directly:

https://stackoverflow.com/a/46677043/27009

Did you know crates.io has added new categories? Make your #Rustlang crate easier to find. Add categories to your Cargo.toml:

categories = ["insert category slugs here"]

https://crates.io/category_slugs

Compare the uncomparable! #Rust enum variants can be compared with `==` only if they implement the `PartialEq` trait, but that isn't always available or convenient for enums with complex data.
However, the `match` expression always works, and there's a handy `matches!()` macro for one-off comparisons.

if value == SomeEnum::Variant(data) { /* maybe */ }
if matches!(value, SomeEnum::Variant(_)) { /* ok */ }

More examples:
https://play.rust-lang.org/?gist=359076b8145247b6d6b0295b46794a8a

If you're developing #Mac or #iOS applications, you can add #Rust dependencies to your projects using https://lib.rs/cargo-xcode

cargo clippy --fix

will automatically apply code improvement suggestions from Clippy. Not every issue can be automatically corrected, so it's still worth running `cargo clippy` afterwards.

Common Rust Lifetime Misconceptions — very helpful resource that helps avoid fighting the borrow checker:

https://github.com/pretzelhammer/rust-blog/blob/master/posts/common-rust-lifetime-misconceptions.md

You can convert a slice (or a `Vec`) to a fixed-length array using the `TryInto` trait:

let arr: [_; 4] = slice[..4].try_into().unwrap();

It's a bit verbose, but the `.try_into().unwrap()` part will be optimized out entirely whenever the compiler can see the slice is long enough.

https://rust.godbolt.org/z/GGTnr1Pqz #rustlang

"Unfortunately" this doesn't generalize to all attributes, so you can't have a cursed syntax like that:

struct Lol {
#![derive(Copy, Clone, Debug)]
}

fn nope() {
#![test]
}

#Rust has meta attributes that can apply to entire modules, like #[cfg(…)], #[allow(…)] and #[deny(…)].

The #[…] attribute syntax used outside of a module is equivalent to #![…] syntax inside it:

#[cfg(windows)]
mod win {
}

mod win {
#![cfg(windows)]
}

You have to use #![…] attribute syntax at the top of the lib.rs file, because there's no outer file that has the `mod` declaration for lib.rs.

The `.get()` method on a `Vec` or `HashMap` will only temporarily borrow an item, and you won't be allowed to move it or use it outside of the scope of the `.get()` call.

If you want to get an _owned_, freely movable value, use `.remove()` instead.

If you need to have an owned value without removing elements from the collection, you're going to have to clone. Clone can be fast if items are wrapped in `Rc` or `Arc`.

https://play.rust-lang.org/?gist=a7ccfd499aaafc4a3cb35d6e4dd16e03 #rustlang

Do you want io::Read::read_exact(), but read into a Vec instead?

let bytes_read = reader
.by_ref() // optional: avoids consuming the reader
.take(length_to_read) // limits number of bytes
.read_to_end(&mut vec)?; // reads up to the limit
// the file could have ended sooner, so needs a check
if bytes_read != length_to_read { return Err("EOF") }

https://play.rust-lang.org/?gist=05ac9c2145aa61b3442359921dd0607d

A few design patterns/idioms that you need to change if you're switching from #cpp to #rust:

https://cppfaq.rs