기호 - 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에서 사용하는 기호와 연산자