✍️ 필사 모드: Rust 프로그래밍 입문 가이드 — 소유권, 라이프타임, 안전한 시스템 프로그래밍

fn main() {
    let s1 = String::from("hello"); // s1이 String의 소유자
    let s2 = s1;                     // 소유권이 s2로 이동(move)
    // println!("{}", s1);           // 컴파일 에러! s1은 더 이상 유효하지 않음
    println!("{}", s2);              // OK
} // s2가 스코프를 벗어나면 메모리 해제

// 정수형은 Copy 트레이트 구현 - 복사됨
let x = 5;
let y = x;
println!("x = {}, y = {}", x, y); // 둘 다 사용 가능

// String은 Copy 미구현 - 이동됨
let s1 = String::from("hello");
let s2 = s1; // 이동!
// s1은 사용 불가

// 명시적 복사가 필요하면 clone 사용
let s3 = String::from("world");
let s4 = s3.clone();
println!("s3 = {}, s4 = {}", s3, s4); // 둘 다 사용 가능

fn calculate_length(s: &String) -> usize {
    s.len()
} // s는 참조이므로 여기서 해제되지 않음

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // 빌림 (불변 참조)
    println!("'{}' 의 길이: {}", s1, len); // s1 여전히 유효
}

fn main() {
    let mut s = String::from("hello");

    // 불변 참조는 여러 개 동시에 가능
    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);

    // 가변 참조는 하나만 가능
    let r3 = &mut s;
    r3.push_str(", world");
    println!("{}", r3);

    // 불변 참조와 가변 참조를 동시에 가질 수 없음
    // let r4 = &s;
    // let r5 = &mut s; // 컴파일 에러!
}

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

fn main() {
    let s = String::from("hello world");
    let word = first_word(&s);
    println!("첫 번째 단어: {}", word); // "hello"
}

// 이 코드는 컴파일되지 않음 - 댕글링 참조 방지
// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s  // s가 함수 끝에서 해제되므로 참조가 무효
// }

// 올바른 방법: 값을 직접 반환
fn no_dangle() -> String {
    let s = String::from("hello");
    s // 소유권이 호출자에게 이동
}

// 두 문자열 슬라이스 중 긴 것을 반환
// 반환값의 라이프타임은 두 인자 중 짧은 쪽을 따름
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
        println!("더 긴 문자열: {}", result); // 여기서는 OK
    }
    // println!("{}", result); // string2가 해제되어 에러 가능
}

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }

    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("주목! {}", announcement);
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence;
    {
        let i = novel.find('.').unwrap_or(novel.len());
        first_sentence = &novel[..i];
    }
    let excerpt = ImportantExcerpt {
        part: first_sentence,
    };
    println!("인용: {}", excerpt.part);
}

// 문자열 리터럴은 항상 'static
let s: &'static str = "이 문자열은 프로그램 전체 수명 동안 유효합니다";

// 주의: 'static을 남용하지 마세요
// 대부분의 경우 더 짧은 라이프타임이면 충분합니다

