Rust Traits And You: A Deep Dive

Traits and You:
A Deep Dive
Nell Shamrell-Harrington
@nellshamrell
Rust Belt Rust 2017

I have learned to harness
the power of traits….

Traits and You: A Deep Dive @nellshamrell
• Sr. Software Engineer at Chef
• Core maintainer of Habitat (written in Rust!)
• Seattle, WA
• @nellshamrell
• nshamrell@chef.io

@nellshamrellTraits and You: A Deep Dive
Our Journey
• 101 - Intro to Traits
• 201 - Trait Bounds
• 301 - Trait Objects

Dungeons and Dragons

Yes…I have simpliﬁed
D&D rules for this
presentation

The focus of this talk is
traits with D&D used
as a metaphor

D&D Races
Dwarf Elf Half-Orc Human

Let’s create some structs!
struct Dwarf {
name: String
}
struct Elf {
name: String
}

struct Dwarf {
name: String
}
struct Elf {
name: String
}
struct HalfOrc {
name: String
}
struct Human {
name: String
}

Let’s make a character!
let my_dwarf = Dwarf {
name: String::from(“NellDwarf”)
};

Character Traits
• Strength
• Dexterity
• Constitution
• Intelligence
• Wisdom
• Charisma

Let’s make a trait!
pub trait Constitution {
}

fn constitution_bonus(&self) -> u8;
}

Let’s implement that trait!
Constitution

impl Constitution for Dwarf {
}
Constitution

Constitution
constitution_bonus

The constitution bonus
for a dwarf is 2

fn constitution_bonus(&self) -> u8 {
}
}
Constitution
constitution_bonus

2
}
}
Constitution
constitution_bonus

Let’s make a character!
let my_dwarf = Dwarf {
name: String::from(“NellDwarf”)
};
my_dwarf.constitution_bonus();
// Returns 2

struct Dwarf {
name: String
}
struct Elf {
name: String
}
struct HalfOrc {
name: String
}
struct Human {
name: String
}

impl Constitution for HalfOrc {
}
Constitution

for a half-orc is 1

impl Constitution for HalfOrc {
1
}
}
Constitution
constitution_bonus

let my_half_orc = HalfOrc {
name: String::from(“NellOrc”)
};

let my_half_orc = HalfOrc {
name: String::from(“NellOrc”)
};
my_half_orc.constitution_bonus();
// Returns 1

for both a human and
a half-elf is 0

We could implement it like this…
impl Constitution for Elf {
0
}
}
impl Constitution for Human {
0
}
}

We could implement it like this…
0
}
}
0
}
}
Repetitive!

Most races have a
constitution bonus
of 0…

Let’s add a default!
fn constitution_bonus(&self) -> u8;
}

Let’s add a default!
0
}
}

Constitution Constitution

}
}

let my_elf = Elf {
name: String::from(“NellElf”)
};
Constitution

let my_elf = Elf {
name: String::from(“NellElf”)
};
my_elf.constitution_bonus();
// Returns 0
Constitution

let my_human = Human {
name: String::from(“Nell”)
};
Constitution

let my_human = Human {
name: String::from(“Nell”)
};
my_human.constitution_bonus();
// Returns 0
Constitution

D&D Races
Dwarf Elf Half-Orc Human Half-Elf

D&D Races
Dwarf Elf Half-Orc Human Half-Elf
How do they communicate?

Languages
Dwarf Elf Half-Elf
Common, Dwarvish Common, Elvish Common, Elvish

pub trait Elvish {
}

pub trait Elvish {
}
impl Elvish for Elf {
}
impl Elvish for HalfElf {
}

Let’s make a function for
speaking Elvish

Let’s make a function!
pub fn speak_elvish() -> String {
}

pub fn speak_elvish() -> String {
String::from(“yes”)
}

pub fn speak_elvish(character: T) -> String {
}
Accept a generic type

pub fn speak_elvish<T: Elvish>(character: T) -> String {
}
Only accept types
that implement
the Elvish Trait

}
let my_elf = Elf { name: String::from(“NellElf”) };
Elvish

}
speak_elvish(my_elf)
Elvish

pub fn understand_elvish<T: Elvish>(character: T) -> String {
}
speak_elvish(my_elf)
// Returns “yes”
Elvish

}
let my_half_elf = HalfElf { name: String::from(“NellElf”) };
Elvish

}
speak_elvish(my_half_elf)
Elvish

}
speak_elvish(my_half_elf)
// Returns “yes”
Elvish

}
let my_half_orc = HalfOrc { name: String::from(“NellOrc”) };

}
speak_elvish(my_half_orc)

