fn dup<T> (x:T) -> (T, T) {
    (x, x)
}

[E0382] Error: use of moved value: `x`
   ╭─[command_2:1:1]
   │
 1 │ fn dup<T> (x:T) -> (T, T) {
   │         │  ┬  
   │         ╰───── help: consider restricting type parameter `T`: `: Copy`
   │            │  
   │            ╰── move occurs because `x` has type `T`, which does not implement the `Copy` trait
 2 │     (x, x)
   │      ┬  ┬  
   │      ╰───── value moved here
   │         │  
   │         ╰── value used here after move
───╯

impl T {
    fn clone(&self) -> T { ... }
    // notez le `&self` et non juste `self`
}

fn dup<T> (x: T) -> (T, T) 
    where T: Clone  // T implémente Clone
{
    let y: T = x.clone();
    (x, y)
}

let v = vec![1,2,3]; // <- a une méthode clone, implémente Clone

println!("{:?}", dup(v));

([1, 2, 3], [1, 2, 3])

struct Foo {bar: i32}

fn dup<T: Clone> (x: T) -> (T, T) {
    let y: T = x.clone();
    (x, y)
}

let v = Foo {bar: 0}; // <- pas de méthode clone

dup(v);

// déclaration du trait `Clone` dans la librairie standard
trait Clone {

    // méthode requise pour implémenter le trait
    fn clone(&self) -> Self;

    // méthode avec une implémentation par défaut
    fn clone_from(&mut self, source: &Self) {
        *self = source.clone()
    }
}

struct Foo {bar: i32}

impl Clone for Foo {
    fn clone(&self) -> Self {
        return Foo { bar: self.bar }
    }

    // si on veut changer l'implémentation par défaut 
    // de `clone_from`, c'est possible
    fn clone_from(&mut self, source: &Self) {
        self.bar = source.bar
    }
}

#[derive(Clone)]
struct Foo {bar: i8}

#[derive(Clone)]
enum Color { HTML(String), RGB(u8, u8, u8) }

let c1 = Color::RGB(0, 0, 0);
let c2 = c1.clone();

// un exemple de trait
trait ToString {
    fn to_string(&self) -> String;
}

// un exemple de type générique
enum Optionnal<T> {
    Ok(T), 
    Error(String) 
}

// on peut implémenter ToString pour Optionnal<T> 
// du moment que T lui-même implémente ToString
impl <T:ToString> ToString for Optionnal<T> {
    fn to_string(&self) -> String {
        match self {
            Optionnal::Ok(t) => t.to_string(),
            Optionnal::Error(s) => s.clone(),
        }
    }
}

trait Foo<T> { fn bar(x:T) { ... } }

pub trait Display {
    // Required method
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}

pub trait Debug {
    // Required method
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}

struct Euros { cents: usize }

use std::fmt;

impl fmt::Display for Euros {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{},{}€", self.cents / 100, self.cents % 100)
    }
}

// implémentation générée par #[derive(Debug)]
impl fmt::Debug for Euros { 
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Euros {{cents: {} }}", self.cents)
    }
}

let x = Euros {cents: 1234 };
println!( "[fmt de Display]  {}\n[fmt de Debug]    {:?}", x, x);
x.to_string()

[fmt de Display]  12,34€
[fmt de Debug]    Euros {cents: 1234 }

"12,34€"

impl<T: Display> ToString for T {
    // --snip--
}

trait A { fn m(&self) -> char; }
trait B { fn m(&self) -> char; }
struct S { }
impl A for S { fn m(&self) -> char { 'A' } }
impl B for S { fn m(&self) -> char { 'B' } }
impl S { fn m(&self) -> char { 'S' }}
let s: S = S {};
let a = <dyn A>::m(&s); // s.m() de A
let b = <dyn B>::m(&s); // s.m() de B
let c = <S>::m(&s);     // s.m() de S
let d = s.m();
(a, b, c, d)

('A', 'B', 'S', 'S')

// in std::default
trait Default {
    fn default() -> Self;
}

fn main() {
    let x: i32 = Default::default(); // == 0
    let y: Option<i32> = Default::default(); // == None
}

trait Add<Rhs = Self> {
    type Output;

    // méthode requise
    fn add(self, rhs: Rhs) -> Self::Output;
}

#[derive(Clone, Debug)]
struct Entier { val: usize }

use std::ops::Add;

impl Add for Entier {
    type Output = Entier;
    fn add(self, rhs: Entier) -> Entier { 
        Entier {val: self.val + rhs.val }
    }
}

impl Add<&Entier> for Entier {
    type Output = usize;
    fn add(self, rhs: &Entier) -> usize { 
        self.val + (*rhs).val 
        // ou bien `rhs.val` (Auto deref)
    }
}

let (un, deux) = (Entier { val: 1 }, Entier { val: 2 });
let trois /* : Entier */ = un + deux;
let quatre = Entier { val: 4 };
let sept /* : usize */ = trois + &quatre;
println!("quatre = {quatre:?}, sept = {sept:?}");

quatre = Entier { val: 4 }, sept = 7

impl<K: Eq + Hash, V> HashMap<K, V> { 
    ...
    fn insert(&mut self, k: K, v: V) -> Option<V> { ... } 
    ...
}

fn dup<T: Copy> (x:T) -> (T, T) { (x, x) }

struct CopyNonCompliant {
    d: Vec<i32>
}

impl<'a> Copy for CopyNonCompliant { }  //<- error

let x: i32 = 0;
let y: f32 = 0.0;

// méthode `to_string` de `impl ToString for i32`
x.to_string() 

// méthode `to_string` de `impl ToString for f32`
y.to_string() 