// 라이프타임 생략 적용 - 규칙 2
fn first_word(s: &str) -> &str {
    // 컴파일러가 fn first_word<'a>(s: &'a str) -> &'a str 로 추론
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

// 기본 열거형
enum Direction {
    Up,
    Down,
    Left,
    Right,
}

// 데이터를 포함하는 열거형
enum Message {
    Quit,                        // 데이터 없음
    Move { x: i32, y: i32 },    // 이름 있는 필드
    Write(String),               // 단일 String
    ChangeColor(i32, i32, i32),  // 세 개의 i32
}

impl Message {
    fn call(&self) {
        match self {
            Message::Quit => println!("종료"),
            Message::Move { x, y } => println!("이동: ({}, {})", x, y),
            Message::Write(text) => println!("메시지: {}", text),
            Message::ChangeColor(r, g, b) => {
                println!("색상 변경: ({}, {}, {})", r, g, b)
            }
        }
    }
}

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

fn divide(numerator: f64, denominator: f64) -> Option<f64> {
    if denominator == 0.0 {
        None
    } else {
        Some(numerator / denominator)
    }
}

fn main() {
    let result = divide(10.0, 3.0);

    // match로 처리
    match result {
        Some(value) => println!("결과: {:.2}", value),
        None => println!("0으로 나눌 수 없습니다"),
    }

    // if let으로 간결하게
    if let Some(value) = divide(10.0, 0.0) {
        println!("결과: {}", value);
    } else {
        println!("나눗셈 실패");
    }

    // unwrap_or로 기본값 지정
    let safe_result = divide(10.0, 0.0).unwrap_or(0.0);
    println!("안전한 결과: {}", safe_result);
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

enum UsState {
    Alabama,
    Alaska,
    Arizona,
    // ...
}

fn value_in_cents(coin: &Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("행운의 동전!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("주 쿼터: {:?}", state);
            25
        }
    }
}

fn classify_number(n: i32) {
    match n {
        // 범위 매칭
        1..=12 => println!("{}월", n),
        13..=19 => println!("십대"),

        // 가드 조건
        x if x % 2 == 0 => println!("짝수: {}", x),
        x if x < 0 => println!("음수: {}", x),

        // 다중 패턴
        20 | 30 | 40 => println!("10의 배수"),

        // 나머지 모두
        _ => println!("기타: {}", n),
    }
}

// 구조체 디스트럭처링
struct Point {
    x: f64,
    y: f64,
}

fn describe_point(point: &Point) {
    match point {
        Point { x: 0.0, y: 0.0 } => println!("원점"),
        Point { x, y: 0.0 } => println!("x축 위: {}", x),
        Point { x: 0.0, y } => println!("y축 위: {}", y),
        Point { x, y } => println!("({}, {})", x, y),
    }
}

use std::fs::File;
use std::io::{self, Read};

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

fn read_file_content(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    match read_file_content("config.toml") {
        Ok(content) => println!("파일 내용: {}", content),
        Err(e) => eprintln!("파일 읽기 실패: {}", e),
    }
}

use std::fs;
use std::io;
use std::num::ParseIntError;

#[derive(Debug)]
enum AppError {
    IoError(io::Error),
    ParseError(ParseIntError),
}

impl From<io::Error> for AppError {
    fn from(e: io::Error) -> Self {
        AppError::IoError(e)
    }
}

impl From<ParseIntError> for AppError {
    fn from(e: ParseIntError) -> Self {
        AppError::ParseError(e)
    }
}

fn read_and_parse(path: &str) -> Result<i32, AppError> {
    let content = fs::read_to_string(path)?; // io::Error -> AppError
    let number = content.trim().parse::<i32>()?; // ParseIntError -> AppError
    Ok(number * 2)
}

// thiserror - 라이브러리용 구체적인 에러 타입 정의
use thiserror::Error;

#[derive(Error, Debug)]
enum DatabaseError {
    #[error("연결 실패: {0}")]
    ConnectionFailed(String),

    #[error("쿼리 실행 에러: {0}")]
    QueryError(String),

    #[error("레코드를 찾을 수 없음: {id}")]
    NotFound { id: u64 },
}

// anyhow - 애플리케이션용 간편한 에러 처리
use anyhow::{Context, Result};

fn load_config() -> Result<Config> {
    let content = fs::read_to_string("config.toml")
        .context("설정 파일을 읽을 수 없습니다")?;

    let config: Config = toml::from_str(&content)
        .context("설정 파일 파싱에 실패했습니다")?;

    Ok(config)
}

// panic!은 프로그램을 즉시 중단
fn check_positive(n: i32) {
    if n < 0 {
        panic!("음수가 입력되었습니다: {}", n);
    }
}

// 배열 인덱스 범위 초과도 panic
let v = vec![1, 2, 3];
// let element = v[99]; // panic!

// 안전한 접근
match v.get(99) {
    Some(value) => println!("값: {}", value),
    None => println!("인덱스 범위 초과"),
}

#[derive(Debug, Clone)]
struct User {
    username: String,
    email: String,
    age: u32,
    active: bool,
}

impl User {
    // 생성자 패턴 (관례적으로 new)
    fn new(username: String, email: String, age: u32) -> Self {
        User {
            username,
            email,
            age,
            active: true,
        }
    }

    // 메서드 (&self로 불변 빌림)
    fn is_adult(&self) -> bool {
        self.age >= 18
    }

    // 가변 메서드 (&mut self)
    fn deactivate(&mut self) {
        self.active = false;
    }

    // 소유권을 가져가는 메서드
    fn into_username(self) -> String {
        self.username
    }
}

fn main() {
    let mut user = User::new(
        "rustacean".to_string(),
        "rust@example.com".to_string(),
        25,
    );

    println!("성인 여부: {}", user.is_adult());
    user.deactivate();
    println!("사용자: {:?}", user);
}

trait Summary {
    fn summarize_author(&self) -> String;

    // 기본 구현 제공 가능
    fn summarize(&self) -> String {
        format!("{}님의 글 더 읽기...", self.summarize_author())
    }
}

struct Article {
    title: String,
    author: String,
    content: String,
}

impl Summary for Article {
    fn summarize_author(&self) -> String {
        self.author.clone()
    }

    fn summarize(&self) -> String {
        format!("{}, by {} - {}...",
            self.title, self.author,
            &self.content[..50.min(self.content.len())]
        )
    }
}

struct Tweet {
    username: String,
    content: String,
}

impl Summary for Tweet {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
    // summarize는 기본 구현 사용
}

// 제네릭 함수 + 트레이트 바운드
fn notify(item: &impl Summary) {
    println!("속보! {}", item.summarize());
}

// 동일한 표현 (트레이트 바운드 문법)
fn notify_verbose<T: Summary>(item: &T) {
    println!("속보! {}", item.summarize());
}

// 복수의 트레이트 바운드
fn display_and_summarize<T: Summary + std::fmt::Display>(item: &T) {
    println!("표시: {}", item);
    println!("요약: {}", item.summarize());
}

// where 절로 가독성 향상
fn complex_function<T, U>(t: &T, u: &U) -> String
where
    T: Summary + Clone,
    U: std::fmt::Display + std::fmt::Debug,
{
    format!("{} - {:?}", t.summarize(), u)
}

struct Stack<T> {
    elements: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self {
        Stack {
            elements: Vec::new(),
        }
    }

    fn push(&mut self, item: T) {
        self.elements.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.elements.pop()
    }

    fn peek(&self) -> Option<&T> {
        self.elements.last()
    }

    fn is_empty(&self) -> bool {
        self.elements.is_empty()
    }

    fn size(&self) -> usize {
        self.elements.len()
    }
}

// 특정 타입에 대한 추가 구현
impl<T: std::fmt::Display> Stack<T> {
    fn print_top(&self) {
        if let Some(top) = self.peek() {
            println!("최상단: {}", top);
        }
    }
}

// async fn은 Future를 반환
async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    let response = reqwest::get(url).await?;
    let body = response.text().await?;
    Ok(body)
}

