Rust par l'exemple

struct A;          // Le type `A` est concret.
struct S(A);       // Le type `S` est concret.
struct SGen<T>(T); // Le type `SGen` est générique.

// Toutes les fonctions qui suivront possèdent les paramètres 
// qui leur sont passés et libèrent la mémoire aussitôt.

// On définit une fonction nommée `reg_fn` qui prend un argument `_s` de type 
// `S`. Ce dernier n'est pas précédé d'un `<T>` (ou, en l'occurrence un `<S>`)
// donc le type n'est pas générique.
fn reg_fn(_s: S) {}

// On définit une fonction nommée `gen_spec_t` qui prend un argument `_s` de type 
// `SGen<T>`.
// Le type d'argument imposé à la structure SGen<T> est précisé, mais puisque 
// `A` n'est pas précédé par le type générique `<A>`, le type n'est pas générique.
fn gen_spec_t(_s: SGen<A>) {}
//          ^ il aurait fallu déclarer `A` comme générique: `<A>`.

// On définit une fonction nommée `gen_spec_i32` qui prend un argument `_s` de 
// type `SGen<i32>`. 
// Le type de paramètre supporté par la structure SGen a été spécifié, `i32`.
// Puisque `i32` n'est pas un type générique, cette fonction n'est pas générique non plus.
fn gen_spec_i32(_s: SGen<i32>) {}

// On définit une fonction nommée `generic` qui prend un paramètre `_s` de type 
// `SGen<T>`. 
// Puisque `SGen<T>` est précédé par le type générique `<T>`, 
// cette fonction est donc générique.
fn generic<T>(_s: SGen<T>) {}

fn main() {
    // Appel des fonctions qui ne sont pas génériques.
    reg_fn(S(A));          // On passe en paramètre un type concret.
    gen_spec_t(SGen(A));   // Type `A` implicitement spécifié car la fonction 
                           // n'accepte que la signature `SGen<A>`.
    gen_spec_i32(SGen(6)); // Type `i32` implicitement spécifié car la fonction 
                           // n'accepte que la signature `SGen<i32>`.

    // Type du paramètre explicitement spécifié pour 
    // la fonction `generic()`.
    // Le type peut être omis car le compilateur peut inférer 
    // le type à partir du littéral.
    generic::<char>(SGen('a'));

    // Type du paramètre implicitement spécifié pour la fonction 
    // `generic()` car le compilateur est capable d'inférer le type 
    // à partir du littéral.
    generic(SGen('c'));
}

struct S; // On déclare le type concret `S`.
struct GenericVal<T>(T); // On déclare le type générique `GenericVal`.

// Implémentation de GenericVal où nous précisons que cette méthode doit être
// implémentée uniquement pour le type `f32`.
impl GenericVal<f32> {
    fn say_hello_f32(&self) -> (){
        println!("I'm a float! :D");
    }
} // On spécifie `f32`
impl GenericVal<S> {
    fn say_hello_s(&self) -> (){
        println!("I'm a S object! :D");
    }
} // On spécifie le type `S` pour les mêmes raisons qu'au-dessus.
// `<T>` doit précéder le type pour le rendre générique.
impl <T> GenericVal<T> {
    fn say_hello(&self) -> (){
        println!("I'm a generic object! :D");
    }
}

struct Val {
    val: f64
}

struct GenVal<T>{
    gen_val: T
}

// Implémentation de Val.
impl Val {
    fn value(&self) -> &f64 { &self.val }
}

// Implémentation de GenVal pour le type générique `T`.
impl <T> GenVal<T> {
    fn value(&self) -> &T { &self.gen_val }
}

fn main() {
    let x = Val { val: 3.0 };
    let y = GenVal { gen_val: 3i32 };

    println!("{}, {}", x.value(), y.value());
    GenericVal(1.0).say_hello_f32();
    GenericVal(S).say_hello_s();
    GenericVal("prout").say_hello();
}

// Types non-copiables.
struct Empty;
struct Null;

// Un trait générique qui reçoit un type générique `T`.
trait DoubleDrop<T> {
    // On déclare une méthode qui sera implémentée par la structure 
    // appelante (caller) et prendra un paramètre `T` en entrée mais n'en fera rien (juste le libérer). 
    fn double_drop(self, _: T);
}

// On implémente `DoubleDrop<T>` pour n'importe quel paramètre `T` et 
// n'importe quelle structure appelante (`U`).
impl<T, U> DoubleDrop<T> for U {
    // Cette méthode prend "possession" des deux paramètres (`U` et `T`),
    // et sont donc tous deux libérés.
    fn double_drop(self, _: T) {}
}

fn main() {
    let empty = Empty;
    let null  = Null;
    
    // `empty` et `null` sont désalloués.
    empty.double_drop(null);

    // empty;
    // null;
    // ^ TODO: Essayez de décommenter ces lignes.
}

// On déclare une fonction nommée `printer` qui prend, en entrée, 
// un type générique `T` qui doit implémenter le trait `Display`.
fn printer<T: Display>(t: T) {
    println!("{}", t);
}

