Rust на примерах

2.0 * ((x1 - x2).abs() + (y1 - y2).abs())

}

// Этот метод требует чтобы вызываемый объект был изменяемым

// `&mut self` - сахар для `self: &mut Self`

fn translate(&mut self, x: f64, y: f64) {

self.p1.x += x;

self.p2.x += x;

self.p1.y += y;

self.p2.y += y;

}

}

// `Pair` владеет ресурсами: два целых числа в куче

struct Pair(Box, Box);

impl Pair {

// Этот метод "съедает" ресурсы вызываемого объекта

// `self` - сахар для `self: Self`

fn destroy(self) {

// деструктуризация `self`

let Pair(first, second) = self;

println!("Destroying Pair({}, {})", first, second);

// `first` и `second` выходят из области видимости и освобождаются

}

}

fn main() {

let rectangle = Rectangle {

// Статические методы вызываются двойными двоеточиями

p1: Point::origin(),

p2: Point::new(3.0, 4.0),

};

// Метод экземпляра вызывается с помощью оператора точка

// Обратите внимание, что первый аргумент `&self` неявно пропускается т.е.

// `rectangle.perimeter()` === `perimeter(&rectangle)`

println!("Rectangle perimeter: {}", rectangle.perimeter());

println!("Rectangle area: {}", rectangle.area());

let mut square = Rectangle {

p1: Point::origin(),

p2: Point::new(1.0, 1.0),

};

// Ошибка! `rectangle` неизменяемый, но этот метод нуждается в изменяемом

// объекте

//rectangle.translate(1.0, 0.0);

// ЗАДАНИЕ ^ Попробуйте удалить комментарий

// Хорошо, изменяемый объект может вызывать изменяемые методы

square.translate(1.0, 1.0);

let pair = Pair(Box::new(1), Box::new(2));

pair.destroy();

// Ошибка! `destroy` вызывает "съеденный" `pair`

//pair.destroy();

// ЗАДАНИЕ ^ Попробуйте удалить комментарий

}

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

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Замыкания

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

|val| val + x

Синтаксис и возможности замыканий делают их очень удобными для использования "на лету". Использование замыканий похоже на использование функций. Однако, тип входных и возвращаемых значений может быть выведен, а название аргумента должно быть указано.

Другие характеристики замыканий включают в себя:

   • использование || вместо () для аргументов.

   • опциональное ограничения тела функции ({}) для одного выражения (в противном случае обязательно).

   • возможность захвата переменных за пределами окружения

fn main() {

// Инкремент с помощью замыкания и функции.

fn function (i: i32) -> i32 { i + 1 }