Warning 작성중인 글입니다. 내용에 수정이 있을 수 있습니다.

Rust 문법 정리

왜 Rust를 쓰는가

Rust만의 독특한 특징들이 있다.

• 컴파일 타임 메모리 안전
• 정의되지 않은 동작 없음
• 현대 언어 기능

컴파일 타임에 보장되는 것들

• 초기화 되지 않은 변수가 없음
• 메모리 누수가 거의 없음 [1]
• 더블 프리가 없음 [2]
• Use After Free가 없음 [3]
• null 포인터가 없음
• 잊힌 잠긴 Mutex가 없음
• 쓰레드간 데이터 레이스가 없음 [4]
• 반복자 무효화가 없음 [5]

[1] 안전한 러스트에서 메모리 누수를 일으키는 것은 기술적으로 가능함. Box::leak 메소드를 사용하면, 소멸자를 실행하지 않고 원시 참조를 가져오고, 이후에 이를 삭제할 수 있음. 안전한 러스트에서 누수를 만드는 많은 다른 방법들이 있지만, "메모리 누수 없음" 은 "우발적인 메모리 누수가 거의 없음" 으로 이해해야함.
[2] 메모리를 두번 해제하는 것
[3] 메모리 free한 뒤에 사용하는 것
[4] 멀티 쓰레드를 사용하는 환경에서 같은 데이터를 이용하고 다른 쓰레드에서 그것을 업데이트하면 생기는 일
[5] https://www.geeksforgeeks.org/iterator-invalidation-cpp/ 참고

런타임에 보장되는 것들

예상치 못한 동작이 일어나지 않음

• 배열 접근은 범위를 확인함
• 정수 오버플로우가 정의됨

러스트에 녹아든 최신 기능

언어 기능

• 열거형 및 패턴 매칭
• 제네릭
• 오버헤드 FFI가 없음

도구

• 자세한 컴파일 에러
• 내장 종속성 관리자
• 테스팅 내장 지원

Types

Scalar Types

	Types	Literals
Signed integers	i8, i16, i32, i64, i128, isize	-10, 0, 1_000, 123i64
Unsigned integers	u8, u16, u32, u64, u128, usize	0, 123, 10u16
Floating point numbers	f32, f64	3.14, -10.0e20, 2f32
Strings	&str	"foo", r#"\\"#
Unicode scalar values	char	'a', 'α', '∞'
Byte strings	&[u8]	b"abc, br#" " " "#
Booleans	bool	true, false

타입들의 너비는 다음과 같음:

• iN, uN, 및 fN은 N-bit width임
• isize와 usize는 포인터의 크기임
• char은 32bit 너비
• bool은 8비트 너비

Compound Types

	Types	Literals
Arrays	[T; N]	[20, 30, 40], [0; 3]
Tuples	(T1, T2, T3, ...)	('x', 1.2, 0)

배열 선언 및 접근

fn main() {
    let mut a: [i8; 10] = [42; 10];
    a[5] = 0;
    println!("a: {:?}", a);
}

튜플 선언 및 접근

fn main() {
    let t: (i8, bool) = (7, true);
    println!("1st index: {}", t.0);
    println!("2nd index: {}", t.1);
}

Reference

C++과 같이, Rust에는 참조가 있음.

fn main() {
    let mut x: i32 = 10;
    let ref_x: &mut i32 = &mut x;
    *ref_x = 20;
    println!("x: {x}");
}

C++과의 차이점

• C 포인터와 비슷하게 ref_x를 할당할때 역참조해야함.
• Rust는 몇몇 경우에 자동으로 역참조를 함.

Dangling Reference

Rust는 허상 참조를[6] 정적으로 금지함.

fn main() {
    let ref_x: &i32;
    {
        let x: i32 = 10;
        ref_x = &x;
    }
    println!("ref_x: {ref_x}");
}