// async 블록
let future = async {
    let data = fetch_data("https://api.example.com/data").await;
    println!("데이터 수신 완료");
    data
};

use tokio;
use std::time::Duration;

#[tokio::main]
async fn main() {
    // 동시에 여러 작업 실행
    let (result1, result2) = tokio::join!(
        async_task("작업1", 2),
        async_task("작업2", 1),
    );

    println!("결과: {:?}, {:?}", result1, result2);
}

async fn async_task(name: &str, seconds: u64) -> String {
    println!("{} 시작", name);
    tokio::time::sleep(Duration::from_secs(seconds)).await;
    println!("{} 완료", name);
    format!("{} 결과", name)
}

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    // 다중 생산자, 단일 소비자 채널
    let (tx, mut rx) = mpsc::channel::<String>(100);

    // 여러 생산자 생성
    for i in 0..5 {
        let tx_clone = tx.clone();
        tokio::spawn(async move {
            let msg = format!("메시지 {}", i);
            tx_clone.send(msg).await.unwrap();
        });
    }
    // 원본 tx 드롭 (모든 생산자가 끝나면 채널 종료)
    drop(tx);

    // 소비자
    while let Some(message) = rx.recv().await {
        println!("수신: {}", message);
    }
}

use std::sync::Arc;
use tokio::sync::Mutex;

#[tokio::main]
async fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = tokio::spawn(async move {
            let mut num = counter.lock().await;
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.await.unwrap();
    }

    println!("최종 카운터: {}", *counter.lock().await);
}

[package]
name = "my-project"
version = "0.1.0"
edition = "2021"
authors = ["Developer <dev@example.com>"]
description = "A sample Rust project"
license = "MIT"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.12", features = ["json"] }
anyhow = "1.0"
thiserror = "2.0"
clap = { version = "4", features = ["derive"] }

[dev-dependencies]
criterion = "0.5"
mockall = "0.13"

[profile.release]
opt-level = 3
lto = true
codegen-units = 1
strip = true

# 프로젝트 생성
cargo new my-project       # 바이너리 프로젝트
cargo new my-lib --lib     # 라이브러리 프로젝트

# 빌드와 실행
cargo build                # 디버그 빌드
cargo build --release      # 릴리스 빌드
cargo run                  # 빌드 후 실행
cargo run -- --arg1 value  # 인자 전달

