Замыкания в Rust

Моя цель - предложение широкого ассортимента товаров и услуг на постоянно высоком качестве обслуживания по самым выгодным ценам.

Прежде чем перейти к статье, хочу вам представить, экономическую онлайн игру Brave Knights, в которой вы можете играть и зарабатывать. Регистируйтесь, играйте и зарабатывайте!

  • Предыдущая часть: Заменяем глобальный аллокатор
  • Начало и содержание: Владение

Трудности замыкания


Замыкания в Rust — это функции, которые используют переменные в своей области видимости, пример:


    let mut call_count = 0;

    let mut sum = | x, y | {
        call_count += 1;
        x + y
    };

    dbg!(sum(2, 2));
    dbg!(sum(3, 3));
    dbg!(sum(4, 4));
    dbg!(call_count);

Тема непростая, и не только для Rust. Казалось бы, что может быть проще JavaScript? Но ведь и там: What is a closure in JavaScript and why most people have the wrong idea?.


В другой статье рассматривается вот такой код:


let fns =[]

for(var i = 0; i < 5; i++) {
    var c = i * 2;
    fns.push( _ => console.log(c))
}

fns.forEach( f => f() )

Как бы, что будет? Код, с точки зрения автора, проблематичен и проблема названа "The For Loop little problem".


Схожий по неочевидности сценарий для Go (подробное обсуждение здесь):


fns := make([]func(),0)

for i := 0; i < 5; i++ {
    f := func(){fmt.Println(i)}
    fns = append(fns, f)
}

for _, f := range(fns){
    f()
}

Для Rust все это многократно усложняется заимствованиями, временами жизни, контролем за изменяемостью (mut), дополнительным способом определения замыканий через move и необходимостью в некоторых случаях использовать Box для возврата замыканий. Количество вариантов огромно, ранее полученные по Rust знания помогают плохо (что особенно досадно и внезапно). В общем, краткая и емкая статья по теме замыканий долго не получалась, норовя обернуться многостраничным (а то и многостатейным) монстром.


В конечном итоге вроде бы нашел подход, он заключается в следующем. Компиляторы для замыканий делают много неявной работы, если эту работу смоделировать и показать в условно эквивалентном коде, все станет намного яснее. Наверное. Попробуем.


Базовые случаи использования внешних переменных в замыканиях Rust


  • Использование значения non-Copy переменной
  • Использование значения Copy-переменной
  • Использование ссылки на Copy или non-Copy
  • move + использование значения Copy-переменной
  • move + использование ссылки на Copy или non-Copy

В реальности, конечно, могут встретиться разнообразные комбинации указанных сценариев (добро пожаловать в ад), но это уже оставляю читателю на самостоятельный разбор.


Использование значения non-Copy переменной


Пример:


    {
        let s = String::from("hello");

        let closure = || {
            dbg!(s);
        };

        // dbg!(s); // error[E0382]: use of moved value: `s`

        closure();
        // closure(); // error[E0382]: use of moved value: `closure`
    }

Такое замыкание безвозвратно "кушает" переменную s, ее больше нельзя использовать, а само замыкание нельзя вызвать более одного раза.


Замыкание такого типа моделируется структурой Closure {s: String,} которая реализует FnOnce:


trait FnOnce {
    fn call_once(self);
}

Наш FnOnce является упрощенной моделью std::ops::FnOnce, через которую замыкание используется в реальности:


pub trait FnOnce<Args> {
    ...
    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
    ...

Тут надо заметить, что такое определение не есть "настоящий сварщик", это как бы intrinsic, который особым образом обрабатывается компилятором.


Данные условно-эквивалентного замыкания инициализируются следующим образом:


    let closure = Closure{s: s};

Ясно, что дальнейшее использование s исключено, так как Copy для строк не реализован и происходит передача владения значением в поле Closure.s.


Вызов происходит так:


    closure.call_once(1);    
    // ClosureFnOnce::call_once(closure, 1);

Во второй строке показан эквивалент вызова и по нему видно, что владение переменной closure переходит в метод call_once(), и closure далее использовать нельзя.


Такое замыкание без проблем можно вернуть из функции или передать в поток, тип возвращаемого значения описывается как impl std::ops::FnOnce() -> ():


fn new_closure() -> impl std::ops::FnOnce() -> () {
    let s = String::from("new_closure");
    || {
        dbg!(s);
    }
}

fn new_equivalent_closure() -> Closure {
    let s = String::from("new_equivalent_closure");
    Closure{s: s}
}

Итого:


  • Захваченные non-Copy переменные далее использовать вне тела замыкания нельзя
  • Замыкание FnOnce можно использовать только один раз
  • При таком способе захвата замыкание можно возвращать из функций и передавать в потоки

Использование значения Copy-переменной


Теперь рассмотрим такой пример:


    // Capturing a variable whose type implements Copy
    {
        let mut p = Point{x: 10, y: 20};
        {
            let closure = || {
                dbg!(p);
            };

            // p.x = 11; // error[E0506]: cannot assign to `p.x` because it is borrowed
            dbg!(p);

            closure(); 
            closure();
        }
        p.x = 11;
        dbg!(p);
    }

В качестве типа захватываемой переменной будем использовать:


#[derive(Copy, Clone, Debug)]
struct Point {
    x: i32,
    y: i32,
}

Для такого случая компилятор "приготовит" Fn:


pub trait Fn<Args>: FnMut<Args> {
    ...
    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}

Обратим внимание, что теперь self передается по ссылке, а определение "эквивалента" содержит ссылку на переменную и пестрит временами жизни:


struct Closure<'a> {
    p: &'a Point,
}

impl<'a> Fn for Closure<'a> {
    fn call(&self) {
        dbg!(*self.p);
    }
}

Иными словами, использование в замыкании переменной такого типа по значению компилируется в использование по ссылке.


Это кардинально меняет свойства замыкания. Теперь его можно вызвать несколько раз но нельзя возвратить из функции, так как в Rust нельзя возвращать ссылки на локальные переменные:


fn new_equivalent_closure<'a>() -> Closure<'a> {
    let p = Point{x: 10, y: 20};
    Closure{p: &p}
}

error[E0515]: cannot return value referencing local variable `p`

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


Замыкание может менять данные, при этом замыкание будет иметь форму FnMut:


pub trait FnMut<Args>: FnOnce<Args> {
    ...
    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
}

Из "эквивалента" видно, что надо везде тщательно проставить mut, плюс замыкание блокирует переменную на запись, так что читать ее в области видимости замыкания нельзя.


Итого:


  • Захваченные на чтение Copy-переменные нельзя изменять в области видимости замыкания
  • Захваченные на запись Copy-переменные нельзя читать в области видимости замыкания
  • Замыкания Fn/FnMut можно использовать несколько раз
  • При таком способе захвата Fn/FnMut нельзя передавать в потоки и возвращать из функций

Использование ссылки на Copy или non-Copy


Получается то же, что и для случая использования Copy-переменной по значению, между Copy и non-Copy разницы нет.


move + использование значения Copy-переменной


Если требуется возвратить замыкание, которое захватывает локальную Copy-переменную, или передать его в поток, то на помощь придет move. При этом переменная будет скопирована в данные замыкания и использована по значению:


    let mut p = Point{x: 10, y: 20};
    {
        let mut closure = move || {
            p.y += 1;
            dbg!(p);
        };
    }

"Эквивалент" теперь выглядит так:


struct Closure {
    p: Point,
}

impl FnMut for Closure {
    fn call(&mut self) {
        self.p.x += 1;
        dbg!(self.p);
    }
}

Никаких ссылок, прекрасно! Теперь замыкание можно возвращать из функций и передавать в потоки:


fn new_closure() -> impl std::ops::FnMut() -> () {
    let mut p = Point{x: 300, y: 400};
    move || {
        p.y += 1;
        dbg!(p);
    }
}

fn new_equivalent_closure() -> Closure {
    let p = Point{x: 500, y: 660};
    Closure{p: p}
}

Изменения данных внутри замыкания никак не сказываются на "захваченной" переменной:


    // move + capturing a variable whose type implements Copy
    {
        let mut p = Point{x: 10, y: 20};
        let mut closure = move || {
            p.x += 1;
            dbg!(p);
        };

        dbg!(p); // 10, 20

        closure();  // 11, 20
        closure();  // 12, 20

        dbg!(p); // 10, 20
    }

Интересный нюанс — компилятор требует изменяемости p, хотя она не меняется. Здесь налицо костыль — через mut внешней переменной мы объявляем изменяемость ее копии в теле замыкания. Фу так делать. В "эквиваленте" все работает без mut:


    // Equivalent
    {
        let p = Point{x: 100, y: 200};
        let mut closure = Closure{p: p};

        dbg!(p);

        closure.call(); 
        closure.call();

        dbg!(p);
    }