Compiling playground v0.0.1 (/playground)  
error[E0597]: `x` does not live long enough  
--> src/main.rs:5:17  
|  
5 | ref_x = &x;  
| ^^ borrowed value does not live long enough  
6 | }  
| - `x` dropped here while still borrowed  
7 | println!("ref_x: {ref_x}");  
| ----- borrow later used here  
  
For more information about this error, try `rustc --explain E0597`.  
error: could not compile `playground` due to previous error

• 참조는 참조하는 값을 "차용"[7]한다고 함
• Rust는 모든 참조의 수명을 추적하여 수명이 충분히 긴지 확인함

[6] 포인터가 여전히 해제된 영역을 가리키고 있는 것
[7] 빌려온다

Slice

슬라이스는 더 큰 Collection 안을 볼 수 있게 해준다.

fn main() {
    let a: [i32; 6] = [10, 20, 30, 40, 50, 60];
    println!("a: {a:?}");

    let s: &[i32] = &a[2..4];
    println!("s: {s:?}");
}

슬라이스는 슬라이스된 타입에서 데이터를 차용해온다. 그렇다면 a[3]를 변경하면 어떻게 될까? s가 바뀔까? 답은 바꿀 수 없다. 일단, 배열 a는 불변이다. 그렇다면 let mut a: [i32; 6]으로 선언하면 가능할까? 배열 s는 현재 a의 값을 차용하고 있다. 우리는 다른 변수나 함수가 빌려간 값에는 값을 할당할 수 없다.

   Compiling playground v0.0.1 (/playground)
error[E0506]: cannot assign to `a[_]` because it is borrowed
 --> src/main.rs:6:5
  |
5 |     let s: &[i32] = &a[2..4];
  |                      - borrow of `a[_]` occurs here
6 |     a[3] = 90;
  |     ^^^^^^^^^ assignment to borrowed `a[_]` occurs here
7 |     println!("s: {s:?}");
  |                   - borrow later used here

For more information about this error, try `rustc --explain E0506`.
error: could not compile `playground` due to previous error

String vs str

러스트에는 두가지 문자열 타입이 있다: &str, String

fn main() {
    let s1: &str = "Hello";
    println!("s1: {s1}");

    let mut s2: String = String::from("Hello ");
    println!("s2: {s2}");
    s2.push_str(s1);
    println!("s2: {s2}");
}

/*
s1: Hello
s2: Hello 
s2: Hello Hello
*/

• &str은 문자열 슬라이스에 대한 불변한 참조이다.
• String은 가변 문자열 버퍼이다.

Function

다음은 Fizz Buzz라는 게임의 러스트 코드이다.

fn main() {
    fizzbuzz_to(20);   // Defined below, no forward declaration needed
}

fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
    if rhs == 0 {
        return false;  // Corner case, early return
    }
    lhs % rhs == 0     // The last expression is the return value
}

fn fizzbuzz(n: u32) -> () {  // No return value means returning the unit type `()`
    match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {
        (true,  true)  => println!("fizzbuzz"),
        (true,  false) => println!("fizz"),
        (false, true)  => println!("buzz"),
        (false, false) => println!("{n}"),
    }
}

fn fizzbuzz_to(n: u32) {  // `-> ()` is normally omitted
    for n in 1..=n {
        fizzbuzz(n);
    }
}

• 반환값이 없는 함수는 ()를 반환한다.
• -> ()는 쓰지 않아도 된다.
• 러스트에서 마지막 표현식은 반환값이다.
• 함수는 사용하는 위치보다 위에 선언하지 않아도 된다.

Method

러스트에는 메서드가 있다. 그들은 특정 타입과 관련된 단순한 함수이다. 메서드의 첫 번째 인수는 메서드와 관련된 타입의 인스턴스이다.

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

    fn inc_width(&mut self, delta: u32) {
        self.width += delta;
    }
}

fn main() {
    let mut rect = Rectangle { width: 10, height: 5 };
    println!("old area: {}", rect.area());
    rect.inc_width(5);
    println!("new area: {}", rect.area());
}

Function Overloading

