A trait is a contract that defines a set of behaviors or properties that a type must implement. It can contain associated types, constants, function or method signatures, and overridable default implementations.
Definition
With No Associates
💡 Mostly used to mark a type as having certain properties to allow in certain operations. Known as Marker Traits.
With the Declarations of Associates
trait Greet {
+ const PREFIX: &'static str;
+ type Item;
+ fn greet(&self) -> String;
+}
+
With the Default Implementations of Associates
trait Greet {
+ const PREFIX: &'static str = "Hello";
+
+ fn greet(&self) -> String {
+ format!("{}!", String::from(Self::PREFIX))
+ }
+}
+
With Supertraits
A trait must have to be implemented first before implementing the current trait.
pub trait Copy: Clone { } // 💡 Any type that copyable should be clonable
+
+// 💡 Any type that clonable should be sized
+pub trait Clone: Sized {
+ fn clone(&self) -> Self;
+ fn clone_from(&mut self, source: &Self) { ... }
+}
+
💯 trait Subtrait: Super or trait Subtrait: SupertraitA + SupertraitB
With Generic Types
// 💡 Convert from one type to another. If successful, retrun Type; else return associated Error
+pub trait TryFrom<T>: Sized {
+ type Error;
+
+ fn try_from(value: T) -> Result<Self, Self::Error>;
+}
+
Trait Impls (Manual Implementation)
Manually implementing a shared behavior defined in a trait for a type via an impl block.
With Required Components
When a trait has only declarations of associated items, it’s required to implement all of them.
struct Person {
+ name: String
+}
+
+trait Greet {
+ const PREFIX: &'static str; // 💡 Required constant
+ fn greet(&self) -> String; // 💡 Required method
+}
+
+impl Greet for Person {
+ const PREFIX: &'static str = "Hello";
+
+ fn greet(&self) -> String {
+ format!("{} {}!", Self::PREFIX.to_owned(), self.name)
+ }
+}
+
+fn main() {
+ let steve = Person { name: "Steve".to_string() };
+ println!("{}", steve.greet()); // Hello Steve!
+}
+
With Provided Components
When a trait has default values and default implementations, it’s possible to implement only some of them or override them.
struct Person {
+ name: String
+}
+
+trait Greet {
+ // 💡 Provided constant
+ const PREFIX: &'static str = "Hello";
+
+ // 💡 Provided method
+ fn greet(&self) -> String {
+ format!("{}!", String::from(Self::PREFIX))
+ }
+}
+
+impl Greet for Person {
+ // 💡 Overridden constant
+ const PREFIX: &'static str = "Good morning";
+
+ // 💡 Overridden method
+ fn greet(&self) -> String {
+ format!("{} {}!", Self::PREFIX.to_owned(), self.name)
+ }
+}
+
+fn main() {
+ let steve = Person { name: "Steve".to_string() };
+ println!("{}", steve.greet()); // Good morning Steve!
+}
+
For Enum Types
#![allow(unused)]
+enum Shape {
+ Circle(f64), // radius
+ Rectangle(u32, u32), // width, height
+}
+
+trait Area {
+ fn area(&self) -> f64;
+}
+
+impl Area for Shape {
+ fn area(&self) -> f64 {
+ match *self {
+ Shape::Circle(radius) => std::f64::consts::PI * radius * radius,
+ Shape::Rectangle(width, height) => (width * height) as f64,
+ }
+ }
+}
+
+fn main() {
+ let circle = Shape::Circle(7.0);
+ let rect = Shape::Rectangle(5, 5);
+
+ println!("{:?}", circle.area());
+ println!("{:?}", rect.area());
+}
+
For Generic Types
impl<T> Trait for Type<T>
#![allow(unused)]
+struct Person<T> {
+ name: String,
+ age: T,
+}
+
+trait Greet {
+ fn greet(&self) -> String;
+}
+
+impl<T> Greet for Person<T> {
+ fn greet(&self) -> String {
+ format!("Hello {}!", self.name)
+ }
+}
+
+fn main() {
+ let steve = Person { name: "Steve".to_string(), age: 65 }; // 💡 age: i32
+ let bill = Person { name: "Bill".to_string(), age: 7.5 }; // 💡 age: f64
+
+ println!("{:?}", steve.greet()); // Hello Steve!
+ println!("{:?}", bill.greet()); // Hello Bill!
+}
+
impl<T> Trait<T> for Type<T>
struct Point<T> {
+ x: T,
+ y: T,
+}
+
+trait IntoTuple<T> {
+ fn into_tuple(self) -> (T, T);
+}
+
+impl<T> IntoTuple<T> for Point<T> {
+ fn into_tuple(self) -> (T, T) {
+ (self.x, self.y)
+ }
+}
+
+fn main() {
+ let a = Point { x: 0, y: 1 }; // Point<i32>
+ let b = Point { x: "2.0", y: "2.2" }; // Point<&str>
+
+ println!("{:?}", a.into_tuple()); // (0, 1)
+ println!("{:?}", b.into_tuple()); // ("2.0", "2.2")
+}
+
👨🏫 Update the above implementation to impl<T, U> Trait<T> for Type<U>.
Derive and Auto Traits (Autogenerate Implementations)
Derive Traits
The compiler generates the trait implementation automatically for you, based on the derived attributes.
#[derive(Debug, Clone, PartialEq)]
+struct Person {
+ name: String,
+}
+
+fn main() {
+ let steve = Person { name: "Steve".to_string() };
+ let bill = Person { name: "Bill".to_string() };
+
+ // Debug: 💡 allow debug print with {:?}
+ println!("{steve:?}"); // Person { name: "Steve" }
+
+ // Clone: 💡 allow duplicate data via .clone()
+ let gates = bill.clone();
+
+ // PartialEq: 💡 support equate the two instances via == and !=
+ println!("{}", steve == bill); // false
+ println!("{}", bill == gates); // true
+}
+
🔎 Check bellow Rust STD documentation pages, of these normal derive-traits.
| Trait | The functionality (implement to the type at compile-time) |
|---|
Debug | Enables debug-printing of the internal state with {:?} |
Default | Allows creating a default initial value with ::default() |
Clone | Allows creating a deep copy explicitly with .clone() |
PartialEq / Eq | Allows comparing instances with == and != operators |
PartialOrd / Ord | Allows comparing instances with <, <=, >, and >= operators |
Hash | Allows the type to be used as a key in a HashMap or HashSet |
💯 Marker traits are the traits that have no associated constants, types, methods, etc. So, the compiler-generated implementation has only an empty impl Trait for Type { } block.
#![allow(unused)]
+
+#[derive(Debug, Clone, Copy)] // 💡 Copy trait needs the Clone trait as a supertrait
+struct Point {
+ x: i32,
+ y: i32,
+}
+
+fn main() {
+ let a = Point { x: 0, y: 1 };
+ let b = a; // Copy: 💡 duplicate data. a and b are separate instances
+
+ println!("{a:?}");
+ println!("{b:?}");
+}
+// 👨🏫 Try remove Copy derive on Point and explisitly copy via .clone()
+
🔎 Copy set the ability to duplicate via simply copying bits (pass by duplicating)
Auto Traits
Implicitly bound/ automatically implemented by the compiler without any keywords.
pub trait Sized { }
+pub unsafe auto trait Sync { }
+pub auto trait Unpin { }
+
#![allow(unused)]
+
+#[derive(Debug)]
+struct Point { // 💡 Sized, Send, Sync: (Automatic) Implicitly bound for most simple types in Rust
+ x: i32,
+ y: i32,
+}
+
+fn main() {
+ let a = Point { x: 0, y: 1 };
+
+ std::thread::scope(|s| {
+ s.spawn(|| println!("{a:?}"));
+ s.spawn(|| println!("{a:?}"));
+ });
+
+ std::thread::spawn(move || println!("{a:?}")).join().unwrap();
+}
+
| Trait | The properties (set to the type automatically) |
|---|
Sized | Able to determine the size at compile time |
Unpin | Safe to move in memory |
Send | Safe to move ownership across threads |
Sync | Safe to shared references between threads |
UnwindSafe | Safe to use in panic unwindings |
RefUnwindSafe | Safe to use shared references in panic unwinding |
👨🏫 Sized/ Unsized
- ⭐️ Most simple types in Rust have a fixed size known at compile time and automatically implement
Sized marker trait. - 💯 Unsized types (or dynamically sized types, DSTs) cannot be used directly as local variables, function parameters, or return values. They must always be placed behind an indirection, such as a reference (
& or &mut), a Box, Rc, or Arc. Common examples include slices ([T], &str) and trait objects (dyn Trait).- 🔎 Pointers to these types are known as “wide pointers” or “fat pointers” because they contain both a pointer to the data and additional metadata. Metadata: for slices - length (number of elements) and for trait objects - a pointer to the vtable/ virtual function table. Ex:
&[T], *mut str, Box<dyn Trait>
- 💡 To allow a type to be unsized (relaxes the default Sized requirement), we can use the
?Sized bound.
Static Dispatch
Monomorphization is a compiler optimization and implementation strategy that transforms polymorphic (generic) code into specialized, monomorphic (single-type) versions for each unique set of concrete types used in a program. This increases the binary size.
Dispatch is the process of deciding which implementation of a polymorphic function to execute, either statically at compile time or dynamically at runtime (via a lookup in a vtable).
Rust compiler generates highly optimized code blocks for each type used for a generic function. So, function calls are statically resolved at compile time and no runtime overhead.
Trait Bounds
Specify the type constraints by traits in generics (<T: Trait>) rather than using exact types. Allowed in a field types & function return and argument.
struct Point { x: i32, y: i32 }
+impl Addr for Point {
+ fn addr(&self) -> String {
+ format!("{}, {}", self.x, self.y)
+ }
+}
+
+struct MapLocation(String, String); // latitude, longitude
+impl Addr for MapLocation {
+ fn addr(&self) -> String {
+ format!("{}, {}", self.0, self.1)
+ }
+}
+
+// --- ⭐️ main Trait & Type with Trait Bounds ⭐️
+trait Addr {
+ fn addr(&self) -> String;
+}
+
+struct Delivery<T: Addr> {
+ location: T,
+}
+
+impl<T: Addr> Delivery<T> {
+ fn new(location: T) -> Self {
+ Self { location }
+ }
+}
+
+// --- ⭐️ fn with Trait Bounds ⭐️
+fn location_info<T: Addr>(location: T) {
+ println!("Latitude/ Longitude: {}", location.addr())
+}
+
+// ---
+fn main() {
+ let ocean = Point { x: 35, y: 20 };
+ let tokyo = MapLocation("35.68951".to_string(), "139.69170".to_string());
+
+ let pkg1 = Delivery::new(ocean);
+ let pkg2 = Delivery::new(tokyo);
+
+ location_info(pkg1.location); // Latitude/ Longitude: 35, 20
+ location_info(pkg2.location); // Latitude/ Longitude: 35.68951, 139.69170
+}
+
Opaque Types
Specify the type constraints via traits (:impl Trait) without specifying full generic syntax. But only allowed as a function return or an argument.
struct Point { x: i32, y: i32 }
+impl Addr for Point {
+ fn addr(&self) -> String {
+ format!("{}, {}", self.x, self.y)
+ }
+}
+
+struct MapLocation(String, String); // latitude, longitude
+impl Addr for MapLocation {
+ fn addr(&self) -> String {
+ format!("{}, {}", self.0, self.1)
+ }
+}
+
+trait Addr {
+ fn addr(&self) -> String;
+}
+
+// --- ⭐️ Opaque Types are only allowed in function parameters
+fn location_info(location: impl Addr) { // 💡 Argument-Position-Impl-Trait/ APIT
+ println!("Latitude/ Longitude: {}", location.addr())
+}
+
+fn tokyo_location() -> impl Addr { // 💡 Return-Position-Impl-Trait/ RPIT
+ MapLocation("35.68951".to_string(), "139.69170".to_string())
+}
+
+// ---
+fn main() {
+ let ocean = Point { x: 35, y: 20 };
+ let tokyo = tokyo_location();
+
+ location_info(ocean); // Latitude/ Longitude: 35, 20
+ location_info(tokyo); // Latitude/ Longitude: 35.68951, 139.69170
+}
+
Dynamic Dispatch
Dynamic dispatch is used when we need to handle multiple different concrete types (mix types) and resolve the trait implementation dynamically at runtime (because this is not possible with static dispatch).
🔎 The compiler uses vtable (virtual method table) pointers. Instead of knowing the type at compile time, the program follows a pointer to a table that contains the addresses of the methods for that specific instance.
Trait Objects
struct Point { x: i32, y: i32 }
+impl Addr for Point {
+ fn addr(&self) -> String {
+ format!("{}, {}", self.x, self.y)
+ }
+}
+
+struct MapLocation(String, String); // latitude, longitude
+impl Addr for MapLocation {
+ fn addr(&self) -> String {
+ format!("{}, {}", self.0, self.1)
+ }
+}
+
+trait Addr {
+ fn addr(&self) -> String;
+}
+
+// --- ⭐️ Trait Object, allow mix types and check dynamically at runtime
+fn locations_info(locations: &[Box<dyn Addr>]) { // 💡 `dyn Addr` is unsized (DST) and needs a pointer
+ for location in locations {
+ println!("Latitude/ Longitude: {}", location.addr())
+ }
+}
+
+// ---
+fn main() {
+ let ocean = Point { x: 35, y: 20 };
+ let tokyo = MapLocation("35.68951".to_string(), "139.69170".to_string());
+
+ let locations: Vec<Box<dyn Addr>> = vec![Box::new(ocean), Box::new(tokyo)];
+
+ locations_info(&locations);
+ // Latitude/ Longitude: 35, 20
+ // Latitude/ Longitude: 35.68951, 139.69170
+}
+
Blanket Impls (One-to-Many Manual Implementation)
Blanket impls are a special kind of trait implementation that applies to all types that have a certain type constraint/bound.
A Simple Blanket Impl
#![allow(unused)]
+
+// --- 💡 Two types with Greet implentation
+struct Person { name: String }
+impl Greet for Person {}
+
+struct Stranger {}
+impl Greet for Stranger {}
+
+trait Greet {
+ const PREFIX: &'static str = "Hello";
+
+ fn greet(&self) -> String {
+ format!("{}!", String::from(Self::PREFIX))
+ }
+}
+
+// --- New Farewell trait
+trait Farewell {
+ const PREFIX: &'static str = "Goodbye";
+
+ fn farewell(&self) -> String {
+ format!("{}!", String::from(Self::PREFIX))
+ }
+}
+
+// ⭐️ Any type that implements Greet gets this Farewell implementation
+impl<T: Greet> Farewell for T {} // 💡or impl<T> Farewell for T where T: Greet {}
+
+// ---
+fn main() {
+ let steve = Person { name: "Steve".to_string() };
+ let stranger = Stranger {};
+
+ println!("{}", steve.greet()); // Hello!
+ println!("{}", stranger.greet()); // Hello!
+
+ println!("{}", steve.farewell()); // Goodbye!
+ println!("{}", stranger.farewell()); // Goodbye!
+}
+
Useful Blanket Impls in STD
- When implement
Display Rust STD automatically implements ToString to the type.
use std::fmt;
+
+struct Person {
+ name: String,
+}
+
+impl fmt::Display for Person {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "Person {{ name: {}}}", self.name) // 💡 {{ }} escaping curly braces
+ }
+}
+
+fn main() {
+ let steve = Person {
+ name: "Steve".to_string(),
+ };
+
+ println!("{steve}"); // Person { name: Steve}
+ println!("{}", steve.to_string()); // Person { name: Steve}
+}
+
- When implement
From<T> Rust STD automatically implements Into<U> to the type.
#![allow(unused)]
+
+use std::convert::From;
+
+#[derive(Debug)]
+struct Person {
+ name: String,
+}
+
+impl From<&str> for Person {
+ fn from(name: &str) -> Self {
+ Person {
+ name: name.to_string(),
+ }
+ }
+}
+
+fn main() {
+ let steve = Person::from("Steve");
+ let bill: Person = "Bill".into();
+
+ println!("{:?}", steve); // Person { name: "Steve" }
+ println!("{:?}", bill); // Person { name: "Bill" }
+}
+
👨🏫 Try to implement TryFrom and check the blanket implementation it provides.
Trait Coherence & Orphan Rule
Rust ensures there is only one implementation of a specific trait for a specific type in the global scope/ in the entire program (Only One Implementation Per Type). This is primarily done to prevent multiple conflicting implementations across different layers of an application. This is called Coherence (or Trait Coherence). If multiple implementations exist, the code will not compile.
To prevent overwriting an existing implementation in a different layer of the application, Rust prohibits implementing a foreign trait for a foreign type. In other words, either the trait or the type must be defined in the current crate. This is called the Orphan Rule.
Suppose you want to implement a std trait for a std/ foreign type but Rust not allow it due to the orphan rule. In that case, we can create a brand-new type that wraps the foreign type and implements the trait for the wrapper type. This is called Newtype Pattern.
use anyhow::{Context, Result};
+use std::fmt;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+struct Timestamp(SystemTime); // 💡 The newtype that wraps the std type
+
+impl Timestamp {
+ fn get_seconds(&self) -> Result<u64> {
+ self.0
+ .duration_since(UNIX_EPOCH)
+ .with_context(|| "Clock is set before 1970")
+ .map(|d| d.as_secs())
+ }
+}
+
+// 💡 Implement std trait, Display for newtype
+impl fmt::Display for Timestamp {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let secs = self.get_seconds().map_err(|_| fmt::Error)?;
+ write!(f, "{secs}")
+ }
+}
+
+fn main() -> Result<()> {
+ let now = Timestamp(SystemTime::now());
+ println!("Current time: {}", now);
+
+ Ok(())
+}
+
