====== Rust ======

===== Resources =====
  * [[https://fasterthanli.me/blog/2020/a-half-hour-to-learn-rust/|Half an hour to learn Rust]]
  * [[https://cheats.rs/|Rust Cheat Sheet]]
===== General =====
Rust uses snake case convention:
  * functions and variables all lower case with _ separating words
  * function parenthesis after function name

Printing data structures is possible using annotations
<code rust>
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

let rect1 = Rectangle {
    width: 30,
    height: 30,
};
println!("{:?}", rect1); // inline
println!("{:#?}", rect1); // multiline
</code>

===Attributes===
<code rust>
#[allow(unused_variables, unused_mut)]
#[allow(unused)]
#[allow(dead_code)]
#[macro_use] // allows to use macros from extern crate
</code>

Attribute at a crate level 
<code rust>
#![allow(unused)]
</code>

===== Cargo =====
<code bash>
cargo new PROJECT_NAME (--bin/lib)
cargo build --release
cargo run
cargo update
cargo doc --open
</code>

===== Diesel =====
[[https://diesel.rs/|Docs]]

CLI comands
<code bash>
cargo install diesel_cli
diesel setup
diesel migration generate create_users
diesel migration run
diesel migration redo
diesel print-schema > src/schema.rs
</code>

<code rust>
#[derive(Queryable)]
pub struct UserModel {
...
}
</code>

===== Data Types =====
=== Integers ===
 (signed ''i8'', unsigned ''u8'') (''isize'' defaults to your computer architecture 32/64 bit)
  * ''i8'', ''i16'', ''i32'', ''i64'', ''i128'', ''isize''
  * Default: ''i32'' even on 64 bit machines

=== Floating-Point ===

  * ''f32''(single precision), ''f64''(double precision)
  * Default: ''f64''

=== Character ===

  * ''char'' specified with single quotes ''let c = 'z' ''
  * four bytes (Unicode - Chinese, Japanese, Korean, Emoji)

=== Tuple ===

<code rust>
fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    let (x, y, z) = tup;
    let five_hundred = tup.0;
}
</code>
  * Fixed length structure holding multiple values
  * Allows destructuring 
  * Can hold different data types

=== Array ===
  * Holds same type of elements
  * Fixed length

<code rust>
let a: [i32; 5] = [1, 2, 3, 4, 5];
let a = [3; 5]; // let a = [3, 3, 3, 3, 3];
</code>

<code rust>
let a = [1, 2, 3, 4, 5];
let index = 10;
llet element = a[index]; //runtime error. Rust does not allow to access memory
</code>

===== Functions =====
Function bodies are made of statements and optionally end with an expression.
  * Statements do not return values ''let x = 3;''
  * Expressions return values ''4+6''
  * Expressions can be start of statements ''let x = 4+6;''
  * Calling a function/macro is an expression
  * Expressions do not end with '';'', adding semicolon will turn it into statement which will not return value

<code rust>
fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("The value of x is: {}", x);
}
</code>

=== Tuples ===
<code rust>
let rect1 = (30, 50);

fn area(dimensions: (u32, u32)) -> u32 {
    dimensions.0 * dimensions.1
}
</code>
===== Control Flow =====
Rust does not transform to bools automatically
<code rust>
let x = 5;
if x {} // error
if x != 0 {} // correct
</code>

Condition in ''let'' statement
<code rust>
let condition = true;
let number = if condition {
    5
} else {
    6
};
 </code>

Rust has 3 types of loops: ''loop'', ''while'', ''for''

=== Loop ===
Executes until you explicitly tell it to stop
<code rust>
loop {
    println!("again!");
}
</code>

<code rust>
fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result);
}
</code>

=== While ===

<code rust>
fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);

        number -= 1;
    }

    println!("LIFTOFF!!!");
}
</code>

=== For ===
<code rust>
fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("the value is: {}", element);
    }
}
</code>

===== Structs =====
Struct instances are mutable.

<code rust>
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

let user1 = User {
    username: String::from("A"),
    email: String::from("a@a.a"),
    active: true,
    sign_in_count: 1,
};

let user2 = {
    username: String::from("B"),
    ..user1
}
</code>

=== Tuple Structs ===
<code rust>
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
</code>

=== Implementing methods ===

<code rust>
impl Rectangle {
    fn area(&self) -> u32 {
        self.height * self.height
    }
}

let area = rect1.area();
</code>

=== Implementing namespaces ===
<code rust>
impl Rectangle {
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}
let rect3 = Rectangle::square(30);
</code>

===== Collections =====
===Vector===
<code rust>
let v: Vec<i32> = Vec::new();
let v = vec![1,2,3,4,5];

let third: &i32 = &v[2]; //crashes for non-existent index

match v.get(2) { // can handle non-existent index
    Some(el) => println!("Third elem is: {}", el),
    None => println!("There is no third elem."),
}
</code>

To change the value of the vector in the loop we have to dereference it
<code rust>
let mut v = vec![100, 32, 57];
for i in &mut v {
    *i += 50;
}
</code>

=====Closures=====
<code rust>
let my_closure = |x| { x+1 };
my_closure(5); // types of closure automatically inferred by the compiler

let my_closure2 = |x: u32| -> u32 { x +1}; // explicit type annotations
</code>

===Memoization / lazy evaluation===
Technique where we execute expensive closure and hold resulting value for the future so we would not need to evaluate the closure again.
<code rust>
struct Cacher<T>
where
    T: Fn(u32) -> u32,
{
    calculation: T,
    value: Option<u32>,
}

impl<T> Cacher<T>
where
    T: Fn(u32) -> u32,
{
    fn new(calculation: T) -> Cacher<T> {
        Cacher {
            calculation,
            value: None,
        }
    }
    fn value(&mut self, arg: u32) -> u32 {
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.calculation)(arg);
                self.value = Some(v);
                v
            }
        }
    }
}
</code>
<code bash>
fn main() {
    let mut my_closure = Cacher::new(|x: u32| x + 1);
    println!("{}", my_closure.value(10)); // calculates for the first time
    println!("{}", my_closure.value(10)); // uses stored value
}
</code>