Ada와 Rust 비교: 자료구조, 분기, 오류 처리 철학

에이다와 러스트는 최고 수준의 안전성과 신뢰성을 지향한다는 공통된 목표를 가졌지만, 그 목표에 도달하는 경로는 뚜렷한 철학적 차이를 보입니다. 이러한 차이는 특히 서로 다른 구조의 데이터를 하나의 타입으로 묶는 방식(합 타입), 그에 따른 조건 분기, 그리고 프로그램의 오류를 다루는 방식에서 명확하게 드러납니다.

## 1. 합 타입(Sum Type) 구현: 조합(Composition) vs. 통합(Integration)

두 언어 모두 여러 데이터 구조 중 하나를 표현하는 '합 타입' 개념을 안전하게 지원하지만, 문법적 접근 방식이 다릅니다.

• 에이다 (Ada): 변형 레코드 (Variant Record) 에이다는 기존의 강력한 기능들을 조합하여 합 타입을 구현합니다. 먼저 데이터의 종류를 구별하는 '태그'로 사용할 열거형을 정의한 후, 이 열거형을 **판별자(Discriminant)**로 삼아 구조가 변하는 레코드를 만드는 2단계 방식을 사용합니다.

  -- 1단계: 종류(태그) 정의
  type IpAddr_Kind is (V4, V6);
  
  -- 2단계: 태그를 판별자로 사용하는 변형 레코드 정의
  type IpAddr (Kind : IpAddr_Kind) is record
     case Kind is
        when V4 => Addr_V4 : array (1 .. 4) of Natural;
        when V6 => Addr_V6 : Unbounded_String;
     end case;
  end record;
  

  이 방식은 '열거형'과 '레코드'라는 직교하는(orthogonal) 개념을 명시적으로 조합하여, 소프트웨어 공학의 원칙에 따라 구조를 체계적으로 구축합니다.

• 러스트 (Rust): 데이터를 포함하는 Enum 러스트는 이 개념을 enum이라는 하나의 키워드 안에 완벽하게 통합했습니다. enum의 각 변종(variant)이 어떤 데이터를 가질지 선언과 동시에 정의합니다.

  // 단일 단계: 선언과 데이터 구조 정의를 통합
  enum IpAddr {
      V4(u8, u8, u8, u8),
      V6(String),
  }
  

  이 접근법은 문법이 더 간결하며, 합 타입을 만들려는 의도를 하나의 구문으로 명확하게 표현합니다.

## 2. 조건 분기: 안전한 접근 vs. 패턴 매칭

정의된 합 타입을 다룰 때, 두 언어 모두 모든 경우를 검사하도록 강제하지만 데이터 활용 방식에서 차이를 보입니다.

• 에이다 (Ada): case 문과 안전한 필드 접근 에이다의 case 문은 판별자 값을 기준으로 분기하며, 컴파일러는 각 분기 블록 내에서 해당되는 필드에만 안전하게 접근하도록 보장합니다.

  case Addr.Kind is
     when V4 =>
        -- 이 블록 내에서만 Addr.Addr_V4 접근이 유효
        Put_Line ("IPv4: " & Addr.Addr_V4'Image);
     when V6 =>
        -- 이 블록 내에서만 Addr.Addr_V6 접근이 유효
        Put_Line ("IPv6: " & To_String(Addr.Addr_V6));
  end case;
  

• 러스트 (Rust): match와 패턴 매칭 러스트의 match는 완전성 검사를 수행할 뿐만 아니라, 변종 내부의 데이터를 즉시 새로운 변수로 추출(destructuring)하는 강력한 패턴 매칭을 제공합니다.

  match addr {
      IpAddr::V4(a, b, c, d) => { // 데이터를 a,b,c,d 변수로 바로 추출
          println!("IPv4: {}.{}.{}.{}", a, b, c, d);
      }
      IpAddr::V6(s) => { // 데이터를 s 변수로 바로 추출
          println!("IPv6: {}", s);
      }
  }
  

  이처럼 분기와 동시에 데이터 바인딩이 일어나므로 코드가 더 간결하고 표현력이 풍부해집니다.

## 3. 오류 처리: 예외(Exception) vs. 반환 값(Return Value)

오류 처리 방식은 두 언어의 철학적 차이를 가장 극명하게 보여줍니다.

• 에이다 (Ada): 구조적 예외 처리 에이다는 전통적인 예외(Exception) 메커니즘을 사용합니다. 오류 발생 시 실행 흐름을 중단하고 예외를 발생(raise)시키면, 호출자는 exception 블록에서 이를 처리합니다. 이는 정상적인 코드 흐름과 오류 처리 흐름을 명확하게 분리하는 장점이 있습니다.

  function Safe_Divide (X : Float; Y : Float) return Float is
  begin
     if Y = 0.0 then
        raise Constraint_Error; -- 예외 발생
     end if;
     return X / Y;
  exception
     when Constraint_Error => -- 예외 처리
        Put_Line("오류: 0으로 나눌 수 없습니다.");
        return 0.0;
  end Safe_Divide;
  

• 러스트 (Rust): Result 열거형을 통한 명시적 처리 러스트는 의도적으로 예외를 배제하고, 오류를 함수의 반환 값으로 다룹니다. 오류 발생 가능성이 있는 함수는 성공(Ok(T)) 또는 실패(Err(E)) 상태를 가지는 Result<T, E> 열거형을 반환합니다. 호출자는 match를 사용해 이 두 가지 경우를 반드시 명시적으로 처리해야 합니다.

  fn safe_divide(x: f64, y: f64) -> Result<f64, String> {
      if y == 0.0 {
          return Err(String::from("오류: 0으로 나눌 수 없습니다.")); // 오류 값을 반환
      }
      Ok(x / y) // 성공 값을 반환
  }
  
  // 호출자는 match로 Ok와 Err를 모두 처리해야 함
  match safe_divide(10.0, 0.0) {
      Ok(value) => println!("결과: {}", value),
      Err(e)    => println!("{}", e),
  }
  

  오류를 타입 시스템의 일부로 만들어 컴파일러가 오류 처리를 강제하도록 유도하는 방식입니다.

## 종합 결론

결론적으로, 에이다는 소프트웨어 공학의 원칙에 입각하여 기능들을 체계적으로 조합하고 실행 흐름을 명확히 분리하여 신뢰성을 확보합니다. 반면, 러스트는 강력한 타입 시스템을 중심으로 기능들을 통합하고 모든 가능한 상태(성공, 실패 포함)를 컴파일 시점에 강제하여 안전성을 달성합니다. 두 언어 모두 최고 수준의 견고함을 제공하지만, 그 방법론은 각기 다른 패러다임을 따르고 있습니다.