Rust

Mantras

Invalid State Should Not Be Represented (hence the builder pattern)

&str, String, &[u8] Vec<u8> conversion map


&str -> String	String::from(s) or s.to_string() or s.to_owned()
&str -> &[u8]	s.as_bytes()
&str -> Vec<u8>	s.as_bytes().to_vec() or s.as_bytes().to_owned()
String -> &str	&s if possible* else s.as_str()
String -> &[u8]	s.as_bytes()
String -> Vec<u8>	s.into_bytes()
&[u8] -> &str	s.to_vec()or s.to_owned()
&[u8] -> String	std::str::from_utf8(s).unwrap(), but don’t**
&[u8] -> Vec<u8>	String::from_utf8(s).unwrap(), but don’t**
Vec<u8> -> &str	&s if possible* else s.as_slice()
Vec<u8> -> String	std::str::from_utf8(&s).unwrap(), but don’t**
Vec<u8> -> &[u8]	String::from_utf8(s).unwrap(), but don’t**

*target should have explicit type (i.e., checker can’t infer that)

**handle the error properly instead

CHIP-8

WGPU

WGSL spec (w3c)
Pipelines and buffers
- https://github.com/gfx-rs/wgpu-rs/issues/18
Engines example
- https://github.com/kvark/vange-rs/tree/master/src/render
- https://github.com/hecrj/coffee/tree/master/src/graphics/backend_wgpu

Are We Web Yet?

Analysis Tools For Rust

speedscope, flamegraph etc (rust profiling)
hotspot, firefox profiler reads perf files

Iterator Sheet

.cloned() is cool, into iter etc https://hermanradtke.com/2015/06/22/effectively-using-iterators-in-rust.html
itertools
https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.enumerate

Futures

Lyon: SVG to mesh thing

Integration for physics basics (and the whole site)

Learning

Exercises

Exercism
AOC2018
- https://github.com/BurntSushi/advent-of-code
AOC2019
- https://github.com/bcmyers/aoc2019
- https://www.youtube.com/playlist?list=PLQXBtq4j4Ozkx3r4eoMstdkkOG98qpBfg

Write Good Code

Rust Patterns and AntiPatterns mdBook
to_owned to express the intent, string::from otherwise
Rust Style Guidelines
Common Rust Lifetime Misconceptions
Rust API Guidelines (good for idiomatic)
Idiomatic Rust
https://github.com/ferrous-systems/elements-of-rust
https://cheats.rs/
Slice pattern maching

fn is_palindrome(items: &[char]) -> bool {
    match items {
        [first, middle @ .., last] => first == last && is_palindrome(middle),
        [] | [_] => true,
    }
}

    let point = [3.14, -42.0];
    let [x, y] = point;

Anonymous lifetime

Use when possible

fn (x: &'x str, y: &'y str) -> &'y str {
// Instead do (etc)
fn(x: &str, y: &'_ str) -> &'_ str {

ref vs &

ref = MAKE a new reference

// doesn't work
Some(&mut remainder) = self.remainder;
// Would match Option<&mut T>

Some(ref mut remainder) = self.remainder;
// Matches Option<T> and then makes a mut ref
==
Some(remainder) = &mut self.remainder;
//Equivalent

as_ref()

let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {:?}", text);

Cow, copy on write

Write an OS In Rust

Flutter rust bridge

Making slow rust code fast

Packages

Pretty Assertions
https://crates.io/crates/splines (for our drawing needs)

Rust API Guidelines

Tokio

When you spawn a task on the Tokio runtime, its type’s lifetime must be ‘static. This means that the spawned task must not contain any references to data owned outside the task.
Tasks spawned by tokio::spawn must implement Send. This allows the Tokio runtime to move the tasks between threads while they are suspended at an .await.
There are a couple of different ways to share state in Tokio. Guard the shared state with a Mutex. Spawn a task to manage the state and use message passing to operate on it.
Throughout Tokio, the term handle is used to reference a value that provides access to some shared state.