[Rust입문 #6] Rust 모듈, 패키지, 크레이트, 트레잇, 제네릭, 표준 라이브러리 한방에 끝내기

[Rust입문 #6] Rust 모듈, 패키지, 크레이트, 트레잇, 제네릭, 표준 라이브러리 한방에 끝내기

 

Rust 모듈 구조부터 패키지, 크레이트, 트레잇, 제네릭, 표준 라이브러리까지 실무에서 필요한 핵심 개념들을 체계적으로 정리한 완전 가이드입니다.

---

왜 Rust 모듈과 패키지 시스템을 알아야 할까?

Rust를 처음 접하는 개발자들이 가장 혼란스러워하는 부분 중 하나가 바로 모듈 시스템입니다.

다른 언어와 달리 Rust는 독특한 모듈 구조를 가지고 있어, 제대로 이해하지 못하면 프로젝트 구조가 복잡해질 수 있습니다.

이 글에서는 Rust의 핵심 개념들을 단계별로 학습하여, 실무에서 바로 적용할 수 있는 수준까지 끌어올리겠습니다.

---

Rust 모듈(Module) 완전 정복

모듈의 기본 개념

모듈(Module)은 Rust에서 코드를 조직화하는 기본 단위입니다.

네임스페이스를 제공하고, 코드의 접근성을 제어하며, 재사용성을 높이는 역할을 합니다.

// 기본 모듈 선언
mod my_module {
    pub fn public_function() {
        println!("외부에서 접근 가능한 함수");
    }

    fn private_function() {
        println!("모듈 내부에서만 사용 가능");
    }
}

모듈의 가시성 제어

Rust에서는 pub 키워드를 사용하여 모듈의 가시성을 제어합니다.

mod network {
    pub mod client {
        pub fn connect() -> bool {
            true
        }
    }

    mod server {
        fn start() {
            // 비공개 함수
        }
    }
}

// 사용 예시
fn main() {
    network::client::connect();
    // network::server::start(); // 오류! 비공개 함수
}

 

Rust 모듈 구조 다이어그램

파일 시스템 기반 모듈

실제 프로젝트에서는 파일과 디렉토리로 모듈을 구성합니다.

// src/lib.rs
mod database;
mod network;

pub use database::Connection;
pub use network::client::connect;

// src/database.rs
pub struct Connection {
    pub url: String,
}

impl Connection {
    pub fn new(url: &str) -> Self {
        Connection {
            url: url.to_string(),
        }
    }
}

---

Rust 패키지(Package)와 크레이트(Crate) 심화

패키지와 크레이트의 차이점

많은 개발자들이 패키지와 크레이트를 혼동합니다.

명확한 차이점을 정리하면 다음과 같습니다

구분	패키지(Package)	크레이트(Crate)
정의	하나 이상의 크레이트를 포함하는 번들	컴파일의 기본 단위
파일	Cargo.toml 포함	라이브러리 또는 바이너리
개수	하나	여러 개 가능
역할	의존성 관리	실제 코드 실행

크레이트 타입

Rust에서 크레이트는 두 가지 주요 타입으로 나뉩니다

1. 라이브러리 크레이트: 다른 프로그램에서 사용할 수 있는 함수들을 제공
2. 바이너리 크레이트: 실행 가능한 프로그램

// 라이브러리 크레이트 예시 (src/lib.rs)
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }
}

// 바이너리 크레이트 예시 (src/main.rs)
use my_library::add;

fn main() {
    let result = add(5, 3);
    println!("결과: {}", result);
}

use 키워드 활용법

use 키워드는 모듈의 경로를 단축하고 가독성을 높이는 중요한 역할을 합니다.

// 기본 사용법
use std::collections::HashMap;
use std::io::{self, Write};

// 별칭 사용
use std::collections::HashMap as Map;

// 글로브 연산자
use std::collections::*;

// 재내보내기
pub use std::collections::HashMap;

 

---

Rust 트레잇(Trait) 마스터하기

트레잇의 기본 개념

트레잇(Trait)은 타입이 가져야 할 기능을 정의하는 인터페이스입니다.

다른 언어의 인터페이스나 추상 클래스와 비슷한 개념이지만, Rust만의 독특한 특징을 가지고 있습니다.

// 기본 트레잇 정의
trait Summary {
    fn summarize(&self) -> String;

    // 기본 구현 제공
    fn summarize_author(&self) -> String {
        format!("(작성자: 익명)")
    }
}

// 구조체 정의
struct NewsArticle {
    pub headline: String,
    pub content: String,
    pub author: String,
}