# 테스트
cargo test                 # 모든 테스트 실행
cargo test test_name       # 특정 테스트만
cargo test -- --nocapture  # 출력 표시

# 검사와 분석
cargo check                # 컴파일 확인 (빌드보다 빠름)
cargo clippy               # 린트 검사
cargo fmt                  # 코드 포매팅

# 문서
cargo doc --open           # 문서 생성 후 브라우저 열기

# 의존성 관리
cargo add serde            # 의존성 추가
cargo update               # 의존성 업데이트
cargo tree                 # 의존성 트리 확인

# 루트 Cargo.toml
[workspace]
members = [
    "crates/core",
    "crates/api",
    "crates/cli",
]

[workspace.dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

# crates/core/Cargo.toml
[package]
name = "my-core"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { workspace = true }

# crates.io 계정 설정
cargo login

# 배포 전 검사
cargo publish --dry-run

# 실제 배포
cargo publish

use clap::Parser;
use std::path::PathBuf;

#[derive(Parser, Debug)]
#[command(name = "file-analyzer")]
#[command(about = "파일 분석 도구", long_about = None)]
struct Cli {
    /// 분석할 파일 경로
    #[arg(short, long)]
    path: PathBuf,

    /// 출력 형식
    #[arg(short, long, default_value = "text")]
    format: String,

    /// 상세 출력
    #[arg(short, long)]
    verbose: bool,

    /// 최대 깊이
    #[arg(short, long, default_value_t = 3)]
    depth: u32,
}

fn main() {
    let cli = Cli::parse();

    if cli.verbose {
        println!("파일 경로: {:?}", cli.path);
        println!("출력 형식: {}", cli.format);
        println!("최대 깊이: {}", cli.depth);
    }

    analyze_file(&cli.path, cli.depth);
}

fn analyze_file(path: &PathBuf, depth: u32) {
    println!("분석 중: {:?} (깊이: {})", path, depth);
    // 파일 분석 로직...
}

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::Json,
    routing::{get, post},
    Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::Mutex;

#[derive(Debug, Serialize, Deserialize, Clone)]
struct Todo {
    id: u64,
    title: String,
    completed: bool,
}

type AppState = Arc<Mutex<Vec<Todo>>>;

#[tokio::main]
async fn main() {
    let state: AppState = Arc::new(Mutex::new(Vec::new()));

    let app = Router::new()
        .route("/todos", get(list_todos).post(create_todo))
        .route("/todos/:id", get(get_todo))
        .with_state(state);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    println!("서버 실행: http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

async fn list_todos(
    State(state): State<AppState>,
) -> Json<Vec<Todo>> {
    let todos = state.lock().await;
    Json(todos.clone())
}

async fn create_todo(
    State(state): State<AppState>,
    Json(payload): Json<CreateTodo>,
) -> (StatusCode, Json<Todo>) {
    let mut todos = state.lock().await;
    let todo = Todo {
        id: todos.len() as u64 + 1,
        title: payload.title,
        completed: false,
    };
    todos.push(todo.clone());
    (StatusCode::CREATED, Json(todo))
}

#[derive(Deserialize)]
struct CreateTodo {
    title: String,
}

async fn get_todo(
    State(state): State<AppState>,
    Path(id): Path<u64>,
) -> Result<Json<Todo>, StatusCode> {
    let todos = state.lock().await;
    todos
        .iter()
        .find(|t| t.id == id)
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u64 {
    if n <= 1 {
        return n as u64;
    }
    let mut a: u64 = 0;
    let mut b: u64 = 1;
    for _ in 2..=n {
        let temp = b;
        b = a + b;
        a = temp;
    }
    b
}

#[wasm_bindgen]
pub struct ImageProcessor {
    width: u32,
    height: u32,
    pixels: Vec<u8>,
}

#[wasm_bindgen]
impl ImageProcessor {
    #[wasm_bindgen(constructor)]
    pub fn new(width: u32, height: u32) -> Self {
        ImageProcessor {
            width,
            height,
            pixels: vec![0; (width * height * 4) as usize],
        }
    }

    pub fn grayscale(&mut self) {
        for chunk in self.pixels.chunks_mut(4) {
            let avg = ((chunk[0] as u16 + chunk[1] as u16 + chunk[2] as u16) / 3) as u8;
            chunk[0] = avg;
            chunk[1] = avg;
            chunk[2] = avg;
        }
    }

    pub fn pixels(&self) -> *const u8 {
        self.pixels.as_ptr()
    }
}