anonymous.rs

Rust Traits: A Guide to Marker Traits

author: anonymous.rs

4 min read

Rust’s Special Language: A Guide to Marker Traits

In the world of Rust traits, most are defined by the methods they require. However, there’s a special category of traits that have no methods at all. These are Marker Traits. Their sole purpose is to act as a “marker” or a “label” for a type, signaling to the Rust compiler that the type has certain properties or can be used in specific ways. They are a cornerstone of Rust’s compile-time safety guarantees, especially in concurrency.

Let’s explore the most important marker traits.

1. Send and Sync: The Concurrency Guardians

These two traits are fundamental to Rust’s “fearless concurrency.”

Send

A type is Send if it is safe to transfer its ownership to another thread.

  • Most primitive types (i32, bool) and structs/enums composed of Send types are automatically Send.
  • A classic example of a non-Send type is std::rc::Rc<T>. Its reference counting mechanism is not atomic, so transferring it to another thread could cause race conditions. The compiler will prevent this.
use std::rc::Rc;
use std::thread;
 
fn main() {
    let non_send_data = Rc::new("hello");
    
    // The compiler will produce an error here!
    // `Rc<T>` cannot be sent safely between threads.
    thread::spawn(move || {
        println!("{}", non_send_data);
    });
}

Sync

A type is Sync if it is safe to have an immutable reference (&T) to it accessed from multiple threads simultaneously.

  • If a type T is Sync, then &T is Send. This makes sense: if it’s safe to share, it’s safe to send a reference to another thread.
  • Most types are Sync. A key example of a non-Sync type is std::cell::RefCell<T>. It performs runtime borrow checking, which is not thread-safe. Allowing multiple threads to access it could lead to data races when trying to mutate it.

2. Copy: The “Copy vs. Move” Marker

By default, Rust uses “move semantics.” When you assign a variable to another, ownership is transferred. However, for simple types like integers, it’s more intuitive and efficient to just copy the bits.

A type is Copy if its value can be duplicated with a simple bit-for-bit copy.

  • To be Copy, a type must also implement Clone.
  • You can’t implement Copy for a type that implements Drop, as there would be ambiguity about which owner is responsible for cleanup.
// This struct can be `Copy` because all its fields are `Copy`.
#[derive(Debug, Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}
 
fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1; // Because `Point` is `Copy`, `p1` is copied, not moved.
 
    // We can still use p1, which would be impossible if it were moved.
    println!("p1 is {:?}, p2 is {:?}", p1, p2);
}

3. Sized: The Compile-Time Size Marker

This is one of the most fundamental marker traits, though often implicit. A type is Sized if its size in memory is known to the compiler at compile time.

  • Almost every type is Sized.
  • Types that are not Sized are called Dynamically Sized Types (DSTs). Examples include str (the primitive string slice, not &str), [T] (a slice, not &[T]), and dyn Trait (a trait object).
  • You cannot store DSTs directly in variables or pass them as function arguments. They must always be handled through a pointer-like type like &T, Box<T>, or Rc<T>, because the pointer itself has a known size.

The ?Sized syntax is used to opt-out of the default Sized requirement in generic functions, allowing them to work with DSTs.

// This function can accept a reference to any type that implements `Debug`,
// even if its size is not known at compile time (like `dyn Debug`).
fn print_debug(item: &impl std::fmt::Debug) {
    println!("{:?}", item);
}

4. Unpin: A Marker for Asynchronous Rust

Unpin is crucial for async/await. Some async operations create “self-referential” futures, meaning the future’s state contains pointers to other parts of its own state. If such a future were moved in memory, those internal pointers would become invalid.

  • A type that is !Unpin (i.e., it cannot be moved after being “pinned”) signals this self-referential nature.
  • Unpin is the default marker for types that are safe to be moved at any time, even after being polled.
  • When you use Box::pin, you are creating a Pin<Box<T>>, which guarantees that the value T will not be moved from its location on the heap, thus satisfying the requirements for !Unpin futures.

Conclusion

Marker traits are a zero-cost abstraction that imbues types with essential properties, allowing the Rust compiler to enforce complex invariants like thread-safety, memory layout, and ownership rules. They are a silent but powerful feature that makes writing safe, high-performance code in Rust possible.

Graph View