vectores - ¿Cómo sumar un vector usando fold?

vectores gratis corel draw

Question

This tutorial de Rust explica bien el mecanismo fold() y este código de ejemplo:

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

Funciona como se espera.

Me gustaría ejecutarlo en un vector, por lo que en base a ese ejemplo, primero escribí esto:

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

que arrojó un error:

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

Supuse que esto podría ser un error relacionado con la referencia por alguna razón, así que lo cambié para fold(0, |sum, &val| sum += val) , lo que resultó

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

Hm, tal vez algo está mal con el cierre? Utilizando {sum += x; sum } {sum += x; sum } , tengo

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

otra vez.

Después de una nueva prueba y error, agregar mut a la sum funcionó:

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

¿Podría alguien explicar la razón por la que fold() para los vectores difiere tanto del tutorial? ¿O hay una mejor manera de manejar esto?

Para referencia, estoy usando Rust beta, 2015-04-02.

Answer 1

Así que resultó que había una gran diferencia en mi código, como escribí

sum += x

en lugar de

sum + x .

Bueno, al menos espero que esta pregunta ayude, en caso de que alguien se encuentre en una situación similar.

Answer 2

Ya te has dado cuenta de que += es el problema, pero me gustaría proporcionar más información.

En su caso, los argumentos proporcionados al cierre de fold son _ y &u32 . El primer tipo es un entero no especificado todavía. Si cambia su llamada a fold(0u32, |sum, val| sum += val) , recibirá un mensaje ligeramente diferente:

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}`

El valor del resultado de la operación de asignación binaria += es () , el tipo de unidad. Esto explica el mensaje de error cuando cambió para fold(0, |sum, &val| sum += val) :

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

Si cambia a fold(0, |sum, &val| {sum += val ; sum}) , obtendrá un error comprensible sobre las variables inmutables:

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`

Desde aquí, puede marcar la sum como mutable, pero la solución correcta es simplemente doblar con la sum + val , como descubrió.

En las versiones más nuevas de Rust, también puede simplemente sum el iterador directamente, omitiendo el fold :

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