FAQ sur la programmation en langage RustConsultez toutes les FAQ

1
2
3
4
5
6
7
8
public class MyClass  
{ 
	    public static void main(String[] args)  
	    { 
	        throw new RuntimeException("Error !"); 
	        System.out.println("Dead code."); 
	    } 
}

1
2
3
4
5
fn main() 
{ 
    panic!("Error !"); 
    println!("Dead code"); 
}

1
2
3
4
5
6
7
8
9
fn main() 
{ 
    let foo : Option<String> = Some("ça passe!".to_string()); 
    let bar : Option<String> = None; 
    let baz : Result<String, String> = Ok("ça passe!".to_string()); 
    let bing : Result<String, String> = Err("ça casse!".to_string()); 
  
    println!("{} {} {} {}", foo.unwrap(), bar.unwrap(), baz.unwrap(), bing.unwrap()); 
}

1
2
3
4
5
6
7
8
9
10
11
12
fn main() 
{ 
    let foo : Option<String> = Some("ça passe!".to_string()); 
    let bar : Option<String> = None; 
    let baz : Result<String, String> = Ok("ça passe!".to_string()); 
    let bing : Result<String, String> = Err("ça casse!".to_string()); 
  
    println!("{} {} {} {}", foo.unwrap(), bar.unwrap_or(String::from("ça passe, mais de justesse !")), baz.unwrap(), bing.unwrap_or(String::from("On évite de faire planter le programme."))); 
    /*  
        Pensez à isoler les appels de la méthode si vous ne souhaitez pas faire planter votre programme. 
    */ 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fn bang(arg: String) -> String 
{ 
    return "Chef, on a eu une erreur: ".to_string() + arg.as_str(); 
} 
fn main() 
{ 
    let foo : Option<String> = Some("ça passe!".to_string()); 
    let bar : Option<String> = None; 
    let baz : Result<String, String> = Ok("ça passe!".to_string()); 
    let bing : Result<String, String> = Err("ça casse!".to_string()); 
  
    bar.unwrap_or_else(|| { return "On évite la casse !".to_string(); }); 
    println!("{}", bing.unwrap_or_else(bang)); 
}

1
2
3
4
5
6
7
8
fn main() { 
    let foo = vec![1, 2, 3]; 
    let foo2: Vec<_> = foo.iter().map(|entry| format!("> {}", entry)).collect(); 
  
    for entry in foo2 { 
        println!("-> \"{}\"", entry); 
    } 
}

1
2
3
-> "> 1" 
-> "> 2" 
-> "> 3"

1
2
3
4
5
6
7
8
9
fn concat(arg: &str) -> Option<String> 
{ 
    Some(arg.to_string() + "world!") 
} 
fn main() 
{ 
    let foo = Some("Hello "); 
    println!("{}", foo.and_then(concat).unwrap()); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
fn foo(string: &String) -> Result<(), std::io::Error>  
{ 
    try!(std::fs::File::create("my_file.txt")); 
    println!("Une chance sur deux pour que je sois du code mort !"); 
    Ok(()) 
} 
  
fn bar(string: &String) -> std::io::Result<()>  
{ // fonctionne également avec l'alias de Result<T, E> 
    try!(std::fs::File::create("my_file.txt")); 
    println!("Une chance sur deux pour que je sois du code mort !"); 
    Ok(()) 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
use std::io::Error; 
fn foo(string: &String) -> Result<(), Error>  
{ 
    std::fs::File::create("my_file.txt")?; 
    println!("Une chance sur deux pour que je sois du code mort !"); 
    Ok(()) 
} 
  
fn bar(string: &String) -> std::io::Result<()>  
{ // fonctionne également avec l'alias de Result<T, E> 
    std::fs::File::create("my_file.txt")?; 
    println!("Une chance sur deux pour que je sois du code mort !"); 
    Ok(()) 
}

2 * 2, if … else …, foo() ;

1
2
3
4
5
macro_rules! assert { 
    ( $ cond : expr ) => { ... }; 
    ( 
$ cond : expr , $ ( $ arg : tt ) + ) => { ... }; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
fn foo(arg: Option<String>) -> () 
{ 
    let bar : String = String::from("Hello world!"); 
    let mut some : Option<String> = None; 
    assert!(!arg.is_none(), "Arg is None"); 
    assert!(arg.unwrap().eq(&bar), "arg n'est pas égal à bar"); 
} 
  
fn main() -> () 
{ 
    foo(Some("Ok".to_string())); 
    foo(None); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
fn foo(arg: Option<String>) -> () 
{ 
    let bar : String = String::from("Hello world!"); 
    let mut some : Option<String> = None; 
    assert!(!arg.is_none(), "Arg is None"); 
    assert_eq!(arg.unwrap(), bar, "arg n'est pas égal à bar"); 
} 
  
fn main() -> () 
{ 
    foo(Some("Ok".to_string())); 
    foo(None); 
}

1
2
3
4
5
fn main() 
{ 
    let foo : Option<String> = Some(String::from("Binding valide")); 
    let bar : Option<String> = None; //binding invalide, ne contient rien 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
fn foo<'a, 'b>(arg: Option<&'a str>) -> Result<String, &'b str> { 
    if let Some(content) = arg { 
        let unwrapping = arg.unwrap(); 
        Ok(unwrapping.to_string()) 
    } else { 
        Err("L'argument ne contient rien.") 
    } 
} 
  
fn main() { 
    match foo(None) { 
        Ok(content) => println!("Ok: {}", content), 
        Err(err) => println!("Error: {}", err.to_string()), 
    } 
}