패턴 문법
리터럴·변수·다중·범위 패턴과 구조체·열거형 해체, 값 무시, 매치 가드·바인딩을 조합해 복잡한 데이터를 분기합니다.
앞의 두 글에서 패턴을 어디에 쓰는지, 어느 구문이 어떤 패턴을 받는지를 보았습니다. 그런데 정작 패턴 자체는 Some(x)와 튜플 정도만 써 왔습니다. 숫자가 어느 구간에 드는지에 따라 나누거나, 구조체의 필드 하나만 보고 나머지는 버리거나, 열거형 안의 열거형까지 한 번에 꺼내려면 패턴을 더 다양하게 적을 수 있어야 합니다. 이 글에서는 패턴에 쓸 수 있는 문법을 하나씩 실행해 보고, 마지막에 이들을 모아 17장의 종합 과제인 메시지 처리기를 완성합니다.
이 글을 읽고 나면 다음을 할 수 있습니다.
- 리터럴,
|, 범위..=로 값을 나누는match를 씁니다. - 구조체, 열거형, 튜플을 중첩된 것까지 패턴으로 해체하고, 쓰지 않을 부분을
_와..로 무시합니다. - 패턴이 바깥 변수를 가려 생긴 버그를 매치 가드로 고치고,
@로 검사한 값을 이름에 묶습니다.
앞 글까지 쓰던 patterns 프로젝트를 그대로 씁니다. 제목이 src/main.rs인 코드는 파일을 통째로 바꾸고 cargo run으로 실행합니다. fn main이 없는 짧은 조각은 main 함수의 중괄호 안에 넣어 실행합니다.
리터럴 매칭
패턴에 리터럴을 적으면 값이 정확히 그 값일 때만 맞습니다.
let x = 1;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("anything"),
}x가 1이므로 one이 출력됩니다. 특정한 값을 받았을 때만 할 일이 있을 때 씁니다.
명명된 변수 매칭
패턴에 적은 이름은 어떤 값에든 맞고, 그 값을 새 변수에 묶습니다. 여기에 함정이 하나 있습니다. match, if let, while let은 각각 새 스코프를 시작하므로, 패턴 안에서 만든 변수는 바깥에 있는 같은 이름의 변수를 가립니다. 다음 코드는 x가 바깥의 y와 같은 값인지 확인하려고 둘째 갈래에 Some(y)를 적었습니다.
fn main() {
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
Some(y) => println!("Matched, y = {y}"),
_ => println!("Default case, x = {x:?}"),
}
println!("at the end: x = {x:?}, y = {y}");
}x 안의 값은 5이고 y는 10입니다. 무엇이 출력될지 먼저 예상해 보세요.
결과 확인하기
Matched, y = 5
at the end: x = Some(5), y = 10첫 갈래의 Some(50)은 Some(5)와 맞지 않습니다. 둘째 갈래의 Some(y)는 바깥의 y와 비교하는 것이 아니라, Some 안의 어떤 값에든 맞는 새 변수 y를 만듭니다. 그래서 새 y에 5가 묶이고 Matched, y = 5가 출력됩니다. match가 끝나면 안쪽 y의 스코프도 끝나므로, 마지막 줄의 y는 다시 바깥의 10입니다.
x가 None이었다면 앞의 두 갈래가 맞지 않아 _ 갈래로 갑니다. 그 갈래의 패턴은 x라는 변수를 새로 만들지 않으므로, 표현식의 x는 바깥의 x이고 Default case, x = None이 출력됩니다. 바깥의 y와 정말로 비교하려면 새 변수를 만드는 대신 조건을 덧붙여야 합니다. 이 코드는 매치 가드를 사용한 추가 조건에서 고칩니다.
다중 패턴
match의 갈래에서 |로 패턴 여러 개를 이으면, 그 가운데 하나에만 맞아도 갈래가 선택됩니다. |는 패턴의 또는(or) 연산자입니다.
let x = 1;
match x {
1 | 2 => println!("one or two"),
3 => println!("three"),
_ => println!("anything"),
}이 코드는 one or two를 출력합니다.
..=를 이용한 값의 범위 매칭
..=는 양 끝을 포함하는 범위에 맞춥니다. 1 | 2 | 3 | 4 | 5라고 적을 것을 1..=5로 줄일 수 있고, 1부터 1,000까지라면 차이가 더 커집니다.
let x = 5;
match x {
1..=5 => println!("one through five"),
_ => println!("something else"),
}x가 5이므로 one through five가 출력됩니다. 범위 패턴은 숫자와 char에 쓸 수 있으며, 컴파일러가 범위가 비어 있지 않은지도 컴파일 시점에 확인합니다. 다음은 char 범위의 예이며, 'c'가 첫 범위에 들어 early ASCII letter가 출력됩니다.
let x = 'c';
match x {
'a'..='j' => println!("early ASCII letter"),
'k'..='z' => println!("late ASCII letter"),
_ => println!("something else"),
}값을 해체하여 분리하기
패턴으로 구조체, 열거형, 튜플을 해체해 각 부분을 따로 쓸 수 있습니다.
구조체 해체하기
다음 코드는 Point 구조체를 let의 패턴으로 나눕니다. 패턴 Point { x: a, y: b }에서 콜론 왼쪽은 필드 이름이고, 오른쪽은 그 필드의 값을 받을 새 변수의 이름입니다.
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 0, y: 7 };
let Point { x: a, y: b } = p;
assert_eq!(0, a);
assert_eq!(7, b);
}assert_eq!가 모두 통과하므로 실행해도 아무것도 출력되지 않고 끝납니다. 변수 이름은 필드 이름과 달라도 되지만, 어느 필드에서 왔는지 알기 쉽게 같은 이름을 쓰는 일이 많습니다. 그때마다 Point { x: x, y: y }라고 적으면 번거로우므로, 필드 이름만 적으면 같은 이름의 변수가 만들어지는 줄임 문법이 있습니다. main을 다음처럼 바꿉니다.
fn main() {
let p = Point { x: 0, y: 7 };
let Point { x, y } = p;
assert_eq!(0, x);
assert_eq!(7, y);
}필드 자리에 변수 대신 리터럴을 적을 수도 있습니다. 그러면 그 필드가 특정 값인지 검사하면서 다른 필드는 변수로 꺼냅니다. 다음 match는 점을 세 경우로 나눕니다. y가 0이면 x 축 위의 점이고, x가 0이면 y 축 위의 점이며, 나머지는 어느 축에도 있지 않은 점입니다.
fn main() {
let p = Point { x: 0, y: 7 };
match p {
Point { x, y: 0 } => println!("On the x axis at {x}"),
Point { x: 0, y } => println!("On the y axis at {y}"),
Point { x, y } => {
println!("On neither axis: ({x}, {y})");
}
}
}p는 y가 7이라 첫 갈래의 y: 0에 맞지 않고, x가 0이라 둘째 갈래에 맞습니다. 그래서 On the y axis at 7이 출력됩니다. p를 Point { x: 0, y: 0 }으로 바꾸면 원점은 두 축 위에 모두 있지만, match는 처음 맞는 갈래에서 멈추므로 On the x axis at 0만 출력됩니다.
열거형 해체하기
열거형을 해체하는 패턴은 각 배리언트가 데이터를 담는 방식을 그대로 따릅니다. 열거형 정의의 Message 열거형으로 확인합니다.
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
fn main() {
let msg = Message::ChangeColor(0, 160, 255);
match msg {
Message::Quit => {
println!("The Quit variant has no data to destructure.");
}
Message::Move { x, y } => {
println!("Move in the x direction {x} and in the y direction {y}");
}
Message::Write(text) => {
println!("Text message: {text}");
}
Message::ChangeColor(r, g, b) => {
println!("Change color to red {r}, green {g}, and blue {b}");
}
}
}이 코드는 Change color to red 0, green 160, and blue 255를 출력합니다. 만들지 않은 배리언트가 있다는 경고가 함께 나오지만 실행에는 지장이 없습니다. 데이터가 없는 Message::Quit은 더 해체할 것이 없어 이름만 적습니다. 구조체 모양인 Message::Move는 구조체 패턴처럼 중괄호 안에 필드를 적고, 튜플 모양인 Message::Write와 Message::ChangeColor는 괄호 안에 원소 수만큼 변수를 적습니다. msg를 Message::Move { x: 3, y: -10 }으로 바꿔 다른 갈래가 실행되는 것도 확인해 보세요.
중첩된 구조체와 열거형 해체하기
패턴은 값이 중첩된 만큼 중첩해 적을 수 있습니다. ChangeColor가 RGB와 HSV 두 가지 색을 받도록 Color 열거형을 더합니다.
enum Color {
Rgb(i32, i32, i32),
Hsv(i32, i32, i32),
}
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(Color),
}
fn main() {
let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));
match msg {
Message::ChangeColor(Color::Rgb(r, g, b)) => {
println!("Change color to red {r}, green {g}, and blue {b}");
}
Message::ChangeColor(Color::Hsv(h, s, v)) => {
println!("Change color to hue {h}, saturation {s}, value {v}");
}
_ => (),
}
}두 갈래 모두 바깥의 Message::ChangeColor에 맞는지 본 다음 안쪽 열거형을 봅니다. 값이 Color::Hsv이므로 둘째 갈래가 맞아 Change color to hue 0, saturation 160, value 255가 출력됩니다. 두 단계의 조건을 match 하나에 적었습니다.
구조체와 튜플 해체하기
해체 패턴은 서로 섞어 중첩할 수도 있습니다. 다음 한 줄은 튜플 안에 든 튜플과 구조체를 한 번에 풀어 feet, inches, x, y 네 변수를 만듭니다. 실행해 보려면 앞에서 쓴 Point 구조체의 정의와 함께 넣습니다.
let ((feet, inches), Point { x, y }) = ((3, 10), Point { x: 3, y: -10 });RUST · 패턴과 코드
해체 패턴은 구조의 각 위치를 검사하거나 바인딩합니다
구조체 필드, 중첩 enum의 variant, 튜플의 위치를 본문의 실제 값과 대응시킵니다.
구조체 · 필드별 바인딩
let p = Point { x: 0, y: 7 };
let Point { x: a, y: b } = p;필드 x→a=0, 필드 y→b=7. 필드 이름과 바인딩 이름은 달라도 됩니다.
구조체 · 리터럴 검사
// match p의 갈래
Point { x, y: 0 } => ...
Point { x: 0, y } => ...p=(0,7)은 첫 갈래의 y=0 검사에 실패하고 두 갈래의 x=0 검사에 성공하여 y=7을 바인딩합니다.
중첩 enum · 계층을 따라 해체
// 값
Message::ChangeColor(
Color::Hsv(0, 160, 255)
)
// 대응 패턴
Message::ChangeColor(
Color::Hsv(h, s, v)
)ChangeColor→Hsv 두 variant를 검사하고 h=0, s=160, v=255를 바인딩합니다.
튜플 + 구조체 · 각 위치 해체
let ((feet, inches), Point { x, y })
= ((3, 10),
Point { x: 3, y: -10 });feet=3, inches=10, x=3, y=-10. 바깥 튜플과 안쪽 튜플·구조체가 같은 구조로 대응됩니다.
전체 enum·Point 정의와 match의 나머지 갈래는 본문에 있습니다. 각 패턴은 단순한 변수 이름보다 구조·검사를 더 많이 표현합니다.
그림은 이 절의 네 예제에서 패턴의 각 자리가 값의 어느 부분과 짝이 되는지를 모은 것입니다. 변수 이름이 있는 자리는 값을 묶고, 리터럴이나 배리언트 이름이 있는 자리는 값을 검사합니다. 마지막 칸에서는 feet가 3, inches가 10, x가 3, y가 -10이 됩니다.
패턴에서 값 무시하기
값의 일부만 필요할 때는 나머지를 패턴에서 무시합니다. 방법은 네 가지입니다. _로 값 하나를 통째로 무시하거나, 다른 패턴 안에 _를 넣거나, 밑줄로 시작하는 이름을 쓰거나, ..로 남은 부분을 한꺼번에 무시합니다.
_로 전체 값 무시하기
_는 어떤 값에든 맞지만 이름에 묶지 않습니다. match의 마지막 갈래에서 써 왔고, 함수 매개변수를 비롯한 어느 패턴에서든 쓸 수 있습니다.
fn foo(_: i32, y: i32) {
println!("This code only uses the y parameter: {y}");
}
fn main() {
foo(3, 4);
}첫 인수 3은 무시되고 This code only uses the y parameter: 4가 출력됩니다. 쓰지 않는 매개변수는 대개 시그니처에서 지우면 됩니다. 하지만 트레이트를 구현할 때처럼 시그니처는 정해져 있는데 본문에서 매개변수 하나가 필요 없는 경우가 있고, 그때 _를 쓰면 쓰지 않는 매개변수 경고가 나지 않습니다.
중첩된 _로 값의 일부 무시하기
다른 패턴 안에 _를 넣으면 모양만 확인하고 값은 쓰지 않을 수 있습니다. 다음 코드는 설정 값을 다룹니다. 이미 설정한 값은 덮어쓰지 못하지만, 설정을 해제하거나 비어 있는 설정에 값을 주는 것은 허용합니다.
let mut setting_value = Some(5);
let new_setting_value = Some(10);
match (setting_value, new_setting_value) {
(Some(_), Some(_)) => {
println!("Can't overwrite an existing customized value");
}
_ => {
setting_value = new_setting_value;
}
}
println!("setting is {setting_value:?}");두 값이 모두 Some이므로 첫 갈래가 맞아 Can't overwrite an existing customized value와 setting is Some(5)가 차례로 출력됩니다. 첫 갈래는 둘 다 Some인지만 알면 되고 안의 값은 필요 없으므로 Some(_)로 적었습니다. 둘 중 하나라도 None이면 _ 갈래로 가서 새 값이 들어갑니다.
_는 한 패턴 안에 여러 번 쓸 수 있습니다. 다음 코드는 원소가 다섯인 튜플에서 둘째와 넷째를 무시하고 Some numbers: 2, 8, 32를 출력합니다.
let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, _, third, _, fifth) => {
println!("Some numbers: {first}, {third}, {fifth}");
}
}_로 시작하는 이름으로 사용하지 않는 변수 무시하기
만들어 놓고 쓰지 않는 변수가 있으면 러스트는 버그일 수 있다고 보아 경고합니다. 아직 쓰지 않을 변수를 미리 만들어 두고 싶을 때는 이름을 밑줄로 시작해 경고를 끕니다. 다음 코드를 컴파일하면 y를 쓰지 않는다는 경고만 나오고 _x에 대해서는 나오지 않습니다.
fn main() {
let _x = 5;
let y = 10;
}_x와 _는 비슷해 보이지만 다릅니다. _x는 여전히 값을 변수에 묶고, _는 아무것도 묶지 않습니다. 값이 String처럼 이동하는 타입일 때 이 차이가 드러납니다. 다음 코드는 컴파일되지 않습니다.
fn main() {
let s = Some(String::from("Hello!"));
if let Some(_s) = s {
println!("found a string");
}
println!("{s:?}");
}Some(_s)가 안의 String을 _s로 옮겼으므로, 그 뒤에 s를 다시 쓰는 마지막 줄에서 컴파일러는 s의 일부가 옮겨진 뒤에 빌렸다는 E0382 오류를 냅니다. _s를 _로 바꾸면 값이 어디에도 묶이지 않아 옮겨지지 않고, 오류가 사라집니다.
fn main() {
let s = Some(String::from("Hello!"));
if let Some(_) = s {
println!("found a string");
}
println!("{s:?}");
}이 코드는 found a string과 Some("Hello!")를 차례로 출력합니다.
..로 값의 나머지 부분 무시하기
부분이 여럿인 값에서는 ..로 적지 않은 나머지를 모두 무시할 수 있어, 자리마다 _를 적지 않아도 됩니다. 다음 코드는 3차원 좌표에서 x만 쓰고 x is 0을 출력합니다. 필드가 많은 구조체에서 한두 개만 볼 때 y: _, z: _를 늘어놓는 것보다 짧습니다.
struct Point {
x: i32,
y: i32,
z: i32,
}
let origin = Point { x: 0, y: 0, z: 0 };
match origin {
Point { x, .. } => println!("x is {x}"),
}튜플에서 ..는 필요한 만큼의 자리를 차지합니다. 다음 코드는 첫 값과 마지막 값만 묶고 가운데는 모두 무시해 Some numbers: 2, 32를 출력합니다.
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, .., last) => {
println!("Some numbers: {first}, {last}");
}
}
}다만 ..가 어느 자리를 차지하는지는 하나로 정해져야 합니다. 가운데 값 하나를 꺼내려고 ..를 양쪽에 써 봅니다.
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(.., second, ..) => {
println!("Some numbers: {second}")
},
}
}error: `..` can only be used once per tuple pattern
--> src/main.rs:5:22
|
5 | (.., second, ..) => {
| -- ^^ can only be used once per tuple pattern
| |
| previously used here컴파일러는 second 앞에서 값을 몇 개 무시하고 뒤에서 몇 개를 무시할지 알 수 없습니다. 2를 건너뛰고 4를 묶으라는 뜻일 수도, 2와 4를 건너뛰고 8을 묶으라는 뜻일 수도 있습니다. second라는 이름은 러스트에게 아무 의미가 없으므로, 튜플 패턴 하나에 ..는 한 번만 쓸 수 있습니다.
패턴 생략 문법 선택
따로 떼어 낸 Some(String) 예에서 _s는 안쪽 String을 이동시켜 나중에 s를 쓰면 오류가 나고, Some(_)은 바인딩하지 않아 원래 s를 계속 쓸 수 있는 차이를 따라갑니다. 잘못된 출력 코드는 실행 단계가 아니라 컴파일 오류로 표시합니다.
RUST · 패턴과 코드
_name은 바인딩하고, _와 ..는 값을 바인딩하지 않습니다
밑줄로 시작하는 이름과 와일드카드의 소유권 차이는 String이 들어 있는 Option 예제에서 드러납니다.
_name은 참조도 바인딩할 수 있습니다. _·..는 배타적 기능이 아니며 중첩 패턴은 각각 판단합니다.
코드·조건·비교표와 보충 설명
_name · 미사용 경고를 피하는 이름
let s = Some(
String::from("Hello!")
);
if let Some(_s) = s {
// 내부 String을 _s로 이동
}
// 아래는 이동 후 사용 오류
println!("{s:?}");_s는 실제 바인딩입니다. 값이나 참조를 바인딩할 수 있으며 이 owned String 예제에서는 내부 값을 이동합니다.
_ · 한 위치를 바인딩하지 않음
let s = Some(
String::from("Hello!")
);
if let Some(_) = s {
// 내부 값을 바인딩하지 않음
}
println!("{s:?}"); // 사용 가능_ 자체는 복사·이동·대여를 만들지 않습니다. 다른 부분에서 값을 이동하는 패턴과 함께 쓸 때는 그 다른 부분을 따로 봅니다.
.. · 나머지 구조를 생략
Point { x, .. }
(first, .., last)구조체의 나머지 필드 또는 튜플·슬라이스의 나머지 위치를 생략합니다. numbers=(2,4,8,16,32)에서 first=2, last=32입니다.
중복 rest · 같은 튜플 안에서는 오류
(.., second, ..) // 허용되지 않음같은 튜플 패턴의 두 ..는 second가 어느 위치인지 모호하게 만듭니다. 각 중첩 하위 패턴의 ..는 별도로 판단합니다.
코드는 본문 예제의 핵심 발췌입니다. _name·_·..는 배타적인 기능이 아니므로 한 구조 패턴 안에서 조합할 수 있습니다.
이 예의 조건
- 본문과 도표에 나온 예의 입력과 조건을 그대로 씁니다. 설명용 수치나 따로 비교하는 경로는 해당 단계에 표시합니다.
- 모든 단계에서 현재 상태·값과 다음 단계로 넘어가는 이유를 같은 자리에 보여 줍니다. 조건이 맞지 않아 실행되지 않은 경로는 성공한 동작이 아닙니다.
| 관찰·상황 | 값·보충 정보 | 변화·이유 |
|---|---|---|
| 두 독립 패턴 Some(String)을 _s 또는 _로 처리하는 독립 사본입니다. |
|
|
| 이동 여부 _s는 내부 값을 바인딩하고, _는 바인딩하지 않습니다. |
|
|
| 후속 사용 판정 원래 s를 쓸 수 있는지는 컴파일할 때 확인합니다. |
|
|
패턴 생략 문법 선택
따로 떼어 낸 Some(String) 예에서 _s는 안쪽 String을 이동시켜 나중에 s를 쓰면 오류가 나고, Some(_)은 바인딩하지 않아 원래 s를 계속 쓸 수 있는 차이를 따라갑니다. 잘못된 출력 코드는 실행 단계가 아니라 컴파일 오류로 표시합니다.
RUST · 패턴과 코드
_name은 바인딩하고, _와 ..는 값을 바인딩하지 않습니다
밑줄로 시작하는 이름과 와일드카드의 소유권 차이는 String이 들어 있는 Option 예제에서 드러납니다.
_name은 참조도 바인딩할 수 있습니다. _·..는 배타적 기능이 아니며 중첩 패턴은 각각 판단합니다.
코드·조건·비교표와 보충 설명
_name · 미사용 경고를 피하는 이름
let s = Some(
String::from("Hello!")
);
if let Some(_s) = s {
// 내부 String을 _s로 이동
}
// 아래는 이동 후 사용 오류
println!("{s:?}");_s는 실제 바인딩입니다. 값이나 참조를 바인딩할 수 있으며 이 owned String 예제에서는 내부 값을 이동합니다.
_ · 한 위치를 바인딩하지 않음
let s = Some(
String::from("Hello!")
);
if let Some(_) = s {
// 내부 값을 바인딩하지 않음
}
println!("{s:?}"); // 사용 가능_ 자체는 복사·이동·대여를 만들지 않습니다. 다른 부분에서 값을 이동하는 패턴과 함께 쓸 때는 그 다른 부분을 따로 봅니다.
.. · 나머지 구조를 생략
Point { x, .. }
(first, .., last)구조체의 나머지 필드 또는 튜플·슬라이스의 나머지 위치를 생략합니다. numbers=(2,4,8,16,32)에서 first=2, last=32입니다.
중복 rest · 같은 튜플 안에서는 오류
(.., second, ..) // 허용되지 않음같은 튜플 패턴의 두 ..는 second가 어느 위치인지 모호하게 만듭니다. 각 중첩 하위 패턴의 ..는 별도로 판단합니다.
코드는 본문 예제의 핵심 발췌입니다. _name·_·..는 배타적인 기능이 아니므로 한 구조 패턴 안에서 조합할 수 있습니다.
이 예의 조건
- 본문과 도표에 나온 예의 입력과 조건을 그대로 씁니다. 설명용 수치나 따로 비교하는 경로는 해당 단계에 표시합니다.
- 모든 단계에서 현재 상태·값과 다음 단계로 넘어가는 이유를 같은 자리에 보여 줍니다. 조건이 맞지 않아 실행되지 않은 경로는 성공한 동작이 아닙니다.
| 관찰·상황 | 값·보충 정보 | 변화·이유 |
|---|---|---|
| 두 독립 패턴 Some(String)을 _s 또는 _로 처리하는 독립 사본입니다. |
|
|
| 이동 여부 _s는 내부 값을 바인딩하고, _는 바인딩하지 않습니다. |
|
|
| 후속 사용 판정 원래 s를 쓸 수 있는지는 컴파일할 때 확인합니다. |
|
|
그림은 이 절의 두 가지 비교를 나란히 놓은 것입니다. 첫 비교에서 Some(_s)는 String을 옮겨 그 뒤의 s 사용이 오류가 되고, Some(_)는 아무것도 묶지 않아 s를 계속 쓸 수 있습니다. 다른 비교에서 (first, .., last)는 first가 2, last가 32로 정해지지만, 같은 튜플에 ..를 두 번 쓰면 자리가 모호해 컴파일 오류입니다.
매치 가드를 사용한 추가 조건
매치 가드(match guard)는 match 갈래의 패턴 뒤에 붙이는 if 조건입니다. 패턴이 맞고 이 조건도 참이어야 그 갈래가 선택됩니다. 패턴만으로는 적을 수 없는 조건을 나타낼 때 쓰며, match에서만 쓸 수 있고 if let이나 while let에는 쓸 수 없습니다. 가드의 조건에서는 패턴이 만든 변수를 쓸 수 있습니다.
let num = Some(4);
match num {
Some(x) if x % 2 == 0 => println!("The number {x} is even"),
Some(x) => println!("The number {x} is odd"),
None => (),
}Some(4)가 Some(x)에 맞고, 가드 x % 2 == 0도 참이므로 The number 4 is even이 출력됩니다. num이 Some(5)였다면 첫 갈래는 패턴에는 맞지만 가드가 거짓이라 선택되지 않고, 가드가 없는 둘째 갈래가 받아 홀수라고 출력합니다. 짝수인지는 패턴으로 적을 방법이 없으므로 가드가 필요합니다. 대신 컴파일러는 가드가 참일지 미리 알 수 없어, 철저한지 따질 때 가드가 붙은 갈래를 빼고 생각합니다.
이제 명명된 변수 매칭의 코드를 고칠 수 있습니다. Some(y)가 새 y를 만들어 바깥의 y와 비교하지 못한 것이 문제였습니다. 패턴에는 다른 이름 n을 쓰고, 비교는 가드로 옮깁니다.
fn main() {
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
Some(n) if n == y => println!("Matched, n = {n}"),
_ => println!("Default case, x = {x:?}"),
}
println!("at the end: x = {x:?}, y = {y}");
}Default case, x = Some(5)
at the end: x = Some(5), y = 10가드 if n == y는 패턴이 아니므로 변수를 새로 만들지 않습니다. 그래서 여기의 y는 바깥의 y이고, n에 묶인 5와 10을 비교한 결과가 거짓이라 _ 갈래로 넘어갑니다. y를 5로 바꾸면 둘째 갈래가 선택되어 Matched, n = 5가 출력됩니다.
가드는 |로 이은 패턴과 함께 쓸 수도 있습니다. 다음 코드는 무엇을 출력할까요? if y가 어디까지 걸리는지 생각하며 먼저 예상해 보세요.
let x = 4;
let y = false;
match x {
4 | 5 | 6 if y => println!("yes"),
_ => println!("no"),
}결과 확인하기
no가 출력됩니다. 가드는 마지막 값 6에만 붙는 것이 아니라 4 | 5 | 6 전체에 붙습니다. 다시 말해 이 갈래는 다음처럼 읽습니다.
(4 | 5 | 6) if y => ...x가 4라 패턴에는 맞지만 y가 false라 가드가 거짓이고, 그래서 다음 갈래로 넘어갑니다. 가드가 6에만 걸렸다면 4는 조건 없이 맞아 yes가 출력되었을 것입니다.
@ 바인딩
범위 패턴은 값이 범위에 드는지 검사하지만 그 값을 변수에 담지는 않습니다. at 연산자 @를 쓰면 패턴으로 검사하면서 같은 값을 이름에 묶을 수 있습니다. 다음 코드는 Message::Hello의 id 필드가 3..=7 범위에 드는지 검사하고, 그 값을 id_variable에 담아 출력에 씁니다.
enum Message {
Hello { id: i32 },
}
let msg = Message::Hello { id: 5 };
match msg {
Message::Hello {
id: id_variable @ 3..=7,
} => println!("Found an id in range: {id_variable}"),
Message::Hello { id: 10..=12 } => {
println!("Found an id in another range")
}
Message::Hello { id } => println!("Found some other id: {id}"),
}id가 5이므로 첫 갈래가 맞아 Found an id in range: 5가 출력됩니다. 세 갈래를 비교하면 @의 쓸모가 보입니다. 둘째 갈래는 범위만 적었으므로 id가 10, 11, 12 가운데 어느 것인지 본문에서 알 수 없습니다. 셋째 갈래는 줄임 문법으로 id 변수를 만들었지만 값에 아무 검사도 하지 않습니다. 첫 갈래만 검사와 바인딩을 함께 합니다.
RUST · 패턴과 코드
새 바인딩, 바깥 값 비교, @의 검사와 바인딩을 구분합니다
본문의 Some(5), 바깥 y=10, id=5를 사용해 각 이름이 어떤 값을 뜻하는지 비교합니다.
Some(y) · 새 y를 바인딩
let x = Some(5);
let y = 10;
// match x의 갈래
Some(y) => ...갈래 안의 y=5가 바깥 y를 가립니다. match 이후 바깥 y는 여전히 10입니다.
guard · 바깥 y와 비교
// 같은 x=Some(5), y=10
Some(n) if n == y => ...n=5는 새 바인딩이고 y=10은 바깥 변수입니다. 5==10이 거짓이므로 다음 갈래로 넘어갑니다.
@ · 검사하면서 값을 저장
// Message::Hello의 필드
id: v @ 3..=7id=5는 범위 검사에 성공하며 v=5를 함께 바인딩합니다. 본문의 id_variable을 v로 줄여 표시했습니다.
or-pattern의 guard는 전체 패턴에 적용
4 | 5 | 6 if y => ...의미는 (4 | 5 | 6) if y입니다. 본문의 x=4, y=false는 패턴에 맞아도 guard가 거짓이므로 다음 갈래에서 no를 출력합니다.
코드는 비교에 필요한 갈래 발췌입니다. @와 guard를 새 이름 바인딩과 함께 조합할 수도 있습니다.
그림은 이 글에서 이름이 무엇을 가리키는지 헷갈리기 쉬운 네 경우를 모은 것입니다. Some(y)는 새 y를 만들어 바깥의 y를 가리고, 가드의 y는 바깥 변수이며, @는 검사한 값을 이름에 묶고, | 뒤의 가드는 패턴 전체에 걸립니다. 그림의 v는 본문의 id_variable을 줄여 적은 것입니다.
더 깊이: 끝을 빼는 범위와 한쪽이 열린 범위
패턴에는 ..= 말고도 범위를 쓰는 형태가 더 있습니다. Reference의 범위 패턴은 아래쪽 끝값만 적어 그 이상을 모두 맞추는 1.., 위쪽 끝값까지 포함하는 ..=10을 정의합니다. Rust 1.80 발표에 따르면 끝을 빼는 a..b와 ..b는 이 버전부터 패턴에 쓸 수 있으며, 그 전까지는 끝을 포함하는 범위와 a.. 형태만 허용되었습니다. 이 버전은 범위의 끝이 서로 이어지지 않거나 겹치는 것을 알려 주는 non_contiguous_range_endpoints와 overlapping_range_endpoints 린트를 함께 더했습니다.
범위 패턴은 적어도 값 하나를 포함해야 하므로, 10..=0이나 10..10은 컴파일 오류입니다. 반대로 0u8..=255u8처럼 타입의 모든 값을 덮는 정수나 char의 범위 패턴은 반박 불가능한 패턴이 됩니다. 2018 에디션까지는 ..= 대신 ...라고도 쓸 수 있었지만, 2021 에디션부터는 이 형태를 쓸 수 없습니다.
더 깊이: 참조를 매칭하면 바인딩은 어떻게 정해질까
이 글의 패턴은 대부분 값 자체에 맞췄지만, 실제 코드에서는 &Option<i32>처럼 참조를 매칭하는 일이 많습니다. Reference의 바인딩 모드 설명에 따르면, 참조 값을 참조가 아닌 패턴으로 매칭하면 컴파일러가 참조를 자동으로 따라가며 기본 바인딩 모드(default binding mode)를 바꿉니다. 처음 모드는 값을 옮기는 move이고, 공유 참조를 지나면 ref가 됩니다. 가변 참조를 지나면 보통 ref mut이 되지만, 이미 ref인 모드는 그대로 유지됩니다. 그래서 x: &Option<i32>에 if let Some(y) = x라고 쓰면, y는 i32가 아니라 &i32로 묶입니다.
2024 에디션은 이 규칙에 제한을 더했습니다. 에디션 가이드에 따르면 기본 바인딩 모드가 move가 아닌 곳에서는 바인딩에 mut, ref, ref mut을 쓸 수 없고, &나 &mut 참조 패턴도 쓸 수 없습니다. cargo fix --edition은 rust_2024_incompatible_pat 린트로 그런 패턴을 let &[ref x, mut y] = ...처럼 모든 단계를 명시한 형태로 바꿔 줍니다.
정리
- 리터럴,
|로 묶은 여러 패턴,..=로 나타낸 숫자나char의 범위에 값을 맞출 수 있습니다. match,if let,while let의 패턴에서 선언한 이름은 새 스코프의 새 변수라 바깥의 같은 이름을 가립니다.- 구조체, 열거형, 튜플을 해체하고 중첩할 수 있으며, 일부 필드를 리터럴로 검사하면서 나머지를 바인딩할 수 있습니다.
_는 값을 바인딩하지 않고,_x는 바인딩하되 쓰지 않아도 경고하지 않으며,..는 남은 부분을 한 번에 무시하되 한 튜플 패턴에 두 번 쓸 수 없습니다.- 매치 가드
if 조건은|로 묶은 패턴 전체에 적용되며,@는 패턴을 검사하면서 그 값을 변수에 바인딩합니다.
연습 문제
1. 무엇이 출력될까
다음 match는 n이 각각 0, 7, 15, 42일 때 무엇을 출력하나요? 갈래는 위에서부터 차례로 비교됩니다.
match n {
0 => println!("zero"),
x @ 1..=9 => println!("digit {x}"),
x if x % 5 == 0 => println!("multiple of five {x}"),
_ => println!("other"),
}해설 보기
0은 첫 갈래에 맞아 zero를 출력합니다. 7은 1..=9 범위에 맞아 x에 바인딩되므로 digit 7을 출력합니다. 15는 범위 밖이고, 셋째 갈래의 패턴 x는 모든 값에 맞으므로 가드가 선택을 정하는데 15 % 5 == 0이 참이라 multiple of five 15를 출력합니다. 42는 가드가 거짓이라 other를 출력합니다.
2. 가드만으로 나눈 match 고치기
다음 코드는 짝수와 홀수를 빠짐없이 나눈 것처럼 보이지만 E0004 오류로 컴파일되지 않습니다. 까닭을 설명하고, 출력이 달라지지 않게 고치세요.
fn main() {
let num = Some(4);
match num {
Some(x) if x % 2 == 0 => println!("The number {x} is even"),
Some(x) if x % 2 != 0 => println!("The number {x} is odd"),
None => (),
}
}해설 보기
컴파일러는 가드가 참일지 거짓일지 미리 알 수 없으므로, 철저한지 따질 때 가드가 붙은 갈래를 세지 않습니다. 두 Some(x) 갈래에 모두 가드가 있어, 컴파일러가 보기에는 Some을 받는 갈래가 하나도 없습니다. 사람은 두 조건이 서로 반대라는 것을 알지만 컴파일러는 그것을 따지지 않습니다. 둘째 갈래의 가드를 지워 Some(x) => println!("The number {x} is odd"),로 쓰면 됩니다. 짝수는 첫 갈래에서 이미 걸러지므로 둘째 갈래에 오는 값은 홀수뿐이고, 출력은 그대로 The number 4 is even입니다.
3. 점의 위치를 분류하는 match 쓰기
x와 y 필드를 가진 Point 값 p를 받아, 원점이면 origin, x와 y가 같으면 diagonal, 그 밖에는 x가 음수이면 left, 아니면 right를 출력하는 match를 쓰세요. main에서 p를 Point { x: 0, y: 0 }, Point { x: 2, y: 2 }, Point { x: -1, y: 4 }로 바꿔 가며 확인합니다.
해설 보기
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: -1, y: 4 };
match p {
Point { x: 0, y: 0 } => println!("origin"),
Point { x, y } if x == y => println!("diagonal"),
Point { x, .. } if x < 0 => println!("left"),
_ => println!("right"),
}
}세 값에서 차례로 origin, diagonal, left가 출력되면 됩니다. 원점을 리터럴 패턴으로 먼저 잡아야, 원점이 x == y 가드에도 맞아 diagonal로 출력되는 일을 막을 수 있습니다. x의 부호만 볼 때는 ..로 y를 무시했습니다. 가드가 붙은 갈래는 철저한지 따질 때 세지 않으므로 마지막에 _ 갈래를 둡니다.
4. 종합 과제: 메시지 처리기
17장에서 만든 조각을 모읍니다. 패턴이 사용될 수 있는 모든 곳의 3번 문제에서 쓴 while let 루프를 뼈대로, 이동량 튜플 대신 이 글의 Message를 큐에 넣고 match로 처리합니다. src/main.rs를 비우고 시작합니다.
완성 조건은 다음과 같습니다.
- 이 글의
Color,Message(ChangeColor(Color)를 가진 쪽), 필드가 둘인Point를 정의합니다. queue는Vec<Message>이고,position은Point { x: 0, y: 0 }에서 시작합니다.while let으로 맨 뒤부터 메시지를 꺼냅니다.Quit이면quit을 출력하고break로 루프를 끝냅니다.Move에서x와y가 모두 0이면stay를 출력합니다. 그 밖에는position에 더하고move by (3, -10)형식으로 출력합니다.Write의 문자열이 비어 있으면empty text, 아니면text: hello형식으로 출력합니다. 빈 문자열인지는text.is_empty()로 확인합니다.ChangeColor가Rgb이면rgb 255, 0, 0형식으로 출력합니다.Hsv이면 첫 값이0..=360범위일 때hue 0형식으로, 범위 밖이면hue out of range를 출력합니다. 나머지 두 값은 쓰지 않습니다.- 루프가 끝나면
position을let으로 해체해final position: (3, -3)형식으로 출력하고,queue.len()으로 큐에 남은 메시지 수를 출력합니다.
힌트: 조건마다 쓸 문법이 하나씩 있습니다. 필드의 리터럴 검사, 매치 가드, 중첩된 열거형 해체, @와 ..입니다. 더 좁은 조건의 갈래를 위에 둡니다.
해설 보기
enum Color {
Rgb(i32, i32, i32),
Hsv(i32, i32, i32),
}
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(Color),
}
struct Point {
x: i32,
y: i32,
}
fn main() {
let mut queue = vec![
Message::Write(String::from("too late")),
Message::Quit,
Message::Write(String::new()),
Message::Write(String::from("hello")),
Message::ChangeColor(Color::Hsv(400, 160, 255)),
Message::ChangeColor(Color::Hsv(0, 160, 255)),
Message::ChangeColor(Color::Rgb(255, 0, 0)),
Message::Move { x: 0, y: 0 },
Message::Move { x: 0, y: 7 },
Message::Move { x: 3, y: -10 },
];
let mut position = Point { x: 0, y: 0 };
while let Some(msg) = queue.pop() {
match msg {
Message::Quit => {
println!("quit");
break;
}
Message::Move { x: 0, y: 0 } => println!("stay"),
Message::Move { x, y } => {
position = Point {
x: position.x + x,
y: position.y + y,
};
println!("move by ({x}, {y})");
}
Message::Write(text) if text.is_empty() => println!("empty text"),
Message::Write(text) => println!("text: {text}"),
Message::ChangeColor(Color::Rgb(r, g, b)) => println!("rgb {r}, {g}, {b}"),
Message::ChangeColor(Color::Hsv(h @ 0..=360, ..)) => println!("hue {h}"),
Message::ChangeColor(Color::Hsv(..)) => println!("hue out of range"),
}
}
let Point { x, y } = position;
println!("final position: ({x}, {y})");
println!("left in queue: {}", queue.len());
}cargo run의 출력이 다음과 같으면 완성입니다. pop은 맨 뒤부터 꺼내므로 벡터에 적은 순서의 반대로 처리됩니다.
move by (3, -10)
move by (0, 7)
stay
rgb 255, 0, 0
hue 0
hue out of range
text: hello
empty text
quit
final position: (3, -3)
left in queue: 1갈래마다 이 글의 문법이 하나씩 들어 있습니다. Move { x: 0, y: 0 }은 두 필드를 리터럴로 검사하며, 이 갈래가 Move { x, y }보다 위에 있어야 선택됩니다. Write(text) if text.is_empty()는 패턴으로 적을 수 없는 조건이라 가드를 썼고, 가드 없는 Write(text)가 나머지를 받습니다. Hsv(h @ 0..=360, ..)는 첫 값을 범위로 검사하면서 h에 묶고 나머지 둘은 ..로 무시하며, 범위 밖의 400은 그 아래의 Hsv(..)가 받습니다. Quit에서 break로 나오므로 그 앞에 있던 too late 메시지는 처리되지 않고 큐에 하나 남습니다. 모든 배리언트를 가드 없는 갈래가 덮고 있어 _ 갈래 없이도 컴파일됩니다.
다르게 나올 때는 다음을 먼저 봅니다.
| 증상 | 확인할 곳 |
|---|---|
stay 대신 move by (0, 0)이 나온다 | Move { x: 0, y: 0 } 갈래가 Move { x, y }보다 위에 있는지 |
empty text가 나오지 않는다 | 가드가 붙은 Write 갈래가 가드 없는 갈래보다 위에 있는지 |
hue out of range 대신 hue 400이 나온다 | h 뒤에 @ 0..=360을 붙였는지 |
| 갈래가 모자라다는 오류가 난다 | 가드가 붙은 갈래만 있고 가드 없는 갈래가 빠진 배리언트가 있는지 |
더 해 보려면 Rgb의 세 값이 모두 0..=255 범위일 때만 출력하고 아니면 invalid rgb를 출력하게 바꾸거나, Move에서 y가 0일 때 horizontal move를 따로 출력하는 갈래를 더해 보세요.
이것으로 17장을 마칩니다. 다음 장의 안전하지 않은 러스트부터는 러스트의 여러 기능 가운데 고급 측면을 살펴봅니다.