// 트레잇 구현
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {}", self.headline, self.author)
    }
}

트레잇 경계(Trait Bounds)

트레잇 경계는 제네릭 타입이 특정 트레잇을 구현해야 함을 명시합니다.

// 트레잇 경계 사용
fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

// 여러 트레잇 경계
fn notify_multiple<T: Summary + Display>(item: &T) {
    println!("{}", item);
}

// where 절 사용
fn some_function<T, U>(t: &T, u: &U) -> i32
where
    T: Display + Clone,
    U: Clone + Debug,
{
    // 함수 본문
    0
}

파생(Derive) 트레잇

자주 사용되는 트레잇들은 derive 속성으로 자동 구현할 수 있습니다.

#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1.clone();

    println!("{:?}", p1);  // Debug 트레잇 사용
    println!("{}", p1 == p2);  // PartialEq 트레잇 사용
}

 

Rust 트레잇 상속 구조

---

Rust 제네릭(Generics) 완전 분석

제네릭의 필요성

제네릭(Generics)은 코드의 재사용성을 높이고 타입 안정성을 보장하는 핵심 기능입니다.

중복 코드를 줄이고, 컴파일 타임에 타입 검사를 수행하여 런타임 오류를 방지합니다.

// 제네릭 함수
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

// 사용 예시
fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    let result = largest(&numbers);
    println!("가장 큰 수: {}", result);

    let chars = vec!['y', 'm', 'a', 'q'];
    let result = largest(&chars);
    println!("가장 큰 문자: {}", result);
}

제네릭 구조체와 열거형

// 제네릭 구조체
struct Point<T> {
    x: T,
    y: T,
}

// 다중 제네릭 타입
struct Point3D<T, U> {
    x: T,
    y: T,
    z: U,
}

// 제네릭 열거형
enum Option<T> {
    Some(T),
    None,
}

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

impl 블록에서의 제네릭

impl<T> Point<T> {
    fn new(x: T, y: T) -> Self {
        Point { x, y }
    }
}

// 특정 타입에 대한 impl
impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

// 메소드에서의 제네릭
impl<T> Point<T> {
    fn mixup<U>(self, other: Point<U>) -> Point<T, U> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

 

---

Rust 표준 라이브러리 핵심 모듈

컬렉션 모듈

표준 라이브러리의 컬렉션 모듈은 실무에서 가장 자주 사용되는 자료구조들을 제공합니다.

use std::collections::{HashMap, HashSet, VecDeque};

fn main() {
    // HashMap 사용
    let mut scores = HashMap::new();
    scores.insert("Blue", 10);
    scores.insert("Yellow", 50);

    // HashSet 사용
    let mut books = HashSet::new();
    books.insert("A Song of Ice and Fire");
    books.insert("The Hobbit");

    // VecDeque 사용
    let mut deque = VecDeque::new();
    deque.push_back(1);
    deque.push_front(2);
}

입출력 모듈

use std::io::{self, BufRead, BufReader, Write};
use std::fs::File;

fn read_file_lines(filename: &str) -> io::Result<Vec<String>> {
    let file = File::open(filename)?;
    let reader = BufReader::new(file);
    let lines = reader.lines().collect::<Result<Vec<_>, _>>()?;
    Ok(lines)
}

fn write_to_file(filename: &str, content: &str) -> io::Result<()> {
    let mut file = File::create(filename)?;
    file.write_all(content.as_bytes())?;
    Ok(())
}

시간 관련 모듈

use std::time::{Duration, Instant, SystemTime};
use std::thread;

fn main() {
    // 현재 시간 측정
    let start = Instant::now();

    // 어떤 작업 수행
    thread::sleep(Duration::from_millis(100));

    let duration = start.elapsed();
    println!("실행 시간: {:?}", duration);

    // 시스템 시간
    let now = SystemTime::now();
    println!("현재 시스템 시간: {:?}", now);
}

 

Rust 표준 라이브러리 구조

---

실전 프로젝트 구조 설계

모듈 구조 베스트 프랙티스

실제 프로젝트에서는 다음과 같은 구조를 권장합니다

src/
├── main.rs          # 바이너리 크레이트 엔트리 포인트
├── lib.rs           # 라이브러리 크레이트 엔트리 포인트
├── models/          # 데이터 모델들
│   ├── mod.rs
│   ├── user.rs
│   └── product.rs
├── services/        # 비즈니스 로직
│   ├── mod.rs
│   ├── user_service.rs
│   └── product_service.rs
├── utils/           # 유틸리티 함수들
│   ├── mod.rs
│   └── helpers.rs
└── config/          # 설정 관련
    ├── mod.rs
    └── database.rs

의존성 관리

# Cargo.toml
[package]
name = "my-rust-project"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.0", features = ["full"] }
sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres"] }

[dev-dependencies]
tokio-test = "0.4"

통합 예제

// src/lib.rs
pub mod models;
pub mod services;
pub mod utils;

pub use models::User;
pub use services::UserService;

// src/models/mod.rs
pub mod user;
pub use user::User;

// src/models/user.rs
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: u32,
    pub name: String,
    pub email: String,
}

