Implementation

Similar to functions, implementations require care to remain generic.

  1. struct S; // Concrete type `S`
  2. struct GenericVal<T>(T,); // Generic type `GenericVal`
  4. // impl of GenericVal where we explicitly specify type parameters:
  5. impl GenericVal<f32> {} // Specify `f32`
  6. impl GenericVal<S> {} // Specify `S` as defined above
  8. // `<T>` Must precede the type to remain generic
  9. impl <T> GenericVal<T> {}
  1. struct Val {
  2.     val: f64
  3. }
  5. struct GenVal<T>{
  6.     gen_val: T
  7. }
  9. // impl of Val
  10. impl Val {
  11.     fn value(&self) -> &f64 { &self.val }
  12. }
  14. // impl of GenVal for a generic type `T`
  15. impl <T> GenVal<T> {
  16.     fn value(&self) -> &T { &self.gen_val }
  17. }
  19. fn main() {
  20.     let x = Val { val: 3.0 };
  21.     let y = GenVal { gen_val: 3i32 };
  23.     println!("{}, {}", x.value(), y.value());
  24. }

See also:

functions returning references, impl, and struct