// Variable declaration. Type can be omitted if it can be inferred from the surrounding code.
let x = 12;
let mut y = 23;

// Type can also be specified explicitly
let x: i32 = 12;

// Assignment performs a move operation. Every type is move-able.
// Moves are just a `memcpy` of the struct and cannot be overridden by the user.
// Old variable cannot be accessed after it has been moved from.
let str1 = "hello".to_string();
let str2 = str1;         // `str1` is moved here
// println!("{}", str1); // compilation error - use of moved value

// Copies are explicit with `.clone()`
// (except on primitives like numbers where a copy is the same as a move)
let str1 = "hello".to_string();
let str2 = str1.clone();

// `let` can destructure values via pattern matching.
// If we don't want to bind some part to a variable, `_` can be used as a placeholder
let (a, _) = (12, 23);

let x = 10_234_567;     // '_' can be used as separator in numbers
let y = 10_234_567_u64; // explicit integer type with `u64` suffix

let arr = [1, 2, 3, 4];     // fixed array `[i32; 4]`
let slice = &[1, 2, 3, 4];  // reference to array `&[i32; 4]`
                            // will implicitly cast to array slice `&[i32]` if needed
let vec = vec![1, 2, 3, 4]; // vector `Vec<i32>`; `vec!` is a macro

let arr = ['a'; 4];     // `[char; 4]` - array of 4 elements each with the value 'a'
let vec = vec!['a'; 4]; // vector `Vec<char>` with 4 elements each with value 'a'

let ivan = Person { name: String::from("Ivan"), email: String::from("[email protected]") };
{
    let name = String::from("Ivan");
    let email = String::from("[email protected]");
    let ivan = Persion { name, email }; // shorthand if field name mathes variable name
}

// Rust strings (`&str`, `String`) are always valid utf8 and are not null terminated.
// If you need to work with a string that may not be utf8 you should use byte arrays
// instead (`&[u8]`, `Vec<u8>`).

let s1: &str  = "...";  // string literal
let c1: char  = 'x';    // character literal
let s2: &[u8] = b"..."; // ASCII byte string literal
let c2: u8    = b'x';   // ASCII byte literal

// standard `if` statement
// no brackets around condition, brackets around body are mandatory
if x < 10 {
    println!("less than 10");
} else {
    println!("10 or more");
}

// `if` is an expression, i.e. it has a value and can be assigned to a variable.
// There is no ternary operator `?` - an if-else expression is used instead.
let result = if x < 10 { "less than 10" } else { "10 or more" };

// `match` is like `switch` but much more powerful.
// Can be used with any type. Allows pattern matching (which is needed for unpacking enums)
// Match arms are tried from top to bottom, the first that matches is executed.
match x {
    0 => println!("x is zero"),
    10 => println!("x is ten");
    _ => println!("x is other");
}

// `match` is also an expression
let x = match val { ... };

// a block is also an expression
// the last expression in a block is the value of the block
let x = { let sum = 1 + 2; sum };

// The last expression in a function is the value of that functions (no `return` required)
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// Closures
|arg1, arg2| expr      // basic syntax
|arg1, arg2| { block } // a block is an expression
|| expr                // closure with no arguments
|| { block }           // closure with no arguments

// Variables are captured by reference. Captured variables are determined from the body
let good_numbers = vec![1, 3, 5];
let is_good = |x| good_numbers.contains(&x); // `is_good` holds a reference to `good_numbers`

// Move closures - same, but variables are captured by value
let good_numbers = vec![1, 3, 5];
let is_good = move |x| good_numbers.contains(&x); // vector `good_numbers` is moved into `is_good`

// Things that end in '!' are macros, not functions. They expand to some rust code.
println!("Hello {}", name);

// Generic functions declared with `<>` after the name
fn size_of<T>() { /* ... */ }

// When used in an expression, generic arguments are usually inferred.
// If they can't be, they are specified via turbofish `::<>`
let size = std::mem::size_of::<i32>();