Rust는 오버로딩을 지원하지 않는다.

• 각각의 함수는 하나의 구현을 가진다:
  • 항상 고정된 수의 매개 변수를 가진다.
  • 항상 단일 매개변수 타입 세트를 사용한다.
• Default Value는 지원되지 않는다.
  • 모든 호출부에는 동일한 수의 인수가 있다.
  • 매크로는 때때로 대안으로 사용된다.

하지만, 함수의 매개변수는 제네릭일 수 있다.

fn pick_one<T>(a: T, b: T) -> T {
    if std::process::id() % 2 == 0 { a } else { b }
}

fn main() {
    println!("coin toss: {}", pick_one("heads", "tails"));
    println!("cash prize: {}", pick_one(500, 1000));
}

Implicit Conversions

Rust는 타입간 암시적 변환을 자동으로 적용하지 않는다. 그렇기에 다음과 같은 프로그램은 작동하지 않는다.

fn multiply(x: i16, y: i16) -> i16 {
    x * y
}

fn main() {
    let x: i8 = 15;
    let y: i16 = 1000;

    println!("{x} * {y} = {}", multiply(x, y)); // error
}

Rust의 정수 타입들은 모두 From<T>와 Into<T> trait을 구현하여 우리가 그들간에 변환을 할 수 있게 도운다. From<T> trait은 from() 메서드를 갖고 있고, 이와 비슷하게 Into<T> trait은 into() 메서드를 가지고 있다. 이러한 trait들을 구현하는 것은 어떻게 타입들이 그들이 다른 타입들로 변환될 수 있는지 보여준다.

표준 라이브러리에는 From<i8> for i16에 대한 구현이 있다. 이는 i8 타입을 가진 변수 x를 i16::from(x)를 호출함으로서 변수 x를 i16으로 변환할 수 있음을 의미한다. 아니면, 간단하게 x.into()를 사용할 수 있다. 왜냐하면 From<i8> for i16 구현이 자동적으로 Into<i16> for i8 구현을 만들기 때문이다.

이제 위의 코드를 제대로 동작하게 만들어보자.

fn multiply(x: i16, y: i16) -> i16 {
    x * y
}

fn main() {
    let x: i8 = 15;
    let y: i16 = 1000;

    println!("{x} * {y} = {}", multiply(x.into(), y));
}

만약 변환을 원하는 타입이 변환이 지원되는지 확인하려면, 표준 라이브러리 문서에서 From<T>가 구현되어 있는지를 확인하면 된다.

Arrays and for Loops

우리는 배열이 다음과 같이 선언된다는것을 배웠다.

let array = [10, 20, 30];

우리는 위와 같은 배열을 {:?} 디버그 표현을 이용하여 출력할 수 있다.

fn main() {
    let array = [10, 20, 30];
    println!("array: {array:?}"); // array: [10, 20, 30]
}

Rust는 우리가 for 키워드를 이용해 배열이나 범위와 같은 것들을 순회할 수 있게 해준다.

fn main() {
    let array = [10, 20, 30];
    print!("Iterating over array:");
    for n in array {
        print!(" {n}");
    }
    println!();

    print!("Iterating over range:");
    for i in 0..3 {
        print!(" {}", array[i]);
    }
    println!();
}

그렇다면 배열을 예쁘게 출력하는 함수 pretty_print를 만들고 이를 이용해서 matrix를 transpose하는 함수를 작성해보자! (row에서 column으로)

fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
    let mut new_matrix: [[i32;3];3] = [[0;3];3];
    for i in 0..3 {
        for x in 0..3 {
            new_matrix[i][x] = matrix[x][i];
        }
    }
    return new_matrix;
}

fn pretty_print(matrix: &[[i32; 3]; 3]) {
    for i in 0..3 {
        println!("{:?}", matrix[i]);
    }
}