Итого:


  • move разрывает связь между замыканием и "захваченной" переменной, переменная используется по значению
  • При таком способе захвата получается замыкание типа Fn/FnMut, его можно возвратить из функций или передать в поток
  • Внутри move-замыканий нельзя использовать non-Copy переменные по значению

Формально, кстати, такая конструкция не является замыканием, так как в ней отсутствуют ссылки на переменные, объявленные вне тела этой функции:


Замыкание (англ. closure) в программировании — функция первого класса, в теле которой присутствуют ссылки на переменные, объявленные вне тела этой функции в окружающем коде и не являющиеся её параметрами. Говоря другим языком, замыкание — функция, которая ссылается на свободные переменные в своей области видимости.

Замыкание (программирование)

move + использование ссылки на Copy или non-Copy


При использовании ссылки на внешнюю переменную эта переменная будет скопирована в данные замыкания и ссылка будет уже на локальную копию.


При помощи этой штуки легко "наступить на грабли":


fn move_by_x(p: &mut Point, delta: i32) {
    p.x += delta;
}

fn main() {
    let mut p = Point{x: 10, y: 20};
    let mut closure = move || {
        move_by_x(&mut p, 1);
        dbg!(&p);
    };
    ...

Т.е. передаем в move_by_x() ссылку, компилятор требует изменяемости p (mut p), можно наивно ожидать, что move_by_x() изменит оригинальное значение, но нет.


Понятно, что вариантом использования по ссылке является вызов метода, у которого получателем (receiver) является &self. Пример:


impl Point {
    fn move_by_x(&mut self, delta: i32) {
        self.x += delta;
    }
}

fn main() {
    let mut p = Point{x: 10, y: 20};
    let mut closure = move || {
        p.move_by_x(1);
        dbg!(&p);
    };
    ...

Свойства замыкания такие же, как и для "move + значение", т.е. получается Fn/FnMut, его можно вызывать много раз, возвращать из функций и передавать в потоки.


Но один интересный нюанс таки есть. Обращаясь к non-Copy переменной по ссылке при помощи move можно сделать возвращаемый (или "передаваемый в потоки") Fn/FnMut:


fn new_closure() -> impl FnMut(){
    let mut s = String::from("Back");
    move || {
        s.push_str(" in the");
        s.push_str(" U.S.S.R");
        dbg!(&s);
    }    
}

fn main() {   
    let mut closure = new_closure();

    closure();
    closure();
    closure();
}

Напротив, вариант без move позволяет вернуть для такой переменной только одноразовый FnOnce:


fn new_closure() -> impl FnOnce(){
    let mut s = String::from("Back");
    || {
        s.push_str(" in the");
        s.push_str(" U.S.S.R");
        dbg!(s);
    }    
}

fn main() {
    let closure = new_closure();

    closure();
    // closure(); // error[E0382]: use of moved value: `closure`
}

Здесь "возращаемость" обеспечивается использованием по значению (dbg!(s)), одновременно это превращает замыкание в FnOnce.


С использованием внешних переменных внутри замыканий разобрались, теперь посмотрим, как замыкания передавать в функции.


Передача замыканий в функции при помощи параметров типа


В Rust есть три встроенных типа, которые соответствуют замыканиям, иерархия такова: Fn -> FnMut -> FnOnce. Т.е. если функция требует FnOnce, вместо него можно подать Fn или FnMut и так далее.


Допустим, у нас есть замыкание:


    let mut call_count = 0;

    let sum = |x, y| {
        call_count += 1;
        x + y
    };

Есть ажно три способа принять его при помощи параметров типа.


Классика:


fn call_sum_way1<F: FnMut(i32, i32) -> i32>(mut sum: F) {

Фастфуд:


fn call_sum_way2(mut sum: impl FnMut(i32, i32) -> i32) {

Стильно, модно, молодежно, рекомендовано:


fn call_sum_way3<F>(mut sum: F)
where
    EXISTS (SELECT FROM Items WITH (NOLOCK) WHERE Name = F.Name AND Type = "FnMut" AND ParamsCount = 2  AND ResultsCount = 1) 
    AND EXISTS (SELECT FROM Params WHERE FuncName = F.Name AND Idx = 0 and Type = "i32") 
    AND EXISTS (SELECT FROM Params WHERE FuncName = F.Name AND Idx = 1 and Type = "i32")     
    AND EXISTS (SELECT FROM Results WHERE FuncName = F.Name AND Idx = 0 and Type = "i32")     

Шутка, вот так на самом деле:


fn call_sum_way3<F>(mut sum: F)
where
    F: FnMut(i32, i32) -> i32,

Все три способа в песочнице.


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


fn main() {
    let sum = |x, y| {
        x + y
    };
    call_sum(sum);

    let sum = |x, y| {
        x + y + 20
    };
    call_sum(sum);
}

fn call_sum<F: FnMut(i32, i32) -> i32>(mut sum: F) {
    sum(2, 2);
    sum(3, 3);
    sum(4, 4);
}   

Каждое замыкание имеет свой собственный неявный тип, так что компилятор сгенерирует два варианта функции call_sum() под каждый из них, несмотря на то, что сигнатуры замыканий идентичны. Чтобы в этом убедиться опять посмотрим в ассемблер, выключив в настройках Symbol Demangling:


_ZN10playground8call_sum17h27c8971da28680efE:
    sub rsp, 56
    mov dword ptr [rsp + 16], 2
    mov dword ptr [rsp + 20], 2
    mov esi, dword ptr [rsp + 16]
    mov edx, dword ptr [rsp + 20]
    lea rdi, [rsp + 8]
    call    _ZN10playground4main28_$u7b$$u7b$closure$u7d$$u7d$17h1ec7382e3c1e9c39E
    jmp .LBB17_1
    ...
_ZN10playground8call_sum17h6c6a460f1c9cf47aE:
    sub rsp, 56
    mov dword ptr [rsp + 16], 2
    mov dword ptr [rsp + 20], 2
    mov esi, dword ptr [rsp + 16]
    mov edx, dword ptr [rsp + 20]
    lea rdi, [rsp + 8]
    call    _ZN10playground4main28_$u7b$$u7b$closure$u7d$$u7d$17h9220f028b950d2f4E
    jmp .LBB18_1
    ...    

Передача замыканий при помощи умных указателей


Принимающая функция может быть скомпилирована в одном варианте ("динамический полиморфизм" или "полиморфизм подтипов"), для этого нужно передавать замыкание через "кучу":


fn main() {
    let sum = |x, y| {
        x + y
    };
    call_sum(Box::new(sum));

    let sum = |x, y| {
        x + y + 20
    };
    call_sum(Box::new(sum));
}

fn call_sum(mut sum: Box<dyn FnMut(i32, i32) -> i32>) {
    sum(2, 2);
    sum(3, 3);
    sum(4, 4);
}

  • Данные перемещаются в кучу при помощи Box::new(sum)
  • Таким образом в кучу можно помещать много чего, не только замыкания
  • В описании параметров нужно использовать волшебное слово dyn (динамический же полиморфизм)
  • call_sum() при этом компилируется в одном экземпляре

Кому-то покажется более изящным такой способ определения параметров:


type MyClosure = dyn FnMut(i32, i32) -> i32;

fn call_sum(mut sum: Box<MyClosure>) {
    sum(2, 2);
    sum(3, 3);
    sum(4, 4);
}

Возврат замыканий из функций


Из функций и методов замыкание можно возвращать таким образом:


fn main() {
    dbg!(get_sum(1)(10, 20));
    dbg!(get_sum(2)(10, 20));
}

fn get_sum(mult: i32) -> impl FnMut(i32, i32) -> i32 {
    return move |x, y| {
        mult * (x + y)
    };
}

Без move тут не получится, так как иначе мы вернем замыкание, которое ссылается на локальную переменную — параметр mult. Так дело не пойдет, опасно, нужно "замести" все переменные в данные замыкания, что и делает move.


Надо заметить, что вернуть замыкание можно только из одного места, например, вот такой пример не компилируется:


fn get_sum2(mult: i32, minus: bool) -> impl FnMut(i32, i32) -> i32 {
    if minus {
        return move |x, y| {
            mult * (x + y)
        };
    } else {
        return move |x, y| {
            mult * (x - y)
        };        
    }
}

Сообщения компилятора шикарны:


  = note: to return `impl Trait`, all returned values must be of the same type
  = note: no two closures, even if identical, have the same type
  = help: consider boxing your closure and/or using it as a trait object

Возврат через impl не работает для интерфейсов:


trait Summer {
    fn get_sum(mult: i32) -> impl FnMut(i32, i32) -> i32;
}

error[E0562]: `impl Trait` not allowed outside of function and method return types
 --> src/lib.rs:2:30
  |
2 |     fn get_sum(mult: i32) -> impl FnMut(i32, i32) -> i32;
  |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^

Интересно, почему? Рассмотрим вот такой пример:


fn call_closure() {
    get_closure()();
}

fn call_closure2() {
    get_closure2()();
}

fn get_closure() -> impl Fn() {
    let array: [i32; 50] = [0; 50];
    return move || {
        dbg!(array);
    };
}

fn get_closure2() -> impl Fn() {
    let array: [i32; 100] = [0; 100];
    return move || {
        dbg!(array);
    };
}

В этом примере мы возвращаем два замыкания с данными разного размера. Включим для ассемблера Symbol Demangling и посмотрим, что получается:


playground::call_closure:
    sub rsp, 200
    mov rdi, rsp
    call    playground::get_closure
    mov rdi, rsp
    call    playground::get_closure::{{closure}}
    add rsp, 200
    ret

playground::call_closure2:
    sub rsp, 408
    lea rdi, [rsp + 8]
    call    playground::get_closure2
    lea rdi, [rsp + 8]
    call    playground::get_closure2::{{closure}}
    add rsp, 408
    ret

Вон оно что, данные замыкания возвращается через стек и вызывающая сторона должна подготовить место для этого (sub rsp, ...). Размер данных замыкания известен компилятору только если он имеет возможность "увидеть" что происходит внутри вызываемой функции. В случае, когда замыкание возвращается из интерфейса, "внутрь" не посмотреть, размер данных неизвестен, может возвращаться что угодно, так что в кучу, товарищи:


trait Summer {
    fn get_sum(mult: i32) -> Box<dyn FnMut(i32, i32) -> i32>;
}

Передача замыканий в потоки


Пример:


use std::thread;

fn main() {
    let s = String::from("Hello");

    let handle = thread::spawn(|| {
        dbg!(s);
    });

    handle.join().unwrap();
}

В данном случае все просто — мы готовим FnOnce, thread::spawn() принимает именно такой тип, все работает (unwrap() требует отдельного рассмотрения, не в этой статье).


Определенные "тонкости" в процессе передачи замыканий в потоки, конечно, есть. Чтобы в них разобраться, рассмотрим сигнатуру thread::spawn:


pub fn spawn<F, T>(f: F) -> JoinHandle<T> 
where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static, 

F: Send + 'static означает, что данные замыкания должны уметь безопасно передаваться между потоками (Send), и все ссылки в данных замыкания (если они есть) должны иметь время жизни static, т.е. ссылаться на локальные переменные внутри замыкания нельзя. Рассмотрим Send и 'static более подробно.


Передача замыканий в потоки::Send


Send это такой маркерный интерфейс типаж, который указывает, что значение может передаваться между потоками. Согласно Книге:


Почти каждый тип Rust является типом Send, но есть некоторые исключения, вроде Rc: он не может быть Send, потому что если вы клонировали значение Rc и попытались передать владение клоном в другой поток, оба потока могут обновить счётчик ссылок одновременно.

Разрешение передачи во владение между потоками с помощью Send

Проверим. Возьмем Box, его цель — просто хранить значение в куче. Работает:


    let p = Box::new(Point { x: 10, y: 20 });

    let handle = thread::spawn(|| {
        dbg!(p);
    });
    handle.join().unwrap();

Мы сохранили значение в куче и передали его через данные замыкания в поток. Теперь очередь Rc. Его задача — хранить значение в куче и вести счетчик ссылок на него, когда все держатели ссылок выйдут из области видимости, память освобождается:


    let p1 = Rc::new(Point { x: 10, y: 20 });
    let p2 = p1.clone();
    let p3 = p1.clone();
    dbg!(p1);
    dbg!(p2);
    dbg!(p3);

  • p1, p2 и p3 ссылаются на единственное значение в куче
  • p1, p2 и p3 можно передать в разные функции и там использовать
  • Менять значение за p1, p2 и p3 нельзя.

Rc быстр, но потокоопасен, поэтому замыкание, которое его использует, лишается почетного значка Send:


    let p = Rc::new(Point { x: 10, y: 20 });

    let handle = thread::spawn(|| {
        dbg!(p);
    });

    handle.join().unwrap();

error[E0277]: `Rc<Point>` cannot be sent between threads safely
   --> src/main.rs:13:18
    |
13  |       let handle = thread::spawn(|| {
    |  __________________^^^^^^^^^^^^^_-
    | |                  |
    | |                  `Rc<Point>` cannot be sent between threads safely

Передача замыканий в потоки::'static


Значения, на которые ссылаются замыкания, передаваемые в потоки, должны жить долго, гарантированно не меньше, чем поток — т.е. то самое 'static. Вот такое не пройдет:


use std::thread;

fn main() {
    let x = 10;

    let handle = thread::spawn(|| {
        dbg!(x);
    });

    handle.join().unwrap();
}

6 |     let handle = thread::spawn(|| {
  |                                ^^ may outlive borrowed value `x`
7 |         dbg!(x);
  |              - `x` is borrowed here
  |
note: function requires argument type to outlive `'static`

Тут-то и пригодится move ||:


use std::thread;

fn main() {
    let x = 10;

    let handle = thread::spawn(move || {
        dbg!(x);
    });

    handle.join().unwrap();
}

В данных замыкания теперь хранится не ссылка, а копия значения, так что требование 'static удовлетворяется — ссылок-то вообще нет. Вроде просто, но есть нюансы. Например, вот так — можно:


use std::thread;

fn main() {
    let s = String::from("hello");

    let handle = thread::spawn(|| {
        dbg!(s);
    });

    handle.join().unwrap();
}

Отличие тут в том, что String не реализует интерфейс Copy, выражение dbg!(s) "съедает" переменную s по значению, поэтому для компилятора нет нужды в данных замыкания хранить ссылку на значение, можно это значение сразу переместить в данные замыкания — вне замыкания изменить s, в отличие от x, нельзя.


Иными словами, ключевое слово move незаменимо, если замыкание передается в поток (или возвращается из функции) и использует локальное значение типа, который умеет в Copy.


Как-то так, пора заканчивать.


Некоторые размышления


В прекрасном языке программирования будущего я бы кардинально упростил замыкания путем их усложнения. Указывать способ "захвата" и изменяемость следует явно, напрямую использовать переменные из окружающей среды нельзя:


    let x = 10;

    // Используем копию x
    let captureByValue = {closurex: x} || {
        dbg!(closurex)
        // dbg!(x) // error[E0425]: cannot find value `x` in this scope
    });

    // Используем изменяемую копию x
    let mutCaptureByValue = {mut closurex: x} || {
        // Изменяем локальную копию
        closurex = 20;
    });    

    // Используем ссылку на x
    let captureByReference = {closurex: &x} || {
        ...
        // Изменяем оригинальное значение
        *closurex += 1;
    });

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


Конечно, будут определенные сложности с определением, приведенным ранее:


"Замыкание (англ. closure) в программировании — функция первого класса, в теле которой присутствуют ссылки на переменные, объявленные вне тела этой функции в окружающем коде и не являющиеся её параметрами"

Тут да, сложнее, имеем дело с традициями, корни которых уходят в прошлое тысячелетие. Замечу, что "замыкания" в Rust, определенные с ключевым словом move, также не являются "замыканиями" в приведенном выше смысле, так у них в теле нет ссылок на внешние переменные.


На этом все по замыканиям.

Источник: https://habr.com/ru/post/588917/


Интересные статьи

Интересные статьи

Рано или поздно, каждый пэхапешник, пишущий на битриксе, начинает задумываться о том, как бы его улучшить, чтобы и всякие стандарты можно было соблюдать, и современные инструменты разработки использов...
Объяснение легковесных потоков в 200 строк на Rust Легковесные потоки (ligthweight threads, coroutines, корутины, green threads) являются очень мощным механизмом в современных языках про...
Снова привет! Мы – @cbmw и @AndreyErmilov, часть команды разработки «Рамблер/Медиа» (портал «Рамблер»). И это вторая часть наших размышлений по поводу сравнения Python и ...
Спустя три года после начала разработки опубликован релиз Sequoia 1.0. Это реализация OpenPGP на языке Rust, содержащая обширную библиотеку функций и инструментарий командной строки. Ре...
Команда Rust рада сообщить о выпуске новой версии, 1.47.0. Rust — это язык программирования, позволяющий каждому создавать надёжное и эффективное программное обеспечение. Если вы уст...