impl User {
    pub fn new(id: u32, name: String, email: String) -> Self {
        User { id, name, email }
    }
}

// src/services/mod.rs
pub mod user_service;
pub use user_service::UserService;

// src/services/user_service.rs
use crate::models::User;
use std::collections::HashMap;

pub struct UserService {
    users: HashMap<u32, User>,
}

impl UserService {
    pub fn new() -> Self {
        UserService {
            users: HashMap::new(),
        }
    }

    pub fn create_user(&mut self, name: String, email: String) -> User {
        let id = self.users.len() as u32 + 1;
        let user = User::new(id, name, email);
        self.users.insert(id, user.clone());
        user
    }

    pub fn get_user(&self, id: u32) -> Option<&User> {
        self.users.get(&id)
    }
}

---

성능 최적화와 메모리 관리

제로 코스트 추상화

Rust의 제네릭과 트레잇은 제로 코스트 추상화를 제공합니다.

컴파일 타임에 모든 제네릭 타입이 구체적인 타입으로 변환되어, 런타임 오버헤드가 없습니다.

// 컴파일 타임에 최적화되는 코드
fn process_data<T: Clone + Debug>(data: Vec<T>) -> Vec<T> {
    data.into_iter()
        .map(|item| {
            println!("Processing: {:?}", item);
            item.clone()
        })
        .collect()
}

메모리 효율성

use std::rc::Rc;
use std::cell::RefCell;

// 스마트 포인터 활용
type SharedData = Rc<RefCell<Vec<i32>>>;

fn create_shared_data() -> SharedData {
    Rc::new(RefCell::new(vec![1, 2, 3, 4, 5]))
}

fn modify_shared_data(data: &SharedData) {
    data.borrow_mut().push(6);
}

---

테스트와 문서화

단위 테스트 작성

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_user_creation() {
        let mut service = UserService::new();
        let user = service.create_user("John".to_string(), "john@example.com".to_string());

        assert_eq!(user.name, "John");
        assert_eq!(user.email, "john@example.com");
    }

    #[test]
    fn test_user_retrieval() {
        let mut service = UserService::new();
        let user = service.create_user("Jane".to_string(), "jane@example.com".to_string());

        let retrieved = service.get_user(user.id);
        assert!(retrieved.is_some());
        assert_eq!(retrieved.unwrap().name, "Jane");
    }
}

문서화 주석

/// 사용자 정보를 관리하는 서비스
/// 
/// # Examples
/// 
/// ```
/// use my_crate::UserService;
/// 
/// let mut service = UserService::new();
/// let user = service.create_user("John".to_string(), "john@example.com".to_string());
/// ```
pub struct UserService {
    users: HashMap<u32, User>,
}

impl UserService {
    /// 새로운 UserService 인스턴스를 생성합니다.
    pub fn new() -> Self {
        UserService {
            users: HashMap::new(),
        }
    }

    /// 새로운 사용자를 생성하고 저장합니다.
    /// 
    /// # Arguments
    /// 
    /// * `name` - 사용자 이름
    /// * `email` - 사용자 이메일 주소
    /// 
    /// # Returns
    /// 
    /// 생성된 사용자 정보
    pub fn create_user(&mut self, name: String, email: String) -> User {
        // 구현 내용...
    }
}

---

마무리

이 글에서는 Rust 모듈 구조부터 패키지, 크레이트, 트레잇, 제네릭, 표준 라이브러리까지 핵심 개념들을 체계적으로 다뤘습니다.

실무에서 바로 적용할 수 있는 예제들과 함께 Rust의 강력한 타입 시스템과 메모리 안전성을 활용하는 방법을 알아봤습니다.

다음 단계로는 비동기 프로그래밍과 실전 프로젝트 구현을 통해 Rust의 진정한 힘을 경험해보시기 바랍니다.

 

참고 자료:

• Rust 공식 문서
• Rust by Example
• Rust 표준 라이브러리 문서

---

관련 글:

• [Rust입문 #5] Rust 구조체, 열거형, 컬렉션 완전 정리