Rust на примерах

Конечно типажи тоже могут быть обобщёнными. Здесь мы определяем, тот который повторно реализует типаж Drop как обобщённый метод, чтобы удалить себя и входные данные.

// Некопируемые типы.

struct Empty;

struct Null;

// Обобщённый типаж от `T`.

trait DoubleDrop {

// Определим метод для типа вызывающего объекта,

// который принимает один дополнительный параметр `T` и ничего с ним не делает.

fn double_drop(self, _: T);

}

// Реализация `DoubleDrop` для любого общего параметра `T` и

// вызывающего объекта `U`.

impl DoubleDrop for U {

// Этот метод получает право владения на оба переданных аргумента и

// освобождает их.

fn double_drop(self, _: T) {}

}

fn main() {

let empty = Empty;

let null = Null;

// Освободить `empty` и `null`.

empty.double_drop(null);

//empty;

//null;

// ^ TODO: Попробуйте раскомментировать эти строки.

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Смотрите также:

Drop, struct и trait

Ограничения

При работе с обобщениями параметры типа часто должны использовать типажи в качестве ограничений, чтобы определить какие функциональные возможности реализует тип. Например, в следующем примере для печати используется типаж Display и поэтому требуется T ограничить по Display. Это значит что T должен реализовать Display.

// Определим функцию `printer`, которая принимает обобщённый тип `T`,

// который должен реализовать типаж `Display`

fn printer(t: T) {

println!("{}", t);

}

Ограничение сужает список типов, допустимых к использованию. То есть:

struct S(T);

// Ошибка! `Vec` не реализует `Display`. Эта

// специализация не удастся

let s = S(vec![1]);

Другой эффект ограничения заключается в том, что обобщённые экземпляры имеют доступ к методам типажей, указанных в ограничениях. Например:

// Типаж, который реализует маркер печати: `{:?}`.

use std::fmt::Debug;

trait HasArea {

fn area(&self) -> f64;

}

impl HasArea for Rectangle {

fn area(&self) -> f64 { self.length * self.height }

}

#[derive(Debug)]

struct Rectangle { length: f64, height: f64 }

#[allow(dead_code)]

struct Triangle { length: f64, height: f64 }

// Обобщённый тип `T` должен реализовать `Debug`. Независимо

// от типа, это будет работать правильно.

fn print_debug(t: &T) {

println!("{:?}", t);

}

// `T` должен реализовать `HasArea`. Любая функция, которая удовлетворяет

// ограничению может получить доступ к функции `area` из `HasArea`.

fn area(t: &T) -> f64 { t.area() }

fn main() {

let rectangle = Rectangle { length: 3.0, height: 4.0 };