Traits: shared behaviour

Why traits?

Different types often share an ability. A train ticket, a movie ticket and a flight ticket all have a price and can print a summary. A trait is a named set of methods that types can promise to provide. Code can then work with "anything that has this ability" without knowing the exact type. This is Rust's main tool for shared behaviour; Rust has no class inheritance.

trait Ticket {
    fn price(&self) -> u32;
    fn summary(&self) -> String;
}

struct Train { from: String, to: String, fare: u32 }
struct Movie { title: String, seats: u32 }

impl Ticket for Train {
    fn price(&self) -> u32 { self.fare }
    fn summary(&self) -> String { format!("Train {} to {}", self.from, self.to) }
}

impl Ticket for Movie {
    fn price(&self) -> u32 { self.seats * 250 }
    fn summary(&self) -> String { format!("{} x{}", self.title, self.seats) }
}

Default methods

A trait can give a method a default body. Types get it for free and can override it. Default methods may call the other methods of the trait.

trait Ticket {
    fn price(&self) -> u32;
    fn summary(&self) -> String;
    fn with_gst(&self) -> u32 {          // default method
        self.price() + self.price() * 18 / 100
    }
}

Using a trait in a function

fn print_receipt(t: &impl Ticket) {
    println!("{}: Rs {}", t.summary(), t.with_gst());
}

Display: making {} work

Display is a standard trait that controls how {} prints a value. You implement its fmt method and use write! to produce the text.

use std::fmt;

struct Rupees(u64);   // paise

impl fmt::Display for Rupees {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Rs {}.{:02}", self.0 / 100, self.0 % 100)
    }
}

fn main() {
    let r = Rupees(12_345);
    println!("{r}");                 // Rs 123.45
    let s = r.to_string();           // to_string comes free with Display
    println!("{}", s.len());         // 9
}

Derivable traits

#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
struct RollNo(u32);

The orphan rule, in plain words

You may implement a trait for a type only if the trait or the type (or both) is defined in your own crate. You can implement Display for your Rupees, or your own Ticket trait for String, but not the standard Display for the standard Vec. This stops two crates from giving conflicting implementations of the same pair.

Common mistakes

• Forgetting to bring a trait into scope. Trait methods only work when the trait is imported with use; the compiler tells you which one.
• Missing a required method in impl: "not all trait items implemented". Add the method.
• Deriving Copy on a type with a String field. Not allowed; derive Clone only.
• Implementing a foreign trait for a foreign type (orphan rule). Wrap the type in your own newtype struct first.