러스트 트레잇 완전 정복 상속, 조합, 그리고 다형성의 비밀

러스트 트레잇 완전 정복 상속, 조합, 그리고 다형성의 비밀

러스트의 심장, 트레잇(Trait)을 만나다

러스트(Rust)를 배우다 보면 필연적으로 '트레잇(Trait)'이라는 거대한 산과 마주하게 됩니다.

다른 언어의 인터페이스(Interface)나 추상 클래스(Abstract Class)와 비슷해 보이면서도, 어딘가 다른 독특한 철학을 담고 있는 이 개념은 러스트의 강력함과 안정성을 지탱하는 가장 핵심적인 기둥입니다.

트레잇은 단순히 '공통된 동작을 정의'하는 것을 넘어, 러스트가 어떻게 제로 코스트 추상화(Zero-Cost Abstraction)를 달성하고, 메모리 안전성을 보장하면서도 유연한 다형성(Polymorphism)을 구현하는지를 이해하는 열쇠입니다.

이 글에서는 트레잇의 기본적인 정의부터 시작하여, 상속과 조합을 통한 확장, 그리고 정적 디스패치와 동적 디스패치를 이용한 다형성 구현까지, 트레잇의 모든 것을 깊이 있게 파헤쳐 보고자 합니다.

이 여정이 끝나면, 여러분은 더 이상 트레잇을 어려운 문법으로만 보지 않고, 러스트다운 코드를 작성하기 위한 가장 강력한 설계 도구로 바라보게 될 것입니다.

트레잇 기본 개념 정의와 구현

가장 기본적인 수준에서, 트레잇은 특정 타입이 반드시 구현해야 할 '메서드의 목록'을 정의하는 방법입니다.

마치 '이런 기능들을 가지고 있다면, 너는 OOO라는 자격을 갖춘 것'이라고 선언하는 '자격증'과도 같습니다.

예를 들어, 화면에 무언가를 출력할 수 있는 기능을 가진 모든 타입을 위한 `Printable`이라는 트레잇을 정의해 보겠습니다.

trait Printable {
    fn print(&self);
}

이제 어떤 타입이든 이 Printable 자격증을 얻으려면, print라는 메서드를 반드시 자신의 몸에 구현해야 합니다.

impl 키워드를 사용하여 i32 타입에 Printable 트레잇을 구현해 보겠습니다.

impl Printable for i32 {
    fn print(&self) {
        println!("The value is: {}", self);
    }
}

fn main() {
    let my_number: i32 = 42;
    my_number.print(); // 출력: The value is: 42
}

이제 i32 타입의 모든 값은 Printable 트레잇에 정의된 print 메서드를 사용할 수 있게 되었습니다.

이것이 트레잇의 가장 기본적인 정의와 구현 방식입니다.

트레잇의 확장 상속과 조합

트레잇의 진정한 강력함은 기존 트레잇을 바탕으로 새로운 트레잇을 만들 수 있는 '확장성'에서 드러납니다.

러스트는 이를 위해 '상속(Inheritance)'과 '조합(Composition)'이라는 두 가지 강력한 메커니즘을 제공합니다.

슈퍼트레잇을 이용한 상속

트레잇 상속은 한 트레잇이 다른 트레잇의 모든 기능을 물려받도록 하는 것입니다.

이를 '슈퍼트레잇(Supertrait)'이라고 부릅니다.

예를 들어, 기존 Printable 트레잇의 기능을 가지면서, 추가로 라벨과 함께 출력하는 기능을 더한 PrintableWithLabel 트레잇을 만들어 보겠습니다.

// PrintableWithLabel은 Printable을 상속합니다.
trait PrintableWithLabel: Printable {
    // 기본 구현(default implementation)을 제공할 수도 있습니다.
    fn print_with_label(&self, label: &str) {
        print!("{}: ", label);
        self.print(); // 상속받은 Printable의 print 메서드를 호출
    }
}

trait PrintableWithLabel: Printable 구문은 'PrintableWithLabel 트레잇을 구현하려는 모든 타입은, 반드시 Printable 트레잇도 먼저 구현해야 한다'는 제약을 명시합니다.

덕분에 print_with_label의 기본 구현 안에서 self.print()를 안전하게 호출할 수 있는 것입니다.

여러 트레잇을 묶는 조합

때로는 여러 개의 기존 트레잇들을 단순히 하나로 묶어 새로운 '자격 요건'으로 만들고 싶을 때가 있습니다.

이것이 바로 조합입니다.

예를 들어, 디버깅을 위한 Debug 트레잇과 사용자에게 보여주기 위한 Display 트레잇을 모두 구현해야만 하는 DisplayAndDebug라는 마커(marker) 트레잇을 정의할 수 있습니다.

use std::fmt::{Display, Debug};

// 이 트레잇을 구현하려면 Display와 Debug를 모두 구현해야 합니다.
trait DisplayAndDebug: Display + Debug {}

// 어떤 타입이든 Display와 Debug를 구현했다면,
// 이 빈 impl 블록만으로 DisplayAndDebug 트레잇을 자동으로 만족하게 됩니다.
impl<T: Display + Debug> DisplayAndDebug for T {}

이처럼 조합은 복잡한 제약 조건을 하나의 의미 있는 이름으로 추상화하여, 코드의 가독성과 재사용성을 높이는 데 매우 유용하게 사용됩니다.

트레잇 바운드와 다형성

트레잇의 가장 중요한 역할 중 하나는 '다형성(Polymorphism)'을 구현하는 것입니다.

