Rust par l'exemple

use std::thread;

static NTHREADS: i32 = 10;

// Ceci est le thread `main`.
fn main() {
    // On créé un vecteur pour récupérer tous les threads 
    // enfants qui ont été créés.
    let mut children = vec![];

    for i in 0..NTHREADS {
        // On passe à un autre thread.
        children.push(thread::spawn(move || {
            println!("this is thread number {}", i)
        }));
    }

    for child in children {
        // On attend que le thread se termine. Renvoie un résultat.
        let _ = child.join();
    }
}

use std::sync::mpsc::{Sender, Receiver};
use std::sync::mpsc;
use std::thread;

static NTHREADS: i32 = 3;

fn main() {
    // Les canaux possèdent deux extrémités: l'envoyeur (`Sender<T>`) et le receveur (`Receiver<T>`),
    // où `T` est le type du message à envoyer.
    // (Le typage est optionnel)
    let (tx, rx): (Sender<i32>, Receiver<i32>) = mpsc::channel();

    for id in 0..NTHREADS {
        // L'envoyeur peut être copié.
        let thread_tx = tx.clone();

        // Chaque thread va envoyer son identifiant par le biais du canal.
        thread::spawn(move || {
            // Le thread prend l'ownership sur `thread_tx`.
            // Chaque thread va ajouter un message dans le file d'attente 
            // dans le canal.
            thread_tx.send(id).unwrap();

            // L'envoi est une opération non-bloquante, le thread continuera à 
            // s'exécuter après l'envoi de son message.
            println!("thread {} finished", id);
        });
    }

    // Ici, on récupère tous les messages.
    let mut ids = Vec::with_capacity(NTHREADS as usize);
    for _ in 0..NTHREADS {
        // La méthode `recv` choisit une message se trouvant dans le canal et 
        // gêlera le thread courant s'il n'y a aucun message.
        ids.push(rx.recv());
    }

    // Montre l'ordre dans lequel les messages ont été envoyés.
    println!("{:?}", ids);
}

use std::path::{Path, PathBuf};
use std::ffi;

fn main() {
    // Création d'un objet `Path` à partir d'une `&'static str`.
    let path = Path::new(".");

    // La méthode `display` renvoie une structure présentable.
    let display = path.display();

    // La méthode `join()` fusionne un chemin avec toutes les ressources 
    // possédant une implémentation de la méthode `as_ref()` pour le type `Path` et 
    // renvoie un nouveau chemin avec le séparateur spécifique à l'OS.
    let new_path = path.join("a").join("b");

    // Convertit le chemin en une vue sur une string.
    match new_path.to_str() {
        None => panic!("new path is not a valid UTF-8 sequence"),
        Some(s) => println!("new path is {}", s),
    }
}

use std::process::Command;

fn main() {
    let output = Command::new("rustc")
        .arg("--version")
        .output().unwrap_or_else(|e| {
            panic!("failed to execute process: {}", e)
    });

    if output.status.success() {
        let s = String::from_utf8_lossy(&output.stdout);

        print!("rustc succeeded and stdout was:\n{}", s);
    } else {
        let s = String::from_utf8_lossy(&output.stderr);

        print!("rustc failed and stderr was:\n{}", s);
    }
}

// Dans le fichier fs.rs
use std::fs;
use std::fs::{File, OpenOptions};
use std::io;
use std::io::prelude::*;
use std::os::unix;
use std::path::Path;

// Une simple implémentation de la commande `cat path`.
fn cat(path: &Path) -> io::Result<String> {
    let mut f = try!(File::open(path));
    let mut s = String::new();
    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}

// Une simple implémentation de la commande `echo s > path`.
fn echo(s: &str, path: &Path) -> io::Result<()> {
    let mut f = try!(File::create(path));

    f.write_all(s.as_bytes())
}

// Une simple implémentation de la commande `touch path` (ignore les fichiers existants).
fn touch(path: &Path) -> io::Result<()> {
    match OpenOptions::new().create(true).write(true).open(path) {
        Ok(_) => Ok(()),
        Err(e) => Err(e),
    }
}

