I don't understand how to extract a helper function in hashmaps3

[GST1DR]

In question https://github.com/rust-lang/rustlings/blob/main/exercises/11_hashmaps/hashmaps3.rs you have to do 3 straitforward things to each of the two teams (get the existing scores or add new ones, if not yet present and update the two scores).
These are just 3 lines of code per team, but for the second team you'll write almost the same somehow fiddely 3 lines.

let team_1 = scores.entry(team_1_name).or_insert_with(TeamScores::default);
team_1.goals_scored += team_1_score;
team_1.goals_conceded += team_2_score;

// Similarly for the second team.
let team_2 = scores.entry(team_2_name).or_insert_with(TeamScores::default);
team_2.goals_scored += team_2_score;
team_2.goals_conceded += team_1_score;

In any other language and production code i would try (DRY) to extract the 3 fiddely lines into a helper method and just call the helper method twice. (and let the compiler inline it for me). In Rust I tried, but did not manage to get it working. Any Idea, how to do something like this?
In Pseudo (non-compiling) rust I would do (and tried several variants):

fn add_single_team_game_result(scores : &mut HashMap<&str, TeamScores>, team_name : &str, scored : u8, conceded : u8)
{
       let team = scores.entry(team_name).or_insert_with(TeamScores::default);
        team.goals_scored += scored;
        team.goals_conceded += conceded;
}

... and in the main method just 2 lines instead of 6:

add_single_team_game_result(&scores, team_1_name, team_1_score, team_2_score);
add_single_team_game_result(&scores, team_2_name, team_2_score, team_1_score);

I fiddeled with livetime annotations and mutability but could not get this to work.
Thx for ideas!

[mo8it]

To make it work in Rust, there are 2 solutions:

Solution 1 (intermediate but efficient)

You need to add the lifetime annotation 'a to tell the compiler that team_name won't be dropped while scores exists.
&str is a pointer to some string in memory. If you drop that string in memory while you still use the pointer as a key in the hash map, then that key would be a dangling pointer.

fn add_single_team_game_result<'a>(
    scores: &mut HashMap<&'a str, TeamScores>,
    team_name: &'a str,
    scored: u8,
    conceded: u8,
) {
    let team = scores.entry(team_name).or_default();
    team.goals_scored += scored;
    team.goals_conceded += conceded;
}

Then you need to pass &mut scores in the function call.

Solution 2 (easy but inefficient)

You might be confused by solution 1 if you aren't familiar with lifetimes yet.
Don't worry, there is an easier solution without lifetimes!

fn add_single_team_game_result(
    scores: &mut HashMap<String, TeamScores>,
    team_name: String,
    scored: u8,
    conceded: u8,
) {
    let team = scores.entry(team_name).or_default();
    team.goals_scored += scored;
    team.goals_conceded += conceded;
}

This code uses String as an owned String instead of &str. This means that nothing is borrowed and you don't need to deal with lifetimes.

You need to convert the team name to String when calling this function. This can be done with to_string:

add_single_team_game_result(
    &mut scores,
    team_1_name.to_string(),
    team_1_score,
    team_2_score,
);

Finally, you need to adjust the signature of the build_scores_table function to return HashMap<String, TeamScores> instead of HashMap<&str, TeamScores>.

Working with owned objects is in general easier. But keep in mind that this solution isn't efficient since we are allocating a String twice in each iteration. So solution 1 would be preferred in production code after one is familiar with lifetimes.

Code in Markdown

BTW, for sharing code snippets in Markdown, please use the following for syntax highlighting:

```rust
YOUR
CODE
```

I edited your question to use this syntax :)