泛型

我们可以使用泛型定义函数，结构体，枚举和方法

  1. fn foo<T>(x: T)
  2. fn bar<T>(x: T, y: T)       // 兩個以上同型別參數
  3. fn baz<T, U>(x: T, y: U)    //兩個以上同型別參數
  5. struct Foo<T> {
  6.     x: T,
  7.     y: T
  8. }
  10. impl<T> Foo<T> {
  11.    fn do_something(x: T, ...) -> ... {
  12.        // Implement method here
  13.    }
  14. }
  16. impl<T> Bar for Foo<T> {
  17.     fn method_from_bar(x: T, ...) -> ... {
  18.         // Implement method here
  19.     }
  20. }
  22. enum Option<T> {
  23.     Some(T),
  24.     None,
  25. }

泛型结构体

  1. struct Point<T, U> {
  2.     x: T,
  3.     y: U,
  4. }
  6. fn main() {
  7.     let both_integer = Point { x: 5, y: 10 };
  8.     let both_float = Point { x: 1.0, y: 4.0 };
  9.     let integer_and_float = Point { x: 5, y: 4.0 };
  10. }

泛型枚举

  1. enum Result<T, E> {
  2.     Ok(T),
  3.     Err(E),
  4. }

泛型方法

  1. struct Point<T, U> {
  2.     x: T,
  3.     y: U,
  4. }
  6. impl<T, U> Point<T, U> {
  7.     fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
  8.         Point {
  9.             x: self.x,
  10.             y: other.y,
  11.         }
  12.     }
  13. }
  15. fn main() {
  16.     let p1 = Point { x: 5, y: 10.4 };
  17.     let p2 = Point { x: "Hello", y: 'c'};
  19.     let p3 = p1.mixup(p2);
  21.     println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
  22. }

泛型函数

  1. use std::ops::Add;
  3. #[derive(Debug)]
  4. struct Point {
  5.     x: i32,
  6.     y: i32,
  7. }
  9. // 为Point实现Add trait
  10. impl Add for Point {
  11.     type Output = Point; //执行返回值类型为Point
  12.     fn add(self, p: Point) -> Point {
  13.         Point{
  14.             x: self.x + p.x,
  15.             y: self.y + p.y,
  16.         }
  17.     }
  18. }
  20. fn add<T: Add<T, Output=T>>(a:T, b:T) -> T {
  21.     a + b
  22. }
  24. fn main() {
  25.     println!("{}", add(100i32, 1i32));
  26.     println!("{}", add(100.11f32, 100.22f32));
  28.     let p1 = Point{x: 1, y: 1};
  29.     let p2 = Point{x: 2, y: 2};
  30.     println!("{:?}", add(p1, p2));
  31. }

输出: 101 200.33 Point { x: 3, y: 3 }

我们增加了自定义的类型，然后让add函数依然可以在上面工作。

  1. use std::ops::Add;
  3. #[derive(Debug)]
  4. struct Point<T: Add<T, Output = T>> { //限制类型T必须实现了Add trait，否则无法进行+操作。
  5.     x: T,
  6.     y: T,
  7. }
  9. impl<T: Add<T, Output = T>> Add for Point<T> {
  10.     type Output = Point<T>;
  12.     fn add(self, p: Point<T>) -> Point<T> {
  13.         Point{
  14.             x: self.x + p.x,
  15.             y: self.y + p.y,
  16.         }
  17.     }
  18. }
  20. fn add<T: Add<T, Output=T>>(a:T, b:T) -> T {
  21.     a + b
  22. }
  24. fn main() {
  25.     let p1 = Point{x: 1.1f32, y: 1.1f32};
  26.     let p2 = Point{x: 2.1f32, y: 2.1f32};
  27.     println!("{:?}", add(p1, p2));
  29.     let p3 = Point{x: 1i32, y: 1i32};
  30.     let p4 = Point{x: 2i32, y: 2i32};
  31.     println!("{:?}", add(p3, p4));
  32. }

输出： Point { x: 3.2, y: 3.2 } Point { x: 3, y: 3 }

我们不仅让自定义的Point类型支持了add操作，同时我们也为Point做了泛型化。

