Rust par l'exemple

struct Point {
    x: f64,
    y: f64,
}

// Toutes les méthodes de la structure `Point` sont implémentées ici.
impl Point {
    // Ceci est une méthode statique.
    // Les méthodes statiques ne sont pas dépendantes des instances.
    // Il est courant d'utiliser les méthodes statiques comme constructeurs.
    fn origin() -> Point {
        Point { x: 0.0, y: 0.0 }
    }

    // Une autre méthode statique possédant
    // deux paramètres.
    fn new(x: f64, y: f64) -> Point {
        Point { x: x, y: y }
    }
}

struct Rectangle {
    p1: Point,
    p2: Point,
}

impl Rectangle {
    // Ceci est une méthode dépendante d'une instance (méthode d'instance).
    // `&self` est le sucre syntaxique de `self: &Self` où `Self` est le 
    // type de l'objet qui appelle les méthodes. En l'occurrence 
    // `Self` = `Rectangle`.
    fn area(&self) -> f64 {
        // `self` donne accès aux champs de la structure via la notation pointée.
        let Point { x: x1, y: y1 } = self.p1;
        let Point { x: x2, y: y2 } = self.p2;

        // `abs` est une méthode renvoyant un réel de type f64 qui représente 
        // la valeur absolue du primitif.
        ((x1 - x2) * (y1 - y2)).abs()
    }

    fn perimeter(&self) -> f64 {
        let Point { x: x1, y: y1 } = self.p1;
        let Point { x: x2, y: y2 } = self.p2;

        2.0 * ((x1 - x2).abs() + (y1 - y2).abs())
    }

    // Cette méthode a besoin d'opérer sur une référence mutable 
    // de l'instance courante `&mut self`.
    // La syntaxe non-raccourcie est `self: &mut Self`.
    fn translate(&mut self, x: f64, y: f64) {
        self.p1.x += x;
        self.p2.x += x;

        self.p1.y += y;
        self.p2.y += y;
    }
}

// `Pair` possède deux entiers alloués dans le tas.
struct Pair(Box<i32>, Box<i32>);

impl Pair {
    // Cette méthode "consomme" les ressources de l'instance courante.
    // `self` est un sucre syntaxique de `self: Self`.
    fn destroy(self) {
        // Déstructure `self` (i.e. récupère les champs désirés).
        let Pair(first, second) = self;

        println!("Destroying Pair({}, {})", first, second);

        // La mémoire occupée par `first` et `second` sera libérée
        // une fois que l'exécution de la méthode prendra fin.
    }
}

fn main() {
    let rectangle = Rectangle {
        // Les méthodes statiques sont appelées par le biais 
        // d'une paire de deux points `::`.
        p1: Point::origin(),
        p2: Point::new(3.0, 4.0),
    };

    // Vous devez, en revanche, utiliser la notation pointée pour appeler 
    // les méthodes d'instance. 
    // Notez que le premier argument passé (implicitement) est `&self`
    // (i.e. `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)`).
    println!("Rectangle perimeter: {}", rectangle.perimeter());
    println!("Rectangle area: {}", rectangle.area());

    let mut square = Rectangle {
        p1: Point::origin(),
        p2: Point::new(1.0, 1.0),
    };

    // Erreur! `rectangle` est immuable alors que cette méthode 
    // nécessite une référence mutable de l'objet.
    // rectangle.translate(1.0, 0.0);
    // TODO ^ Essayez de décommenter cette ligne.

    // C'est bon! Les objets mutables peuvent appeler les méthodes
    // "mutables".
    square.translate(1.0, 1.0);

    let pair = Pair(Box::new(1), Box::new(2));

    pair.destroy();

    // Erreur! L'appel de la méthode `destroy` a consommé
    // l'instance `pair`.
    // pair.destroy();
    // TODO ^ Essayez de décommenter cette ligne.
}

fn main() {
    // Incrémentation avec les closures et fonctions.
    fn  function            (i: i32) -> i32 { i + 1 }

    // Les closures sont anonymes, ici nous assignons leurs références.
    // Les closures sont typées de la même manière qu'une fonction classique
    // mais le typage est optionnel. Chaque version (raccourcie et non-raccourcie)
    // est assignée à un identificateur approprié.
    let closure_annotated = |i: i32| -> i32 { i + 1 };
    let closure_inferred  = |i     |          i + 1  ;

    let i = 1;
    // Appelle la fonction et les closures.
    println!("function: {}", function(i));
    println!("closure_annotated: {}", closure_annotated(i));
    println!("closure_inferred: {}", closure_inferred(i));

    // Une closure qui ne prend aucun argument et renvoie un 
    // entier de type `i32`.
    // Le type de renvoi est inféré.
    let one = || 1;
    println!("closure returning one: {}", one());

}

fn is_odd(n: u32) -> bool {
    n % 2 == 1
}

fn main() {
    println!("Find the sum of all the squared odd numbers under 1000");
    let upper = 1000;

    // Approche impérative.
    // On déclare un accumulateur.
    let mut acc = 0; // 0, 1, 2, ... ∞
    for n in 0.. {
        // Le carré du nombre.
        let n_squared = n * n;

        if n_squared >= upper {
            // On sort de la boucle si le carré de `n_squared` 
            // dépasse la limite imposée par `upper`.
            break;
        } else if is_odd(n_squared) {
            // On accumule le carré de `n_squared` si c'est impair.
            acc += n_squared;
        }
    }
    println!("imperative style: {}", acc);

    // Approche fonctionnelle.
    let sum_of_squared_odd_numbers: u32 =
        (0..).map(|n| n * n)             // On calcule le carré de chaque nombre.
             .take_while(|&n| n < upper) // On vérifie que le carré se trouve toujours sous la limite de `upper`.
             .filter(|&n| is_odd(n))     // On récupère le nombre si il est impair.
             .fold(0, |sum, i| sum + i); // On accumule le carré du nombre impair.
    println!("functional style: {}", sum_of_squared_odd_numbers);
}