Traits и Generics: система типов Rust

1trait Summary {
2    fn summarize(&self) -> String;
3
4    // Метод по умолчанию
5    fn preview(&self) -> String {
6        format!("{}...", &self.summarize()[..50])
7    }
8}

1struct Article {
2    title: String,
3    author: String,
4    content: String,
5}
6
7impl Summary for Article {
8    fn summarize(&self) -> String {
9        format!("{}, by {} - {}", self.title, self.author, &self.content[..100])
10    }
11}
12
13struct Tweet {
14    username: String,
15    content: String,
16}
17
18impl Summary for Tweet {
19    fn summarize(&self) -> String {
20        format!("{}: {}", self.username, self.content)
21    }
22}

1fn largest<T: PartialOrd>(list: &[T]) -> &T {
2    let mut largest = &list[0];
3    for item in &list[1..] {
4        if item > largest {
5            largest = item;
6        }
7    }
8    largest
9}
10
11fn main() {
12    let numbers = vec![34, 50, 25, 100, 65];
13    println!("Largest: {}", largest(&numbers));
14}

1struct Point<T> {
2    x: T,
3    y: T,
4}
5
6// Разные типы
7struct Point2<T, U> {
8    x: T,
9    y: U,
10}
11
12impl<T> Point<T> {
13    fn x(&self) -> &T {
14        &self.x
15    }
16}
17
18// Методы только для определённых типов
19impl Point<f32> {
20    fn distance_from_origin(&self) -> f32 {
21        (self.x.powi(2) + self.y.powi(2)).sqrt()
22    }
23}

1// Через where
2fn process<T>(item: T) -> String
3where
4    T: Summary + Display,
5{
6    format!("{}: {}", item.summarize(), item)
7}
8
9// Инлайн
10fn process<T: Summary + Display>(item: T) -> String {
11    format!("{}: {}", item.summarize(), item)
12}

1use std::fmt::{Debug, Display};
2
3fn print_if_display<T: Display + Debug>(item: T) {
4    println!("Display: {}", item);
5    println!("Debug: {:?}", item);
6}
7
8// Множественные bounds
9fn complex_function<T, U>(t: T, u: U) -> String
10where
11    T: Display + Clone,
12    U: Debug + Default,
13{
14    format!("{}: {:?}", t, u)
15}

1trait Iterator {
2    type Item;
3
4    fn next(&mut self) -> Option<Self::Item>;
5}
6
7struct Counter {
8    current: u32,
9    max: u32,
10}
11
12impl Iterator for Counter {
13    type Item = u32;
14
15    fn next(&mut self) -> Option<Self::Item> {
16        if self.current < self.max {
17            self.current += 1;
18            Some(self.current)
19        } else {
20            None
21        }
22    }
23}

1// Реализация trait для всех типов, реализующих другой trait
2impl<T: Display> ToString for T {
3    fn to_string(&self) -> String {
4        // ...
5    }
6}
7
8// Реализация для всех ссылок
9impl<T: Summary> Summary for &T {
10    fn summarize(&self) -> String {
11        (**self).summarize()
12    }
13}

1trait Animal {
2    fn name(&self) -> &str;
3    fn sound(&self) -> &str {
4        "No sound"
5    }
6}
7
8struct Dog {
9    name: String,
10}
11
12impl Animal for Dog {
13    fn name(&self) -> &str {
14        &self.name
15    }
16
17    fn sound(&self) -> &str {
18        "Woof!"
19    }
20}
21
22struct Fish {
23    name: String,
24}
25
26impl Animal for Fish {
27    fn name(&self) -> &str {
28        &self.name
29    }
30    // sound() использует значение по умолчанию
31}

1// Код дженерика дублируется для каждого типа
2fn process_static<T: Summary>(item: T) {
3    println!("{}", item.summarize());
4}
5
6// Вызов
7process_static(article);  // Отдельная функция для Article
8process_static(tweet);    // Отдельная функция для Tweet

1// Одна функция для всех типов
2fn process_dynamic(item: &dyn Summary) {
3    println!("{}", item.summarize());
4}
5
6// Использование
7let items: Vec<Box<dyn Summary>> = vec![
8    Box::new(article),
9    Box::new(tweet),
10];
11
12for item in &items {
13    process_dynamic(item.as_ref());
14}

1#[derive(Debug, Clone, PartialEq)]
2struct User {
3    name: String,
4    age: u32,
5}
6
7// Автоматическая реализация
8impl std::fmt::Display for User {
9    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10        write!(f, "User {{ name: {}, age: {} }}", self.name, self.age)
11    }
12}

1fn find_largest<T>(list: &[T]) -> &T
2where
3    T: PartialOrd,
4{
5    let mut largest = &list[0];
6    for item in &list[1..] {
7        if item > largest {
8            largest = item;
9        }
10    }
11    largest
12}

1struct Meters(f64);
2struct Kilometers(f64);
3
4impl Meters {
5    fn to_kilometers(&self) -> Kilometers {
6        Kilometers(self.0 / 1000.0)
7    }
8}