Hey guys, There was a Rust book I was meaning to read, I even recommended it to someone on the Rust discord, but my search-fu is not strong enough to find it any more, and the time has come!
It was a book introducing you to some of the most important and common Rust traits.
Anyone got a link? Thanks!
Was it an e-book or a paperback book?
Maybe you find it here:
Hi @trembel, unfortunately it's not on that list.
It's one of those rust books websites, that uses the same template/framework as the official book, gentle intro, by example, nomicon etc.
This is not a book, but this blog post covers a bunch of basic standard library traits:
Off the top of my head, the first thing that comes to mind, regarding
some of the most important and common Rust traits
is: https://doc.rust-lang.org/reference/special-types-and-traits.html
Otherwise:
https://stevedonovan.github.io/rustifications/2018/09/08/common-rust-traits.html
EDIT: Oh, @mbrubeck beat me to it for that one 
Just fyi, those are generated by a tool made with rust called mdbook. Generated from plain markdown.
Ahh i think it may be steve donavans blog now! Thank you!
Also, interesting tip on mdbook thank you
That was a good read. Is there anything similar for smart pointers (and when to use them)?
I have written a fairly complex app in Rust and have not needed to use a smart pointer once. (I do use a mut* though, and yes, i acknowledge it's hacky 
)
Learning Rust With Entirely Too Many Linked Lists is a good practical approach to them.
I personally wrote this post that explains the role of the most pervasive / important wrapper types in the standard library:
I have been using for some time by now and I never needed Ref or Refcell am i missing something?
The key notion to understand with Rust is the duality of shared access vs. unique access; and the different approaches to get a mutable access out of them:
one gets mutable access out of unique access "for free", that's why &mut references (unique references) are abusingly called mutable references;
but when dealing with shared acces, things get trickier, and one needs to use the appropriate wrapper type with the desired properties / semantics (e.g., unsynchronized and thus single-threaded mutation, or thread-safe mutation through atomics or synchronization primitives).
For that, I recommend the following posts:
Great answer thank you! But i think this assumes I'm comfortable already with the uses cases and the problems they solve, (and when indeed these tools are the correct solution to the problem i have)
The above; i would encapsulate under programming competence. Can you suggest any learning material that takes a step back and introduces me to the problem before teaching me how to solve them? (Perhaps 'with entirely too many linked lists' is the ticket! But any other recommendations also appreciated)