实际撰写泛型程式时，设定相关的trait相当重要，Rust需要足够的资讯来判断泛型中的变数是否能够执行特定的行为，而这个资讯是透过trait来指定

  1. use std::fmt;
  3. pub struct Point<T> where T: Copy + fmt::Display {
  4.     x: T,
  5.     y: T
  6. }
  8. impl<T> Point<T> where T: Copy + fmt::Display {
  9.     pub fn new(x: T, y: T) -> Point<T> {
  10.         Point::<T>{ x: x, y: y }
  11.     }
  12. }
  14. impl<T> Point<T> where T: Copy + fmt::Display {
  15.     pub fn x(&self) -> T {
  16.         self.x
  17.     }
  18. }
  20. impl<T> Point<T> where T: Copy + fmt::Display {
  21.     pub fn y(&self) -> T {
  22.         self.y
  23.     }
  24. }
  26. impl<T> fmt::Display for Point<T> where T: Copy + fmt::Display {
  27.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  28.         write!(f, "({}, {})", self.x(), self.y())
  29.     }
  30. }
  32. fn main() {
  33.     let p1 = Point::<i32>::new(3, 4);
  34.     println!("{}", p1);
  36.     let p2 = Point::<f64>::new(2.4, 3.6);
  37.     println!("{}", p2);
  38. }

实例：实作向量运算

我们用一个比较长的例子展示如何实作泛型程式在我们这个例子中，我们实作向量类别，这个类别可以进行向量运算;为了简化范例，我们仅实作向量加法首先，建立Vector类别，内部使用Rust内建的vector来储存资料，在这里一并呼叫相关的特征：

  1. extern crate num;
  3. use std::fmt;
  4. use std::ops::Add;
  6. pub struct Vector<T> where T: Copy + fmt::Display + num::Num {
  7.      vec: Vec<T>,
  8. }
  10. //接著，實作 Clone trait，使得本向量類別可以像基礎型別般，在計算時拷貝向量，由於 Rust 的限制，目前不能實作 Copy trait。
  12. impl<T> Clone for Vector<T> where T: Copy + fmt::Display + num::Num {
  13.      fn clone(&self) -> Vector<T> {
  14.          let mut vec: Vec<T> = Vec::new();
  16.          for i in 0..(self.vec.len()) {
  17.              vec.push(self.vec[i]);
  18.          }
  20.          Vector::<T>{ vec: vec }
  21.      }
  22.  }
  24.  // 我們的建構子可接受 slice，簡化建立物件的流程：
  26.  // Constructor
  27. impl<T> Vector<T> where T: Copy + fmt::Display + num::Num {
  28.     pub fn from_slice(v: &[T]) -> Vector<T> {
  29.         let mut vec: Vec<T> = Vec::new();
  31.         for i in 0..(v.len()) {
  32.              vec.push(v[i])
  33.         }
  35.         Vector::<T>{ vec: vec }
  36.     }
  37. }
  39. // 實作 fmt::Debug trait，之後可直接從 console 印出本類別的內容。這裡實作的方式參考 Rust 的 vector 在終端機印出的形式。
  41. // Overloaded debug string
  42. impl<T> fmt::Debug for Vector<T> where T: Copy + fmt::Display + num::Num {
  43.     fn fmt(&self, f:&mut fmt::Formatter) -> fmt::Result {
  44.         let mut s = String::new();
  46.         s += "[";
  48.         for i in 0..(self.vec.len()) {
  49.             s += &format!("{}", self.vec[i]);
  51.             if i < self.vec.len() - 1 {
  52.                 s += ", ";
  53.             }
  54.         }
  56.         s += "]";
  58.         // Write string to formatter
  59.         write!(f, "{}", s)
  60.     }
  61. }
  63. // 实作加法运算子，需实作std::ops::Add性状。向量加法的方式是两向量间同位置元素相加，相加前应检查两向量是否等长。
  65. // Overloaded binary '+' operator
  66. impl<T> Add for Vector<T> where T: Copy + fmt::Display + num::Num {
  67.     type Output = Vector<T>;
  69.     fn add(self: Vector<T>, other: Vector<T>) -> Vector<T> {
  70.         if self.vec.len() != other.vec.len() {
  71.             panic!("The length of the two vectors are unequal");
  72.         }
  74.         let mut v: Vec<T> = Vec::new();
  76.         for i in 0..(self.vec.len()) {
  77.             v.push(self.vec[i] + other.vec[i]);
  78.         }
  80.         Vector{ vec: v }
  81.     }
  82. }
  84. // 最後，從外部程式呼叫此類別：
  86. fn main() {
  87.     let v1 = vec![1, 2, 3];
  88.     let v2 = vec![2, 3, 4];
  90.     let vec1 = Vector::<i32>::from_slice(&v1);
  91.     let vec2 = Vector::<i32>::from_slice(&v2);
  93.     // We have to explictly clone our Vector object at present.
  94.     let vec3 = vec1.clone() + vec2.clone();
  96.     println!("{:?}", vec1);
  97.     println!("{:?}", vec2);
  98.     println!("{:?}", vec3);
  99. }