// fonction `default` de `impl Default for usize`
let z : usize = Default::default()

Object o;
if (/* random */) {
    o = Integer.valueOf(1);
} else {
    o = Float.valueOf(0);
}

// liaison dynamique
String s = o.toString(); // <- toString() de Integer ou Float, 
                         // on ne sait pas encore

let x: i32 = 0;
let y: f32 = 0.0;

// z est un pointeur vers un objet qui implémente le trait ToString
let z: Box<dyn ToString> = 

    if /* ... */ { 
        Box::new(x) 
    } else {
        Box::new(y) 
    };

z.to_string() // liaison dynamique

trait Foo { fn foo() -> Self; }
trait Bar : Foo { fn bar(self); } // hérite de Foo
struct S { }
impl Foo for S { fn foo () -> Self { S{} } }

// pas possible sans `impl Foo for S` avant
impl Bar for S { fn bar(self) { } }

trait PartialEq<Rhs> {
    fn eq(&self, other: &Rhs) -> bool;
    fn ne(&self, other: &Rhs) -> bool { ... /* Impl par défaut */ }
}

trait Eq: PartialEq<Self> { }

let v    : Vec<i32> = vec![1,2,3,4];
let s    : String   = "hello".to_string();

// un emprunt vers un type qui n'est pas `Sized`
let ptr1 : &[i32]   = &v[1..2];

// autre exemple
let ptr2 : &str     = &s;

// autre exemple, mais avec une boîte
let ptr3 : Box<dyn ToString> = Box::new(s);

for x in c { ...
}

trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>; 
    ...
}

trait IntoIterator {
    type Item;
    type IntoIter: Iterator<Item = Self::Item>; // <- constraint
    fn into_iter(self) -> Self::IntoIter; 
}

// Le type qui se cache derrière `0..N`
struct Range {
    start: i32,
    end: i32, 
}

impl Iterator for Range {
    type Item = i32;
    fn next(&mut self) -> Option<i32> {
        if self.start < self.end {
            let r = self.start; 
            self.start += 1;
            return Some(r)
        } else {
            return None
        }
    }
}

for x in v { ... } // x:T, consomme `v`
for x in &mut v { ... } // x:&mut T, permet de modifier v via x
for x in &v { ... } // x:&T, emprunt partagé de v, laisse v inchangé

impl<T> IntoIterator for Vec<T> { 
    type Item = T;
    type IntoIter = IntoIter<T>;
    fn into_iter(self) -> IntoIter<T> { ... }
}

impl<'a, T> IntoIterator for &'a Vec<T> { 
    type Item = &'a T;
    type IntoIter = Iter<'a, T>;
    fn into_iter(self) -> Iter<'a, T> { ... }
}

impl<'a, T> IntoIterator for &'a mut Vec<T> { 
    type Item = &'a mut T;
    type IntoIter = IterMut<'a, T>;
    fn into_iter(self) -> IterMut<'a, T> { ... }
}

for x in &mut v { ... } // x:&mut T, mutable borrow, modifies the elements of v. 

impl<'a, T> IntoIterator for &'a mut Vec<T> { 
    type Item = &'a mut T;
    type IntoIter = IterMut<'a, T>;
    fn into_iter(self) -> IterMut<'a, T> { ... }
}

class Parent {
    void run() { hook(); } // this.hook(), liaison dynamique
    void hook() { System.out.println("parent");  } 
}
class Child extends Parent {
    void hook() { System.out.println("child");  } 
}
class Main {
    void main() { 
        Parent o = new Child();
        o.run(); // -> affiche "child"
    }
}

Paradigmes et interprétation - semaine 2¶

Intro Rust 2: Notion de trait¶

Plan¶

Retour sur une des questions du TP1¶

Qu'est-ce qu'un trait?¶

Comment implémenter un trait?¶

Trait et généricité¶

Les traits `Display` et `Debug`¶

Implémenteur¶

Surcharge et appel de méthode pleinement spécifié¶

Le trait `Default`¶

Le trait `Add`¶

Autres traits associés à des opérateurs¶

Combiner des contraintes de traits¶

Contrats de traits¶

Marker traits¶

Liaison statique¶

Liaison dynamique (ou liaison tardive)¶

Duplication de code¶

Héritage¶

Le trait `Sized`¶

Itérateurs¶

Intervalles¶

Itérer sur `Vec<T>`¶

(rappel cours 1)¶

Ce qu'il faut retenir¶

En TP¶

La semaine prochaine¶

Complément: liaison dynamique et héritage: les "crochets"¶

Paradigmes et interprétation - semaine 2¶

Intro Rust 2: Notion de trait¶

Plan¶

Retour sur une des questions du TP1¶

Qu'est-ce qu'un trait?¶

Comment implémenter un trait?¶

Trait et généricité¶

Les traits Display et Debug¶

Implémenteur¶

Surcharge et appel de méthode pleinement spécifié¶

Le trait Default¶

Le trait Add¶

Autres traits associés à des opérateurs¶

Combiner des contraintes de traits¶

Contrats de traits¶

Marker traits¶

Liaison statique¶

Liaison dynamique (ou liaison tardive)¶

Duplication de code¶

Héritage¶

Le trait Sized¶

Itérateurs¶

Intervalles¶

Itérer sur Vec<T>¶

(rappel cours 1)¶

Ce qu'il faut retenir¶

En TP¶

La semaine prochaine¶

Complément: liaison dynamique et héritage: les "crochets"¶

Les traits `Display` et `Debug`¶

Le trait `Default`¶

Le trait `Add`¶

Le trait `Sized`¶

Itérer sur `Vec<T>`¶