Вивчіть X за Y хвилин

// Це коментар. Він починається в цьому рядку...
// і продовжується в цьому

/// Цей коментар включає в себе документацію і підтримує markdown.
/// # Приклади
///
/// ```
/// let five = 5
/// ```

///////////////
// 1. Основи //
///////////////

#[allow(dead_code)]
// Функції
// `i32` - це 32-бітний цілочислений знаковий тип даних
fn add2(x: i32, y: i32) -> i32 {
    // неявне повернення результату (в кінці рядку немає крапки з комою)
    x + y
}

#[allow(unused_variables)]
#[allow(unused_assignments)]
#[allow(dead_code)]
// Головна функція
fn main() {
    // Числа //

    // Незмінне число
    let x: i32 = 1;

    // суфікси для позначення цілого числа та числа з плаваючою змінною
    let y: i32 = 13i32;
    let f: f64 = 1.3f64;

    // Вивід типів
    // Як правило, Rust може самостійно визначити тип змінної, отож
    // ви можете не прописувати його явно
    // В даному документі типи явно прописані в багатьох місцях, це зроблено 
    // виключно в навчальних цілях. В реальному коді вивід типів спрацює 
    // в більшості випадків
    let implicit_x = 1;
    let implicit_f = 1.3;

    // арифметика
    let sum = x + y + 13;

    // Змінні
    let mut mutable = 1;
    mutable = 4;
    mutable += 2;

    // Строки //

    // Строкові літерали
    let x: &str = "Привіт, світ!";

    // Друк на екран
    println!("{} {}", f, x); // 1.3 Привіт, світ!

    // `String` – строка, що розміщується в "купі"
    let s: String = "hello world".to_string();

    // Строковий зріз - це незмінне відображення якоїсь строки (або її частини)
    // Зріз можна розглядати як константну пару покажчиків (на початок та кінець
    // якоїсь строки)
    let s_slice: &str = &s;

    println!("{} {}", s, s_slice); // Привіт, світ! Привіт, світ!

    // Вектори/масиви //

    // Масив фіксованого розміру
    let four_ints: [i32; 4] = [1, 2, 3, 4];

    // Масив змінного розміру (вектор)
    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
    vector.push(5);

    // Зріз - незмінне відображення масиву
    // Це схоже на строковий зріз, але в даному випадку мова йде про вектори
    let slice: &[i32] = &vector;

    // Використовуйте `{:?}` щоб вивести щось в цілях відлагодження
    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]

    // Кортеж //

    // Кортеж - це набір фіксованого розміру, що включає значення кількох типів
    let x: (i32, &str, f64) = (1, "привіт", 3.4);

    // розбираємо кортеж "х" на окремі змінні "a", "b" та "с"
    let (a, b, c) = x;
    println!("{} {} {}", a, b, c); // 1 привіт 3.4

    // доступ по індексу
    println!("{}", x.1); // привіт

    //////////////
    // 2. Типи //
    //////////////

    // Структура
    struct Point {
        x: i32,
        y: i32,
    }

    let origin: Point = Point { x: 0, y: 0 };

    // Структура з безіменними полями, "кортежна структура"
    struct Point2(i32, i32);

    let origin2 = Point2(0, 0);

    // перелічуваний тип даних
    enum Direction {
        Left,
        Right,
        Up,
        Down,
    }

    let up = Direction::Up;

    // перелічуваний тип даних з полями
    enum OptionalI32 {
        AnI32(i32),
        Nothing,
    }

    let two: OptionalI32 = OptionalI32::AnI32(2);
    let nothing = OptionalI32::Nothing;

    // Узагальнене програмування //

    struct Foo<T> { bar: T }

    // Ось так стандартна бібліотека Rust оголошує `Option`
    enum Optional<T> {
        SomeVal(T),
        NoVal,
    }

    // Методи //

    impl<T> Foo<T> {
        // Методи приймають неявний параметр `self`
        fn get_bar(self) -> T {
            self.bar
        }
    }

    let a_foo = Foo { bar: 1 };
    println!("{}", a_foo.get_bar()); // 1

    // Типажі (в інших мовах програмування схожою сутністю є інтерфейси) //

    trait Frobnicate<T> {
        fn frobnicate(self) -> Option<T>;
    }

    impl<T> Frobnicate<T> for Foo<T> {
        fn frobnicate(self) -> Option<T> {
            Some(self.bar)
        }
    }

    let another_foo = Foo { bar: 1 };
    println!("{:?}", another_foo.frobnicate()); // Some(1)

    /////////////////////////
    // 3. Відповідність шаблону //
    /////////////////////////

    let foo = OptionalI32::AnI32(1);
    match foo {
        OptionalI32::AnI32(n) => println!("Це тип i32: {}", n),
        OptionalI32::Nothing  => println!("Це ніщо!"),
    }

    // Складніший приклад
    struct FooBar { x: i32, y: OptionalI32 }
    let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };

    match bar {
        FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
            println!("Числа рівні нулю!"),
        FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
            println!("Числа однакові"),
        FooBar { x: n, y: OptionalI32::AnI32(m) } =>
            println!("Числа різні: {} {}", n, m),
        FooBar { x: _, y: OptionalI32::Nothing } =>
            println!("Друге число - ніщо!"),
    }

    /////////////////////
    // 4. Потік керування //
    /////////////////////

    // Цикл `for` 
    let array = [1, 2, 3];
    for i in array {
        println!("{}", i);
    }

    // Діапазони
    for i in 0u32..10 {
        print!("{} ", i);
    }
    println!("");
    // друкує `0 1 2 3 4 5 6 7 8 9 `

    // `if`
    if 1 == 1 {
        println!("Математика працює!");
    } else {
        println!("Ой, лишенько...");
    }

    // `if` як вираз
    let value = if true {
        "добре"
    } else {
        "погано"
    };

    // Цикл `while`
    while 1 == 1 {
        println!("Всесвіт функціонує стабільно.");
        // Вираз break перериває цикл
        break
    }

    // Нескінченний цикл
    loop {
        println!("Привіт!");
        // Вираз break перериває цикл
        break
    }

    /////////////////////////////////
    // 5. Вказівники і безпека пам'яті //
    /////////////////////////////////

    // Володіючий вказівник - тільки хтось один може "володіти" вказівником в 
    // будь-який момент. Це означає, що коли "Box" вийде за межі області 
    // видимості - його можна безпечно звільнити
    let mut mine: Box<i32> = Box::new(3);
    *mine = 5; // розіменування `mine` з присвоєнням йому нового значення
    // `now_its_mine` перебирає на себе володіння над `mine`. Іншими словами, 
    // `mine` переміщується.
    let mut now_its_mine = mine;
    *now_its_mine += 2;

    println!("{}", now_its_mine); // 7
    // println!("{}", mine); // цей код не скомпілюється, оскільки тепер 
    // покажчиком на дані володіє `now_its_mine`

    // Посилання – незмінний вказівник на дані
    // При створенні посилання на якесь значення, ми говоримо, що значення 
    // було "запозичене". Поки значення є запозиченим - воно не може бути 
    // змінене або переміщене. Запозичення пропадає, як тільки стається вихід з 
    // області видимості, де було створене посилання
    let mut var = 4;
    var = 3;
    let ref_var: &i32 = &var;

    println!("{}", var); // На відміну від `mine`, `var` можна використати
    println!("{}", *ref_var);
    // var = 5; // цей код не скомпілюється, оскільки `var` зараз є запозиченим
    // *ref_var = 6; // цей код також не зкомпілюється, оскільки `ref_var` 
    // є незмінним посиланням

    // Змінне посилання
    // Значення можна запозичити з можливістю зміни. У цьому випадку доступ до 
    // оригінального значення втрачається.
    let mut var2 = 4;
    let ref_var2: &mut i32 = &mut var2;
    *ref_var2 += 2;    // '*' використовується для доступу до змінного посилання

    println!("{}", *ref_var2); // 6 , // при заміні на var2 код не зкомпілюється
    // ref_var2 має тип &mut i32, отож зберігає посилання на i32, а не  значення
    // var2 = 2; // цей рядок не зкомпілюється, оскільки `var2` є запозиченим.
}