#[derive(PartialEq)] // Разрешаем для данного типа сравнения.
struct PhantomTuple(A,PhantomData);
// Фантомная структура, которая имеет обобщение `A` со скрытым параметром `B`.
#[derive(PartialEq)] // Разрешаем для данного типа сравнения.
struct PhantomStruct { first: A, phantom: PhantomData }
// Заметьте: память выделена для обобщённого типа `A`, но не для `B`.
// Следовательно, `B` не может быть использована в вычислениях.
fn main() {
// Здесь `f32` и `f64` - скрытые параметры.
// Тип PhantomTuple объявлен с ``.
let _tuple1: PhantomTuple = PhantomTuple('Q', PhantomData);
// Тип PhantomTuple объявлен с ``.
let _tuple2: PhantomTuple = PhantomTuple('Q', PhantomData);
// Тип определён как ``.
let _struct1: PhantomStruct = PhantomStruct {
first: 'Q',
phantom: PhantomData,
};
// Тип определён как ``.
let _struct2: PhantomStruct = PhantomStruct {
first: 'Q',
phantom: PhantomData,
};
// Ошибка времени компиляции! Типы не совпадают, так что сравнение не может быть произведено:
//println!("_tuple1 == _tuple2 даёт в результате: {}",
// _tuple1 == _tuple2);
// Ошибка времени компиляции! Типы не совпадают, так что сравнение не может быть произведено:
//println!("_struct1 == _struct2 даёт в результате: {}",
// _struct1 == _struct2);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Смотрите также:
derive, struct и кортежные структуры
Пример: unit clarification
Полезный метод преобразования единиц измерения может быть получен путём реализации типажа Add с параметром фантомного типа. trait``Add рассмотрен ниже:
// Эта конструкция будет навязывать: `Self + RHS = Output`
// где RHS по умолчанию Self, если иное не указано в реализации.
pub trait Add {
type Output;
fn add(self, rhs: RHS) -> Self::Output;
}
// `Output` должен быть `T` так что `T + T = T`.
impl Add for T {
type Output = T;
...
}
Вся реализация:
use std::ops::Add;
use std::marker::PhantomData;
/// Создаём пустые перечисления для определения типов единиц измерения.
#[derive(Debug, Clone, Copy)]
enum Inch {}
#[derive(Debug, Clone, Copy)]
enum Mm {}
/// `Length` - тип с параметром фантомного типа `Unit`,
/// и не обобщён для типа длины (который `f64`).
///
/// Для `f64` уже реализованы типажи `Clone` и `Copy`.
#[derive(Debug, Clone, Copy)]
struct Length(f64, PhantomData);
/// Типаж `Add` объявляет поведение оператора `+`.
impl Add for Length {
type Output = Length;
// add() возвращает новую структуру `Length`, содержащую сумму.
fn add(self, rhs: Length) -> Length {
// `+` вызывает реализацию `Add` для `f64`.
Length(self.0 + rhs.0, PhantomData)
}
}
fn main() {
// Объявим, что `one_foot` имеет парамет фантомного типа `Inch`.
let one_foot: Length = Length(12.0, PhantomData);
// `one_meter` имеет параметр фантомного типа `Mm`.
let one_meter: Length = Length(1000.0, PhantomData);
// `+` вызывает метод `add()`, который мы реализовали для `Length`.
//
// Так как `Length` реализует `Copy`, `add()` не поглощает
// `one_foot` и `one_meter`, а копирует их в `self` и `rhs`.
let two_feet = one_foot + one_foot;
let two_meters = one_meter + one_meter;
// Сложение работает.
println!("один фут + один фут = {:?} фута", two_feet.0);
println!("один метр + один метр = {:?} метра", two_meters.0);
// Бессмысленные операции потерпят неудачу, как и должно быть:
// Ошибка времени компиляции: несоответствие типов.
//let one_feter = one_foot + one_meter;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Смотрите также:
Заимствование (&), ограничения (X: Y), перечисления, impl & self, перегрузка, ref, типажи (X for Y) и кортежные структуры.
Правила области видимости
Области видимости играют важную роль во владении, заимствовании и времени жизни. То есть, они указывают компилятору, когда заимствования действительны, когда ресурсы могут быть освобождены, и когда переменные создаются или уничтожаются.
RAII
Переменные в Rust не только держат данные в стеке, они также могут владеть ресурсами; к примеру, Box владеет памятью в куче. Поскольку Rust строго придерживается идиоме RAII, то когда объект выходит за зону видимости, вызывается его деструктор, а ресурс, которым он владеет освобождается.
Такое поведение защищает от багов, связанных с утечкой ресурсов. Вам больше никогда не потребуется вручную освобождать память или же беспокоиться об её утечках! Небольшой пример:
// raii.rs
fn create_box() {
// Выделить память для целого число в куче
let _box1 = Box::new(3i32);
// `_box1` здесь уничтожается, а память освобождается
}