2장: 소유권과 차용 체크 멘탈 모델

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

fn main() {
    // Copy 타입: 정수, 부동소수점, bool, char, 고정 크기 튜플
    let x = 42;
    let y = x;      // Copy — x도 여전히 유효
    println!("x={}, y={}", x, y); // 정상 동작
 
    // Move 타입: String, Vec, Box 등 힙 데이터를 소유하는 타입
    let s1 = String::from("hello");
    let s2 = s1;    // Move — s1은 무효
    // println!("{}", s1); // 컴파일 에러
}

fn calculate_length(s: &String) -> usize {
    s.len()
    // s는 빌린 것이므로 여기서 해제되지 않음
}
 
fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // s1을 빌려줌
    println!("'{}'의 길이는 {}", s1, len); // s1 여전히 사용 가능
}

fn append_world(s: &mut String) {
    s.push_str(", world");
}
 
fn main() {
    let mut s = String::from("hello");
    append_world(&mut s);
    println!("{}", s); // "hello, world"
}

fn main() {
    let mut s = String::from("hello");
 
    let r1 = &s;     // 불변 참조 — OK
    let r2 = &s;     // 불변 참조 — OK (여러 개 가능)
    // let r3 = &mut s; // 컴파일 에러! 불변 참조가 있는 동안 가변 참조 불가
 
    println!("{} and {}", r1, r2);
    // r1, r2는 여기서 마지막으로 사용됨 (NLL 덕분에 여기서 빌림 종료)
 
    let r3 = &mut s;  // 이제 가변 참조 가능
    r3.push_str("!");
    println!("{}", r3);
}

fn main() {
    // String: 힙에 할당, 소유권 있음, 가변 가능
    let mut owned = String::from("hello");
    owned.push_str(", world");
 
    // &str: 문자열 슬라이스, 빌림, 불변
    let slice: &str = &owned;       // String에서 &str로 빌림
    let literal: &str = "hello";    // 문자열 리터럴은 &str
 
    greet(&owned);   // String → &str 자동 변환 (Deref coercion)
    greet(literal);  // &str 직접 전달
}
 
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn sum(numbers: &[i32]) -> i32 {
    numbers.iter().sum()
}
 
fn main() {
    let v: Vec<i32> = vec![1, 2, 3, 4, 5];
    let total = sum(&v);         // Vec<i32> → &[i32] 자동 변환
    println!("합계: {}", total);
 
    let partial = sum(&v[1..4]); // 슬라이스: [2, 3, 4]
    println!("부분 합계: {}", partial);
}

// 두 문자열 참조 중 더 긴 것을 반환
// 반환값이 어떤 입력의 참조인지 컴파일러가 판단할 수 없으므로
// 라이프타임을 명시해야 합니다
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
 
fn main() {
    let s1 = String::from("long string");
    let result;
    {
        let s2 = String::from("xyz");
        result = longest(&s1, &s2);
        println!("더 긴 문자열: {}", result); // s2가 아직 유효하므로 OK
    }
    // println!("{}", result); // 에러! s2가 스코프를 벗어남
}

// Java에서 이렇게 작성하면:
// String s1 = new String("hello");
// String s2 = s1;  // 같은 객체를 참조 (GC가 관리)
 
// Rust에서는:
let s1 = String::from("hello");
let s2 = s1.clone();  // 명시적 복제 — 깊은 복사
println!("{} {}", s1, s2); // 둘 다 사용 가능 (각자 소유)
 
// 또는 빌림으로:
let s3 = String::from("world");
let s4 = &s3;  // 빌림 — 복사 없이 참조
println!("{} {}", s3, s4); // 둘 다 사용 가능

use axum::{Json, extract::State};
use std::sync::Arc;
 
// AppState는 Arc로 감싸서 여러 핸들러가 공유
struct AppState {
    db_pool: String, // 실제로는 sqlx::PgPool
}
 
// Json<CreateUser>: 요청 본문의 소유권을 핸들러가 가져감
// State<Arc<AppState>>: 공유 상태를 빌림
async fn create_user(
    State(state): State<Arc<AppState>>,
    Json(payload): Json<CreateUser>,
) -> Json<User> {
    // payload는 이 핸들러가 소유 — 자유롭게 사용
    // state는 Arc로 공유 — 여러 핸들러가 동시 접근 가능
    let user = User {
        name: payload.name, // Move: payload.name의 소유권이 user.name으로 이동
    };
    Json(user)
}
 
struct CreateUser { name: String }
struct User { name: String }