Syntaxe des génériques Rust pour la fonction moyenne

Vous effectuez 2 opérations différentes dans votre fonction générique:

• Addition de toutes les valeurs de la tranche: vous devez indiquer que vos éléments peuvent être sommés en ajoutant une limite Sum à votre paramètre de type générique.
• Opération de division avec 2 éléments: votre type générique doit être converti en f64 ou en tout type flottant que vous souhaitez limiter. Puisque vous utilisez num crate, j'ai ajouté ToPrimitive comme limite qui indique que votre type générique peut être converti en un type primitif.

Voici l'implémentation:

fn mean<'a, T: 'a>(numbers: &'a [T]) -> Option<f64>
where
    T: ToPrimitive + Sum<&'a T>,
{
    match numbers.len() {
        0 => None,
        _ => {
            let sum = numbers.iter().sum::<T>();
            let length = f64::from_usize(numbers.len())?;

            T::to_f64(&sum).map(|sum| sum / length)
        }
    }
}

Aire de jeux

Les autres réponses vous aideront probablement à résoudre votre vrai problème d'écriture générique de cette fonction.

La véritable erreur que vous avez posée est juste une erreur de syntaxe. Vous avez écrit ceci:

let sum: () = numbers.iter().sum;

Mais presque certainement destiné à écrire:

let sum = numbers.iter().sum();

Le compilateur a vu le : que vous avez accidentellement inclus et pense que vous essayez d'utiliser l'attribution de type. L'attribution de type est une syntaxe permettant d'utiliser des annotations de type en ligne dans une expression, au lieu de simplement dans des déclarations de variables.

Ce que vous avez écrit est très similaire à:

let sum = numbers.iter().sum: ();

Si vous deviez activer l'attribution de type dans une build nightly rustc, l'erreur changerait car maintenant le compilateur vous dira que sum est une fonction et n'a certainement pas de type () .

Que diriez-vous de ceci:

use std::iter::Sum;

fn main() {
    let err = "Slice is empty.";

    // Test aray of integers
    let numbers = [10, -21, 15, 20, 18, 14, 18];
    println!("Mean is {:.3}", mean(numbers.iter()).expect(err));

    // Test array of floating point numbers
    let numbers = [10f64, -21f64, 15f64, 20f64, 18f64, 14f64, 18f64];
    println!("Mean is {:.3}", mean(numbers.iter()).expect(err));

    // Test empty array
    let numbers: [i32; 0] = [];
    match mean(numbers.iter()) {
        Some(mean_) => println!("Mean is {:.3}", mean_),
        None => println!("Empty array"),
    }
}

fn mean<'a, T, I>(iter: I) -> Option<f64>
where
    T: Into<f64> + Sum<&'a T> + 'a,
    I: Iterator<Item = &'a T>,
{
    let mut len = 0;
    let sum = iter
        .map(|t| {
            len += 1;
            t
        })
        .sum::<T>();

    match len {
        0 => None,
        _ => Some(sum.into() / len as f64),
    }
}

Même code dans le Rust Playground

Il semble avoir les avantages suivants par rapport aux réponses publiées jusqu'à présent:

1. Définition de type générique beaucoup plus simple.
2. Pas de dépendance à l'égard de la caisse externe num .
3. Pas besoin de traits difficiles à deviner comme FromPrimitive et Zero .
4. Aucune déclaration manuelle de durée de vie.

Ou cette version qui présente les différences suivantes par rapport à celle ci-dessus:

1. Peut prendre des tableaux plutôt que des vecteurs.
2. Ne consomme pas le tableau (ou le vecteur).
3. Nécessite des déclarations de durée de vie manuelles.

use std::iter::Sum;

fn main() {
    let err = "Slice is empty.";

    // Test vector of integers
    let numbers = vec![10i32, -21, 15, 20, 18, 14, 18];
    println!("Mean is {:.3}", mean(numbers.into_iter()).expect(err));

    // Test vector of floating point numbers
    let numbers = vec![10f64, -21f64, 15f64, 20f64, 18f64, 14f64, 18f64];
    println!("Mean is {:.3}", mean(numbers.into_iter()).expect(err));

    // Test empty vector
    let numbers: Vec<i32> = Vec::new();    
    println!("Mean is {:.3}", mean(numbers.into_iter()).expect(err));
}

fn mean<T, I: Iterator<Item = T>>(iter: I) -> Option<f64>
where
    T: Into<f64> + Sum<T>,
{
    let mut len = 0;
    let sum = iter
        .map(|t| {
            len += 1;
            t
        })
        .sum::<T>();

    match len {
        0 => None,
        _ => Some(sum.into() / len as f64)
    }
}

Merci à mon ami Sven pour la contribution au code.