Tipos genéricos

Tipos genéricos es el tema de la generalización de tipos y funcionalidades a casos más amplios. Esto es extremadamente útil para reducir la duplicación de código de muchas formas, pero puede requerir una sintaxis bastante compleja. Es decir, ser genérico requiere tener mucho cuidado para especificar sobre qué tipos se considera realmente un tipo genérico válido. El uso más simple y común de tipos genéricos es para parámetros de tipo.

Un parámetro de tipo se especifica como genérico mediante el uso de corchetes angulares y camel case de mayúsculas: <Aaa, Bbb, ...>. Los "parámetros de tipo genérico" se representan normalmente como <T>. En Rust, "tipo genérico" también describe cualquier cosa que acepte uno o más parámetros de tipo genérico <T>. Cualquier tipo especificado como parámetro de tipo genérico es genérico y todo lo demás es concreto (no genérico).

Por ejemplo, definir una función de tipo genérico llamada foo que toma un argumento T de cualquier tipo:

fn foo<T>(arg: T) { ... }

Debido a que T se ha especificado como un parámetro de tipo genérico usando <T> , se considera tipo genérico cuando se usa aquí como (arg: T) . Este es el caso incluso si T se ha definido previamente como una struct.

Este ejemplo muestra parte de la sintaxis en acción:

// Un tipo concreto `A`.
struct A;

// Al definir el tipo `Simple`, el primer uso de `A` no está precedido por `<A>`.
// Por lo tanto, `Simple` es un tipo concreto y `A` se define como arriba.
struct Simple(A);
//            ^ Aquí está el primer uso de `Simple` del tipo `A`.

// Aquí, `<T>` precede al primer uso de `T`, por lo que `SimpleGen` es un tipo genérico.
// Dado que el parámetro de tipo `T` es genérico, podría ser cualquier cosa, incluido
// el tipo concreto `A` definido en la parte superior.
struct SimpleGen<T>(T);

fn main() {
    // `Simple` es concreto y toma explícitamente `A`.
    let _s = Simple(A);
    
    // Crea una variable `_char` de tipo `SimpleGen<char>` y le da el valor
    // `SimpleGen('a')`.
    // Aquí, `SimpleGen` tiene un parámetro de tipo especificado explícitamente.
    let _char: SimpleGen<char> = SingleGen('a');

    // `SimpleGen` también puede tener un parámetro de tipo especificado implícitamente:
    let _t    = SimpleGen(A); // Utiliza `A` definida en la parte superior.
    let _i32  = SimpleGen(6); // Utiliza `i32`.
    let _char = SimpleGen('a'); // Utiliza `char`.
}

Ve también

structs