Commentaire parodique

• Yo! Man t’a grave assuré, ça fait le taff. Magnifico.

• Uptime?

• Feel good!

• Reboot de temps à autre… on s’est jamais <:-) sûr.

Explication du commentaire

Dommage, l’écriture inclusive ! Dommage, le franglais ! Dommage, ces maladresses !

Chouette article didactique qui prend l’approche d’expliquer tout ce sur quoi repose les Stream pour en expliquer le fonctionnement. Top :)

Un petit détail sur la partie où X implémente Copy pour permettre de le réutiliser et éviter le move. En fait, ce n’est pas le compilateur qui décide de faire une copie avant d’effectuer la boucle for, c’est bien la signature de into_iter qui force ce comportement:

fn into_iter(self) -> Self::IntoIter

La fonction prend self par valeur. Pour une structure implémentant Copy, une copie sera faite, sinon ce sera un move.

Du coup, l’exemple ne se “désugarise” pas en:

let x = X { state: 0 };

let x_copy1 = x; // x_copy1 = X { state: 0 } -- copie de x en x_copy1
let iterator1 = x_copy1.into_iter(); // x_copy1 est consommé par into_iter mais pas x
for i in iterator1 {
    println!("{i}")
}

let x_copy2 = x; // x_copy2 = X { state: 0 } -- copie de x en x_copy2
let iterator2 = x_copy2.into_iter(); // x_copy2 est consommé par into_iter mais pas x
for i in iterator2 {
    println!("{i}")
}

Mais plutôt en:

let x = X { state: 0 };

let iterator1 = x.into_iter(); // x est copié pour l'envoyer à into_iter qui veut consommer self
for i in iterator1 {
    println!("{i}")
}

let iterator2 = x.into_iter(); // idem
for i in iterator2 {
    println!("{i}")
}

Sinon, bon article. Merci :)

Merci du repost :D

Super article !

Un grand merci pour ce partage. Article claire et de très bonne qualité. Je m’appuierai dessus pour expliquer les réseaux à des novices.