Thinkful vs Bloc для вивчення Rust у 2026: Порівняння буткемпів та посібник із самостійного навчання

// Безпека пам'яті без garbage collector
fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // Явне клонування
    
    println!("s1 = {}, s2 = {}", s1, s2);
}

// Приклад обробки помилок у Rust
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("username.txt")?;
    let mut username = String::new();
    file.read_to_string(&mut username)?;
    Ok(username)
}

// Базові структури даних у Rust
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

impl User {
    fn new(username: String, email: String) -> User {
        User {
            username,
            email,
            sign_in_count: 1,
            active: true,
        }
    }
    
    fn deactivate(&mut self) {
        self.active = false;
    }
}

// Приклад з розділу про дженерики
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    
    largest
}

fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    let result = largest(&numbers);
    println!("Найбільше число: {}", result);
}

// Pattern matching — ключова концепція Rust
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("Кінець програми"),
        Message::Move { x, y } => println!("Переміщення до ({}, {})", x, y),
        Message::Write(text) => println!("Текст: {}", text),
        Message::ChangeColor(r, g, b) => {
            println!("Зміна кольору на RGB({}, {}, {})", r, g, b)
        }
    }
}

// Просунуті можливості — lifetimes
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// Async/await у Rust
async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    let response = reqwest::get(url).await?;
    let body = response.text().await?;
    Ok(body)
}

// Приклад простого CLI на Rust
use clap::{App, Arg};
use std::fs;

fn main() {
    let matches = App::new("File Counter")
        .version("1.0")
        .author("Developer")
        .about("Підраховує рядки у файлах")
        .arg(
            Arg::with_name("file")
                .short('f')
                .long("file")
                .value_name("FILE")
                .help("Шлях до файлу")
                .required(true),
        )
        .get_matches();

    if let Some(file_path) = matches.value_of("file") {
        match fs::read_to_string(file_path) {
            Ok(contents) => {
                let line_count = contents.lines().count();
                println!("Файл {} містить {} рядків", file_path, line_count);
            }
            Err(e) => eprintln!("Помилка: {}", e),
        }
    }
}

// Простий HTTP сервер з Axum
use axum::{
    routing::get,
    Router,
    Json,
};
use serde::Serialize;

#[derive(Serialize)]
struct Health {
    status: String,
    version: String,
}

async fn health_check() -> Json<Health> {
    Json(Health {
        status: "ok".to_string(),
        version: "1.0.0".to_string(),
    })
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/health", get(health_check));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    
    axum::serve(listener, app).await.unwrap();
}

// Приклад з Rustlings — виправлення помилок
// Оригінальне завдання:
// fn main() {
//     let x = 5;
//     x = 6; // Помилка: не можна двічі присвоїти значення незмінній змінній
// }

// Розв'язок:
fn main() {
    let mut x = 5;
    println!("Значення x: {}", x);
    x = 6;
    println!("Нове значення x: {}", x);
}

// Часте запитання: Чим відрізняється &str від String?
fn string_vs_str() {
    // String — володіння, мутабельний, алокований у heap
    let mut owned: String = String::from("Hello");
    owned.push_str(", World!");
    
    // &str — запозичений, немутабельний, може вказувати на heap або stack
    let borrowed: &str = "Hello, World!";
    
    // Конвертація
    let to_string: String = borrowed.to_string();
    let to_str: &str = &owned;
}

// Питання про smart pointers
use std::rc::Rc;
use std::cell::RefCell;

fn smart_pointers_example() {
    // Box — одноосібне володіння у heap
    let boxed = Box::new(5);
    
    // Rc — підрахунок посилань (один потік)
    let shared = Rc::new(vec![1, 2, 3]);
    let clone = Rc::clone(&shared);
    
    // RefCell — interior mutability
    let mutable = RefCell::new(5);
    *mutable.borrow_mut() += 1;
}