Sorry if this is a stupid question, but I’m struggling with what I think is ownership in rust.
I’m completely new to rust, but have done low level languages before so I know the concept of pointers pretty well. However, this rust ownership I can’t quite wrap my head around.
I’m trying to refactor my solution to AoC Day 4 Part 2 using a struct reference instead of a stand-alone vector.
The error I’m getting, and can’t figure out is in the process function at line
cards.iter_mut().for_each(|card | {
The error is
cannot borrow cards as mutable more than once at a time second mutable borrow occurs here
There is a lot of parsing in my code, so I stuck that in a spoiler below.
The relevant code is:
#[derive(Debug)]
struct Card {
id: u32,
score: u32,
copies: u32,
}
fn process(input: &str) -> u32 {
let mut cards: Vec = parse_cards(input);
cards.iter_mut().for_each(|card| {
let copy_from = card.id as usize + 1;
let copy_to: usize = copy_from + card.score as usize - 1;
if card.score == 0 || copy_from > cards.len() {
return;
}
for card_copy in cards[copy_from - 1..copy_to].iter() {
let id = card_copy.id as usize - 1;
let add = cards[card.id as usize - 1].copies;
cards[id].copies += add;
}
});
return cards.iter().map(|c| c.copies).sum();
}
Other code:
spoiler
fn main() {
let input = include_str!("./input1.txt");
let output = process(input);
dbg!(output);
}
fn parse_cards(input: &str) -> Vec {
return input.lines().map(|line| parse_line(line)).collect();
}
fn parse_line(line: &str) -> Card {
let mut card_split = line.split(':');
let id = card_split
.next()
.unwrap()
.replace("Card", "")
.trim()
.parse::()
.unwrap();
let mut number_split = card_split.next().unwrap().trim().split('|');
let winning: Vec = number_split
.next()
.unwrap()
.trim()
.split_whitespace()
.map(|nbr| nbr.trim().parse::().unwrap())
.collect();
let drawn: Vec = number_split
.next()
.unwrap()
.trim()
.split_whitespace()
.map(|nbr| nbr.trim().parse::().unwrap())
.collect();
let mut score = 0;
for nbr in &drawn {
if winning.contains(&nbr) {
score = score + 1;
}
}
return Card {
id,
score,
copies: 1,
};
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn full_test() {
let result = process(
"Card 1: 41 48 83 86 17 | 83 86 6 31 17 9 48 53
Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19
Card 3: 1 21 53 59 44 | 69 82 63 72 16 21 14 1
Card 4: 41 92 73 84 69 | 59 84 76 51 58 5 54 83
Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36
Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11",
);
assert!(result != 0);
assert_eq!(result, 30);
}
}
You’re trying to iterate over a Vec while mutating its contents in other places, which is something the borrow checker doesn’t like. Altough the later cards that get their copies count increased aren’t the same as the iterating reference
card, Rust forbids two mutable references into the same Vec, even if they reference different elements of the Vec.You could try to iterate over indices into the array instead of directly over array elements, then you get rid of the reference in the outer loop. This would probably require the least change to your code.
Another option would be to split apart the data structures between what needs to be mutated and what doesn’t. I’ve solved this puzzle in Rust and had a separate mutable Vec for the number of copies of each card. Then you can iterate over and mutate both Vecs separately without having conflicting references.
I used a separate vector when I first solved it, but wanted to try out this solution as well.
Using indices worked, thank you!