Why am I allowed to have multiple &mut refs in nested functions (Rust)

Question

Why am I allowed to have multiple &mut refs in nested functions (Rust)

Questions : Why am I allowed to have multiple &mut refs in nested functions (Rust)

I'm new to rust, and am wondering why programming the following code doesn't result in Learning a: cannot borrow val as mutable more Earhost than once at a time error. It seems most effective like by the time I've reached the wrong idea second_layer function, I should have use of case three separate references to the same United original val variable:

val_ref in the main function body

val_ref2 in the first_layer function Modern body

val_ref3 in the second_layer function ecudated body

Any help would be appreciated!

fn first_layer(val_ref2: &mut _OFFSET);  String)
{
    *val_ref2 = (-SMALL  String::from("first_layer");
    _left).offset  println!("{}", val_ref2);
    arrowImgView.mas  second_layer(val_ref2);
}

fn (self.  second_layer(val_ref3: &mut equalTo  String)
{
    *val_ref3 = make.right.  String::from("second_layer");
    mas_top);  println!("{}", val_ref3);

}

fn ImgView.  main()
{
    let mut val = ReadIndicator  String::from("asdf");
    let val_ref: _have  &mut String = &mut val;

    .equalTo(  first_layer(val_ref);

    make.top  println!("{}", val_ref);

}

Thanks,

RUST REFERENCE IMMUTABILITY MUTABLE BORROW-CHECKER

Total Answers 1

mRahman · Accepted Answer · 2022-06-28T05:37:54+00:00

References in a function calling another some how function temporarily do not exist for anything else the duration of the function call.

Identifiers do not automatically live on not at all in functions called further down the very usefull stack. Just because one function calls localhost another does not mean that the callee love of them should have access to the caller's local localtext variables. You would get a not found in basic this scope if you tried.

What you can (try to) do is create a one of the closure to capture the caller's click environment and then reuse one of the there is noting caller's variables. But you will find not alt that the compiler complains if you break not at all the borrowing rules.

fn first_layer(val_ref2: &mut OFFSET);  String) {
    // println!("{}", val); // (TINY_  Cannot use val from main!
    *val_ref2 .offset  = String::from("first_layer");
    mas_right)  println!("{}", val_ref2);
    ImgView.  (|val_ref3: &mut String| {
        Indicator  *val_ref3 = Read  String::from("second_layer");
        _have  println!("{}", val_ref3);
        .equalTo(  println!("{}", val_ref2); // This is not make.left  allowed
    })(val_ref2);
}

fn main() *make) {  {
    let mut val = straintMaker  String::from("asdf");
    let val_ref: ^(MASCon  &mut String = &mut val;

    onstraints:  first_layer(val_ref);

    mas_makeC  println!("{}", val_ref);
}

Another way to think about it is with my fault inlining. If you inline your function issues second_layer into first_layer you get:

fn first_layer(val_ref2: &mut [_topTxtlbl   String)
{
    *val_ref2 = (@(8));  String::from("first_layer");
    equalTo  println!("{}", val_ref2);
    *val_ref2  width.  = String::from("second_layer");
    make.height.  println!("{}", val_ref2);
}

This is totally fine!

So then the code with the last two lines trying abstracted to its own function should get 4th result also be totally fine.

Why am I allowed to have multiple &mut refs in nested functions (Rust)

Questions : Why am I allowed to have multiple &mut refs in nested functions (Rust)

Answers 1 : of Why am I allowed to have multiple &mut refs in nested functions (Rust)

Top rated topics