상구리의 기술 블로그

Rust 기초 강좌
러스트의 모든 문법을 설명하면 너무 길어지므로, 가장 기초적인 내용만 작성합니다.
1. 시작하기
1.1 Hello World
fn main() {
    println!("Hello World!");
}
첫 번째 Rust 프로그램입니다. main 함수는 프로그램의 진입점이며, println! 매크로를 사용해 텍스트를 출력합니다.
1.2 주석
// 한 줄 주석
/* 여러 줄 
   주석 */
/// 문서화 주석
1.3 서식화된 출력
println!("{} 더하기 {} 은 {}", 1, 2, 1 + 2);
println!("{:?}", (3, 4)); // 디버그 출력
2. 기본 자료형
2.1 숫자형
let integer: i32 = 42;    // 정수
let float: f64 = 3.14;    // 부동소수점
let boolean: bool = true; // 불리언
2.2 복합 자료형
// 튜플
let tuple = (1, "hello", 3.14);
// 배열
let array = [1, 2, 3, 4, 5];
3. 변수와 가변성
let x = 5;        // 불변 변수
let mut y = 10;   // 가변 변수
y = 15;           // 값 변경 가능
4. 함수
fn add(a: i32, b: i32) -> i32 {
    a + b  // 암시적 반환
}
fn main() {
    let result = add(5, 3);
    println!("결과: {}", result);
}
5. 제어문
5.1 if 표현식
let number = 5;
if number < 10 {
    println!("10보다 작음");
} else {
    println!("10보다 크거나 같음");
}
5.2 반복문
// for 반복문
for i in 0..5 {
    println!("{}", i);
}
// while 반복문
let mut n = 0;
while n < 5 {
    println!("{}", n);
    n += 1;
}
6. 소유권과 대여
6.1 소유권 규칙
복사는 Copy/Clone 트레이트 참조
let s1 = String::from("hello");
let s2 = s1;  // s1의 소유권이 s2로 이동
// println!("{}", s1);  // 컴파일 에러!
6.2 참조와 대여
fn calculate_length(s: &String) -> usize {
    s.len()
}
let s1 = String::from("hello");
let len = calculate_length(&s1);
7. 구조체
struct User {
    username: String,
    email: String,
    active: bool,
}
let user = User {
    username: String::from("rust_user"),
    email: String::from("user@example.com"),
    active: true,
};
8. 열거형과 패턴 매칭
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}
let msg = Message::Write(String::from("hello"));
match msg {
    Message::Quit => println!("종료"),
    Message::Move { x, y } => println!("이동: x={}, y={}", x, y),
    Message::Write(text) => println!("텍스트: {}", text),
}
9. 에러 처리
use std::fs::File;
fn main() {
    let file_result = File::open("hello.txt");
    match file_result {
        Ok(file) => println!("파일 열기 성공"),
        Err(error) => println!("에러: {}", error),
    }
}
10. 트레이트
10.1 주요 트레이트
Copy와 Clone
// Copy는 값의 비트 단위 복사를 수행
#[derive(Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}
// Clone은 명시적인 복제 메서드 제공
let p1 = Point { x: 1, y: 2 };
let p2 = p1.clone();
Display와 Debug
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}
// Debug 출력
println!("{:?}", rectangle);
// Display 구현
impl std::fmt::Display for Rectangle {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}x{}", self.width, self.height)
    }
}
From과 Into
struct Number {
    value: i32,
}
impl From<i32> for Number {
    fn from(item: i32) -> Self {
        Number { value: item }
    }
}
let num = Number::from(30);
let int: i32 = num.into();
Default
#[derive(Default)]
struct Settings {
    timeout: u32,
    port: u16,
}
let settings = Settings::default();
PartialEq와 Eq
#[derive(PartialEq, Eq)]
struct Id(i32);
let id1 = Id(1);
let id2 = Id(1);
assert_eq!(id1, id2);
Drop
struct Resource {
    data: String,
}
impl Drop for Resource {
    fn drop(&mut self) {
        println!("리소스 해제: {}", self.data);
    }
}
10.2 트레이트 구현
trait Summary {
    fn summarize(&self) -> String;
}
struct NewsArticle {
    headline: String,
    content: String,
}
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}: {}", self.headline, self.content)
    }
}
10.3 트레이트 바운드
기본 트레이트 바운드
// T는 Display와 Clone 트레이트를 구현해야 함
fn print_and_clone<T: Display + Clone>(t: T) {
    println!("{}", t);
    let _cloned = t.clone();
}
where 절을 사용한 트레이트 바운드
fn complex_function<T, U>(t: T, u: U) -> i32 
where 
    T: Display + Clone,
    U: Clone + Debug,
{
    println!("{}", t);
    println!("{:?}", u);
    42
}
트레이트 객체
trait Draw {
    fn draw(&self);
}
struct Button {
    label: String,
}
impl Draw for Button {
    fn draw(&self) {
        println!("그리기: {}", self.label);
    }
}
// 트레이트 객체를 사용한 동적 디스패치
fn draw_ui(ui_element: &dyn Draw) {
    ui_element.draw();
}
let button = Button {label: "button".to_string()};
draw_ui(&button);
제네릭 트레이트 바운드
use std::ops::Add;
fn sum<T: Add<Output = T>>(a: T, b: T) -> T {
    a + b
}
// 사용 예시
let int_sum = sum(5, 10);
let float_sum = sum(3.14, 2.86);
11. 클로저
11.1 기본 문법
// 기본 클로저
let add = |x, y| x + y;
let result = add(5, 3);
// 타입 명시
let multiply: fn(i32, i32) -> i32 = |x, y| x * y;
11.2 클로저 트레이트
// Fn - 불변 참조로 캡처
let text = String::from("Hello");
let print = || println!("{}", text);
// FnMut - 가변 참조로 캡처
let mut counter = 0;
let mut increment = || {
    counter += 1;
    println!("{}", counter);
};
// FnOnce - 소유권 획득
let text = String::from("Hello");
let consume = move || {
    println!("{}", text);
};
11.3 클로저 캡처
let mut list = vec![1, 2, 3];
let mut borrows = || list.push(4);
// move 키워드로 소유권 이전
let list = vec![1, 2, 3];
let owns = move || println!("소유: {:?}", list);
11.4 Iterator와 클로저
let numbers = vec![1, 2, 3, 4, 5];
// map
let doubled: Vec<_> = numbers.iter().map(|x| x * 2).collect();
// doubled = [2, 4, 6, 8, 10]
// filter
let evens: Vec<_> = numbers.iter().filter(|x| *x % 2 == 0).collect();
// evens = [2, 4]
// fold
let sum = numbers.iter()
              .fold(0,    // 초기값 0으로 시작
              |acc, x|    // acc: 누적값, x: 현재 요소
              acc + x);