fn main() {
    let matrix = [
        [101, 102, 103], // <-- the comment makes rustfmt add a newline
        [201, 202, 203],
        [301, 302, 303],
    ];

    println!("matrix:");
    pretty_print(&matrix);

    let transposed = transpose(matrix);
    println!("transposed:");
    pretty_print(&transposed);
}

Variables

Rust는 Type Safety를 정적 타이핑을 통해 제공한다. 변수는 기본적으로 불변으로 선언된다.

fn main() {
    let x: i32 = 10;
    println!("x: {x}");
    // x = 20; (error)
    // println!("x: {x}");
}

Type Inference

러스트는 변수의 타입을 추론한다.

fn takes_u32(x: u32) {
    println!("u32: {x}");
}

fn takes_i8(y: i8) {
    println!("i8: {y}");
}

fn main() {
    let x = 10;
    let y = 20;

    takes_u32(x);
    takes_i8(y);
    // takes_u32(y);
}

러스트 컴파일러가 변수의 타입을 추론하는 법
아래 코드는 _를 placeholder로 사용하여 포함된 타입을 명시적으로 지정하는 코드 없이 특정 일반 컨테이너에 복사하도록 컴파일러에게 지시한다.

fn main() {
    let mut v = Vec::new();
    v.push((10, false));
    v.push((20, true));
    println!("v: {v:?}");

    let vv = v.iter().collect::<std::collections::HashSet<_>>();
    println!("vv: {vv:?}");
 }

collect는 HashSet이 구현하는 FromIterator에 의존한다.

Static and Constant Variables

전역 상태는 정적 및 상수 변수들에 의해 관리된다.

const

const 키워드를 통해 컴파일 타임 상수를 선언할 수 있다.

const DIGEST_SIZE: usize = 3;
const ZERO: Option<u8> = Some(42);

fn compute_digest(text: &str) -> [u8; DIGEST_SIZE] {
   let mut digest = [ZERO.unwrap_or(0); DIGEST_SIZE];
   for (idx, &b) in text.as_bytes().iter().enumerate() {
       digest[idx % DIGEST_SIZE] = digest[idx % DIGEST_SIZE].wrapping_add(b);
   }
   digest
}

fn main() {
   let digest = compute_digest("Hello");
   println!("Digest: {digest:?}");
}

Rust RFC Book에 따르면 이들은 사용시 인라인된다.

static

static 키워드를 통해 정적 변수를 선언할 수 있다.

static BANNER: &str = "Welcome to RustOS 3.14";

fn main() {
    println!("{BANNER}");
}

Rust RFC Book의 노트에 따르면, 이들은 사용시 인라인 되지 않고 실제 연결된 메모리 위치를 가진다. 이는 안전하지 않은 임베디드 코드에 유용하며 static한 수명이 있다.

• const는 의미론적으로 C++의 constexpr와 비슷하다.
• 반면에 static은 C++의 const나 가변 전역 변수들과 더 비슷하다.
• 런타임 평가 상수가 필요한 경우가 흔하지는 않지만 정적을 사용하는 것보다 유용하고 안전하다.

Scopes and Shadowing

바깥 스코프에 있는 변수가 같은 스코프에 있는 변수를 쉐도잉 할 수 있다.

fn main() {
    let a = 10;
    println!("before: {a}");

    {
        let a = "hello";
        println!("inner scope: {a}");

        let a = true;
        println!("shadowed in inner scope: {a}");
    }

    println!("after: {a}");
}

• 쉐도잉은 모호해보이지만, .unwrap() 뒤에 값을 유지하는데 편리하다.
• 다음 코드는 타입이 변경되지 않는 경우에도 스코프에서 불변 변수를 숨길 때 컴파일러가 단순히 메모리 위치를 재사용할 수 없는 이유를 보여준다.

fn main() {
    let a = 1;
    let b = &a;
    let a = a + 1;
    println!("{a} {b}");
}

Memory Management

전통적으로, 언어들은 두개의 큰 범주로 나뉜다.

