Python이 그러하듯 Rust도 declarative programming(선언형 프로그래밍)을 지원한다. 그 중 map()은 이러한 코딩스타일의 대표처럼 사용되고는 하는데, 이것을 이용하면 길고 장황한 코드를 간결하게 나타낼 수 있다.

기본적 사용법

1 부터 10까지 1씩 증가하는 값을 가진 i32 형의 10칸짜리 배열 arr이 있다고 할 때, 그 안에 있는 각 원소들에 2를 곱하는 코드이다.

// 배열의 각 요소들에 x2를 수행하고 결과를 출력.
// 실행결과:
// Doubled array: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

fn main() {
    // i32 type 배열 선언.
    let arr: [i32; 10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // map()을 사용해서 각 element들에 x2를 수행.
    let d_arr = arr.map(|x| x * 2);
    println!("Doubled array: {:?}", d_arr);
}

위의 코드는 Python과 같은 다른 언어에서도 사용하는 형식을 가지고 있어서 직관적이고 그 내용을 이해하기도 비교적 쉽다. 그렇다면 vector에 대해 같은 코드를 작성하면 어떨까? 10칸짜리 vector, vec를 만들고 동일한 동작을 수행해 보도록 하자.

// 벡터의 각 요소들에 x2를 수행하고 결괄르 출력.
// 실행결과:
// Doubled vector: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

fn main() {
    // Vector를 선언하고 1 부터 10까지 값들로 초기화.
    let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // map()을 사용해서 각 element들에 x2를 수행.
    let d_vec = vec.iter().map(|x| x * 2).collect::<Vec<_>>();
    println!("Doubled vector: {:?}", d_vec);
}

앞에서의 배열에 대한 map() 연산과 달리 뭔가 복잡해 졌다. 10번째 줄을 보면, map()을 호출하기 전에 iter()를 통해서 먼저 iterator(반복자)를 받고, 그 다음에 map()의 내용을 lambda로 수행한 다음에 collect::<Vec<_>>()라는 기괴한 구문으로 끝을 맺고 있다.

The “Lazy Pipeline”

이와 같이 data soruce로 부터 반복자를 받아서 map()을 통해 형태를 변경하고 다시 collect()로 넘겨 최종 처리하는 패턴(Create – Transform – Consume)이 Rust에서 자주 사용되는데 이것을 “Iterator Bridge” 패턴 혹은 “Lazy Pipeline”이라고 부른다.

이렇게 복잡한 pipeline을 거치는 이유는 크게 두가지 정도를 생각해 볼 수 있는데, 첫번째는 원하는 목적에 따라 각 단계의 함수(메소드)들을 다른 종류로 대체할 수 있기 때문이고 두번째는 앞서 살펴본 array와 달리 컴파일 시간에 그 크기가 정해지지 않는 동적 타입에 대해 실행시간을 최대한 미루는 게으른 처리(lazy evaluation)을 이용하여 성능을 향상시키기 위함이다.

각 함수(메소드)들의 대체

위의 예제에서는 Vector type의 source에 대하여 x2라는 transformation을 수행하고, collect::<Vec<_>>()로 consume해서 새로운 vector를 생성해 냈다. 반복자를 호출하는 방법에도 소유권을 넘겨주는 지 혹은 빌려오는지에 따라 iter_into() 혹은 iter()와 같은 다양한 종류의 반복자 반환 메소드를 사용할 수 있고, transformation을 수행하는 메소드도 map() 뿐만 아니라 특정한 조건을 만족하는 원소를 걸러내는 filter()같은 메소드들을 사용할 수 있으며, 최종단의 consumer 역시도 새로운 container를 만들어 내는 collect()외에도 요소의 갯수를 반환하는 count() 나 요소의 합을 계산하는 sum() 같은 다양한 메소드들로 목적에 맞게 파이프라인을 구성할 수 있다.

동일한 패턴을 유지하면서 vector내부에 있는 짝수의 총 합을 계산하는 다음 코드를 한번 보자.

// 벡터안의 짝수만 걸러서(filter) 합을 구하기
// 실행결과:
// Sum of all even numbers: 30

fn main() {
    let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    let sum = vec.iter().filter(|x| *x % 2 == 0).sum::<i32>();
    println!("Sum of all even numbers: {}", sum);
}

게으른 처리 (Lazy Evaluation)

Adapter인 map() 혹은 filter()로 호출한 구문은 consumer(collect(), fold(), sum(), count(), for loop 등)을 만나기 전까지는 아무런 수행도 하지 않았다가 consumer를 만나고 나서야 동작을 수행하게 된다. 이러한 동작은 pipeline이 구성된 후에 수행되기 때문에 불필요하게 중간상태를 보관하기 위한 메모리를 할당할 필요 없이 최적화된 코드 수행을 할 수 있도록 해준다. 실행시간에 크기가 변화하는 Vector와 같은 container를 감안할 때, 코드 수행단계마다 처리해서 임시 메모리에 쌓아두는 것 보다, 필요 할 때까지 미루어 뒀다가 최종 상태를 감안해서 처리하는 게으른 처리는 메모리 소모와 성능면에서 좋은 전략이 될 수 있다.

Option과 Result에 대한 map() 사용

언뜻 보면 일관성이 없어 보이기도 하지만, Option과 Result에도 map()을 사용할 수 있는데, 이는 Option의 Some()이나 Result의 Ok() 상태 처럼 정상동작한 경우에 대해 수행할 동작을 정의하고자 할 때 사용할 수 있어서, if let 구문이나 match 구문을 대체하여 코드를 간결하게 유지할 수 있도록 해준다.

// 실행결과:
//the value is SOME: 'some value'
//the result is OK: Result was good

use std::io::{Error, ErrorKind};

fn main() {
    // Option, map()
    let opt = Some("some value");
    //let opt: Option<String> = None;
    opt.map(|x| println!("{}", format!("the value is SOME: '{x}'")));

    // Result, map()
    let res: Result<String, Error> = Ok("Result was good".to_string());
    //let res: Result<String, Error> = Err(Error::new(ErrorKind::Other, "Some error"));
    let _ = res.map(|x| println!("{}", format!("the result is OK: {x}")));
}

Conclusion

Rust에서 사용되는 map()의 활용에 대해 살펴 보았다. Container에 대해 map()을 사용하는 것은 비교적 우리에게 익숙하지만, Option / Result에 map()을 사용하는 개념은 상대적으로 그렇지 않은데, 많은 설명들에 따르면, 이것은 “상자 속에 들어 있는” 어떤 값에 대해 그 내부를 직접 들여다 보지 않고 적용한다는 점에서 container와 Option, Result 공통으로 적용할 수 있는 선언형 프로그래밍의 철학이 적용된 것이라고 한다.