Error al usar genéricos en funciones Rust

Publicado por Brisa
hace 5 meses

Hola a todos,

Estoy teniendo problemas al intentar utilizar genéricos en una función en Rust. He estado experimentando con genéricos y he creado una función que recibe dos parámetros de tipo genérico y debería retornar la suma de ellos.

Aquí está el código:

fn sum<T>(a: T, b: T) -> T {
    a + b
}

fn main() {
    let num1 = 5;
    let num2 = 10;
    let result = sum(num1, num2);

    println!("El resultado es: {}", result);
}

El problema es que al intentar compilar este código, me sale el siguiente error:

error[E0369]: binary operation `+` cannot be applied to type `T`
 --> src/main.rs:3:5
  |
3 |     a + b
  |     - ^ -
  |     |
  |     T
  |
  = note: an implementation of `std::ops::Add` might be missing for `T`

No comprendo completamente qué significa este error y cómo solucionarlo. Si alguien pudiera explicarme qué está pasando y cómo puedo corregir este error, estaría muy agradecida.

¡Gracias de antemano!

Compartir en

Respuesta de Gordon Shumway
hace 5 meses

¡Hola Brisa!

El error que estás viendo indica que el compilador de Rust no puede garantizar que el tipo genérico T que estás usando tenga implementada la operación de suma (+). En Rust, las operaciones entre tipos son manejadas por traits (algo así como interfaces en otros lenguajes), y para poder sumar dos valores de algún tipo, ese tipo debe implementar el trait std::ops::Add.

Para resolver el error, puedes restringir el tipo genérico T para asegurarse de que solo acepte tipos que implementen std::ops::Add. Además, std::ops::Add requiere que especifiques el tipo de retorno con Output. Aquí te dejo el código con la corrección:

use std::ops::Add;

fn sum<T>(a: T, b: T) -> T
where
    T: Add<Output = T>,
{
    a + b
}

fn main() {
    let num1 = 5;
    let num2 = 10;
    let result = sum(num1, num2);

    println!("El resultado es: {}", result);
}

En este código, usamos una cláusula where para restringir el tipo genérico T: estamos diciendo que T debe implementar el trait Add y que el resultado de la operación + debe ser del mismo tipo T. Con esto debería compilar sin problemas, siempre y cuando uses tipos que cumplan con esas restricciones, como los tipos numéricos básicos (i32, f64, etc.).

Espero que esto te sea de ayuda. ¡Feliz codificación!