fn main() {
    let x = 5;
}

let (x, y) = (1, 2);

let x: i32 = 5;

let x = 5;
x = 10; // will error on compile

let mut x = 5;
x = 10

fn main() {
    let x: i32;
}

fn main() {
    let x: i32;
    let y = x + 5; // error
}

fn main() {
    let x: i32 = 17;
    {
        let y: i32 = 3;
    }
    let z = x + y // error
}

fn main() {
    let x: i32 = 8;
    {
        // x is 8
        let x = 12;
        // x is 12
    }
    // x is 8
}

fn foo() {

}

fn do_something(x: i32) {
   
}

fn inc(x: i32) -> i32 {
    x + 1
}

fn inc(x: i32) -> i32 {
    return x + 1; // early return

    x + 2 // never reached
}

let f: fn(i32) -> i32;

// without type inference
let f: fn(i32) -> i32 = inc;

// with type inference
let f = inc;

let six = f(5);

fn inc(x: i32) -> i32 {
    x + 1
}

let x = true;

let y: bool = false;

let x: char = 'x';
let two_hearts = '💕';

let x: i8 = 3;

let x = 42; // x has type i32

let y = 1.0; // y has type f64

let a = [1, 2, 3]; 

let mut b: [i32; 3] = [1,2,3];

let c = [0; 20]; // initialize each element to 0

let a = [1, 2, 3]; 

let len = a.len()

let three = a[2];

let a = [0, 1, 2, 3, 4];
let complete = &a[..]; // A slice containing all of the elements in a
let middle = &a[1..4]; // A slice of a: only the elements 1, 2, and 3

let x = (1, false);

let x: (i32, bool) = (1, true);

let a = (1, 2, 3);

let (x, y, z) = a

let (x, y, z) = (1, 2, 3);

let tuple = (1, 2, 3);

let x = tuple.0;
let y = tuple.1;
let z = tuple.2;

let x = 5;

if x == 5 {
    do_something();
} else {
    do_something_else();
}

let x = 5;

if x == 5 {
    do_something();
} else if x == 6 {
    do_something();
}

let x = 5;
let y = if x == 5 { 10 } else { 15 };

loop {
    do_something(); //repeat forever
}

let mut x = 5;
let mut done = false;

while !done {
    x += 2;
    if x % 5 == 0 {
        done = true;
    }
}

for (i,j) in (5..10).enumerate() {
    do_something(i, j);
}

let lines = "hello\nworld".lines();

for (linenumber, line) in lines.enumerate() {
    do_something(line_number, line);
}

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

fn main() {
    let origin = Point { x: 0, y: 0 }; 
    println!("The origin is at ({}, {})", origin.x, origin.y);
}

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

fn main() {
    let mut point = Point { x: 0, y: 0 };

    point.x = 5;

    println!("The point is at ({}, {})", point.x, point.y);
}

struct Point3d {
    x: i32,
    y: i32,
    z: i32,
}

let mut point = Point3d { x: 0, y: 0, z: 0 };
point = Point3d { y: 1, .. point };

struct Colour(i32, i32, i32);
struct Point(i32, i32, i32);

let black = Colour(0, 0, 0);
let origin = Point(0, 0, 0);

struct Circle {
    x: f64,
    y: f64,
    radius: f64,
}

impl Circle {
    fn area(&self) -> f64 {
        3.14 * (self.radius * self.radius)
    }
}

fn main() {
    let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
    println!("{}", c.area());
}

enum Message {
    Quit,
    ChangeColor(i32, i32, i32),
    Move { x: i32, y: i32 },
    Write(String),
}

let x: Message = Message::Move { x: 3, y: 4 };

let v = vec!["Hello".to_string(), "World".to_string()];

let v1 = v.into_iter().map(Message::Write).collect();
// v1 is a vec of [Message::Write("Hello"), Message::Write("World")]

let number = 3
let size = match number {

	0 => "none",
	2 | 3 => "tiny",
	4...7 => "small",	
	8...20 => "medium",
	_ => "large"
};

enum Message {
    Quit,
    ChangeColor(i32, i32, i32),
    Move { x: i32, y: i32 },
    Write(String),
}

fn quit() { /* ... */ }
fn change_color(r: i32, g: i32, b: i32) { /* ... */ }
fn move_cursor(x: i32, y: i32) { /* ... */ }

fn process_message(msg: Message) {
    match msg {
        Message::Quit => quit(),
        Message::ChangeColor(r, g, b) => change_color(r, g, b),
        Message::Move { x: x, y: y } => move_cursor(x, y),
        Message::Write(s) => println!("{}", s),
    };
}

let pair = (1,2);
let smaller = match pair {
	(x, y) if x < y => x,
	(_, y) => y
};

match point {
	Point {x: 2...6, y: -1...5} => println!("I like this point"),
	_ => println!("I do not like this point")
}

enum Option<T> {
    Some(T),
    None,
}

let x: Option<i32> = Some(5);

fn takes_anything<T>(x: T) {
    // do something with x
}

fn takes_two_of_the_same_things<T>(x: T, y: T) {
    // ...
}

fn takes_two_things<T, U>(x: T, y: U) {
    // ...
}

struct Point<T> {
    x: T,
    y: T,
}

let int_origin = Point { x: 0, y: 0 };
let float_origin = Point { x: 0.0, y: 0.0 };

trait Pointy {
        fn poke(&self, at: &str);
        // One can also give full function bodies here
}

impl Pointy for Point {
        fn poke(&self, at: &str) {
                println!("Poked {}", at);
        }
}

fn poke_forever<T: Pointy>(pointy: T, at: &str) {
        loop {
         pointy.poke(at)
        }
}

let v = vec![1, 2, 3];

let v2 = v;

println!("v[0] is: {}", v[0]); // error

fn take(v: Vec<i32>) {
    // what happens here isn’t important.
}

let v = vec![1, 2, 3];

take(v);

println!("v[0] is: {}", v[0]); // error

fn helper(value: Vec<i32>) {
    println!("The list was: {}", value);
}

fn main() {
    let list = vec![1,2,3];
    
    helper(list); // move by default
    helper(list); // error
}

fn helper(value: Vec<i32>) -> Vec<i32> {
    println!("The list was: {}", value);
    value
}

fn main() {
    let list = vec![1,2,3];
   
    let a = helper(list); // transfer ownership and acquire ownership of return value
    
}

fn foo(v1: &Vec<i32>, v2: &Vec<i32>) -> i32 {
    // do stuff with v1 and v2

    42
}

let v1 = vec![1, 2, 3];
let v2 = vec![1, 2, 3];

let answer = foo(&v1, &v2);