struct S<T: Display>(T);

// Erreur! `Vec<T>` n'implémente pas le trait `Display`.
let s = S(vec![1]);

// Un trait qui implémente le marqueur `{:?}`.
use std::fmt::Debug;

trait HasArea {
    fn area(&self) -> f64;
}

impl HasArea for Rectangle {
    fn area(&self) -> f64 { self.length * self.height }
}

#[derive(Debug)]
struct Rectangle { length: f64, height: f64 }
#[allow(dead_code)]
struct Triangle  { length: f64, height: f64 }

// Le type générique `T` doit implémenter le trait `Debug`.
// Qu'importe le type de `T`, cela fonctionnera.
fn print_debug<T: Debug>(t: &T) {
    println!("{:?}", t);
}

// `T` doit implémenter le trait `HasArea`. N'importe quelle 
// structure remplissant les conditions d'entrée peut accéder 
// à la méthode `area` du trait `HasArea`.
fn area<T: HasArea>(t: &T) -> f64 { t.area() }

fn main() {
    let rectangle = Rectangle { length: 3.0, height: 4.0 };
    let _triangle = Triangle  { length: 3.0, height: 4.0 };

    print_debug(&rectangle);
    println!("Area: {}", area(&rectangle));

    // print_debug(&_triangle);
    // println!("Area: {}", area(&_triangle));
    // ^ TODO: Essayez de décommenter ces lignes.
    // | Erreur: N'implémente pas l'un de ces traits: `Debug` ou `HasArea`.
}

use std::fmt::{Debug, Display};

fn compare_prints<T: Debug + Display>(t: &T) {
    println!("Debug: `{:?}`", t);
    println!("Display: `{}`", t);
}

fn compare_types<T: Debug, U: Debug>(t: &T, u: &U) {
    println!("t: `{:?}", t);
    println!("u: `{:?}", u);
}

fn main() {
    let string = "words";
    let array = [1, 2, 3];
    let vec = vec![1, 2, 3];

    compare_prints(&string);
    // compare_prints(&array);
    // TODO ^ Essayez de décommenter cette ligne.

    compare_types(&array, &vec);
}

impl <A: TraitB + TraitC, D: TraitE + TraitF> MyTrait<A, D> for YourType {}

// Les restrictions sont explicitées 
// par la condition `where`.
impl <A, D> MyTrait<A, D> for YourType where
    A: TraitB + TraitC,
    D: TraitE + TraitF {}

use std::fmt::{Debug, Formatter, Result};

trait PrintInOption {
    fn print_in_option(self);
}

// Parce que nous pourrions modifier la restriction sans spécifier le 
// conteneur `T: Debug` ou adopter une autre approche,
// il est nécessaire d'utiliser la condition `where`: 
impl<T> PrintInOption for T where
    Option<T>: Debug{
    // Nous spécifions la restriction de type `Option<T>: Debug` parce que 
    // c'est ce que nous souhaitons afficher. Faire autrement pourrait nous 
    // induire en erreur quant au type de restriction à spécifier.
    fn print_in_option(self) {
        println!("{:?}", Some(self)); 
    }
}

fn main() {
    let vec = vec![1, 2, 3];
    vec.print_in_option();
}

use std::marker::PhantomData;

// Un tuple qui prend un type générique `A` et un paramètre fantôme `B`.
#[derive(PartialEq)] // Permet de tester l'égalité entre les instances du type.
struct PhantomTuple<A, B>(A,PhantomData<B>);

// Un tuple qui prend un type générique `A` et un paramètre fantôme `B`.
#[derive(PartialEq)] // Permet de tester l'égalité entre les instances du type.
struct PhantomStruct<A, B> { first: A, phantom: PhantomData<B> }

// Note: De la mémoire sera allouée pour le type générique `A`, mais pas pour `B`.
//       En revanche, `B` ne pourra pas être utilisé à l'exécution.

fn main() {
    // Ici, les types `f32` et `f64` sont des paramètres fantômes.
    // Types spécifiés pour PhantomTuple: `<char, f32>`.
    let _tuple1: PhantomTuple<char, f32> = PhantomTuple('Q', PhantomData);
    // Types spécifiés pour PhantomTuple: `<char, f64>`.
    let _tuple2: PhantomTuple<char, f64> = PhantomTuple('Q', PhantomData);

    // Types spécifiés pour PhantomStruct: `<char, f32>`.
    let _struct1: PhantomStruct<char, f32> = PhantomStruct {
        first: 'Q',
        phantom: PhantomData,
    };
    // Types spécifiés pour PhantomStruct: `<char, f64>`.
    let _struct2: PhantomStruct<char, f64> = PhantomStruct {
        first: 'Q',
        phantom: PhantomData,
    };

    // Erreur! Les deux ressources ne peuvent pas être comparées:
    // println!("_tuple1 == _tuple2 yields: {}",
    //          _tuple1 == _tuple2);

    // Erreur! Les deux ressources ne peuvent pas être comparées:
    // println!("_struct1 == _struct2 yields: {}",
    //          _struct1 == _struct2);
}