Анонимни функции II

22 ноември 2018

Преговор

Fn traits

Fn
FnMut
FnOnce

Преговор

move премества стойността, независимо как се използва

let nums = vec![0, 1, 2, 3];

// прихваща `nums` като `Vec<i32>`
let f = move || {
    for n in &nums {
        println!("{}", n);
    }
};

Moving closure captures

Няколко трика ако искаме да преместим някоя стойност, но да прихванем друга по референция

let nums = vec![0, 1, 2, 3];
let s = String::from("cookies");

let f = || {
    let nums = nums;         // move `nums`

    println!("{:?}", nums);
    println!("{:?}", s);
};

// println!("{:?}", nums);   // комп. грешка
println!("{:?}", s);

                    "cookies"

                

Moving closure captures

let nums = vec![0, 1, 2, 3];
let s = String::from("cookies");

{
    let s = &s;             // move `s: &String`

    let f = move || {
        println!("{:?}", nums);
        println!("{:?}", s);
    };
}

// println!("{:?}", nums);   // комп. грешка
println!("{:?}", s);

                    "cookies"

                

Saving closures

Да си направим адаптер за итератор, който работи подобно на
адаптера връщан от Iterator::map()

struct Map<I, F, B> where
    I: Iterator,
    F: FnMut(I::Item) -> B
{
    iter: I,
    f: F,
}

Saving closures

Имплементираме Iterator

impl<I, F, B> Iterator for Map<I, F, B> where
    I: Iterator,
    F: FnMut(I::Item) -> B
{
    type Item = B;

    fn next(&mut self) -> Option<Self::Item> {
        match self.iter.next() {
            Some(item) => Some((self.f)(item)),
            None => None,
        }
    }
}

Saving closures

Малко улеснение

impl<I, F, B> Iterator for Map<I, F, B> where
    I: Iterator,
    F: FnMut(I::Item) -> B
{
    type Item = B;

    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().map(|x| (self.f)(x))
    }
}

Saving closures

// vec![1, 2, 3].into_iter().map(|x| x * 3)

let map = Map {
    iter: vec![1, 2, 3].into_iter(),
    f: |x| x * 3,
};

let v = map.collect::<Vec<_>>();
println!("{:?}", v);

                    [3, 6, 9]

                

Returning closures

fn get_incrementer() -> ??? {
    |x| x + 1
}

Returning closures

Да проверим какъв е типът на closure-а

let _: () = |x| x + 1;

Returning closures

Да проверим какъв е типът на closure-а

let _: () = |x| x + 1;

                    error[E0308]: mismatched types
 --> /main_f4ff4185076e43830fdfe11463e56a301ab6f9e8.rs:2:13
  |
2 | let _: () = |x| x + 1;
  |             ^^^^^^^^^ expected (), found closure
  |
  = note: expected type `()`
             found type `[closure@/main_f4ff4185076e43830fdfe11463e56a301ab6f9e8.rs:2:13: 2:22]`

                

Тип генериран от компилатора, това не ни е полезно

Returning closures

Вариант 1

Ако closure не прихваща променливи, той може автоматично да се сведе до указател към функция

fn get_incrementer() -> fn(i32) -> i32 {
    |x| x + 1
}

Returning closures

Вариант 2

Често се налага да прихванем променливи

fn curry(a: u32) -> ??? {
    |b| a + b
}

Returning closures

Вариант 2

Можем да използваме Trait objects

struct F<'a> {
    closure: &'a Fn()
}

struct F {
    closure: Box<Fn()>
}

Returning closures

Вариант 2

Така дали ще е добре?

fn curry(a: u32) -> Box<Fn(u32) -> u32> {
    Box::new(|b| a + b)
}

Returning closures

Вариант 2

Така дали ще е добре?

fn curry(a: u32) -> Box<Fn(u32) -> u32> {
    Box::new(|b| a + b)
}

                    error[E0373]: closure may outlive the current function, but it borrows `a`, which is owned by the current function
 --> /main_b925fec74e8963be19f9a39c9c688dab6f0b453d.rs:4:14
  |
4 |     Box::new(|b| a + b)
  |              ^^^ - `a` is borrowed here
  |              |
  |              may outlive borrowed value `a`
help: to force the closure to take ownership of `a` (and any other referenced variables), use the `move` keyword
  |
