$ cargo new myproject

$ multirust run stable cargo new myproject

$ vim myproject/src/lib.rs

// Main takes no arguments and returns nothing
fn main(){
    // The function body is the *scope* inside these curly braces
    // Create a variable. It owns a string.
    let what_to_say = "Hello World";
    // Meet print syntax
    println!("This program says {}", what_to_say);
}

fn not_main(){
    let what_to_say = "Hello World";
}
fn main(){
    println!("This program says {}", what_to_say);
}

<anon>:5:42: 5:53 error: unresolved name `what_to_say` [E0425]
<anon>:5         println!("This program says {}", what_to_say);
                                                  ^~~~~~~~~~~
<std macros>:2:25: 2:56 note: in this expansion of format_args!
<std macros>:3:1: 3:54 note: in this expansion of print! (defined in <std
macros>)
<anon>:5:9: 5:55 note: in this expansion of println! (defined in <std macros>)
<anon>:5:42: 5:53 help: see the detailed explanation for E0425
error: aborting due to previous error

fn main(){
    let what_to_say = "Hello World"
    println!("This program says {}", what_to_say);
}

<anon>:6:9: 6:16 error: expected one of `.`, `;`, or an operator, found `println`
<anon>:6         println!("This program says {}", what_to_say);
                 ^~~~~~~

fn main(){
    let what_to_say = "Hello World"
    println!("Hello");
}

<anon>:4:13: 4:24 warning: unused variable: `what_to_say`,
#[warn(unused_variables)] on by default
<anon>:4         let what_to_say = "Hello World";
                     ^~~~~~~~~~~

fn main(){let what_to_say="Hello World";println!
("This program says {}",what_to_say);}

fn
main
(
    )
{
let what_to_say
    =
"Hello World"
;
println
!  (
"This program says {}"
    , what_to_say
) ;           }

fn and(x: bool,  y: bool) -> bool{
    x && y
}
fn another_and(x: bool,  y: bool) -> bool{
    return x && y;
}
fn main() {
    println!("{}", and(true, false));
    println!("{}", another_and(true, false));
}

fn and(x: bool,  y: bool) -> bool{
    x && y;
}
...

<anon>:1:5: 3:6 error: not all control paths return a value [E0269]
<anon>:1     fn and(x: bool,  y: bool) -> bool{
<anon>:2         x && y;
<anon>:3     }
<anon>:1:5: 3:6 help: see the detailed explanation for E0269
<anon>:2:15: 2:16 help: consider removing this semicolon:
<anon>:2         x && y;
                       ^
error: aborting due to previous error

fn and(x: bool,  y: bool) -> bool{
    return  3;
}
...

<anon>:2:15: 2:16 error: mismatched types:
 expected `bool`,
    found `_`
(expected bool,
    found integral variable) [E0308]
<anon>:2        return 3;
                       ^
<anon>:2:15: 2:16 help: see the detailed explanation for E0308

fn and(x: bool,  y: bool) -> i32{
    if x && y {
        return 3;
    }
    return 0;
}

fn and(x: bool,  y: bool) -> i32{
    if x && y {
        return 3;
    }
    // what if we don't do anything here?
}

<anon>:2:9: 4:10 error: mismatched types:
 expected `i32`,
    found `()`
(expected i32,
    found ()) [E0308]
<anon>:2         if x && y {
<anon>:3             return 3;
<anon>:4         }
...

fn main() {
    let number = 13;
    // TODO ^ Try different values for `number`

    println!("Tell me about {}", number);
    match number {
        // Match a single value
        1 => println!("One!"),
        // Match several values
        2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
        // Match an inclusive range
        13...19 => println!("A teen"),
        // Handle the rest of cases
        _ => println!("Ain't special"),
    }
}

fn main() {
    let boolean = true;
    // Match is an expression too
    let binary = match boolean {
        // The arms of a match must cover all the possible values
        false => 0,
        true => 1,
        // TODO ^ Try commenting out one of these arms
    };

    println!("{} -> {}", boolean, binary);
}

fn main() {
    // `n` will take the values: 1, 2, ..., 100 in each iteration
    for n in 1..101 {
        if n % 15 == 0 {
            println!("fizzbuzz");
        } else if n % 3 == 0 {
            println!("fizz");
        } else if n % 5 == 0 {
            println!("buzz");
        } else {
            println!("{}", n);
        }
    }
}

fn main() {
    // `n` will take the values: 1, 2, ..., 100 in each iteration
    for n in 1..101 {
        ...
    }
    println!{"{}", n}
}

<anon>:14:24: 14:25 error: unresolved name `n` [E0425]
<anon>:14         println!{"{}", n}
                                 ^
<std macros>:2:25: 2:56 note: in this expansion of format_args!
<std macros>:3:1: 3:54 note: in this expansion of print! (defined in <std
macros>)
<anon>:14:9: 14:26 note: in this expansion of println! (defined in <std
macros>)
<anon>:14:24: 14:25 help: see the detailed explanation for E0425

fn borrow_int(borrowed_int: &i32) {
    println!("I borrowed the int {}", borrowed_int);
}

fn main() {
    let my_int : i32 = 42;
    borrow_int(&my_int);
    println!("I still have my int. it's {}.", my_int)
}

fn main() {
    let immutable_int = 42;
    println!("immutable_int contains {}", immutable_int);
    let mut mutable_int = immutable_int; // this makes a copy
    println!("mutable_int contains {}", mutable_int);
    println!("immutable_int contains {}", immutable_int);
    mutable_int = 5;
    println!("mutable_int now contains {}", mutable_int);
}

immutable_int contains 42
mutable_int contains 42
immutable_int contains 42
mutable_int now contains 5

fn main() {
    let immutable = "I'm immutable!".to_string();
    println!("immutable contains {}", immutable);
    let mut mutable = immutable; //move the value, not copy
    println!("mutable contains {}", mutable);
    mutable = "I have been mutated".to_string();
    println!("mutable now contains {}", mutable);
}

immutable_string contains I'm immutable!
mutable_string contains I'm immutable!
mutable_string now contains I have been mutated

fn main() {
    let immutable = "I'm immutable!".to_string();
    let mut mutable = immutable; //move the value, not copy
    println!("immutable contains {}", immutable);
}

<anon>:5:43: 5:52 error: use of moved value: `immutable` [E0382]
<anon>:5         println!("immutable contains {}", immutable);
                                                   ^~~~~~~~~
...
<anon>:5:43: 5:52 help: see the detailed explanation for E0382
<anon>:4:13: 4:24 note: `immutable` moved here because it has type
`collections::string::String`, which is moved by default
<anon>:4         let mut mutable = immutable; //move the value, not copy
                     ^~~~~~~~~~~