&cardinal));
println!("Голубая сойка {} птица", blue(&blue_jay));
//println!("Индюк {} птица", red(&_turkey));
// ^ TODO: Попробуйте раскомментировать эту строку.
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Смотрите также:
std::cmp::Eq, std::marker::Copy и трейты
Множественные ограничения
Множественные ограничения по типажу могут быть применены с помощью +. Разные типы разделяются с помощью ,.
use std::fmt::{Debug, Display};
fn compare_prints(t: &T) {
println!("Debug: `{:?}`", t);
println!("Display: `{}`", t);
}
fn compare_types(t: &T, u: &U) {
println!("t: `{:?}", t);
println!("u: `{:?}", u);
}
fn main() {
let string = "words";
let array = [1, 2, 3];
let vec = vec![1, 2, 3];
compare_prints(&string);
//compare_prints(&array);
// ЗАДАНИЕ ^ Попробуйте удалить комментарий.
compare_types(&array, &vec);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Смотрите также:
std::fmt и trait
Утверждения where
Ограничение типажа также может быть выражено с помощью утверждения where непосредственно перед открытием {, а не при первом упоминании типа. Кроме того, утверждения where могут применять ограничения типажей к произвольным типам, а не только к параметрам типа.
В некоторых случаях утверждение where является полезным:
• При указании обобщённых типов и ограничений типажей отдельно, код становится более ясным:
impl MyTrait for YourType {}
// Выражение ограничений типажей через утверждение `where`
impl MyTrait for YourType where
A: TraitB + TraitC,
D: TraitE + TraitF {}
• Использование утверждения where более выразительно, чем использование обычного синтаксиса. В этом примере impl не может быть непосредственно выражен без утверждения where:
use std::fmt::Debug;
trait PrintInOption {
fn print_in_option(self);
}
// Потому что в противном случае мы должны были бы выразить это как
// `T: Debug` или использовать другой метод косвенного подхода,
// для этого требуется утверждение `where`:
impl PrintInOption for T where
Option: Debug {
// Мы хотим использовать `Option: Debug` как наше ограничение
// типажа, потому то это то, что будет напечатано. В противном случае
// использовалось бы неправильное ограничение типажа.
fn print_in_option(self) {
println!("{:?}", Some(self));
}
}
fn main() {
let vec = vec![1, 2, 3];
vec.print_in_option();
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Смотрите также:
RFC, структуры, и типажи
New Type идиома
Идиома newtype гарантирует во время компиляции, что программе передаётся значение правильного типа.
Например, функция верификации возраста, которая проверяет возраст в годах должна получать значение типа Years.
struct Years(i64);
struct Days(i64);
impl Years {
pub fn to_days(&self) -> Days {
Days(self.0 * 365)
}
}
impl Days {
/// truncates partial years
pub fn to_years(&self) -> Years {
Years(self.0 / 365)
}
}
fn old_enough(age: &Years) -> bool {
age.0 >= 18
}
fn main() {
let age = Years(5);
let age_days = age.to_days();
println!("Old enough {}", old_enough(&age));
println!("Old enough {}", old_enough(&age_days.to_years()));
// println!("Old enough {}", old_enough(&age_days));
}
Удалите комментарий с последнего println, чтобы увидеть, что тип должен быть Years.
Чтобы получить из newtype-переменной значение базового типа, вы можете использовать кортежный синтаксис, как в примере:
struct Years(i64);
fn main() {
let years = Years(42);
let years_as_primitive: i64 = years.0;
}
Смотрите также:
struct
Ассоциированные элементы
"Ассоциированные элементы" относятся к набору правил, касающихся элементов различных типов. Это расширение для обобщённых типажей, которое позволяет им определить новый элемент внутри себя.
Каждый такой элемент называется ассоциированным типом и предоставляет упрощённый шаблон использования, когда trait является обобщённым для своего контейнера.
Смотрите также:
RFC
Проблема
trait, являющийся обобщённым для своего контейнера, есть требование к спецификации типа - пользователи trait