Rust

// 1. 변수와 타입
fn main() {
    // 불변 변수 (기본값)
    let name: &str = "Rust";
    let year: u32 = 2015;

    // 가변 변수
    let mut count = 0;
    count += 1;

    // 구조체 정의
    struct User {
        username: String,
        email: String,
        active: bool,
    }

    let user = User {
        username: String::from("rustacean"),
        email: String::from("rust@example.com"),
        active: true,
    };

    // 열거형 (Enum)
    enum Message {
        Quit,
        Move { x: i32, y: i32 },
        Write(String),
    }

    // 패턴 매칭
    let msg = Message::Move { x: 10, y: 20 };
    match msg {
        Message::Quit => println!("종료"),
        Message::Move { x, y } => println!("이동: ({}, {})", x, y),
        Message::Write(text) => println!("메시지: {}", text),
    }

    println!("{} 언어, {}년 출시", name, year);
}

// 2. 소유권(Ownership)과 빌림(Borrowing)
fn main() {
    // 소유권 이동 (Move)
    let s1 = String::from("hello");
    let s2 = s1;  // s1의 소유권이 s2로 이동
    // println!("{}", s1);  // 오류! s1은 더 이상 유효하지 않음
    println!("{}", s2);

    // 복제 (Clone)
    let s3 = String::from("world");
    let s4 = s3.clone();  // 깊은 복사
    println!("s3: {}, s4: {}", s3, s4);  // 둘 다 사용 가능

    // 불변 참조 (Borrowing)
    let s5 = String::from("rust");
    let len = calculate_length(&s5);  // 불변 참조로 빌림
    println!("'{}' 길이: {}", s5, len);  // s5 여전히 유효

    // 가변 참조
    let mut s6 = String::from("hello");
    change(&mut s6);
    println!("변경됨: {}", s6);

    // 슬라이스
    let s7 = String::from("hello world");
    let hello = &s7[0..5];
    let world = &s7[6..11];
    println!("{} {}", hello, world);
}

fn calculate_length(s: &String) -> usize {
    s.len()  // 참조만 사용, 소유권 가져가지 않음
}

fn change(s: &mut String) {
    s.push_str(", world!");
}

// 3. Result 타입과 에러 처리
use std::fs::File;
use std::io::{self, Read};

fn main() {
    // Result 기본 사용
    let result = divide(10, 2);
    match result {
        Ok(value) => println!("결과: {}", value),
        Err(e) => println!("에러: {}", e),
    }

    // ? 연산자로 에러 전파
    match read_file_content("config.txt") {
        Ok(content) => println!("파일 내용: {}", content),
        Err(e) => println!("파일 읽기 실패: {}", e),
    }

    // unwrap_or_else 사용
    let config = read_file_content("config.txt")
        .unwrap_or_else(|_| String::from("기본 설정"));
    println!("설정: {}", config);

    // Option 타입
    let numbers = vec![1, 2, 3];
    match numbers.get(5) {
        Some(value) => println!("값: {}", value),
        None => println!("인덱스 범위 초과"),
    }
}

fn divide(a: i32, b: i32) -> Result {
    if b == 0 {
        Err(String::from("0으로 나눌 수 없습니다"))
    } else {
        Ok(a / b)
    }
}

fn read_file_content(path: &str) -> Result {
    let mut file = File::open(path)?;  // ? 연산자: 에러시 즉시 반환
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}