pub trait Elvish {
}
impl Elvish for Elf {
}
impl Elvish for HalfElf {
}
Not implemented for
Half-Orc

}
speak_elvish(my_half_orc)
// Returns error on compile
// The trait ‘Elvish” is not implemented for ‘HalfOrc’

Trait bounds allow a function
to only accept types that
implement a certain trait

Traditional Object Oriented Languages
Object

Traditional Object Oriented Languages
Object
Data
Behavior

Rust

Rust
Data
Enums/Structs

Rust
Data Behavior
Enums/Structs Traits

Trait objects behave
more like traditional
objects

Trait objects contain
both data and behavior

Trait Object
Trait Object

Trait Object
Trait Object
Pointer
(Data)
Heap
Value

Trait Object
Trait Object
Pointer
(Data)
Heap
Value
Trait
(Behavior)

You cannot add data
to a trait object

Spells in D&D

Spells in D&D
• Cantrip
• Transmutation
• Enchantment
• Necromancy

struct Cantrip {
}
struct Transmutation {
}
struct Enchantment {
}
struct Necromancy {
}

struct Cantrip {
}
struct Transmutation {
}
struct Enchantment {
}
struct Necromancy {
}
All of these need to be cast…

pub trait Cast {
}

pub trait Cast {
fn cast(&self);
}

impl Cast for Cantrip {
fn cast(&self) {
// Details of casting a Cantrip Spell
}
}

impl Cast for Cantrip {
fn cast(&self) {
// Details of casting a Cantrip Spell
}
}
impl Cast for Transmutation {
fn cast(&self) {
// Details of casting a Transmutation Spell
}
}

impl Cast for Enchantment {
fn cast(&self) {
// Details of casting an Enchantment Spell
}
}

impl Cast for Enchantment {
fn cast(&self) {
// Details of casting an Enchantment Spell
}
}
impl Cast for Necromancy {
fn cast(&self) {
// Details of casting a Necromancy Spell
}
}

In a Spellbook, of course!
Some Cantrip
A Transmutation
Special Enchantment
Dark Necromancy
This is some text, here more test
For casting the spell, yay spell!
Oh such wonderful text!
This is some text for something
For casting the spell yay casting
Oh such wonderful text! Yay!

Let’s create a struct!
struct Spellbook {
}

struct Spellbook {
pub spells: Vec<Box<Cast>>,
}

struct Spellbook {
}
???

Vec<T>,
Vector that
contains objects
of a type

Vec<Box<T>>,

Box<T>
Box
(Pointer)

Box<T>
Box
(Pointer)
Heap
Value

Vec<Box<T>>,
Type of value
Box can point to

Vec<Box<Cast>>,
Box: must point
to a value that
implements the
Cast trait

struct Spellbook {
}
Vector

struct Spellbook {
}
Vector contains
Boxes

struct Spellbook {
}
Vector contains
Boxes that point to
values that
implement the
Cast trait

How can we cast ALL of these?
Some Cantrip
A Transmutation
Special Enchantment
Dark Necromancy

Let’s implement behavior!
impl Spellbook {
}

impl Spellbook {
pub fn run(&self) {
}
}

impl Spellbook {
pub fn run(&self){
for spell in self.spells.iter() {
}
}
}
Iterate over
Spellbooks’s
spells

impl Spellbook {
pub fn run(&self){
for spell in self.spells.iter() {
spell.cast();
}
}
}
Cast spell

Run

Cantrip
Transmutation
Enchantment
Necromancy
Run
Cast
Cast
Cast
C
ast

let spell_book = Spellbook {
};

spells: vec![
],
};

spells: vec![
Box::new(Cantrip{} ),
Box::new(Transmutation {}),
Box::new(Enchantment{}),
Box::new(Necromancy {}),
],
};
Different types
of spells
(each implements
Cast)

spells: vec![
Box::new(Cantrip{} ),
Box::new(Transmutation {}),
Box::new(Enchantment{}),
Box::new(Necromancy {}),
],
};
spell_book.run(); Casts each spell

Trait objects are great for
heterogenus collections

It doesn’t matter what type
something is, as long as it
implements a certain trait

Where can I ﬁnd out more about traits?
• Best source - The Rust Programming Language (2nd Edition)
• Traits Basics - Ch. 10.2
• Trait Bounds - Ch. 10.2
• Trait Objects - Ch. 17.2

• Sr. Software Engineer at Chef
• Core maintainer of Habitat (written in Rust!)
• Seattle, WA
• @nellshamrell
• nshamrell@chef.io
Thank You!

Rust Traits And You: A Deep Dive

More Related Content

What's hot (20)

More from Nell Shamrell-Harrington (20)

Recently uploaded (20)

Rust Traits And You: A Deep Dive