while let - Topics about IT

Rust의 기호(=>, ::, ., -> 등)와 연산자(산술, 비교, 사칙연산자, 논리 연산자, 패턴 매치 연산자 등) 는 종류도 많고 다른 언어와 다른 것도 있어 많이 헷갈리므로 이것에 대해 전체적으로 알아보겠습니다.

Ⅰ. 기호

1. =>

match 문에서 패턴 매핑 결과를 지정할 때 사용합니다.

let num = 2;
match num {
    1 => println!("one"),
    2 => println!("two"),
    _ => println!("other"),
}

위에서 2 => println!(“two”)는 num이 2일 때 실행됩니다.

2. ::

경로(네임스페이스) 구분자. 모듈, 구조체, 열거형, 연관함수, 상수 등에 접근할 때 사용합니다.

let color = Color::Red;
let s = String::from("hello");

Color 열거형의 Red variant, String 타입의 from 연관 함수에 접근합니다.

3. .

필드 접근하거나 메서드를 호출할 때 사용합니다.

let s = String::from("hi");
let len = s.len();  // 메서드 호출
let point = (3, 4);
let x = point.0;    // 튜플의 첫 번째 요소

s.len()은 s 객체의 len 메서드를, point.0은 튜플의 첫번째 값을 뜻합니다 .

4. ->

함수 또는 클로저의 반환 타입을 지정할 때 사용합니다.

fn add_one(x: i32) -> i32 {
    x + 1
}

이 함수는 매개변수 x를 받아 i32 타입으로 결과를 반환합니다.

5. :

변수의 타입을 명시하거나 패턴 매칭에서 사용됩니다.

let score: i32 = 100;

변수 score의 타입이 i32임을 명시합니다.

아래는 패턴 매칭에서 :이 사용된 예입니다.
Point { x, y: 0 }에서 y: 0은 y 필드가 정확히 0일 때 매칭됨을 의미합니다.

struct Point { x: i32, y: i32 }

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})"),
    }
}

6. ;

구문(문장)의 끝을 표시합니다.

let x = 5;
println!("{}", x);

7. ,

목록(튜플, 인수 등)을 구분할 때 사용합니다.

rustlet point = (3, 4);
fn add(x: i32, y: i32) -> i32 { x + y }

8. ..

범위를 표현할 때 사용합니다.

for i in 1..5 {
    println!("{}", i); // 1, 2, 3, 4 출력 (5는 포함X)
}

..는 시작값 이상, 끝값 미만의 범위를 의미하며, 끝값을 포함할 때는 ..=으로 사용합니다.

9. &

참조(Reference)를 의미합니다.

let x = 3;
let y = &x;

y는 x의 참조를 가집니다 (메모리 주소 공유).

10. *

역참조(Dereference)를 의미합니다.

let x = 5;
let y = &x;
println!("{}", *y); // y가 참조하는 실제 값(x) 출력

*y는 y가 가리키는 값을 가져옵니다.

11. @

의미: 패턴 매칭에서 값 바인딩

let v = Some(10);
if let id @ Some(x) = v {
    println!("id: {:?}", id);
}

id @ Some(x)는 Some(10) 전체를 id에 바인딩합니다.

Ⅱ. 연산자

1. 산술 연산자

연산자	설명	예시	결과 설명
+	덧셈	let a = 10 + 5;	a는 15
–	뺄셈	let b = 10 – 5;	b는 5
*	곱셈	let c = 10 * 5;	c는 50
/	나눗셈	let d = 10 / 2	d는 5
%	나머지	let e = 10 % 3	e는 1

2. 비교(관계) 연산자

연산자	설명	예시	결과
==	같다	a == b	true 또는 false
!=	같지 않다	a != b	true 또는 false
>	크다	a > b	true 또는 false
<	작다	a < b	true 또는 false
>=	크거나 같다	a >= b	true 또는 false
<=	작거나 같다	a <= b	true 또는 false

3. 논리 연산자