由于Rust为了保持函数库的相容性，现阶段不允许对非copy data实作复制trait，像是本例的向量类别内部使用的vector，所以，我们必须在外部程序中明确地拷贝向量类别。经笔者实测，对于有解构子的类别也不能使用Copy trait，所以，即使我们用C风格的阵列重新实作vector，同样也不能用Copy trait。

另外，我们在这里用了一个外部函数库提供Num trait，这个trait代表该型别符合数字，透过使用这个trait，不需要重新实现代表数字的trait，简化我们的程式。

刚开始写Rust泛型程式时，会遭到许多错误而无法顺利编译，让初学者感到挫折。解决这个问题的关键在于Rust的trait系统。撰写泛型程式时，若没有对泛型变数T加上任何的trait限制，Rust没有足够的信息是否能对T呼叫相对应的内建trait，因而引发错误讯息。即使是使用运算子，Rust也会呼叫相对应的trait;因此，熟悉trait的运作，对撰写泛型程式有相当的帮助。

（案例选读）模拟方法重载

Rust不支持方法重载，不过，可以利用泛型加上多型达到类似的效果。由于呼叫泛型函数时，不需要明确指定参数的型别，使得外部程式在呼叫该函式时，看起来像是方法重载般。接下来，我们以一个范例来展示如何模拟方法重载。首先，定义公开的特质：

  1. use std::fmt;
  3. // An holder for arbitrary type
  4. pub trait Data: fmt::Display {
  5.     // Omit interface
  6.     // You may declare more methods later.
  7. }
  9. pub trait IntoData {
  10.     type OutData: Data;
  12.     fn into_data(&self) -> Self::OutData;
  13. }
  15. // 接着，实作Reader类别，在这个类别中，实作了一个泛型函数，搭配先前的特征类别来模拟方法重载：
  17. pub struct Reader {}
  19. // Use generic method to mimic functional overloading
  20. impl<'a> Reader {
  21.     pub fn get_data<I>(& self, data: I) -> Box<Data + 'a>
  22.     where I: IntoData<'a> + 'a {
  23.         Box::new(data.into_data())
  24.     }
  25. }
  27. // 接着，实作StrData类别，这个类别会实作Data和IntoData这两个trait，以满足前述介面所定义的行为：
  29. pub struct StrData<'a> {
  30.     str: &'a str
  31. }
  33. impl<'a> StrData<'a> {
  34.     pub fn new(s: &'a str) -> StrData<'a> {
  35.         StrData{ str: s }
  36.     }
  37. }
  39. impl<'a> fmt::Display for StrData<'a> {
  40.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  41.         write!(f, "{}", self.str)
  42.     }
  43. }
  45. impl<'a> Data for StrData<'a> {
  46.     // Omit implementation
  47. }
  49. impl<'a> IntoData<'a> for StrData<'a> {
  50.     type OutData = &'a str;
  52.     fn into_data(&self) -> &'a str {
  53.         self.str
  54.     }
  55. }
  57. /* Even Data trait is empty, it is necessary to
  58.    explictly implement it. */
  59. impl<'a> Data for &'a str {
  60.     // Omit implementation
  61. }
  63. // 接着，类似以StrData的方式实动词} IntData：
  65. pub struct IntData{
  66.     int: i32
  67. }
  69. impl IntData {
  70.     pub fn new(i: i32) -> IntData {
  71.         IntData{ int: i }
  72.     }
  73. }
  75. impl fmt::Display for IntData {
  76.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  77.         write!(f, "{}", self.int)
  78.     }
  79. }
  81. impl Data for IntData {
  82.     // Omit implementation
  83. }
  85. impl IntoData for IntData {
  86.     type OutData = i32;
  88.     fn into_data(&self) -> i32 {
  89.         self.int
  90.     }
  91. }
  93. /* Even Data trait is empty, it is necessary to
  94.    explictly implement it. */
  95. impl<'a> Data for i32 {
  96.     // Omit implementation
  97. }
  99. // 最后，从外部程式呼叫：
  101. fn main() {
  102.     let reader = Reader{};
  103.     let str_data = StrData::new("string data");
  104.     let int_data = IntData::new(10);
  106.     // Call hidden generic method to minic functional overloading
  107.     let str = reader.get_data(str_data);
  108.     let int = reader.get_data(int_data);
  110.     println!("Data from StrData: {}", str);
  111.     println!("Data form IntData: {}", int);
  112. }

在我们这个范例中，除了用泛型的机制模拟出方法重载以外，一个另外重点在于get_data函式隐藏了一些内部的操作，对于程式设计者来说，实只要动词} Data状语从句：IntoData后，从外部程式呼叫时，不需要在意其中操作的细节，这也是物件导向的优点之一。