Faça uma operação em matrizes, quadrando o comprimento, por exemplo.

É útil ter um tipo genérico (comof32, f64), mas você também pode querer um comprimento genérico, masnão um comprimento dinâmico.

Aqui está um exemplo de uma função ao quadrado que recebe 2 argumentos.

use std::ops::{Add, AddAssign, Sub, Mul};

const CAN_THIS_BE_GENERIC: usize = 2;

fn squared_length<T>(
    a: &[T; CAN_THIS_BE_GENERIC],
    b: &[T; CAN_THIS_BE_GENERIC]
) -> T
    where T:
        Copy +
        Add +
        AddAssign +
        Add<Output=T> +
        Sub<Output=T> +
        Mul<Output=T>
{
    let mut d: T = a[0] - a[0];  // zero :(
    for (elem_a, elem_b) in a.iter().zip(b.iter()) {
        let elem_dim: T = *elem_a - *elem_b;
        d += elem_dim * elem_dim;
    }
    return d;
}

fn main() {
    println!("Length A! {}", squared_length::<f64>(&[0.5, 3.5], &[10.0, 0.0]));
    println!("Length B! {}", squared_length::<i32>(&[10, -6], &[4, 8]));
    println!("Length C! {}", squared_length::<f32>(&[-3.0, 0.0], &[9.0, 0.0]));
}

Atualmente, o comprimento do vetor é definido em 2.

É possível definir funções genéricas em que o tamanho não é dinâmico, mas genérico, da mesma maneira que os tipos podem ser genéricos?