Is this the Correct way to make mutable variable immutable again in rust?

Question

I've created a simple list that has mutable push behaviour but no need to have that same mutability for peek fn

fn peek(){
        let  mut list = List::new();//take a mutable ref here to perform push
        list.push(1);
        let list = list; //shadow the variable with the same name and take a immut ref
        
        assert_eq!(list.peek().unwrap(),&1);

    }

From the duplicate: *"Downgrading" a mutable binding to immutable is quite common in Rust.* So yeah, that's fine and normal. — trent, Sep 12 '20 at 14:38

score 4 · Answer 1 · answered Sep 12 '20 at 14:38

Your way is fine. It's typical to include a comment like this:

let list = list; // discard mut

Another way to do it (it's arguable whether it's better or not, complexity vs. readability vs. separation of concerns) is to separate the initialization.

fn peek() {
        let list = {
            let mut list = List::new();
            list.push(1);
            list
        };
        
        assert_eq!(list.peek().unwrap(),&1);
}

score 2 · Answer 2 · answered Sep 12 '20 at 14:39

Your solution is correct enough. Maybe it would be a bit more readable to do it this way:

fn peek(){
    let list = { 
        let mut li = List::new();//take a mutable ref here to perform push
        li.push(1);
        li
    };   
    assert_eq!(list.peek().unwrap(),&1);
}

But in your case there is another option:

fn peek(){
    let list = std::iter::once(1).collect::<List<_>>(); 
    assert_eq!(list.peek().unwrap(),&1);
}

Is this the Correct way to make mutable variable immutable again in rust?

2 Answers2