4 |     Box::new(move |b| a + b)
  |              ^^^^^^^^

                

Returning closures

Вариант 2

move

fn curry(a: u32) -> Box<Fn(u32) -> u32> {
    Box::new(move |b| a + b)
}
assert_eq!(curry(1)(2), 3);

Closures & lifetimes

fn curry<'a>(a: &'a u32) -> Box<Fn(&u32) -> u32> {
    Box::new(move |b| a + b)
}

                    error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
 --> /main_698f4bc0a6590f9f7f37c0d31d5c3b0cabdf3a02.rs:3:14
  |
3 |     Box::new(move |b| a + b)
  |              ^^^^^^^^^^^^^^
  |
note: first, the lifetime cannot outlive the lifetime 'a as defined on the function body at 2:10...
 --> /main_698f4bc0a6590f9f7f37c0d31d5c3b0cabdf3a02.rs:2:10
  |
2 | fn curry<'a>(a: &'a u32) -> Box<Fn(&u32) -> u32> {
  |          ^^
  = note: ...so that the types are compatible:
          expected &u32
             found &'a u32
  = note: but, the lifetime must be valid for the static lifetime...
  = note: ...so that the expression is assignable:
          expected std::boxed::Box<(dyn for<'r> std::ops::Fn(&'r u32) -> u32 + 'static)>
             found std::boxed::Box<dyn for<'r> std::ops::Fn(&'r u32) -> u32>

                

Closures & lifetimes

struct State<'b> {
    a: &'b u32
}

// impl Fn, FnMut, FnOnce for State

fn curry<'a>(a: &'a u32) -> Box<State<'a>> {
    let state = State { a };    // State<'a>
    Box::new(state)             // очаква 'static
}

Closures & lifetimes

Lifetime на структура

Какво означава обект (който не е референция) да има 'static lifetime

Lifetime-а показва максимално ограничение до което може да живее някаква стойност

struct Foo<'a> { a: &'a i32 }

{
    let a = 10;                     // ---+- 'a
                                    //    |
    let foo = Foo { a: &a };        // ---+- foo: 'a
                                    //    |
}                                   // <--+

Closures & lifetimes

Lifetime на структура

Когато обект не държи референции няма такова ограничение

Затова се приема че обекта има 'static lifetime

struct Foo { a: i32 }

{
    let a = 10;

    let foo = Foo { a: a };         // foo: 'static
}

Closures & lifetimes

По подразбиране се очаква trait object-а да няма такова ограничение

Box<Fn(&u32) -> u32> -> Box<Fn(&u32) -> u32 + 'static>;

Ако имаме ограничение трябва да го укажем изрично

fn curry<'a>(a: &'a u32) -> Box<Fn(&u32) -> u32 + 'a> {
    Box::new(move |b| a + b)
}
assert_eq!(curry(&1)(&2), 3);

Returning closures

Вариант 3 (impl Trait)

fn curry(a: u32) -> impl Fn(u32) -> u32 {
    move |b| a + b
}
assert_eq!(curry(1)(2), 3);

impl Trait

Може да стои на мястото на типа на аргумент или return типа

use std::fmt::Debug;

fn id(arg: impl Debug) -> impl Debug {
    arg
}
println!("{:?}", id(1));
println!("{:?}", id("foo"));

                    1
"foo"

                

impl Trait

Не може да правите нищо друго с него освен това което имплементира

use std::fmt::Debug;

fn id(arg: impl Debug) -> impl Debug {
    arg
}
println!("{}", id(1));

                    error[E0277]: `impl std::fmt::Debug` doesn't implement `std::fmt::Display`
 --> /main_8bf7039ea5b999af5f79cbab4e653a034da9476d.rs:7:16
  |
7 | println!("{}", id(1));
  |                ^^^^^ `impl std::fmt::Debug` cannot be formatted with the default formatter
  |
  = help: the trait `std::fmt::Display` is not implemented for `impl std::fmt::Debug`
  = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
  = note: required by `std::fmt::Display::fmt`

                

impl Trait

Разликата между generics и impl Trait

generics поддържа turbofish синтаксис и изисква да се пише задължително при функция като f<T>() -> T
impl Trait оставя компилатора да оправи типа включително и като return тип, но не може да използваме turbofish при извикване на функцията

EventEmitter