83 lines
2.2 KiB
Markdown
83 lines
2.2 KiB
Markdown
# Traits
|
|
A trait tells the Rust compiler about functionality a particular type has and can share with other types. We can use traits to define shared behavior in an abstract way. We can use trait bounds to specify that a generic type can be any type that has certain behavior.
|
|
|
|
> Note: Traits are similar to a feature often called interfaces in other languages, although with some differences.
|
|
|
|
## Examples
|
|
```rust,editable
|
|
struct Sheep { naked: bool, name: String }
|
|
|
|
trait Animal {
|
|
// Associated function signature; `Self` refers to the implementor type.
|
|
fn new(name: String) -> Self;
|
|
|
|
// Method signatures; these will return a string.
|
|
fn name(&self) -> String;
|
|
|
|
fn noise(&self) -> String;
|
|
|
|
// Traits can provide default method definitions.
|
|
fn talk(&self) {
|
|
println!("{} says {}", self.name(), self.noise());
|
|
}
|
|
}
|
|
|
|
impl Sheep {
|
|
fn is_naked(&self) -> bool {
|
|
self.naked
|
|
}
|
|
|
|
fn shear(&mut self) {
|
|
if self.is_naked() {
|
|
// Implementor methods can use the implementor's trait methods.
|
|
println!("{} is already naked...", self.name());
|
|
} else {
|
|
println!("{} gets a haircut!", self.name);
|
|
|
|
self.naked = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Implement the `Animal` trait for `Sheep`.
|
|
impl Animal for Sheep {
|
|
// `Self` is the implementor type: `Sheep`.
|
|
fn new(name: String) -> Sheep {
|
|
Sheep { name: name, naked: false }
|
|
}
|
|
|
|
fn name(&self) -> String {
|
|
self.name.clone()
|
|
}
|
|
|
|
fn noise(&self) -> String {
|
|
if self.is_naked() {
|
|
"baaaaah?".to_string()
|
|
} else {
|
|
"baaaaah!".to_string()
|
|
}
|
|
}
|
|
|
|
// Default trait methods can be overridden.
|
|
fn talk(&self) {
|
|
// For example, we can add some quiet contemplation.
|
|
println!("{} pauses briefly... {}", self.name, self.noise());
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
// Type annotation is necessary in this case.
|
|
let mut dolly: Sheep = Animal::new("Dolly".to_string());
|
|
// TODO ^ Try removing the type annotations.
|
|
|
|
dolly.talk();
|
|
dolly.shear();
|
|
dolly.talk();
|
|
}
|
|
```
|
|
|
|
|
|
fn main() {
|
|
assert_eq!(5, sum(2i8, 3u8));
|
|
assert_eq!(50, sum(20, 30.1));
|
|
} |