Funciones

Se puede aplicar el mismo conjunto de reglas a las funciones: un tipo T se vuelve genérico cuando está precedido por <T>.

El uso de funciones genéricas a veces requiere especificar explícitamente los parámetros de tipo. Este puede ser el caso si se llama a la función donde el tipo de retorno es genérico, o si el compilador no tiene suficiente información para inferir los parámetros de tipo necesarios.

Una llamada a función con parámetros de tipo especificados explícitamente se ve así: fun::<A, B, ...>().

struct A;          // Tipo concreto `A`.
struct S(A);       // Tipo concreto `S`.
struct SGen<T>(T); // Tipo genérico `SGen`.

// Todas las siguientes funciones toman posesión de la variable pasada a ellos
// e inmediatamente salen del alcance, liberando la variable.

// Define una función `reg_fn` que tome un argumento `_s` de tipo `S`.
// Esto no tiene `<T>` por lo que no es una función genérica.
fn reg_fn(_s: S) {}

// Define una función `gen_spec_t` que tome un argumento `_s` de tipo `SGen<T>`.
// Se le ha dado explícitamente el parámetro de tipo `A`, pero debido a que `A` no
// se ha especificado como un parámetro de tipo genérico para `gen_spec_t`, no es
// genérico.
fn gen_spec_t(_s: SGen<A>) {}

// Define una función `gen_spec_i32` que tome un argumento `_s` de tipo `SGen<i32>`.
// Se le ha dado explícitamente el parámetro de tipo `i32`, que es un tipo específico.
// Como `i32` no es un tipo genérico, esta función tampoco es genérica.
fn gen_spec_i32(_s: SGen<i32>) {}

// Define una función `generica` que tome un argumento `_s` de tipo `SGen<T>`.
// Debido a que `SGen<T>` está precedido por `<T>`, esta función es genérica sobre `T`.
fn generica<T>(_s: SGen<T>) {}

fn main() {
    // Usando las funciones no genéricas
    reg_fn(S(A));          // Tipo concreto
    gen_spec_t(SGen(A));   // Parámetro de tipo `A` especificado implícitamente.
    gen_spec_i32(SGen(6)); // Parámetro de tipo `i32` especificado implícitamente.

    // Parámetro de tipo `char` especificado explícitamente a `generica()`.
    generica::<char>(SGen('a'));

    // Parámetro de tipo `char` especificado implícitamente a `generica()`.
    generica(SGen('c'));
}

Ve también

funciones y structs