This is a list of places in Rust where implementing a trait or using a struct
affects the syntax of your code. I think of these features as "magical" because
using them can change the behavior of very basic Rust code (let, for-in,
&, etc.).
What follows is a small list of (hopefully) illustrative examples, and a short epilogue pointing you to more articles if this topic interests you.
Contents
trait Droptrait IntoIteratorandfor-intrait Deref,DerefMut, and&trait Display,Debug, and{}trait CopyOption,Result, and?- Epilogue
trait Drop (Playground Link)
struct Foo {
text: String,
}
impl Drop for Foo {
fn drop(&mut self) {
println!("{} was dropped", self.text);
}
}
fn main() {
let mut foo = Some(Foo {
text: String::from("the old value"),
});
// this calls the drop() we wrote above
foo = None;
}
trait IntoIterator and for-in (Playground Link)
struct MyCustomStrings(Vec<String>);
impl IntoIterator for MyCustomStrings {
type Item = String;
type IntoIter = std::vec::IntoIter<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()
}
}
fn main() {
let my_custom_strings = MyCustomStrings(vec![
String::from("one"),
String::from("two"),
String::from("three"),
]);
// We can use for-in with our struct
//
// prints "one", "two", "three"
for a_string in my_custom_strings {
println!("{}", a_string);
}
}
trait Deref, DerefMut, and & (Playground Link)
use std::ops::Deref;
struct Smart<T> {
inner: T,
}
// You can implement `DerefMut` to coerce exclusive references (&mut).
impl<T> Deref for Smart<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
fn main() {
let text = Smart {
inner: String::from("what did you say?"),
};
// The `impl Deref` lets us invoke the `&str` method
// `to_uppercase()` on a `&Smart<String>`
println!("{}", &text.to_uppercase());
}
trait Display, Debug, and {} (Playground Link]
use std::fmt;
struct Goat {
name: String,
}
impl fmt::Display for Goat {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "a goat named {}", self.name)
}
}
fn main() {
let goat = Goat {
name: String::from("Yagi"),
};
// This invokes our `Display`'s `fmt()`
println!("{}", goat);
}
trait Copy (Playground Link)
#[derive(Clone, Copy, Debug)]
struct Point {
x: usize,
y: usize,
}
fn main() {
let point_a = Point { x: 1, y: 2 };
let point_b = point_a;
// point_a is still valid because it was copied rather than moved.
println!("{:?}", point_a);
}
Option, Result, and ? (Playground Link)
// Notes:
// * This works very similarly with Option<T>
// * We need to derive(Debug) to use the error in a Result.
//
#[derive(Debug)]
struct SomeError;
fn uh_oh() -> Result<(), SomeError> {
Err(SomeError)
}
fn main() -> Result<(), SomeError> {
// The following line desugars to:
//
// match uh_oh() {
// Ok(v) => v,
// Err(SomeError) => return Err(SomeError),
// }
//
uh_oh()?;
Ok(())
}
Epilogue
When I first started compiling this list, I asked around in the Rust community discord. scottmcm from the Rust Language team introduced me to the concept of lang items. If you search for articles on this topic, you get some fantastic resources:
So what is a lang item? Lang items are a way for the stdlib (and libcore) to define types, traits, functions, and other items which the compiler needs to know about.
— Rust Tidbits: What is a Lang Item? by Manish Goregaokar
Not all lang items are magical, but most magical things are lang items. If you want a deeper or more comprehensive understanding, I recommend reading Manish's article in its entirety.