Tudor Pagu's questions

Eu me deparei com um erro surpreendente (para mim) ao usar RefCell e quero entender melhor por que isso está acontecendo. Eu tinha algo parecido com este código abaixo, onde eu tenho um bloco while let consumindo uma função mutável em um RefCell emprestado:

struct Foo {
    val: i32,
}
impl Foo {
    fn increment(&mut self) -> Option<i32> {
        if self.val >= 10 {
            return None;
        }
        self.val += 1;
        Some(self.val)
    }
}
fn main() {
    let r = RefCell::new(Foo { val: 0 });
    while let Some(v) = r.borrow_mut().increment() {
        println!("iteration: {}", v);
        println!("borrow: {}", r.borrow().val); // panic!: BorrowError, already mutably borrowed
    }
}

Mas claramente eu não uso a referência mutável r depois que ela é criada, então por que ela ainda está viva? A maneira que eu encontrei para consertar isso é:

    while let Some(v) = {
        let mut borrowed = r.borrow_mut();
        borrowed.increment()
    } {
        println!("iteration: {}", v);
        println!("borrow: {}", r.borrow().val); // now this works fine
    }

Mas se eu tentar remover o temporário, mesmo dentro do escopo, ele ainda quebra.

    while let Some(v) = { r.borrow_mut().increment() } {
        println!("iteration: {}", v);
        println!("borrow: {}", r.borrow().val); // panic! BorrowError
    }

Além disso, esses erros me parecem ser específicos de while let, porque não me deparei com esse erro ao verificar alguma propriedade diretamente sem while let. Então, qual é exatamente o mecanismo/regra aqui que governa como o RefCell atualiza seu contador de empréstimo?

Eu tenho esta estrutura:

typedef struct {
    int *array;
    int first;
    int last;
} arguments;

e eu estaria interessado em ter uma estrutura diferente com alguns argumentos adicionados:

typedef struct {
    int *array;
    int first;
    int last;
    // only used in children
    int read_fd;
    int write_fd;
} child_arguments;

mas tenho algumas funções que esperamarguments

void do_something(arguments* args) { ... }

É seguro fazer esse tipo de gesso:

void do_something_in_child(child_arguments* child_args) {
    do_something( (arguments*) child_args );
}

Imagino que, como C não reordena membros em uma struct, e elementos adicionados depois não devem afetar o preenchimento de elementos antigos, isso pode ser seguro. Mas é? E se for, é compatível com C ou é um comportamento tecnicamente indefinido, mas seguro na maioria dos compiladores?