// sum = 15
// chain
let more_numbers = vec![6, 7, 8];
let combined: Vec<_> = numbers.iter()
    .chain(more_numbers.iter())
    .collect();
// combined = [1, 2, 3, 4, 5, 6, 7, 8]
11.5 고차 함수
fn apply<F>(f: F, x: i32) -> i32 
where 
    F: Fn(i32) -> i32 
{
    f(x)
}
let double = |x| x * 2;
let result = apply(double, 5);
// 클로저 반환
fn create_adder(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x + n
}
let add_five = create_adder(5);
let result = add_five(10); // 15
12. 모듈과 패키지 시스템
12.1 모듈 기본
// lib.rs
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
        fn seat_at_table() {}
    }
}
use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}
// main.rs
use RustTest::eat_at_restaurant;
fn main() {
    eat_at_restaurant();
}
12.2 파일 시스템 기반 모듈
my_project/
├── Cargo.toml
└── src/
    ├── main.rs
    ├── lib.rs
    └── models/
        ├── mod.rs
        ├── user.rs
        └── order.rs
// models/mod.rs
pub mod user;
pub mod order;
// models/user.rs
pub struct User {
    pub name: String,
    pub age: u32,
}
// main.rs
use crate::models::user::User;
12.3 가시성과 프라이버시
mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,  // private 필드
    }
    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("복숭아"),
            }
        }
    }
}
12.4 use 키워드
use std::collections::HashMap;
use std::io::{self, Write};
// 재내보내기
pub use crate::front_of_house::hosting;
// as 키워드로 이름 변경
use std::io::Error as IoError;
// glob 연산자
use std::collections::*;
12.5 패키지와 Cargo.toml
[package]
name = "my_project"
version = "0.1.0"
edition = "2021"
[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = "1.0"
[dev-dependencies]
pretty_assertions = "1.0"
[workspace]
members = [
    "core",
    "cli",
    "web",
]
12.6 작업공간(Workspace)
workspace/
├── Cargo.toml
├── core/
│   ├── Cargo.toml
│   └── src/
├── cli/
│   ├── Cargo.toml
│   └── src/
└── web/
    ├── Cargo.toml
    └── src/
12.7 외부 크레이트 사용
// Cargo.toml에 의존성 추가 후
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct Point {
    x: i32,
    y: i32,
}
13. 스마트 포인터
13.1 Box<T>
// 힙에 데이터 할당
let b = Box::new(5);
println!("b = {}", b);
// 재귀적 타입 정의
#[derive(Debug)]
enum List {
    Cons(i32, Box<List>),
    Nil,
}
use List::{Cons, Nil};
let list = Cons(1, Box::new(Cons(2, Box::new(Nil))));
13.2 Rc<T> (Reference Counting)
use std::rc::Rc;
// 여러 소유자
let data = Rc::new(vec![1, 2, 3]);
let data2 = Rc::clone(&data);
let data3 = Rc::clone(&data);
println!("참조 카운트: {}", Rc::strong_count(&data));
// 순환 참조 방지
struct Node {
    next: Option<Rc<Node>>,
    value: i32,
}
13.3 RefCell<T>
use std::cell::RefCell;
// 내부 가변성
let data = RefCell::new(5);
// 런타임 borrowing 규칙 체크
let mut mut_ref = data.borrow_mut();
*mut_ref += 1;
drop(mut_ref);  // 명시적 반환
let ref_one = data.borrow();
println!("데이터: {}", *ref_one);
13.4 Arc<T> (Atomic Reference Counting)
use std::sync::Arc;
use std::thread;
// 스레드 간 공유
let data = Arc::new(vec![1, 2, 3, 4]);
let mut handles = vec![];
for i in 0..3 {
    let data_clone = Arc::clone(&data);
    handles.push(thread::spawn(move || {
        println!("스레드 {}: {:?}", i, *data_clone);
    }));
}
for handle in handles {
    handle.join().unwrap();
}
13.5 Mutex<T>와 Arc<T> 조합
use std::sync::{Arc, Mutex};
use std::thread;
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
    let counter = Arc::clone(&counter);
    handles.push(thread::spawn(move || {
        let mut num = counter.lock().unwrap();
        *num += 1;
    }));
}
for handle in handles {
    handle.join().unwrap();
}
println!("Result: {}", *counter.lock().unwrap());
13.6 Weak<T>
use std::rc::{Rc, Weak};
use std::cell::RefCell;
// 순환 참조 해결
struct Node {
    next: Option<Rc<RefCell<Node>>>,
    parent: RefCell<Weak<RefCell<Node>>>,
    value: i32,
}
impl Node {
    fn new(value: i32) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(Node {
            next: None,
            parent: RefCell::new(Weak::new()),
            value,
        }))
    }
}
// 사용 예시
let leaf = Node::new(3);
let branch = Node::new(5);
leaf.borrow_mut().parent = RefCell::new(Rc::downgrade(&branch));
branch.borrow_mut().next = Some(Rc::clone(&leaf));
13.7 Custom Smart Pointer
struct CustomSmartPointer<T> {
    data: T,
}
impl<T> Drop for CustomSmartPointer<T> {
    fn drop(&mut self) {
        println!("CustomSmartPointer 메모리 해제!");
    }
}
impl<T> Deref for CustomSmartPointer<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.data
    }
}
// 사용
let c = CustomSmartPointer { data: String::from("데이터") };
println!("포인터: {}", *c);
14. 비동기 프로그래밍
14.1 기본 개념
use tokio;
#[tokio::main]
async fn main() {
    println!("비동기 시작");
    let result = do_something().await;
    println!("결과: {}", result);
}
async fn do_something() -> String {
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    String::from("완료")
}
14.2 Future 트레이트
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
struct MyFuture {
    count: u32,
}
impl Future for MyFuture {
    type Output = u32;
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        if self.count >= 10 {
            Poll::Ready(self.count)
        } else {
            cx.waker().wake_by_ref();
            self.count += 1;
            Poll::Pending
        }
    }
}
#[tokio::main]
async fn main() {
    println!("Timer started!");
    let timer = MyFuture { count: 0 };
    let result = timer.await;
    println!("Result: {}", result);
}
14.3 동시성 처리
use tokio;
#[tokio::main]
async fn main() {
    // 병렬 작업
    let handles: Vec<_> = (0..3)
        .map(|i| {
            tokio::spawn(async move {
                tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
                println!("작업 {} 완료", i);
                i
            })
        })
        .collect();
    // 결과 수집
    for handle in handles {
        let result = handle.await.unwrap();
        println!("결과: {}", result);
    }
}
14.4 Stream
use tokio;
use futures::stream::{self, StreamExt};
async fn process_stream() {
    let mut stream = stream::iter(1..=5)
        .map(|x| async move { x * 2 })
        .buffer_unordered(2);
    while let Some(n) = stream.next().await {
        println!("값: {}", n);
    }
}
#[tokio::main]
async fn main() {
    process_stream().await;
}
14.5 Select와 Join
use tokio::select;
async fn race_tasks() {
    let t1 = some_async_task();
    let t2 = another_async_task();
    // select로 먼저 완료되는 작업 처리
    select! {
        val = t1 => println!("task 1 완료: {}", val),
        val = t2 => println!("task 2 완료: {}", val),
    }
    // join으로 모든 작업 완료 대기
    let (result1, result2) = tokio::join!(t1, t2);
}
14.6 채널 통신
use tokio::sync::mpsc;
#[tokio::main]
async fn main() {
    let (tx, mut rx) = mpsc::channel(32);
    // 송신자 작업
    let sender = tokio::spawn(async move {
        for i in 0..5 {
            tx.send(i).await.unwrap();
        }
    });
    // 수신자 작업
    while let Some(value) = rx.recv().await {
        println!("받은 값: {}", value);
    }
}
14.7 오류 처리
use std::io;
use tokio;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    match async_operation().await {
        Ok(result) => println!("성공: {}", result),
        Err(e) => eprintln!("에러: {}", e),
    }
    Ok(())
}
async fn async_operation() -> io::Result<String> {
    // 비동기 작업 시뮬레이션
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    Ok(String::from("작업 완료"))
}
14.8 비동기 락과 동기화
use tokio::sync::{Mutex, RwLock};
#[tokio::main]
async fn main() {
    // 비동기 뮤텍스
    let mutex = Arc::new(Mutex::new(0));
    // 읽기-쓰기 락
    let rwlock = Arc::new(RwLock::new(String::new()));
    // 뮤텍스 사용
    let mut lock = mutex.lock().await;
    *lock += 1;
    drop(lock);
    // 읽기-쓰기 락 사용
    let mut write = rwlock.write().await;
    write.push_str("데이터");
    drop(write);
    let read = rwlock.read().await;
    println!("데이터: {}", *read);
}
15. 매크로 시스템
15.1 선언적 매크로 (Declarative Macros)
// 기본 매크로 정의
macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
}
// 매개변수를 받는 매크로
macro_rules! print_ex {
    ($x:expr) => {
        println!("{:?}", $x);
    };
}
// 여러 패턴 매칭
macro_rules! vec_strs {
    // 빈 벡터
    () => {
        Vec::new()
    };
    // 쉼표로 구분된 표현식들
    ($($x:expr),*) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($x.to_string());
            )*
            temp_vec
        }
    };
}
15.2 절차적 매크로 (Procedural Macros)
// Cargo.toml
[lib]
proc-macro = true
[dependencies]
syn = "1.0"
quote = "1.0"
proc-macro2 = "1.0"
// lib.rs
use proc_macro::TokenStream;
use quote::quote;
use syn;
// 속성 매크로
#[proc_macro_attribute]
pub fn route(attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(item as syn::ItemFn);
    let name = &input.sig.ident;
    let output = quote! {
        #[get(#attr)]
        pub fn #name() {
            println!("라우트 처리");
        }
    };
    output.into()
}
// 파생 매크로
#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
    let ast = syn::parse(input).unwrap();
    impl_hello_macro(&ast)
}
// 함수형 매크로
#[proc_macro]
pub fn sql(input: TokenStream) -> TokenStream {
    let sql = input.to_string();
    let output = quote! {
        println!("SQL: {}", #sql);
    };
    output.into()
}
15.3 매크로 규칙과 지정자
macro_rules! match_type {
    // expr: 표현식
    ($x:expr) => { ... };
    // ident: 식별자
    ($x:ident) => { ... };
    // ty: 타입
    ($x:ty) => { ... };
    // path: 경로
    ($x:path) => { ... };
    // tt: 토큰 트리
    ($x:tt) => { ... };
    // item: 아이템
    ($x:item) => { ... };
}
15.4 매크로 반복과 조건
macro_rules! vector {
    ( $( $x:expr ),* ) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($x);
            )*
            temp_vec
        }
    };
}
// 조건부 매크로
macro_rules! conditional {
    ($x:expr, $y:expr, if $condition:expr) => {
        if $condition {
            $x
        } else {
            $y
        }
    };
}
15.5 매크로 내보내기와 가져오기
// 매크로 내보내기
#[macro_export]
macro_rules! public_macro {
    () => {
        println!("공개 매크로");
    };
}
// 매크로 가져오기
use my_crate::public_macro;
// 또는
#[macro_use]
extern crate my_crate;
15.6 디버깅과 오류 처리
macro_rules! debug_print {
    ($($arg:tt)*) => {{
        #[cfg(debug_assertions)]
        println!("디버그: {}", format!($($arg)*));
    }};
}
// 매크로 확장 추적
#[rustc_macro_transparency = "semitransparent"]
macro_rules! trace_macro {
    ($name:ident) => {
        println!("매크로 {} 실행", stringify!($name));
    };
}

Rust 기초 강좌

댓글