Rust tips @rust@octodon.social

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

#Rust constants create a new temporary value every time you mention them.

You can do with whatever you want with the temporary value from a constant, even mutate it. But it only affects each temporary copy, not the constant.

```
use std::cell::Cell;

const C: Cell<bool> = Cell::new(false);

fn main() {
C.set(true);
assert_eq!(false, C.get());
}
```

If your project depends on a Nightly version of the #Rust compiler, you can create `rust-toolchain` file with the required version. It will make Cargo automatically switch to the right compiler for the build.

https://rust-lang.github.io/rustup/overrides.html#the-toolchain-file

If you're defining an alias for your crate's Result type, instead of:

type Result<T> = std::result::Result<T, MyError>;

use:

type Result<T, E = MyError> = std::result::Result<T, E>;

This still works as `Result<()>`, but doesn't cause errors when someone accidentally shadows std's Result with it. It also makes Rustdoc display the error type explicitly in the documentation.

#rustlang

If you want to create an async stream, the easy solution is a generator macro:

https://lib.rs/async-stream

It lets you write the stream as a loop with `yield` instead of implementing traits and managing state manually.

#rustlang

Does your #rust crate have optional features? Are you sure all combinations of the feature flags work correctly? You can verify this with this cargo plugin: https://lib.rs/cargo-all-features

In #Rust you can cast concrete type to an abstract trait object (e.g. `&i32` as `&dyn Debug`), but you can't (yet) cast a trait object as another trait (e.g. `dyn Error` can't be cast as `dyn Debug`).

The workaround is to add a method to the trait that asks for a different dyn type (e.g. `as_debug(&self) -> &dyn Debug`). That allows trait implementers to cast their concrete type.

This workaround can be automated: https://stackoverflow.com/a/28664881/27009

async {} block in #Rustlang behaves like a closure. It does _not_ run any code automatically. It only creates an inactive object, which has to be spawned or awaited to start doing anything.

Example of incorrect usage:

fn main() {
async {
println!("closure");
return;
};
println!("surprise");
}

It prints "surprise", and nothing else!

Dropping of a #Rust #Future stops its execution. There's also a higher-level wrapper that makes Futures cancellable on demand:

https://docs.rs/futures/0.3.4/futures/future/struct.Abortable.html

You can limit number of asynchronous tasks running at once (e.g. number of requests to a back-end) with a Semaphore

https://docs.rs/tokio/0.2.11/tokio/sync/struct.Semaphore.html

#rustlang

The latest version of #rustlang started warning about missing `dyn` keywords. You don't have to add them by hand! Run:

cargo fix --edition-idioms

and it'll automatically add all the missing bits of the syntax.

How to convert an Option/Result/Iterator into another kind of Option/Result/Iterator? Here's a tool that lists all the options:

https://jethrogb.github.io/rust-combinators/

A dozen of optimization tips for #Rust:

https://gist.github.com/jFransham/369a86eff00e5f280ed25121454acec1