• 泛型
    • 参见：

    泛型

    泛型（generic）可以泛化类型和功能，以扩大适用范围。减少代码的重复是相当重要的，这可以通过多种方式实现，不过需要相当繁琐的语法。也就是说，用到泛型需要特别谨慎地指出哪种类型对于泛型类型来说是有效的。使用泛型最简单且最常见的方式就是用到类型参量（type parameter）。（本段原文：
    Generics is the topic of generalizing types and functionalities to broader
    cases. This is extremely useful for reducing code duplication in many ways,
    but can call for rather involving syntax. Namely, being generic requires
    taking great care to specify over which types a generic type
    is actually considered valid. The simplest and most common use of generics
    is for type parameters.）

    类型参量指定为泛型要使用尖括号和 CamelCase（驼峰式命名）：<Aaa, Bbb, ...> 。“泛型类型参量”一般用 <T> 来表示。在 Rust 中，“泛型”也表示可以接受一个或多个泛型类型参量 <T> 的任何内容。任何指定为泛型类型参量的类型都是泛型，其他的都是具体类型（非泛型）。

    例如定义一个名为 foo 的 泛型函数，可接受一个任意类型的参数 T：

    1. fn foo<T>(T) { ... }

    因为 T 被指定为一个使用 <T> 的泛型类型参量，所以在这里用到的 (T) 会变成泛型 。即使 T 在前面被定义为 struct 也是如此。

    下面例子展示了一些操作中的语法：

    1. // 具体的类型 `A`。
    2. struct A;
    4. // 在定义类型 `Single` 时，在 `A` 的首次使用之前没有出现 `<A>`。
    5. // 因此，`Single` 是一个具体的类型，`A` 在上面已经定义。
    6. // （原文：In defining the type `Single`, the first use of `A` is not preceded
    7. // by `<A>`. Therefore, `Single` is a concrete type, and `A` is defined as above.）
    8. struct Single(A);
    9. //            ^ 这里是 `Single` 对类型 `A` 的第一次使用。
    11. // 此处 `<T>` 在第一次使用 `T` 前出现，所以 `SingleGen` 是一个泛型类型。
    12. // 因为类型参量 `T` 是泛型，所以它可以是任何类型，包括在上面定义的具体类型 `A`。
    13. struct SingleGen<T>(T);
    15. fn main() {
    16.     // `Single` 是具体类型并显式地接受 `A`。
    17.     let _s = Single(A);
    19.     // 创建一个 `SingleGen<char>` 类型的变量 `_char`，并给一个 `SingleGen('a') 值。
    20.     // 这里的 `SingleGen` 拥有显式指定的类型参量。
    21.     let _char: SingleGen<char> = SingleGen('a');
    23.     // `SingleGen` 也可以拥有隐式指定的类型参量：
    24.     let _t    = SingleGen(A); // 使用在上面定义的 `A`。
    25.     let _i32  = SingleGen(6); // 使用 `i32` 类型。
    26.     let _char = SingleGen('a'); // 使用 `char`。
    27. }

    参见：

    struct