Разопаковане на избори и стойности по подразбиране
Има няколко начина за разгъване на Option и връщане на стойност по
подразбиране, ако проверяваната стойност е None. За да изберем най-подходящия
начин, трябва да преценим следното:
- дали ни е нужно алчно или лениво изчисление на подадения запасен аргумент?
- дали трябва да запазим първоначалната празна стойност, или да я променим на място?
методът or – верижен, алчен, не пипа празната стойност
pub fn or(self, optb: Option<T>) -> Option<T> може да се изпълнява верижно
(няколко пъти последователно), а запасният му аргумент се изчислява алчно, както
се вижда от следващия пример. Забележете, че понеже аргументът бива оценен
алчно, стойността на подадената на or променлива бива преместена.
#[derive(Debug)] enum Fruit { Apple, Orange, Banana, Kiwi, Lemon } fn main() { let apple = Some(Fruit::Apple); let orange = Some(Fruit::Orange); let no_fruit: Option<Fruit> = None; let first_available_fruit = no_fruit.or(orange).or(apple); println!("first_available_fruit: {:?}", first_available_fruit); // first_available_fruit: Some(Orange) // `or` премества аргумента си. // В горния пример `or(orange)` връща `Some`, така че `or(apple)` не се // извиква. Но въпреки това стойността на променливата `apple` бива // преместена и не може да се ползва повече. // println!("Променливата apple е преместена, така че този ред // няма да се компилира: {:?}", apple); // ЗАДАЧА: Разкоментирайте горния ред, за да видите грешката при компилиране. }
методът or_else – верижен, ленив, не пипа празната стойност
Друга възможност е да ползвате pub fn or_else<F>(self, f: F) -> Option<T> where F: FnOnce() -> Option<T>,.
Той също може да бъде извикан верижно, а подаденият му като запасен аргумент,
който е функция или затваряне, бива изчислен лениво. Вижте следния пример.
#[derive(Debug)] enum Fruit { Apple, Orange, Banana, Kiwi, Lemon } fn main() { let apple = Some(Fruit::Apple); let no_fruit: Option<Fruit> = None; let get_kiwi_as_fallback = || { println!("Предоставяме киви в запас"); Some(Fruit::Kiwi) }; let get_lemon_as_fallback = || { println!("Предоставяме лимон в запас"); Some(Fruit::Lemon) }; let first_available_fruit = no_fruit .or_else(get_kiwi_as_fallback) .or_else(get_lemon_as_fallback); println!("first_available_fruit: {:?}", first_available_fruit); // Предоставяме киви в запас // first_available_fruit: Some(Kiwi) }
методът get_or_insert – алчен, променя празната стойност на място
За да се подсигурим, че даден Избор съдържа стойност, можем да ползваме
pub fn get_or_insert(&mut self, value: T) -> &mut T, за да го променим на място,
като му дадем стойност по подразбиране. Забележете, че get_or_insert
изчислява запасния аргумент алчно, така че стойността на променливата apple
бива преместена:
#[derive(Debug)] enum Fruit { Apple, Orange, Banana, Kiwi, Lemon } fn main() { let mut моят_плод: Option<Fruit> = None; let apple = Fruit::Apple; let първият_наличен_плод = моят_плод.get_or_insert(apple); println!("първият_наличен_плод е: {:?}", първият_наличен_плод); println!("моят_плод е: {:?}", моят_плод); // първият_наличен_плод е: Apple // my_fruit е: Some(Apple) //println!("Стойността на `apple` е преместена: {:?}", apple); // ЗАДАЧА: разкоментирайте горния ред, за да видите грешката при // компилиране }
методът get_or_insert_with – ленив, променя празната стойност на място
Вместо изрично да подаваме стойност за връщане, можем да подадем затваряне на
pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut T where F: FnOnce() -> T,,
както следва:
#[derive(Debug)] enum Fruit { Apple, Orange, Banana, Kiwi, Lemon } fn main() { let mut my_fruit: Option<Fruit> = None; let get_lemon_as_fallback = || { println!("Предоставяме лимон в запас"); Fruit::Lemon }; let first_available_fruit = my_fruit .get_or_insert_with(get_lemon_as_fallback); println!("first_available_fruit е: {:?}", first_available_fruit); println!("my_fruit е: {:?}", my_fruit); // Предоставяме лимон в запас // first_available_fruit is: Lemon // my_fruit is: Some(Lemon) // Ако Option има стойност, тя не се променя и затварянето не се извиква let mut my_apple = Some(Fruit::Apple); let ше_да_е_ябълка = my_apple.get_or_insert_with(get_lemon_as_fallback); println!("ше_да_е_ябълка е: {:?}", ше_да_е_ябълка); println!("my_apple не е променена: {:?}", my_apple); // Изходът е, както следва. Забележете, че затварянето // `get_lemon_as_fallback` не е извикано. // ше_да_е_ябълка is: Apple // my_apple не е променена: Some(Apple) }
Вижте също:
Затваряния, get_or_insert, get_or_insert_with, moved variables, or, or_else