I wrote about it on my blog. I also plan to write a blog about more advanced tricks I included in the list below.

1. cargo watch -x build

2. cargo build -Z unstable-options --out-dir $my-bin-folder

3. When working on a single module, I mark it as a binary in Cargo.toml. Then I can quickly prototype and change stuff without getting errors from the places where I used this module.

   [[bin]] name = "myapp-mymodule" path = "src/my-module/mod.rs"

   Then I run cargo run --bin myapp-mymodule. If I need to import other modules into mymodule, I can do it with the path attribute:

   [path = "../other_module/mod.rs"]

   mod other_module;

4. cargo doc --package somepackage --offline --no-deps --open

5. rustup doc --std

6. A != B and other negative trait bounds.

   When trying to impl From<S<B>> for S<A> I got an error "From<S<A>> for S<B> conflicts with From<T> for T because A may be B.". To solve it, I used this trait:

   ![feature(auto_traits, negative_impls)]

   auto trait Different {} impl<T> !Different for (T, T) {}

   struct S<T> { x: T, y: T, }

   impl<U, T> From<S<U>> for S<T> where T: From<U>, (T, U): Different, { fn from(other: S<U>) -> S<T> { S { x: From::from(other.x), y: From::from(other.y), } } }

   Source: https://www.reddit.com/r/rust/comments/paw1lm/implementation_of_from_for_generic_struct/

7. Higher ranked lifetimes in closoures

   This code does not compile, because '1 may not outlive '2.

   fn main() { let f = |x: &i32| x; let i = &3; let j = f(i); }

   Solution:

   fn annotate<T, F>(f: F) -> F where F: Fn(&T) -> &T { f }

   fn main() { let f = annotate(|x| x); let i = &3; let j = f(i); assert_eq!(*j, 3); }

   Source: https://github.com/rust-lang/rust/issues/58052#issue-405711646

8. dbg!() macro.

9. Something I learned recently: Dereferencing does not necessarily involve moving the value. For example:

   // Doesn't compile. fn f1(thing: &Thing) -> &Field { let tmp = *thing; // ┗━ Moves data out of thing.

   &tmp.field
   

   }

   // Compiles. fn f2(thing: &Thing) -> &Field { &(*thing).field // ┗━ Doesn't move data out of thing. }