// Only the ambiguous types or part of types need to be specified.
// If something is set to `_`, it is filled with the type inference algorithm.
//
// Ex: we need to specify the collection for `collect` - it could be `Vec`, `HashSet`, etc.
// We don't need to specify the item in the collection - it is known to be `i32` from the iterator.
let vec = [1, 2, 3].iter().collect::<Vec<_>>();

// A struct definition - only fields, no methods
struct SomeStruct {
    field1: u32,
    field2: SomeOtherStruct,
}

// Methods are written separately in an `impl` block
impl SomeStruct {
    // An associated function ("static method" in c++).
    // Called as `SomeStruct::new()`.
    //
    // There is no formal concept of constructor, this is just a regular funciton
    // which creates an instance of the struct.
    //
    // `Self` is a type alias for the type of the impl block.
    // In this case `Self` = `SomeStruct`.
    pub fn new() -> Self {
        SomeStruct {
            field1: 0,
            field2: SomeOtherStruct::new(),
        }
    }

    // Methods take as a first argument one of:
    // `self` - meaning argument named `self` of type `Self`
    // `&self` - meaning argument named `self` of type `&Self`
    // `&mut self` - meaning argument named `self` of type `&mut Self`
    //
    // Also it is valid to have field and method of the same name - it is actually
    // not ambiguous when which one is used.
    pub field1(&self) -> u32 {
        self.field1
    }
}

// Structs without fields
struct NoFieldsV1 {}
struct NoFieldsV2;

// Tuple struct - like a named tuple
struct Color(f32, f32, f32);

// C-style enum
enum MyEnum {
    Foo,
    Bar,
}

// Variants can also contain data
// This is like a tagged union or `std::variant<...>`
enum MyEnum {
    Variant1,
    Variant2(String),
    Variant3 { x: u32, y: u32 },
}

// trait declaration
trait ToJson {
    // required method
    fn to_json(&self) -> String;

    // provided method, but can be overridden
    fn write_json(&self, buffer: &mut String) {
        buffer.push_str(&self.to_json());
    }
}

// implementing the trait for a type
impl ToJson for String {
    fn to_json(&self) -> String {
        format!("\"{:?}\"", escape(self));
    }
}

// must add trait bound on `Debug` to be able to print it with the "{:?}" placeholder
fn print_val<T: std::fmt::Debug>(val: T) {
    println!("{:?}", val);
}

// equivalent to the above - just different syntax
fn print_val<T>(val: T)
where
    T: std::fmt::Debug
{
    println!("{:?}", val);
}

fn print_val(val: &dyn std::fmt::Debug) {
    println!("{:?}", val);
}

// standard simple loops
while cond { /* code */ }
loop { /* code */ }         // same as `while true`

// `for` loops use iterators
// there are usually three ways to iterate a collection:
// - `collection.iter()`      or `&collection`     - iterate over const references to elements
// - `collection.iter_mut()`  or `&mut collection` - iterate over mut references to elements
// - `collection.into_iter()` or `collection`      - consume collection and iterate over values
for item in collection.iter() { /* code */ }
for item in &collection { /* code */ }

// to iterate from 0 to n use ranges
for i in 0..n { /* code */ }

// iterator methods are usually prefered over `if`s and `break`/`continue`
for (index, elem) in collection.iter()
    .enumerate()
    .filter(|(_, elem)| is_odd(elem))
{
}

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

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn something() -> Result<MyVal, MyErr> {
    let result = /*...*/;

    // both are equivalent
    // ================
    let x = result?;
    // ================
    let x = match result {
        Ok(val) => val,
        Err(e) => return Err(e.into())
    };
    // ================

    Ok(make_my_val(x))
}

fn something() -> Option<MyVal> {
    let option = /*...*/;

    // both are equivalent
    // ================
    let x = option?;
    // ================
    let x = match option {
        Some(val) => val,
        None => return None,
    };
    // ================

    Some(make_my_val(x))
}

// Ex: function returns a slice of the input string after the given pattern.
// We must annotate that the output is associated with the `input` string and not with `pattern`.
fn strip_prefix(input: &'a str, pattern: &str) -> Option<&'a str>;

// Ex: one way to make an iterator over a slice
pub struct SliceIter<'a, T> {
    slice: &'a [T],
    current_index: usize,
}