Comment puis-je calculer la somme d'un vecteur à l'aide de plier?

Cette Rouille tutoriel explique la fold() mécanisme bien, et cet exemple de code:

let sum = (1..4).fold(0, |sum, x| sum + x);

fonctionne comme prévu.

J'aimerais le faire tourner sur un vecteur, en se basant sur cet exemple, j'ai d'abord écrit ce qui suit:

let sum: u32 = vec![1,2,3,4,5,6].iter().fold(0, |sum, val| sum += val);

qui a jeté une erreur:

error: binary assignment operation `+=` cannot be applied to types `_` and `&u32` [E0368]
let sum = ratings.values().fold(0, |sum, val| sum += val);
                                              ^~~~~~~~~~

J'ai deviné cela pourrait être une référence-erreur lié pour quelque raison, donc j'ai changé pour fold(0, |sum, &val| sum += val), ce qui a entraîné

error: mismatched types:
expected `u32`,
   found `()`

Hm, peut-être que quelque chose ne va pas avec la fermeture? À l'aide de {sum += x; sum }, j'ai eu

binary assignment operation `+=` cannot be applied to types `_` and `&u32`

de nouveau.

Après d'autres essais et d'erreurs, l'ajout de mut à sum travaillé:

let sum = vec![1,2,3,4,5,6].iter().fold(0, |mut sum, &x| {sum += x; sum});

Quelqu'un pourrait-il expliquer la raison pour laquelle fold() pour les vecteurs diffère tellement du tutoriel? Ou est-il une meilleure façon de gérer cela?

Pour référence, je suis en utilisant la Rouille bêta, 2015-04-02.

  • Vous avez mis en place une grande différence par le remplacement de sum + x par sum += x.
  • Je ne peux pas le croire, comment ai-je pu rater ça... Merci!
InformationsquelleAutor mmatyas | 2015-04-09
  1. 31

    Vous avez déjà compris que += est le problème, mais je tiens à préciser un peu plus d'exposition.

    Dans votre cas, les arguments fournis à la fold fermeture sont _ et &u32. Le premier type est un pas-encore-entier spécifié. Si vous modifiez votre pli appel à fold(0u32, |sum, val| sum += val), vous aurez un peu différente message:

    let sum: u32 = vec![1,2,3,4,5,6].iter().fold(0u32, |sum, val| sum += val);
    error[E0308]: mismatched types
  |
2 |     let sum: u32 = vec![1,2,3,4,5,6].iter().fold(0u32, |sum, val| sum += val);
  |                                                                          ^^^ expected u32, found &{integer}
  |
  = note: expected type `u32`
  = note:    found type `&{integer}`

    La valeur du résultat de l'binaire opération d'affectation += est (), le type de l'unité. C'est ce qui explique le message d'erreur lorsque vous avez changé de fold(0, |sum, &val| sum += val):

    let mut a = 1;
let what_am_i = a += 1;
println!("{:?}", what_am_i); //=> ()

    Si vous changez de fold(0, |sum, &val| {sum += val ; sum}), vous obtenez alors une erreur compréhensible sur immuable variables:

    let sum: u32 = vec![1,2,3,4,5,6].iter().fold(0, |sum, &val| {sum += val; sum});
    error[E0384]: re-assignment of immutable variable `sum`
 --> src/main.rs:2:66
  |
2 |     let sum: u32 = vec![1,2,3,4,5,6].iter().fold(0, |sum, &val| {sum += val; sum});
  |                                                      ---         ^^^^^^^^^^ re-assignment of immutable variable
  |                                                      |
  |                                                      first assignment to `sum`

    À partir d'ici, vous pourrait marque sum comme mutables, mais la bonne solution est tout simplement de se plier à sum + val, comme vous l'avez découvert.

    Dans les versions plus récentes de la Rouille, vous pouvez aussi simplement somme l'itérateur directement, en sautant fold:

    let sum: u32 = vec![1,2,3,4,5,6].iter().sum();
    InformationsquelleAutor Shepmaster
  2. 9

    Donc en fait il y a une énorme différence dans mon code, comme je l'ai écrit

    sum += x

    au lieu de

    sum + x.

    Bien, au moins, je l'espère, cette question permet, dans le cas où quelqu'un se trouve dans une situation similaire.

    InformationsquelleAutor mmatyas