• 수동 메모리 관리를 통한 전체 제어: C, C++, Pascal, ...
• 런타임시 자동 메모리 관리를 통한 완벽한 안전성: Java, Python, Go, Haskel, ...

Rust는 다음과 같은 새로운 조합을 제공한다.

올바른 메모리 관리의 컴파일 시간 적용을 통한 완벽한 제어 및 안전성

명시적인 소유권 개념을 사용하여 이를 수행한다.
먼저 메모리 관리가 작동하는 방식을 다시 살펴보자.

The Stack vs The Heap

• 스택: 지역 변수를 위한 연속적인 메모리 영역

  • 값은 컴파일 타임에 알려진 고정 크기를 가짐
  • 매우 빠름: 스택 포인터를 이동하기만 하면 됨
  • 관리하기 쉬움: 함수 호출을 따른다
  • 훌륭한 메모리 지역성

• 힙: 함수 호출 외부의 값 저장

  • 값에는 런타임 시 결정되는 동적 크기가 있음
  • 스택보다 약간 느림. 약간의 부기(book-keeping)이 필요함
  • 메모리 지역성을 보장하지 않음

Stack Memory

String을 생성하는 것은 고정된 크기의 데이터를 stack에 넣고 다이나믹한 크기의 데이터를 heap에 넣는다.

fn main() {
    let s1 = String::from("Hello");
}

 Stack                             Heap
.- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - -.
:                           :     :                               :
:    s1                     :     :                               :
:   +-----------+-------+   :     :   +----+----+----+----+----+  :
:   | ptr       |   o---+---+-----+-->| H  | e  | l  | l  | o  |  :
:   | len       |     5 |   :     :   +----+----+----+----+----+  :
:   | capacity  |     5 |   :     :                               :
:   +-----------+-------+   :     :                               :
:                           :     `- - - - - - - - - - - - - - - -'
`- - - - - - - - - - - - - -' 

• String은 Vec에 의해서 지원되므로, 용량과 길이가 있으며 힙의 재할당을 통해 변경 가능한 경우 커질 수 있다.

Manual Memory Management

Heap 메모리를 직접 할당 및 할당 해제 할 수 있다.
주의해서 수행하지 않으면 충돌, 버그, 보안 취약성 및 메모리 누수가 발생할 수 있다.

C Example

malloc으로 할당한 모든 포인터를 free해줘야 한다.

void foo(size_t n) {
    int* int_array = (int*)malloc(n * sizeof(int));
    //
    // ... lots of code
    //
    free(int_array);
}

함수가 malloc과 free 사이에 일찍 반환될 경우, 포인터가 유실되며, 메모리를 해제할 수 없기 때문에 메모리 누수가 발생된다.

Ownership

모든 변수 바인딩에는 유효한 범위가 있으며 해당 범위 밖에서 변수를 사용하면 오류가 난다.

struct Point(i32, i32);

fn main() {
    {
        let p = Point(3, 4);
        println!("x: {}", p.0);
    }
    println!("y: {}", p.1);
}

Rust에서는 변수가 값을 소유한다고 말한다. 모든 Rust 값에는 항상 정확히 하나의 소유자가 있다.

스코프가 끝나면 변수는 삭제되고 데이터는 해제된다. 여기서 소멸자(destructor)를 실행하여 리소스를 확보할 수 있다.

Assignment

할당은 변수간의 소유권 이전을 말한다.

fn main() {
    let s1: String = String::from("Hello!");
    let s2: String = s1;
    println!("s2: {s2}");
    // println!("s1: {s1}");
}

• s1 변수에서 s2 변수로의 할당은 소유권을 이전안다.
• s1이 스코프 밖으로 나갈때, 아무것도 일어나지 않는다. (아무것도 소유하고 있지 않음)
• s2가 스코프 밖으로 나갈때, 문자열 데이터는 해제된다.

함수에 값을 전달할때, 그 값은 함수의 매개변수에 할당된다. 이것은 소유권을 이전한다.

Clone

무언가를 복사하고 싶을때, Clone trait를 이용하면 된다.

