Rust tips @rust@octodon.social
Rust tips
boosted
When you create a #Rustlang function expecting an optional reference, use `Option<&Foo>` rather than `&Option<Foo>`.
fn optional(good: Option<&Foo>, bad: &Option<Foo>) {…}
Both optimize to the same representation, but `Option<&Foo>` is easier to work with, and is more universal, because it can be cheaply created from an owned option with `.as_ref()`.
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
Rust tips
boosted
How to write fast Rust code, http://likebike.com/posts/How_To_Write_Fast_Rust_Code.html.
A collection of tips and tricks to improve Rust code performance.
Rust tips
boosted
Rust tips
boosted
"What will Rust development look like in 2020? That's partially up to you!"
#Rust folks are calling for blog posts
"We are accepting ideas about almost anything having to do with Rust: language features, tooling needs, community programs, ecosystem needs... if it's related to Rust, we want to hear about it."
https://blog.rust-lang.org/2019/10/29/A-call-for-blogs-2020.html
Rust tips
boosted
Since people may not have heard of it, here's a non threaded PSA post: add `--document-private-items` to `cargo doc` to get a nice reference for your own #rust code.
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:
A dozen of optimization tips for #Rust:
https://gist.github.com/jFransham/369a86eff00e5f280ed25121454acec1
Unsafe code in #Rust still has to uphold language's safety properties. Some things are really hard to get right. Here's a mini guide of unsafe gotchas:
https://github.com/exphp-share/unsafe-gotchas/blob/master/src/SUMMARY.md
You can print numbers and strings padded to a fixed number of characters, e.g.:
println!("{:>5}", num);
Prints a number, right-aligned, padded to 5 characters. {:<5} left-aligns, {:^5} centers.
Multiple #rustlang tips here: https://github.com/spacejam/elements-of-rust
e.g. instead of nesting match statements:
match a {
Some(a) => {
match b {
…
you can match multiple values at the same time:
match (a, b) {
(Some(a), Some(b)) => …
You can extend Cargo's functionality by installing new subcommands:
https://crates.rs/development-tools/cargo-plugins
e.g. cargo install cargo-edit
Show installed ones with cargo --list
Rust tips
boosted
--------#rust----------
rust macro println!("...") is based on the rust macro format!("...").
Print version prints on the stdio whereas the format will print on a std::String.
rust println/format macros also allow convenient formatting in binary and hexadecimal.
println!("0x{:04X}", 1000); will print 0x03E8 and
println!("b'{:08b}'", 2); will print b'00000010' as an example.
-----------------------
Please reply to report error rust:1008
Shared references in #Rust don't have to be immutable. Interior mutability allows safely "cheating" the type system.
There are a few wrapper types for this, because each has a single-threaded and a multi-threaded version:
Rc → Arc
RefCell → Mutex
Cell<usize> → AtomicUsize
https://manishearth.github.io/blog/2015/05/27/wrapper-types-in-rust-choosing-your-guarantees/
Rust tips
boosted
When Rust doesn't allow you to unwrap an `Option`, use `.as_ref()`.
Unwrapping `&Option<Foo>` causes "cannot move out of borrowed content" error, because it assumes you want to take ownership of `Foo`, and that's not allowed through a reference.
`option.as_ref()` flips it inside-out to become `Option<&Foo>`, and `unwrap()` will get a reference rather than ownership, which is fine.
Try it: https://is.gd/3lPJqk
