Прихващане

Затварянията са много гъвкави и правят всичко възможно да си вършат работата без допълнителни указания. Това позволява прихващането на променливи да бъде нагаждано според както е необходимо – чрез преместване или чрез заемане. Затварянията могат да прихващат променливи като:

  • препратки: &T
  • меними препратки: &mut T
  • стойност: T

Променливите биват прихващани най-вече като препратки, а другояче – само по необходимост.

fn main() {
    use std::mem;
    
    let color = String::from("green");

    // Затваряне, отпечатващо `color`, което незабавно заема (`&`) `color`.
    // Заетото и затварянето се съхраняват в променливата `print`.
    // Променливата остава заета до последното извикване на `print`. 
    //
    // `println!` изисква аргументи само като неменими препратки, така че
    // не налага допълнителни ограничения.
    let print = || println!("`color`: {}", color);

    // Извикваме затварянето, използвайки заетата променлива.
    print();

    // `color` може да бъде заета отново, защото `print` държи само неменима
    // препратка към `color`. 
    let _reborrow = &color;
    print();

    // пресместване или заемане на `color` отново е разрешено след последното
    // ползване на `print`
    let _color_moved = color;


    let mut count = 0;
    // Затваряне, което да увеличи стойността на `count`, може да заеме `&mut
    // count` или `count`, но `&mut count` е по-малко ограничаващо, така че прави
    // това. Незабавно заема `count`.
    //
    // Задължително е `inc` да е `mut`, защото съхраняваме в него менима
    // препратка (`&mut`). Като извикваме затварянето, ние го променяме и
    // затова трябва да го опишем като менимо – `mut`.
    let mut inc = || {
        count += 1;
        println!("`count`: {}", count);
    };

    // Извикваме затварянето, използвайки менима заемка.
    inc();

    // Затварянето `inc` все още заема `count` като менима променлива, защото
    // се извиква отново по-късно.
    // Ако се опитаме да я заемем пак, това ще доведе до грешка.
    // let _reborrow = &count; 
    // ^ ЗАДАЧА: разкоментирайте този ред.
    inc();

    // `inc` вече не заема `&mut count`. Затова можем да я заемем без грешка.
    let _count_reborrowed = &mut count; 

    
    // Некопируем тип
    let movable = Box::new(3);

    // `mem::drop` изисква `T`, така че следващият код ще прихване `movable`
    // по стойност (ще го премести вътре в затварянето). Ако типът беше
    // копируем, щеше да се копира в затварянето, а първоизточникът да си
    // остане недокоснат.
    // Некопируем тип задължително бива преместен и затова `movable` незабавно
    // се мести в затварянето.
    let consume = || {
        println!("`movable`: {:?}", movable);
        mem::drop(movable);
    };

    // `consume` *поглъща* променливата, затова може да бъде извикана само веднъж.
    consume();
    // consume();
    // ^ ЗАДАЧА: разкоментирайте този ред.
}

Ако напишем move преди отвесните чертички, караме затварянето да овладее прихванатите променливи:

fn main() {
    // `Vec` е некопируем.
    let haystack = vec![1, 2, 3];

    let contains = move |needle| haystack.contains(needle);

    println!("{}", contains(&1));
    println!("{}", contains(&4));

    // println!("There're {} elements in vec", haystack.len());
    // ^ Ако разкоментирате горния ред, ще получите грешка при компилацията,
    // защото проверителят на заемите не позволява повторното използване на
    // променливи, след като са преместени.
    
    // Ако премахнете `move` от обявлението на затварянето, то ще заеме
    // haystack като неменима препратка, така че haystack ще може да се ползва.
    // Тогава, ако разкоментирате реда с println! по-горе, няма да има грешка.
}

Вижте също:

Box и std::mem::drop