#[derive(Default)]
struct Backends {
    hostnames: Vec<String>,
    weights: Vec<f64>,
}

impl Backends {
    fn set_hostnames(&mut self, hostnames: &Vec<String>) {
        self.hostnames = hostnames.clone();
        self.weights = hostnames.iter().map(|_| 1.0).collect();
    }
}

Copy Types

변수 할당시 소유권 이전이 기본이지만, 몇몇 타입들은 기본적으로 복제된다.

fn main() {
    let x = 42;
    let y = x;
    println!("x: {x}"); // would not be accessible if not Copy
    println!("y: {y}");
}

이러한 타입들은 Copy trait을 구현한다.

#[derive(Copy, Clone, Debug)]
struct Point(i32, i32);

fn main() {
    let p1 = Point(3, 4);
    let p2 = p1;
    println!("p1: {p1:?}");
    println!("p2: {p2:?}");
}

• 할당 후에, p1과 p2 모두 자신의 데이터를 소유하고 있다.
• p1.clone()을 통해 명시적으로 데이터를 복제할 수 있다.

The Drop Trait

Drop trait를 구현하는 값들은 스코프 밖으로 나갔을 때 실행할 코드를 정할 수 있다.

struct Droppable {
    name: &'static str,
}

impl Drop for Droppable {
    fn drop(&mut self) {
        println!("Dropping {}", self.name);
    }
}

fn main() {
    let a = Droppable { name: "a" };
    {
        let b = Droppable { name: "b" };
        {
            let c = Droppable { name: "c" };
            let d = Droppable { name: "d" };
            println!("Exiting block B");
        }
        println!("Exiting block A");
    }
    drop(a);
    println!("Exiting main");
}

Smart Pointers

Box<T>

Box는 힙의 데이터에 대한 소유 포인터이다.

fn main() {
    let five = Box::new(5);
    println!("five: {}", *five);
}

Box<T>는 Deref<Target = T>를 구현한다. 이는 즉 Box<T>에서 T의 메서드를 직접 호출할 수 있다는 뜻이다.

재귀 유형, 혹은 동적 크기의 메이터 유형을 Box를 사용해야한다.

#[derive(Debug)]
enum List<T> {
    /// A non-empty list: first element and the rest of the list.
    Element(T, Box<List<T>>),
    /// An empty list.
    Nil,
}

fn main() {
    let list: List<i32> =
        List::Element(1, Box::new(List::Element(2, Box::new(List::Nil))));
    println!("{list:?}");
}

Rc

Rc는 참조 계산된 공유 포인터이다.
여러 위치에서 동일한 데이터를 참조해야 할 때 이 방법을 사용하면 된다.

use std::rc::Rc;

fn main() {
    let a = Rc::new(10);
    let b = Rc::clone(&a);

    println!("a: {a}");
    println!("b: {b}");
}

• 다중 스레드 컨텍스트에 있다면 Arc와 Mutex를 보면 된다.
• 공유 포인터를 Weak 포인터로 다운그레이드하여 삭제되는 주기를 만들 수 있다.

Trait Objects

Trait ojects는 예를 들어 컬렉션에서 다양한 유형의 값을 허용한다.

struct Dog {
    name: String,
    age: i8,
}
struct Cat {
    lives: i8,
}

trait Pet {
    fn talk(&self) -> String;
}

impl Pet for Dog {
    fn talk(&self) -> String {
        format!("Woof, my name is {}!", self.name)
    }
}

impl Pet for Cat {
    fn talk(&self) -> String {
        String::from("Miau!")
    }
}

fn main() {
    let pets: Vec<Box<dyn Pet>> = vec![
        Box::new(Cat { lives: 9 }),
        Box::new(Dog { name: String::from("Fido"), age: 5 }),
    ];
    for pet in pets {
        println!("Hello, who are you? {}", pet.talk());
    }
}

References

Google, Comprehensive Rust: https://google.github.io/comprehensive-rust/