다형성이란 '하나의 코드가 여러 다른 타입의 객체를 다룰 수 있는 능력'을 의미합니다.

러스트는 이를 '정적 디스패치(Static Dispatch)'와 '동적 디스패치(Dynamic Dispatch)'라는 두 가지 방식으로 구현합니다.

정적 디스패치 제네릭과 트레잇 바운드

정적 디스패치는 '제네릭(Generics)'을 통해 컴파일 시간에 다형성을 구현하는 방식입니다.

T: Printable과 같이 '트레잇 바운드(Trait Bound)'를 사용하여, 함수가 특정 트레잇을 구현하는 모든 타입을 받을 수 있도록 정의합니다.

// T는 Printable 트레잇을 구현하는 어떤 타입이든 될 수 있습니다.
fn print_something<T: Printable>(item: T) {
    item.print();
}

fn main() {
    print_something(100); // T는 i32가 됩니다.
    // print_something("hello"); // &str은 Printable을 구현하지 않았으므로 컴파일 에러!
}

이 함수가 컴파일될 때, 러스트 컴파일러는 print_something을 호출하는 모든 구체적인 타입(우리 예제에서는 i32)에 대해 각각 별도의 코드를 생성합니다.

이를 '모노모피제이션(Monomorphization)'이라고 부릅니다.

이 방식은 런타임에 어떤 함수를 호출할지 찾는 과정이 전혀 없기 때문에 매우 빠르다는 장점이 있습니다.

이것이 바로 러스트가 '제로 코스트 추상화'를 달성하는 핵심 원리입니다.

동적 디스패치 트레잇 객체

하지만 때로는 컴파일 시점에 타입을 확정할 수 없는 경우가 있습니다.

예를 들어, Circle과 Square라는 서로 다른 타입의 객체들을 하나의 벡터(Vector)에 담아두고, 각 객체의 draw 메서드를 순서대로 호출하고 싶을 때입니다.

이럴 때 사용하는 것이 바로 '트레잇 객체(Trait Object)'를 이용한 동적 디스패치입니다.

트레잇 객체는 &dyn Trait 또는 Box<dyn Trait> 형태로 표현되며, '이것이 어떤 구체적인 타입인지는 모르지만, 아무튼 Trait에 정의된 모든 메서드를 호출할 수 있다'는 것을 보장하는 일종의 '포인터'입니다.

trait Shape {
    fn draw(&self);
}
struct Circle { radius: f64 }
impl Shape for Circle { fn draw(&self) { println!("Drawing a circle"); } }

struct Square { side: f64 }
impl Shape for Square { fn draw(&self) { println!("Drawing a square"); } }

fn main() {
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { radius: 1.0 }),
        Box::new(Square { side: 2.0 }),
    ];

    for shape in shapes {
        // 런타임에 실제 타입을 확인하여 적절한 draw 메서드를 호출합니다.
        shape.draw();
    }
}

이 코드가 실행될 때, shape.draw()를 호출하는 부분은 런타임에 shape이 가리키는 실제 객체(Circle인지 Square인지)를 확인한 뒤, 그에 맞는 draw 메서드를 찾아 실행합니다.

이 과정에서 약간의 런타임 비용이 발생하지만, 대신 서로 다른 타입을 하나의 컬렉션에서 다룰 수 있는 엄청난 유연성을 얻게 됩니다.

연관 타입과 제네릭 제약 더 복잡한 트레잇 설계

트레잇은 '연관 타입(Associated Types)'과 '제네릭 제약(Generic Constraints)'을 통해 훨씬 더 복잡하고 정교한 관계를 정의할 수 있습니다.

• 연관 타입: 트레잇 자체에 '딸려 있는' 타입을 정의하는 것입니다.
  
  표준 라이브러리의 Iterator 트레잇이 가장 대표적인 예입니다.
  
  Iterator는 자신이 어떤 타입의 요소를 만들어내는지 Item이라는 연관 타입을 통해 명시합니다.
  
  
• 제네릭 제약: where 절을 사용하여 제네릭 타입이나 연관 타입이 만족해야 할 추가적인 조건을 명시하는 것입니다.
  
  예를 들어, '이터레이터의 Item 타입은 반드시 Sum 트레잇을 구현해야 한다'와 같은 복잡한 제약을 걸 수 있습니다.
  
  

이러한 고급 기능들은 라이브러리나 프레임워크를 설계할 때 매우 강력한 도구가 되며, 타입 시스템을 통해 더 많은 오류를 컴파일 시간에 잡아낼 수 있게 해줍니다.

결론 트레잇은 러스트의 언어입니다

이처럼 러스트의 트레잇은 단순한 인터페이스를 넘어, 상속, 조합, 다형성, 그리고 정교한 타입 제약까지 아우르는 매우 강력하고 표현력 높은 시스템입니다.

정적 디스패치를 통해 성능 손실 없이 추상화를 제공하고, 필요할 때는 트레잇 객체를 통해 유연한 동적 다형성을 지원하는 이 두 가지 접근 방식의 균형은 러스트 설계의 백미라고 할 수 있습니다.

처음에는 트레잇의 다양한 개념들이 다소 복잡하게 느껴질 수 있습니다.

하지만 트레잇에 익숙해진다는 것은 곧 '러스트다운 방식'으로 생각하고 코드를 설계하는 능력을 갖추게 됨을 의미합니다.

트레잇을 자유자재로 다룰 수 있게 될 때, 여러분은 비로소 러스트라는 언어가 가진 진정한 힘과 아름다움을 온전히 경험하게 될 것입니다.