연산자	설명	예시	결과
&&	논리 AND	(a > 1 ) && (b < 5)	둘 다 true면 true
<code>\|\|</code>	논리 OR	`(a == 1)
!	논리 NOT	!is_valid	true->false, false->true

4. 비트 연산자

연산자	설명	예시	결과
&	비트 AND	a & b	각 비트 AND
<code>\|</code>	비트 OR	`a	b`
^	비트 XOR	a ^ b	각 비트 XOR
!	비트 NOT	!a	각 비트 반전
<<	왼쪽 시프트	a << 2	비트를 왼쪽 이동
>>	오른쪽 시프트	a >> 1	비트를 오른쪽 이동

5. 복합 할당 연산자

연산자	설명	예시
+=	더해서 할당	a +=1;
-=	빼서 할당	b -=2;
*=	곱해서 할당	c *= 3;
/=	나눠서 할당	d /= 2;
%=	나머지를 할당	e %= 4;

※ Rust는 ++와 –(증가/감소 연산자)를 지원하지 않습니다.

6. 기타 연산자

가. as: 타입 변환

let x: f32 = 10 as f32;

나. 단항 부정 연산자

-a : a의 음수
!a : a의 반전

Ⅲ. 패턴 매칭 관련 연산자 및 문법

match는 여러 패턴에 따라 코드를 분기할 수 있는 핵심 문법으로, C 계열의 switch보다 다양하고 강력한 매칭을 제공합니다 .

let value = Some(7);
match value {
    Some(x) if x > 5 => println!("greater than five: {}", x),
    Some(x) => println!("got: {}", x),
    None => println!("no value"),
}

1. | (or 패턴 연산자)

여러 패턴을 한 번에 처리할 수 있습니다.

let x = 1;
match x {
    1 | 2 => println!("one or two"),
    3 => println!("three"),
    _ => println!("other"),
}

이 예시에서 1 | 2는 x가 1 또는 2일 때 모두 해당 arm을 실행합니다.

2. _ (와일드카드/전부수용 패턴)

모든 값을 의미하며, 사용하지 않을 값을 무시할 때 씁니다.

match some_value {
    1 => println!("one"),
    _ => println!("other"),
}

3. @ (패턴 바인딩 연산자)

패턴과 동시에 값을 바인딩할 때 사용합니다.

let v = Some(42);
match v {
    id @ Some(n) if n > 40 => println!("big! {:?}", id),
    _ => println!("other"),
}

id @ Some(n)은 Some(42) 전체를 id에 바인딩하면서 n 값도 패턴 매칭합니다.

4. if let

특정 패턴만 처리하고 나머지는 무시하고 싶을 때 간결하게 쓸 수 있는 문법입니다 .

if let Some(x) = option {
    println!("have value: {}", x);
}

5. while let

while let은Rust에서 반복문과 패턴 매칭을 결합해, 어떤 값이 특정 패턴에 계속 일치하는 동안만 루프를 실행하는 구문입니다. 보통 Option, Result, Iterator 등에서 값을 꺼내거나 처리할 때 매우 자주 사용됩니다.

가. Stack처럼 값 꺼내기

let mut stack = vec![1, 2, 3];

while let Some(top) = stack.pop() {
    println!("스택에서 꺼냄: {}", top);
}

벡터에서 값을 꺼내는 동작이지만, 동시에 벡터를 스택(LIFO)처럼 쓰는 대표적인 패턴이라 “스택처럼 값 꺼내기”라고 표현한 것입니다.
stack.pop()이 벡터의 마지막 요소를 꺼내서(Some) 반환합니다. 벡터가 비어 있다면 None을 반환합니다. Vec은 동적 배열이지만, pop은 이를 스택처럼 사용하게 해 줍니다.
값이 없을 때 None이 반환되고 루프가 끝납니다 .

나. Option을 이용한 카운팅

let mut optional = Some(0);

while let Some(i) = optional {
    if i > 9 {
        println!("9보다 커서 종료!");
        optional = None;
    } else {
        println!("현재 값: {}", i);
        optional = Some(i + 1);
    }
}

optional이 Some(i)에 매칭되는 동안 루프 실행.

다. Result 타입, Iterator 등에도 활용

let mut results = vec![Ok(1), Err("Error"), Ok(2)];

while let Some(res) = results.pop() {
    match res {
        Ok(v) => println!("ok: {}", v),
        Err(e) => println!("err: {}", e),
    }
}

Result값을 반복적으로 처리하다가 벡터가 비면 자동 종료.

라. while let, if let, match 비교

구문	실용 상황	특징와 차이점
while let	값이 반복적으로 패턴에 매칭될 때	패턴 매칭이 실패하면 자동으로 루프 종료
if let	단일 조건만 한 번 검사할 때	한 번만 검사, 반복X
match	모든 경우의 수를 분기 처리할 때	모든 possibility처리, 반복X

Rust는 패턴 매칭을 통해 다양한 값 구조를 해체하고 조건에 따라 분기할 수 있도록 지원합니다. match, if let과 while let은 이를 위해 자주 사용하는 문법입니다.

1. 복습: match 표현식

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

enum은 Coin의 종류를 열거하고 있습니다.
match는 모든 경우를 명시해야 합니다. 위 경우 Coin의 종류 4개를 모두 다루고 있습니다.
컴파일러가 exhaustiveness(완전성 – 모든 경우를 다룸)을 검사합니다.
함수에서 coin을 인수로 받는데, type은 Coin 열거형이고, 반환 type은 u8로 0과 양수입니다.
열거형을 분기할 때 열거형의 이름에 variant(변형)을 ::으로 연결하며,
반환 값은 => 다음에 적고, 각각의 경우를 ,로 구분합니다.

위 코드를 실행하려면 main 함수가 아래와 같이 필요합니다.

fn main() {
    let coin1 = Coin::Penny;
    println!("{} 센트", value_in_cents(coin1));
}

Coin의 종류를 Coin:: 다음에 입력하면 value_in_cents 함수에 의해 해당하는 센트를 표시합니다.

{}가 값이 출력될 위치(placeholder)이고, 값은 value_in_cents(coin1)으로 구합니다.

2. 패턴 바인딩

enum Message {
    Hello { id: i32 },
}

fn main() {
    let msg = Message::Hello { id: 42 };

    match msg {
        Message::Hello { id: 1 } => println!("ID는 1"),
        Message::Hello { id } => println!("다른 ID: {}", id),
    }
}

Message 열거형은 Hello 구조체를 변형으로 갖으므로 id에 해당하는 정수를 값으로 받습니다.
let msg = Message::Hello { id: 42 };
: Message 열거형으로 Hello 구조체를 만드는데 id는 42입니다.
이 패턴은 Hello { id: i32 }에 매칭되며, id 값을 꺼내서 변수 id에 바인딩합니다.
따라서, 두번째 분기만 있어도 되는데, 1인 경우를 별도의 경우로 빼낸 것입니다.
다시 말해, 특정 값 비교와 변수 추출을 동시에 할 수 있습니다.

3. 와일드카드와 _, |, .., ..=

fn main() {
    let x = 7;

    match x {
        1 => println!("하나"),
        2 | 3 => println!("둘 또는 셋"),
        4..=6 => println!("4에서 6 사이"),
        _ => println!("기타"),
    }
}

|: 여러 패턴 매칭(or).
위 경우 2 | 3은 2또는 3인 경우가 됩니다.
..=6: 범위 매칭(=은 포함, 없으면 미만).
위 경우 4..=6은 4이상 6이하가 되며, 4..6은 4이상 6미만이므로 4와 5만 해당됩니다.
_: 나머지 모든 경우 (wildcard, else)
x의 데이터 형식은 정수이므로 i32가 돼서 부호있는 32비트 정수이므로 -2^31 (약 -21억)부터 2^31 – 1 (약 21억)까지의 값을 표현 가능
위 코드를 실행하면 x가 7이므로 _에 해당되어 “기타”가 출력됩니다.

4. if let 표현식

match가 너무 장황할 때 if let을 사용해 간단히 표현할 수 있습니다.

let some_value = Some(5);

if let Some(x) = some_value {
    println!("값은 {}", x);
} else {
    println!("값이 없습니다");
}

Some은 Option enum의 variant중 하나로서, if let을 이용해서 match의 단일 분기를 간단히 표현한 것이며,
match 연산자를 이용하면 아래와 같이 해야 됩니다.

    match some_value {
        Some(x) => println!("값은 {}", x),
        None => println!("값이 없습니다"),
    }

if let Some(x) = some_value는 “x가 5라면”이 되므로, “값은 5″가 출력됩니다.
match 연산자의 경우는 None을 사용하는데, if 제어문이라 else를 사용했는데 없어도 됩니다.

5. while let 반복문

let mut stack = vec![1, 2, 3];

while let Some(top) = stack.pop() {
    println!("꺼낸 값: {}", top);
}

vec은 아직 설명하지 않았는데, array가 크기가 고정되어 있다면 vec은 가변 길이의 배열입니다.
while let을 이용하면 값이 존재하는 동안 반복합니다.
Option, Result와 같이 반복 가능한 열거형에 유용
위 코드를 main 함수에 넣고 실행하면 아래와 같이 출력됩니다.

🧠 요약

문법	설명
match	여러 경우를 완전하게 분기
바인딩	패턴 내부에서 변수에 값 대입 가능
_	기타 모든 경우 처리
if let	한 가지 매칭에 적합한 축약형
while let	값이 남아 있는 동안 반복

[태그:] while let

Rust에서 사용하는 기호와 연산자