Rust Style Guidelines#

• cargo fmt is your friend. I use the default settings.
• clippy is a great tool, and should be a requirement for getting PRs merged.
• unsafe is fine when called for, but use carefully
  • It should be commented
  • It should be wrapped in a safe abstraction

Error Handling#

• Panicking always indicates a bug
  • Especially in a library
  • Also in an application
  • Doesn’t mean you can’t call panic
    • But if that code path is actually activated, it’s a bug
• Use ? even in toy projects
• unwrap does not belong in your repos. expect is acceptable.
  • It is too prone to abuse. clippy should be configured to ban it.
  • Use expect where unwrap would be appropriate
    • expect is appropriate for indicating logic errors
      • A panic is always a bug, especially in a library
      • unlock() is an appropriate place to use expect
    • expect is not appropriate as a band-aid on bad flow control
      • Use if let Some(x) = rather than is_some followed by unwrap
    • ? should be preferred in most non-logic error situations
      • Or explicit handling
    • Write a useful message with expect
      • To aid debugging if you were wrong
      • To show to the reader why you think it will never be called
    • Consider writing panicking functions over calling expect repeatedly
      • Array indexes are a good example of this
  • This is controversial
    • Some experts think unwrap is OK in some situations where I allow expect
      • I think unwrap is too tempting for the situations where neither expect or unwrap is OK
    • No experts think unwrap is fine to use much more liberally than that
  • unwrap is OK in draft code where it is interpreted as a XXX
    • Don’t let this into your production codebase
    • Make sure you have the unwrap check in clippy enabled in CI so it doesn’t slip in
• Use thiserror for libraries, use anyhow or eyre for binaries.

Things I love about Rust#

The Programming Language Itself#

• That it has proper sum types in enums
• That it has all the expressive power of C++ if you need it, while demarcating a safe subset
• That Rust lifetimes have finally rescued “regions” from academia
  • And therefore made RAII complete
• That it doesn’t have OOP-style inheritance

Standard Library#

• The map APIs are quite excellent

The Ecosystem#

• That everyone uses log but there are multiple backends available
• That cargo is so ergonomic

How I wish Rust had been made differently (but it’s too late to change)#

• I wish unwrap were not part of the standard library
• I wish the C/C++ distinction between . and -> were retained, because I think sometimes automatically dereferencing and sometimes not is surprising.