fn main() {
    println!("`mkdir a`");
    // Crée un répertoire et renvoie un objet `io::Result<()>`.
    match fs::create_dir("a") {
        Err(why) => println!("! {:?}", why.kind()),
        Ok(_) => {},
    }

    println!("`echo hello > a/b.txt`");
    // Le match précédent peut être simplifié en utilisant la méthode `unwrap_or_else()`.
    echo("hello", &Path::new("a/b.txt")).unwrap_or_else(|why| {
        println!("! {:?}", why.kind());
    });

    println!("`mkdir -p a/c/d`");
    // Crée un répertoire récursivement, renvoie un objet `ìo::Result<()>`.
    fs::create_dir_all("a/c/d").unwrap_or_else(|why| {
        println!("! {:?}", why.kind());
    });

    println!("`touch a/c/e.txt`");
    touch(&Path::new("a/c/e.txt")).unwrap_or_else(|why| {
        println!("! {:?}", why.kind());
    });

    println!("`ln -s ../b.txt a/c/b.txt`");
    // Crée un lien symbolique, renvoie un objet `io::Result<()>`.
    if cfg!(target_family = "unix") {
        unix::fs::symlink("../b.txt", "a/c/b.txt").unwrap_or_else(|why| {
        println!("! {:?}", why.kind());
        });
    }

    println!("`cat a/c/b.txt`");
    match cat(&Path::new("a/c/b.txt")) {
        Err(why) => println!("! {:?}", why.kind()),
        Ok(s) => println!("> {}", s),
    }

    println!("`ls a`");
    // Lit le contenu d'un répertoire, renvoie un objet `io::Result<Vec<Path>>`.
    match fs::read_dir("a") {
        Err(why) => println!("! {:?}", why.kind()),
        Ok(paths) => for path in paths {
            println!("> {:?}", path.unwrap().path());
        },
    }

    println!("`rm a/c/e.txt`");
    // Supprime un fichier, renvoie un objet `io::Result<()>`.
    fs::remove_file("a/c/e.txt").unwrap_or_else(|why| {
        println!("! {:?}", why.kind());
    });

    println!("`rmdir a/c/d`");
    // Supprime un répertoire vide, renvoie un objet `io::Result<()>`.
    fs::remove_dir("a/c/d").unwrap_or_else(|why| {
        println!("! {:?}", why.kind());
    });
}

$ rustc fs.rs && ./fs
`mkdir a`
`echo hello > a/b.txt`
`mkdir -p a/c/d`
`touch a/c/e.txt`
`ln -s ../b.txt a/c/b.txt`
`cat a/c/b.txt`
> hello
`ls a`
> "a/b.txt"
> "a/c"
`rm a/c/e.txt`
`rmdir a/c/d`

$ tree a
a
|-- b.txt
`-- c
    `-- b.txt -> ../b.txt

1 directory, 2 files

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();

    // Le premier argument est le chemin à partir duquel le programme 
    // a été appelé.
    println!("My path is {}.", args[0]);

    // Le reste des arguments sont ceux passés en ligne de commande au programme.
    // On appelle le programme comme ceci:
    //  $ ./args arg1 arg2
    println!("I got {:?} arguments: {:?}.", args.len() - 1, &args[1..]);
}

// Dans le fichier ffi.rs
use std::fmt;

// Ce bloc externe lie la bibliothèque libm.
#[link(name = "m")]
extern {
    // Ceci est une fonction externe 
    // qui calcule la racine carrée d'un nombre complexe à précision simple.
    fn csqrtf(z: Complex) -> Complex;
}

fn main() {
    // z = -1 + 0i
    let z = Complex { re: -1., im: 0. };

    // Appeler une fonction externe est une opération dite "à risque".
    let z_sqrt = unsafe {
        csqrtf(z)
    };

    println!("the square root of {:?} is {:?}", z, z_sqrt);
}

// Implémentation minimale d'un nombre complex à précision simple.
#[repr(C)]
#[derive(Clone, Copy)]
struct Complex {
    re: f32,
    im: f32,
}

impl fmt::Debug for Complex {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if self.im < 0. {
            write!(f, "{}-{}i", self.re, -self.im)
        } else {
            write!(f, "{}+{}i", self.re, self.im)
        }
    }
}

// Dans le fichier safe.rs
use std::fmt;

#[link(name = "m")]
extern {
    fn ccosf(z: Complex) -> Complex;
}

// Wrapper sécurisé.
fn cos(z: Complex) -> Complex {
    unsafe { ccosf(z) }
}

fn main() {
    // z = 0 + 1i
    let z = Complex { re: 0., im: 1. };

    println!("cos({:?}) = {:?}", z, cos(z));
}

// Implémentation minimale d'un nombre complexe à précision simple.
#[repr(C)]
#[derive(Clone, Copy)]
struct Complex {
    re: f32,
    im: f32,
}

impl fmt::Debug for Complex {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if self.im < 0. {
            write!(f, "{}-{}i", self.re, -self.im)
        } else {
            write!(f, "{}+{}i", self.re, self.im)
        }
    }
}