Go to Rust: #1. 시작하기 - Rust 소개와 환경 설정

// Go: 간결하고 읽기 쉬움
func sum(numbers []int) int {
    total := 0
    for _, n := range numbers {
        total += n
    }
    return total
}

// Rust: 더 명시적이지만 더 많은 보장
fn sum(numbers: &[i32]) -> i32 {
    numbers.iter().sum()
}

// 또는 Go 스타일로 작성할 수도 있음
fn sum_imperative(numbers: &[i32]) -> i32 {
    let mut total = 0;
    for n in numbers {
        total += n;
    }
    total
}

# macOS / Linux
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Windows는 rustup-init.exe 다운로드
# https://rustup.rs 방문

# 설치 확인
rustc --version
cargo --version

# 최신 버전으로 업데이트
rustup update

# 설치된 도구체인 확인
rustup show

# nightly 버전 설치 (실험적 기능 사용 시)
rustup install nightly

# 기본 도구체인 변경
rustup default stable

# 프로젝트별 도구체인 설정
rustup override set nightly

# VS Code 확장 설치
# 1. rust-analyzer (공식 권장)
# 2. Even Better TOML (Cargo.toml 편집용)
# 3. Error Lens (인라인 에러 표시)
# 4. CodeLLDB (디버깅용)

{
    "rust-analyzer.checkOnSave.command": "clippy",
    "rust-analyzer.inlayHints.typeHints.enable": true,
    "rust-analyzer.inlayHints.parameterHints.enable": true,
    "[rust]": {
        "editor.formatOnSave": true,
        "editor.defaultFormatter": "rust-lang.rust-analyzer"
    }
}

# 필수 도구들
rustup component add clippy      # 린터
rustup component add rustfmt     # 포매터

# 유용한 cargo 확장
cargo install cargo-edit         # cargo add/rm/upgrade
cargo install cargo-watch        # 파일 변경 감지 자동 빌드
cargo install cargo-expand       # 매크로 확장 보기
cargo install cargo-audit        # 보안 취약점 검사
cargo install cargo-outdated     # 의존성 업데이트 확인

# Go의 air나 reflex처럼 파일 변경 시 자동 실행
cargo watch -x run

# 테스트 자동 실행
cargo watch -x test

# 여러 명령 조합
cargo watch -x check -x test -x run

# 새 프로젝트 생성
cargo new hello_rust
cd hello_rust

# 프로젝트 구조
# hello_rust/
# ├── Cargo.toml
# └── src/
#     └── main.rs

[package]
name = "hello_rust"
version = "0.1.0"
edition = "2021"

[dependencies]
# 여기에 의존성 추가

fn main() {
    println!("Hello, world!");
}

// Go
package main

import "fmt"

func main() {
    fmt.Println("Hello, world!")
}

// Rust
fn main() {
    println!("Hello, world!");
}

# 개발 빌드 (최적화 없음, 빠른 컴파일)
cargo build
# 실행 파일: target/debug/hello_rust

# 실행
cargo run

# 릴리스 빌드 (최적화, 느린 컴파일)
cargo build --release
# 실행 파일: target/release/hello_rust

# 문법 검사만 (빌드보다 빠름)
cargo check

# 라이브러리 프로젝트 생성
cargo new mylib --lib

# 구조
# mylib/
# ├── Cargo.toml
# └── src/
#     └── lib.rs    # main.rs 대신 lib.rs

# 특정 예제 실행
cargo run --example basic

# 모든 예제 나열
cargo run --example

# 설치
cargo install evcxr_repl

# 실행
evcxr

>> let x = 42;
>> x * 2
84
>> :type x
i32

cargo install evcxr_jupyter
evcxr_jupyter --install

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct User {
    name: String,
    age: u32,
    #[serde(rename = "emailAddress")]  // Go의 `json:"emailAddress"`와 동일
    email: String,
}

fn main() {
    let user = User {
        name: "Alice".to_string(),
        age: 30,
        email: "alice@example.com".to_string(),
    };
    
    // 직렬화
    let json = serde_json::to_string(&user).unwrap();
    println!("{}", json);
    
    // 역직렬화
    let parsed: User = serde_json::from_str(&json).unwrap();
    println!("{:?}", parsed);
}

[dependencies]
tokio = { version = "1", features = ["full"] }

#[tokio::main]
async fn main() {
    let result = fetch_data().await;
    println!("{}", result);
}

async fn fetch_data() -> String {
    // 비동기 작업
    "data".to_string()
}

[dependencies]
anyhow = "1.0"      # 애플리케이션용
thiserror = "1.0"   # 라이브러리용

// anyhow: Go의 fmt.Errorf와 비슷
use anyhow::{Context, Result};

fn read_config() -> Result<String> {
    std::fs::read_to_string("config.toml")
        .context("Failed to read config file")?;  // 컨텍스트 추가
    Ok("config".to_string())
}

// thiserror: 커스텀 에러 타입 정의
use thiserror::Error;

#[derive(Error, Debug)]
enum MyError {
    #[error("Invalid input: {0}")]
    InvalidInput(String),
    #[error("IO error")]
    Io(#[from] std::io::Error),
}

[dependencies]
clap = { version = "4", features = ["derive"] }

use clap::Parser;

#[derive(Parser, Debug)]
#[command(name = "myapp")]
#[command(about = "A sample CLI application")]
struct Args {
    /// Name of the user
    #[arg(short, long)]
    name: String,
    
    /// Verbose mode
    #[arg(short, long, default_value_t = false)]
    verbose: bool,
}

fn main() {
    let args = Args::parse();
    println!("Hello, {}!", args.name);
}

[dependencies]
tracing = "0.1"
tracing-subscriber = "0.3"

use tracing::{info, warn, error, instrument};

#[instrument]  // 함수 진입/종료 자동 로깅
fn process_request(user_id: u32) {
    info!(user_id, "Processing request");
    // ...
    warn!("Something might be wrong");
}

fn main() {
    // 구독자 초기화
    tracing_subscriber::fmt::init();
    
    process_request(42);
}

/// 두 숫자를 더합니다.
/// 
/// # Examples
/// 
/// ```
/// let result = mylib::add(2, 3);
/// assert_eq!(result, 5);
/// ```
/// 
/// # Panics
/// 
/// 오버플로우 시 패닉합니다 (debug 모드에서).
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

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