07. Често срещани trait-ове

27 октомври 2017

Административни неща

Домашно 1 приключи
1ви ноември (следващата сряда) няма лекция
15ти декември, лекцията е в зала 200

Преговор

Generics/Обобщени типове (за функции, структури, енумерации)
Turbofish!
Traits/Типажи
Trait objects

Гласуване

Как да наричаме оператора ::?

четири точки
две по две точки
scope оператор
turbo

Домашното

Demo

Често използвани trait-ове

В стандартната библиотека са дефинирани много често използвани trait-ове
Голяма част от rust екосистемата разчита на тях
Само ние можем да имплементираме стандартните trait-ове за наши типове
Затова е добре да имплементираме всички стандартни trait-ове, които можем

Често използвани trait-ове

Списък

Copy
Clone
Eq
PartialEq
Ord
PartialOrd
Hash
Debug
Display
Default

Clone

trait Clone {
    fn clone(&self) -> Self;

    fn clone_from(&mut self, source: &Self) { ... }
}

Създава копие на обекта
Позволява да си дефинираме собствена логика за копирането
Поддържа #[derive(Clone)], ако всички полета имплементират Clone
derive извиква clone на всички полета рекурсивно
Рядко ще се налага да правим ръчна имплементация на Clone, защото не работим с гола памет!

Copy

trait Copy: Clone { }

Marker trait
Показва, че стойността може да се копира чрез копиране на паметта бит по бит
т.е. memcopy
Променя се семантиката за присвояване на стойност от преместване (move) на копиране (copy)
Supertrait Clone
Може да се добави с #[derive(Copy)]

Можем да имплементираме Copy само ако:

всички полета са Copy
типа няма дефиниран деструктор (т.е. не е Drop)

Drop

pub trait Drop {
    fn drop(&mut self);
}

Позволява да дефинираме деструктори
Извиква се когато обекта излезе от scope
Не може да се извика ръчно
Можем използваме std::mem::drop за това

Default

trait Default {
    fn default() -> Self;
}

Позволява създаване на обект със стойност по подразбиране
Може да се добрави с #[derive(Default)], ако всички полета имплементират Default
Q: Default или fn new() -> Self
A: и двете

Hash

Използва се от типове и функции, които използват хеширане
Например ключовете на HashMap и HashSet
Може да се добави с #[derive(Hash)], ако всички полета имплементират Hash
Няма да показваме ръчна имплементация

Display & Debug

struct MagicTrick {
    description: String,
    secrets: Vec<String>,
    skills: Vec<String>
}

let trick = MagicTrick {
    description: String::from("Изчезваща монета"),
    secrets: vec![String::from("Монетата се прибира в ръкава")],
    skills: vec![String::from("Бързи ръце"), String::from("Заблуда")]
};

println!("{}", trick);
println!("===");
println!("{:?}", trick);

Display & Debug

Ще очакваме следния изход след като имплементираме Dispay и Debug за MagicTrick

Магически трик "Изчезваща монета"
===
Трик
  Описание: "Изчезваща монета"
  Тайни: ["Монетата се прибира в ръкава"]
  Умения: ["Бързи ръце", "Заблуда"]

Display

Използва се за форматиране на стойност, която ще се показва на потребителя
Не може да се derive-не за разлика от Debug
Използва се от placeholder-a {}

Display

use std::fmt::{self, Display, Formatter};

impl Display for MagicTrick {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(f, "Магически трик {:?}", self.description)
    }
}

Display

Нека да разбием примера и да видим какво oзначават новите неща

Макрос write

write!(f, "Магически трик {:?}", self.description)

Подобно на print! и format!
Записва форматиран текст в структура, която имплементира Write trait

Result

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Големият брат на Option<T>
Позволява връщане на резултат с Ok(T) или грешка с Err(E)
Има type alias-и в някои модули, например:
mod fmt { type Result = Result<(), fmt::Error> }
mod io { type Result<T> = Result<T, io::Error> }

Display

let trick = MagicTrick {
    description: String::from("Изчезваща монета"),
    secrets: vec![String::from("Монетата се прибира в ръкава")],
    skills: vec![String::from("Бързи ръце"), String::from("Заблуда")]
}

println!("{}", trick);

Debug

Използва се за форматиране на стойност, която ще се показва само с цел debug
Както знаете #[derive(Debug)] имплементира версия по подразбиране
Използва се от placeholder-a {:?}

Debug

use std::fmt::{self, Debug, Formatter};

impl Debug for MagicTrick {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write! {
            f,
            r#"
            Трик
              Описание: {:?}
              Тайни {:?}
              Умения {:?}
            "#,
            self.description,
            self.secrets,
            self.skills
        }
    }
}

Display & Debug

let trick = MagicTrick {
    description: String::from("Изчезваща монета"),
    secrets: vec![String::from("Монетата се прибира в ръкава")],
    skills: vec![String::from("Бързи ръце"), String::from("Заблуда")]
};

println!("{}", trick);
println!("===");
println!("{:?}", trick);

Предефиниране на оператори

Операторите се дефинират с trait-ове

Видяхме trait-а Add, с който дефинираме оператора +

trait Add<RHS = Self> {
    type Output;

    fn add(self, rhs: RHS) -> Self::Output;
}

Предефиниране на оператори

Примери

Add, Sub, Mul, Div, Rem
BitAnd, BitOr, BitXor, Shl, Shr
*Assign
Neg, Not
Index
IndexMut

Предефиниране на оператори

Demo

Предефиниране на оператори

Eq

trait PartialEq<Rhs = Self> where Rhs: ?Sized {
    fn eq(&self, other: &Rhs) -> bool;

    fn ne(&self, other: &Rhs) -> bool { ... }
}

Дефинира операторите == и !=
Не е задължително a == a да върне true
assert_eq!(f64::NAN == f64::NAN, false);

Предефиниране на оператори

Eq

trait Eq: PartialEq<Self> { }

Marker trait
Задължава a == a да е true

Предефиниране на оператори

Ord

trait PartialOrd<Rhs = Self>: PartialEq<Rhs> where Rhs: ?Sized {
    fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;

    fn lt(&self, other: &Rhs) -> bool { ... }
    fn le(&self, other: &Rhs) -> bool { ... }
    fn gt(&self, other: &Rhs) -> bool { ... }
    fn ge(&self, other: &Rhs) -> bool { ... }
}

enum Ordering {
    Less,
    Equal,
    Greater,
}

Предефиниране на оператори

Ord

Дефинира операторите < <= > >=

PartialOrd дефинира частична наредба

assert_eq!(f64::NAN < 0., false);
assert_eq!(f64::NAN >= 0., false);

Предефиниране на оператори

Ord

trait Ord: Eq + PartialOrd<Self> {
    fn cmp(&self, other: &Self) -> Ordering;

    fn max(self, other: Self) -> Self { ... }
    fn min(self, other: Self) -> Self { ... }
}

Дефинира тотална наредба

Въпроси

http://fmi.rust-lang.bg/