Início / coding / Perguntas / 77738362
Accepted
Osteri
Asked: 2023-12-31 14:12:19 +0800 CST

Capturar o fechamento do FnMut não dura o suficiente

  • 772

Problema

Resumindo: estou tentando implementar um structque contenha um retorno de chamada para um encerramento, que captura o estado de forma mutável. A ideia é que o usuário forneça callback (fechamento) e possa ser informado posteriormente quando um evento específico acontecer.

Eu tenho uma versão funcional de prova de conceito ( exemplo de código #1 ).

Este PoC funciona ( exemplo de código nº 1 ):

fn fun<F>(f: F) -> F
    where
        F: FnMut() -> (),
{
    f
}

fn main() {
    let mut abc = "abc".to_string();
    let mut f = fun(|| {
        abc.push_str(".");
        println!("closure: {:?}", abc);
    });
    f();
    f();
    f();
    println!("end: {:?}", abc);
}

Saída:

closure: "abc."
closure: "abc.."
closure: "abc..."
end: "abc..."

Isso falha ( exemplo de código nº 2 ):

A mesma ideia (um pouco diferente) da anterior, mas tentando conter o encerramento dentro Foo.

struct Foo<'a, T> {
    pub cb: Box<dyn FnMut(&T) + 'a>,
}

impl<'a, T> Foo<'a, T> {
    fn new(f: impl FnMut(&T) + 'a) -> Self {
        Self { cb: Box::new(f) }
    }
    fn on_change(&mut self, f: impl FnMut(&T) + 'a)
    {
        self.cb = Box::new(f);
    }
}

impl<'a, T> Default for Foo<'a, T>
{
    fn default() -> Self {
        Self::new(|_| {})
    }
}

fn main() {
    let mut abc = "abc".to_string();
    let mut f = Foo::default();
    f.on_change(|a| {
        abc.push_str("."); // PROBLEM HERE; uncomment and it works!
        println!("- param: {:?}", a);
    });
    let param = "a".to_string();
    (f.cb)(&param);
    (f.cb)(&param);
    (f.cb)(&param);
    println!("end: {:?}", abc);
}

Resultado esperado:

- param: "a"
- param: "a"
- param: "a"
end: "abc..."

Saída real (erro do compilador):

error[E0502]: cannot borrow `abc` as immutable because it is also borrowed as mutable
  --> src/main.rs:33:27
   |
25 |     f.on_change(|a| {
   |                 --- mutable borrow occurs here
26 |         abc.push_str("."); // PROBLEM HERE; uncomment and it works!
   |         --- first borrow occurs due to use of `abc` in closure
...
33 |     println!("end: {:?}", abc);
   |                           ^^^ immutable borrow occurs here
34 | }
   | - mutable borrow might be used here, when `f` is dropped and runs the destructor for type `Foo<'_, String>`

O erro do compilador é bastante claro e definitivamente tem algo a ver com o tempo de vida. Acho que meu problema é que preciso informar ao compilador sobre o fechamento e a vida útil de seus parâmetros - mas a questão é: como?

Como devo modificar o exemplo de código nº 2 para que o registro de retorno de chamada funcione como no exemplo de código nº 1 ?

REPL:

rust

1 respostas

  1. Best Answer

    abcainda está vinculado f.

    As variáveis ​​são destruídas no final do escopo em que vivem. fvive em main, então fsão destruídas no final de main, o que significa que durante o println, fainda vive e se liga abc.

    Para destruir uma variável anteriormente, você precisa de possibilidades:

    • ligue droppara isso
    • coloque-o em um escopo aninhado

    Aqui com drop:

    struct Foo<'a, T> {
    pub cb: Box<dyn FnMut(&T) + 'a>,
}

impl<'a, T> Foo<'a, T> {
    fn new(f: impl FnMut(&T) + 'a) -> Self {
        Self { cb: Box::new(f) }
    }
    fn on_change(&mut self, f: impl FnMut(&T) + 'a) {
        self.cb = Box::new(f);
    }
}

impl<'a, T> Default for Foo<'a, T> {
    fn default() -> Self {
        Self::new(|_| {})
    }
}

fn main() {
    let mut abc = "abc".to_string();
    let mut f = Foo::default();
    f.on_change(|a| {
        abc.push_str("."); // PROBLEM HERE; uncomment and it works!
        println!("- param: {:?}", a);
    });
    let param = "a".to_string();
    (f.cb)(&param);
    (f.cb)(&param);
    (f.cb)(&param);

    drop(f);

    println!("end: {:?}", abc);
}

    E aqui com um escopo aninhado:

    struct Foo<'a, T> {
    pub cb: Box<dyn FnMut(&T) + 'a>,
}

impl<'a, T> Foo<'a, T> {
    fn new(f: impl FnMut(&T) + 'a) -> Self {
        Self { cb: Box::new(f) }
    }
    fn on_change(&mut self, f: impl FnMut(&T) + 'a) {
        self.cb = Box::new(f);
    }
}

impl<'a, T> Default for Foo<'a, T> {
    fn default() -> Self {
        Self::new(|_| {})
    }
}

fn main() {
    let mut abc = "abc".to_string();

    {
        let mut f = Foo::default();
        f.on_change(|a| {
            abc.push_str("."); // PROBLEM HERE; uncomment and it works!
            println!("- param: {:?}", a);
        });
        let param = "a".to_string();
        (f.cb)(&param);
        (f.cb)(&param);
        (f.cb)(&param);
    }

    println!("end: {:?}", abc);
}

    Ambos os trechos de código são impressos:

    - param: "a"
- param: "a"
- param: "a"
end: "abc..."
    • 1

relate perguntas