如何修改列表中的结构条目？

Question

I'm struggling to understand how to modify a struct entry in a list by invoking a function. In the write_largest_to_first function, I would like to set the first entry in a job list with the largest value of age. (I don't care about the remaining entries at the moment.)

#![allow(unused)]
struct Job {
    age: i8
}

// Version 1
fn write_largest_to_first(list: &mut [Job]) -> &Job {
    let mut largest = &mut list[0];

    for item in list[1..].iter_mut() {
        if item.age > largest.age {
            largest.age = item.age;
        }
    }
    largest
}

fn main() {
    let mut job_list = vec![
        Job{age: 10},
        Job{age: 3},
        Job{age: 120}];

    println!("Before write_largest_to_first, the first job has age {}", job_list[0].age);
    let result = write_largest_to_first(&mut job_list);
    println!("The oldest job has age {}", result.age);
    
    let first_job = &job_list[0];
    println!("After write_largest_to_first, the first job has age {}", first_job.age);
}

However, the code cannot be compiled:

error[E0499]: cannot borrow `*list` as mutable more than once at a time
  --> src/main.rs:9:17
   |
6  | fn write_largest_to_first(list: &mut [Job]) -> &Job {
   |                                 - let's call the lifetime of this reference `'1`
7  |     let mut largest = &mut list[0];
   |                       ------------ first mutable borrow occurs here
8  | 
9  |     for item in list[1..].iter_mut() {
   |                 ^^^^ second mutable borrow occurs here
...
14 |     largest
   |     ------- returning this value requires that `list[_]` is borrowed for `'1`

error: aborting due to previous error

Questions:

1. Refer to another post , modifying the elements that you get from the iterator is allowed. I have tried to skip the first entry using slice, why doesn't it work?
2. Ultimately, I would like to replace largest.age = item.age; by largest = item; . What is the proper way to achieve this?

Answer 1

Regarding your first question, your main problem is that you create two concurrent mutable borrows of the list. The borrow checker cannot see that these borrows do not actually overlap. The easiest solution is to use the split_first_mut() method to split the first element off the slice in a way that you retain mutable access to the remainder:

fn write_largest_to_first(list: &mut [Job]) -> &Job {
    let (largest, tail) = list.split_first_mut().unwrap();
    for item in tail.iter_mut() {
        if item.age > largest.age {
            largest.age = item.age;
        }
    }
    largest
}

Regarding your second question, the easiest option is to track the index of the element with the largest age. Once you found the right index, you can copy the element to the beginning of the list. This of course requires Job to implement Clone , since otherwise we can't create copies.

#[derive(Clone)]
struct Job {
    age: i8,
}

fn write_largest_to_first(list: &mut [Job]) -> &Job {
    let mut max_age_index = 0;
    for i in 1..list.len() {
        if list[i].age > list[max_age_index].age {
            max_age_index = i;
        }
    }
    list[0] = list[max_age_index].clone();
    &list[0]
}