XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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

std::mem::drop, Fn, FnMut, Обобщения, where и FnOnce

Анонимность типов

Замыкания временно захватывают переменные из окружающих областей видимости. Имеет ли это какие-либо последствия? Конечно. Как видите, использование замыкания в аргументах функции требует обобщённых типов из-за особенностей реализации замыканий:

#![allow(unused)]

fn main() {

// `F` должен быть обобщённым типом.

fn apply(f: F) where

F: FnOnce() {

f();

}

}

Во время определения замыкания компилятор неявно создаёт новую анонимную структуру для хранения захваченных переменных, тем временем реализуя функциональность для некого неизвестного типа с помощью одного из типажей: Fn, FnMut, или FnOnce. Этот тип присваивается переменной, которая хранится до самого вызова замыкания.

Так как этот новый тип заранее неизвестен, любое его использование в функции потребует обобщённых типов. Тем не менее, неограниченный параметр типа по прежнему будет неоднозначным и недопустим. Таким образом, ограничение по одному из типажей: Fn, FnMut, или FnOnce (которые он реализует) необходимо для использования этого типа.

// `F` должен реализовать `Fn` для замыкания, которое

// ничего не принимает и не возвращает - именно то,

// что нужно для `print`.

fn apply(f: F) where

F: Fn() {

f();

}

fn main() {

let x = 7;

// Захватываем `x` в анонимный тип и реализуем

// `Fn` для него. Сохраняем его как `print`.

let print = || println!("{}", x);

apply(print);

}

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

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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

Подробный разбор, Fn, FnMut, и FnOnce

Входные функции

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

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

// ограниченный типажом `Fn`, и вызывает его.

fn call_me(f: F) {

f();

}

// Объявляем функцию-обёртку, удовлетворяющую ограничению `Fn`

fn function() {

println!("Я функция!");

}

fn main() {

// Определяем замыкание, удовлетворяющее ограничению `Fn`

let closure = || println!("Я замыкание!");

call_me(closure);

call_me(function);

}