Welcome to Comprehensive Rust 🦀

현재 구글 사이트에 번역 통합 작업 중으로 현재 버전은 archived 되었습니다.(23-01-10)

더이상 업데이트는 되지 않고 최종 반영 되면 사라질 예정입니다.

자세한 사항은 원문을 참조 하세요

이것은 안드로이드 팀에 의해 개발된 4일간의 러스트 강좌입니다. 기본 문법부터 제너릭, 에러 핸들링과 같은 고급주제까지 러스트의 모든 것을 포함합니다. 마지막 날에는 안드로이드에 대한 것 까지 다룹니다.

This is a four day Rust course developed by the Android team. The course covers the full spectrum of Rust, from basic syntax to advanced topics like generics and error handling. It also includes Android-specific content on the last day.

강의는 당신이 러스트에 대해서 아무것도 모른다고 가정하고 아래의 목표를 가지고 있습니다.

• 러스트 구문과 언어에 대한 포괄적인 이해를 제공합니다.
• 기존 프로그램을 수정하고 러스트에서 새 프로그램을 작성할 수 있습니다.
• 일반적인 러스트 관용구를 보여줍니다.

The goal of the course is to teach you Rust. We assume you don’t know anything about Rust and hope to:

• Give you a comprehensive understanding of the Rust syntax and language.
• Enable you to modify existing programs and write new programs in Rust.
• Show you common Rust idioms.

4일차 강의에 우리는 아래와 같은 안드로이드 특유의 것들도 설명합니다.

• 러스트에서 Android 구성 요소를 구축.
• AIDL 서버 및 클라이언트.
• C, C++ 및 Java와의 상호 운용성.

On Day 4, we will cover Android-specific things such as:

• Building Android components in Rust.
• AIDL servers and clients.
• Interoperability with C, C++, and Java.

이 과정은 러스트로 안드로이드 어플리케이션을 개발하는 것은 다루는 것이 아니라, 안드로이드 OS에서의 러스트 코드 작성을 다룹니다.

It is important to note that this course does not cover Android application development in Rust, and that the Android-specific parts are specifically about writing code for Android itself, the operating system.

Non-Goals

러스트는 몇일만에 모든 것을 다루기에는 너무 큰 언어입니다. 그래서 아래와 같은것을 목표로 하지 않습니다.

Rust is a large language and we won’t be able to cover all of it in a few days. Some non-goals of this course are:

• 비동기적 러스트 사용법 — 간단하게 언급정도는 하겠지만 좀 더 자세한 내용은 Asynchronous Programming in Rust를 참조해주세요

• Learn how to use async Rust — we’ll only mention about async Rust when covering traditional concurrency primitives. Please see Asynchronous Programming in Rust instead for details on this topic.

• 매크로를 개발하는 방법. Chapter 19.5 in the Rust Book와 Rust by Example를 참조하세요

• Learn how to develop macros, please see Chapter 19.5 in the Rust Book and Rust by Example instead.

Assumptions

본 강좌는 당신이 프로그래밍 자체에 대해서는 알고 있다고 가정합니다. 러스트는 정적타입 언어이며, 강좌에서는 C와 C++과 비교, 대조를 통해 러스트를 설명할 것입니다.

The course assumes that you already know how to program. Rust is a statically typed language and we will sometimes make comparisons with C and C++ to better explain or contrast the Rust approach.

만일 당신이 동적 타입 언어(Python이나 JavaScript)로 프로그래밍 하는 방법을 알고 있다면 잘 따라올 수 있을 것입니다.

If you know how to program in a dynamically typed language such as Python or JavaScript, then you will be able to follow along just fine too.

Using Cargo

러스트를 시작하려고하면 당신은 곧 Cargo라는 러스트 생태계에서 사용하는 표준 빌드/실행 도구를 만날 것 입니다. 여기서는 카고가 무엇인지, 그리고 카고가 더 넓은 생태계에 어떻게 적합한지, 그리고 이 교육에 어떻게 적합한지에 대한 간략한 개요를 제공하고자 합니다.

When you start reading about Rust, you will soon meet Cargo, the standard tool used in the Rust ecosystem to build and run Rust applications. Here we want to give a brief overview of what Cargo is and how it fits into the wider ecosystem and how it fits into this training.

Debian이나 Ubuntu에서 cargo와 rust-src를 아래 커맨드로 설치합니다.

On Debian/Ubuntu, you can install Cargo and the Rust source with

$ sudo apt install cargo rust-src

VS Code에서 작업하는 걸 추천 드립니다. rust-analyzer 확장을 통해 정의 이동 등 개발에 도움 받을 수 있습니다.(또는 다른 IDE나 편집기를 사용해도 무방합니다.)

This will allow rust-analyzer to jump to the definitions. We suggest using VS Code to edit the code (but any LSP compatible editor works)

참고로, 만약 가능하다면 rustup과 같은 러스트 생태계 툴을 통한 설치를 추천드립니다.

As a sidenote: if you have the access/capability to do so, it’s recommended to install Rust’s tooling via rustup since it’s better integrated with the rest of the ecosystem.

The Rust Ecosystem

러스트의 생태계는 여러가지 도구들로 구성되어 있으며, 그 중 중요한 것들은 아래와 같습니다.

The Rust ecosystem consists of a number of tools, of which the main ones are:

• rustc: .rs확장자 파일을 바이너리 혹은 다른 중간자 형식으로 변환해주는 Rust 컴파일러입니다.

• rustc: the Rust compiler which turns .rs files into binaries and other intermediate formats.

• cargo: 러스트 종속성 관리자 및 빌드도구 입니다. https://crates.io에서 호스팅되는 여러 종속성을 다운로드하고 rustc가 당신의 프로젝트를 빌드할 때 이를 전달합니다. 또한 유닛 테스트를 실행하는 테스트 툴을 내장하고 있습니다.

• cargo: the Rust dependency manager and build tool. Cargo knows how to download dependencies hosted on https://crates.io and it will pass them to rustc when building your project. Cargo also comes with a built-in test runner which is used to execute unit tests.

• rustup: 러스트 툴체인 설치 프로그램 및 업데이트 프로그램. 이 도구는 새 버전의 러스트가 출시될 때 rustc 및 cargo 설치하고 업데이트하는 데 사용됩니다. 또한 rustup은 표준 라이브러리에 대한 문서를 다운로드할 수도 있습니다. 한 번에 여러 버전의 러스트를 설치할 수 있으며 rustup을 통해 필요에 따라 이들 버전을 전환할 수 있습니다

• rustup: the Rust toolchain installer and updater. This tool is used to install and update rustc and cargo when new versions of Rust is released. In addition, rustup can also download documentation for the standard library. You can have multiple versions of Rust installed at once and rustup will let you switch between them as needed.

Code Samples in This Training

이 교육을 위해 우리는 당신의 브라우저에서 실행될 수 있는 예제를 제공할 것입니다. 이렇게 하면 설치가 훨씬 쉬워지고 모든 사용자가 일관된 환경을 사용할 수 있게됩니다.

For this training, we will mostly explore the Rust language through examples which can be executed through your browser. This makes the setup much easier and ensures a consistent experience for everyone.

카고(cargo)를 설치하는 것은 여전히 좋습니다. 이 것은 당신의 연습을 더 쉽게 만들어 줍니다. 마지막 날 강의에서 당신이 Cargo를 필요로 하는 의존성을 가지고 작업하는 경험을 할 것입니다.

Installing Cargo is still encouraged: it will make it easier for you to do the exercises. On the last day, we will do a larger exercise which shows you how to work with dependencies and for that you need Cargo.

이 과정의 코드 블록들은 전부 대화형으로 구성되 있습니다.

The code blocks in this course are fully interactive:

fn main() {
    println!("Edit me!");
}

코드 블록에 포커스를 두고 Ctrl-Enter를 눌러 실행해 볼 수 있습니다.

You can use Ctrl-Enter to execute the code when focus is in the text box.

역주:

• 저런 블록들은 과정 사이트에서 실행됩니다.
• 소스단(md)에선 실행안됩니다(..)

Running Code Locally with Cargo

만약 당신이 로컬 시스템에서 코드를 실행해보려면 먼저 러스트를 설치해야 합니다. Rust Book의 지침에 따라 rustc와 cargo를 함께 설치 하세요 설치 후 아래 커맨드를 통해 각 생태계 툴의 버전을 확인 할 수 있습니다.

If you want to experiment with the code on your own system, then you will need to first install Rust. Do this by following the instructions in the Rust Book. This should give you a working rustc and cargo. At the time of writing, the latest stable Rust release has these version numbers:

% rustc --version
rustc 1.61.0 (fe5b13d68 2022-05-18)
% cargo --version
cargo 1.61.0 (a028ae4 2022-04-29)

정상적으로 설치가 되었으면 강의의 코드 블록중 하나를 아래 단계를 따라 로컬에서 실행할 수 있습니다.

With this is in place, then follow these steps to build a Rust binary from one of the examples in this training:

1. 예시 블록에 있는 “Copy to clipboard“버튼을 클릭해서 복사합니다.

1. Click the “Copy to clipboard” button on the example you want to copy.

2. shell에서 cargo new exercise를 입력해서 새로운 exercise/ 폴더를 만듭니다.

2. Use cargo new exercise to create a new exercise/ directory for your code:

    $ cargo new exercise
         Created binary (application) `exercise` package

3. exercise/ 폴더로 이동한 후, cargo run 커맨드로 코드를 실행합니다.

3. Navigate into exercise/ and use cargo run to build and run your binary:

    $ cd exercise
    $ cargo run
       Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)
        Finished dev [unoptimized + debuginfo] target(s) in 0.75s
         Running `target/debug/exercise`
    Hello, world!

4. 보일러플레이트 코드는 src/main.rs에 작성합니다. 예를 들어 이전 페이지의 소스를 아래와 같이 src/main.rs에 작성합니다.

4. Replace the boiler-plate code in src/main.rs with your own code. For example, using the example on the previous page, make src/main.rs look like

    fn main() {
        println!("Edit me!");
    }

5. cargo run커맨드로 소스를 빌드하고 실행합니다.

5. Use cargo run to build and run your updated binary:

    $ cargo run
       Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)
        Finished dev [unoptimized + debuginfo] target(s) in 0.24s
         Running `target/debug/exercise`
    Edit me!

6. cargo check커맨드는 빠르게 당신의 프로젝트에서 에러를 확인할 수 있습니다.
   • cargo build는 실행없이 소스를 컴파일 합니다. 이 경우에 target/debug/폴더에서 output을 확인 할 수 있습니다.
   • cargo build --release커맨드는 릴리즈 버전의 최적화된 output으로 컴파일하며 target/release/폴더에서 확인 할 수 있습니다.

6. Use cargo check to quickly check your project for errors, use cargo build to compile it without running it. You will find the output in target/debug/ for a normal debug build. Use cargo build --release to produce an optimized release build in target/release/.

7. Cargo.toml파일에는 당신의 프로젝트에 사용하는 의존성 패키지를 추가할 수 있습니다.
   • cargo커맨드를 실행하면 자동으로 프로젝트의 의존성 패키지를 다운로드, 컴파일 해줍니다.

7. You can add dependencies for your project by editing Cargo.toml. When you run cargo commands, it will automatically download and compile missing dependencies for you.

역주:

• (혹시몰라 기록하자면)학습용 폴더를 하나 만들고 거기서 지시사항을 실행합니다.

Course Structure

강의는 빠른 속도로 진행되면 다음 3,4일동안 많은 범위의 부분을 다룹니다.

The course is fast paced and we will cover a lot of ground over the next 3–4 days:

• 1일차: 러스트 기본, 소유권(ownership)과 빌림(borrow) 체크.
• 2일차: 복합 데이터 유형, 패턴 매칭, 표준 라이브러리
• 3일차: 트레잇(traits)과 제너릭(generics), 에러 핸들링(오류 처리), 테스트, 안전하지 않은 러스트.
• 4일차: 러스트의 동시성 및 다른 언어와의 상호 운용성

• Day 1: Basic Rust, ownership and the borrow checker.
• Day 2: Compound data types, pattern matching, the standard library.
• Day 3: Traits and generics, error handling, testing, unsafe Rust.
• Day 4: Concurrency in Rust and interoperability with other languages

4일차의 연습: 러스트 프로젝트에서 C/C++로 작성된 코드를 이전해서 연결하려고 한다면 종속성이 적을 수록 좋습니다. 코드를 구문분석하는 것이 이상적입니다.

Exercise for Day 4: Do you interface with some C/C++ code in your project 면 which we could attempt to move to Rust? The fewer dependencies the better. Parsing code would be ideal.

Format

강의는 대화식이며 당신의 질문이 러스트 탐험을 이끌 것입니다!

The course is interactive and your questions will drive our exploration of Rust!

• 질문이 생기면 질문해주세요
• 토론은 매우 권장됩니다!
• 강의의 자료는 참고자료일 뿐으로 건너띌 수 있습니다.

• Please ask questions when you get them, don’t save them to the end.
• Discussions are very much encouraged!
• We will likely talk about things ahead of the slides.
  • The slides are just a support and we are free to skip them as we like.

Welcome to Day 1

강의의 첫 날입니다. 우리는 오늘 많은 부분을 다룰 것입니다.

This is the first day of Comprehensive Rust. We will cover a lot of ground today:

• 러스트 기본 문법: 변수, 스칼라 / 복합 타입, 열거형, 구조체, 참조형, 함수와 메서드.

• Basic Rust syntax: variables, scalar and compound types, enums, structs, references, functions, and methods.

• 메모리 관리: 스택과 힙, 수동 메모리 관리, 스코프(범위)기반 메모리 관리, 가비지 컬렉션(GC)

• Memory management: stack vs heap, manual memory management, scope-based memory management, and garbage collection.

• 소유권: 의미 이동, 복사와 복제, 빌림, 수명.

• Ownership: move semantics, copying and cloning, borrowing, and lifetimes.

What is Rust?

러스트는 2015년 1.0으로 릴리즈된 새로운 프로그램 언어입니다.

Rust is a new programming language which had its 1.0 release in 2015:

• 러스트는 C++과 비슷한 역할을 하는 정적 컴파일 언어입니다.
  • rustc는 LLVM을 백엔드로 사용합니다.
• 러스트는 다양한 플랫폼과 아키텍쳐를 지원합니다.
  • x86, ARM, WebAssembly, …
  • Linux, Mac, Windows, …
• 러스트는 넓은 범위의 장치에 적용될 수 있습니다.
  • 펌웨어와 부트로더(임베디드)
  • 스마트 디스플레이
  • 스마트폰
  • 데스크탑
  • 서버

• Rust is a statically compiled language in a similar role as C++
  • rustc uses LLVM as its backend.
• Rust supports many platforms and architectures:
  • x86, ARM, WebAssembly, …
  • Linux, Mac, Windows, …
• Rust is used for a wide range of devices:
  • firmware and boot loaders,
  • smart displays,
  • mobile phones,
  • desktops,
  • servers.

Hello World!

가장 간단한 러스트 프로그램으로 고전적인 Hello World 출력 프로그램을 작성해 보겠습니다.

Let us jump into the simplest possible Rust program, a classic Hello World program:

fn main() {
    println!("Hello 🌍!");
}

위 소스에서 알 수 있는 것:

• 함수는 fn으로 선언됩니다.
• C/C++과 마찬가지로 중괄호{}로 블록을 표시합니다.
• main 함수는 프로그램 진입점입니다.
• 러스트는 위생적인 매크로를 가지고 있습니다. println!는 그 예시입니다.
• 러스트의 문자열은 UTF-8로 인코딩되며 이모지와 같은 유니코드 문자를 포함할 수 있습니다.

What you see:

• Functions are introduced with fn.
• Blocks are delimited by curly braces like in C and C++.
• The main function is the entry point of the program.
• Rust has hygienic macros, println! is an example of this.
• Rust strings are UTF-8 encoded and can contain any Unicode character.

역주

• 매크로: 다른 코드를 작성하는 코드입니다(meta-programming). 런타임이 아닌 컴파일 전에 대치 작업이 이뤄지는데 C계열의 #define 문법을 생각하시면 됩니다.
• 위생적인 매크로(hygienic macros, 위키)는 식별자가 겹치지 않음이 보장되는 매크로… 라는데 일단은 그렇구나하고 진행

Small Example

러스트로 작성된 작은 예제입니다.

Here is a small example program in Rust:

fn main() {              // 프로그램 진입점(Program entry point)
    let mut x: i32 = 6;  // 가변 변수 할당(Mutable variable binding)
    print!("{x}");       // printf와 같은 출력 매크로(Macro for printing, like printf)
    while x != 1 {       // 표현식에는 괄호 없음(No parenthesis around expression)
        if x % 2 == 0 {  // 수학식 기호는 다른언어와 유사(Math like in other languages)
            x = x / 2;
        } else {
            x = 3 * x + 1;
        }
        print!(" -> {x}");
    }
    println!();
}

Why Rust?

러스트만의 독특한 세일즈 포인트(장점):

• 컴파일 시 메모리 안전
• 정의되지 않은 런타임 동작이 없습니다.
• 모던한 언어적 특징

Some unique selling points of Rust:

• Compile time memory safety.
• Lack of undefined runtime behavior.
• Modern language features.

Compile Time Guarantees

컴파일 시 정적 메모리 관리:

• 초기화되지 않는 변수가 없습니다.
• 메모리 누수 없음(거의. 강의참조노트 참고.)
• 메모리 이중 해제는 안됩니다.
• 메모리 해제 후 사용 안됩니다.
• NULL포인터는 없습니다.
• 잠긴 뮤텍스를 잊을 수 없습니다.
• 스레드간 데이터레이스가 없습니다.
• 이터레이터(반복자, iterator) 무효화가 없습니다.

Static memory management at compile time:

• No uninitialized variables.
• No memory leaks (mostly, see notes).
• No double-frees.
• No use-after-free.
• No NULL pointers.
• No forgotten locked mutexes.
• No data races between threads.
• No iterator invalidation.

역자주

• mutexes : 멀티스레딩에서 자원을 선점한 작업자가 잠그면(lock) 다른 작업자들은 lock이 해제될때까지 자원에 대해 접근을 할 수 없도록 막는 방식.
  • cf. semaphore: 자원에 접근 할 수 있는 작업자(스레드,프로세스)의 수를 나타내는 값을 둬서 상호 배제하는 방식.

Runtime Guarantees

런타임 시 정의되지 않음(undefined) 동작 없음:

• 배열 접근시 경계 체크
• 정수형의 오버플로우가 정의되어있습니다.

No undefined behavior at runtime:

• Array access is bounds checked.
• Integer overflow is defined.

Modern Features

러스트는 지난 40년간의 모든 (프로그래밍 언어들의) 경험으로 만들어졌습니다.

Rust is built with all the experience gained in the last 40 years.

Language Features

• 열거형과 패턴 매칭
• 제너릭
• FFI¹ 런타임 오버헤드 없음

• Enums and pattern matching.
• Generics.
• No overhead FFI.

Tooling

• 엄청난 컴파일러 에러 체커
• 내장 종속성 관리자
• 내장 테스트 지원 툴

• Great compiler errors.
• Built-in dependency manager.
• Built-in support for testing.

역주

Basic Syntax

대부분의 러스트 문법은 C/C++과 유사합니다.

• 블록과 스코프 범위는 중괄호{}로 표현합니다.
• 인라인 주석은 // ..., 블록 주석은 /* ... */로 사용합니다.
• if나 while같은 키워드도 동일합니다.
• 변수 할당은 =, 비교는 ==를 사용합니다.

Much of the Rust syntax will be familiar to you from C or C++:

• Blocks and scopes are delimited by curly braces.
• Line comments are started with //, block comments are delimited by /* ... */.
• Keywords like if and while work the same.
• Variable assignment is done with =, comparison is done with ==.

Scalar Types

각 타입의 크기는 다음과 같습니다:

• 정수 및 소수형은 뒤의 숫자와 같은 bits 입니다.(i8=8 bit)
• isize 와 usize 는 포인터와 같은 크기입니다.¹
• 문자는 32 bit 입니다.
• bool은 8 bit 입니다.

The types have widths as follows:

• iN, uN, and fN are N bits wide,
• isize and usize are the width of a pointer,
• char is 32 bit wide,
• bool is 8 bit wide.

역주

Compound Types

Array assignment and access:

fn main() {
    let mut a: [i8; 10] = [42; 10]; //타입과 사이즈 선언
    a[5] = 0;
    println!("a: {:?}", a);
}

튜플 선언과 접근:

Tuple assignment and access:

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

역주

• js기준으로 설명하면 튜플은 ‘순서가 중요해서 사이즈 N으로 고정된 불변(immutable) 배열’ 이라고 보면 됨.
  • 정확히는 서수(순서가 의미가 있는 내용)의 묶음(모음). 갯수N개에 대해서 N-tuple이라고 부르며 2-tuple을 흔히 쓰긴 함.(cf. 열거형)

References

C++과 마찬가지로 러스트도 참조형을 갖습니다:

Like C++, Rust has references:

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

C++과의 차이점:

• C포인터와 유사하게 ref_x에 할당할 경우 참조를 해제해야 합니다.
• 러스트는 특정한 경우(메서드 호출)에 자동으로 참조 해제를 합니다.
• mut로 선언된 참조는 수명에 따라 다른 값으로 할당될 수 있습니다.

Some differences from C++:

• We must dereference ref_x when assigning to it, similar to C pointers,
• Rust will auto-dereference in some cases, in particular when invoking methods (try count_ones).
• References that are declared as mut can be bound to different values over their lifetime.

역주

• count_ones 메서드를 만들어서 테스트해보세요

Dangling References

러스트는 댕글링 참조를 금지합니다:

Rust will statically forbid dangling references:

fn main() {
    let ref_x: &i32;
    {
        let x: i32 = 10;
        ref_x = &x;
    } // 스코프가 끝나서 x는 삭제되고 ref_x도 참조 해제 됩니다.(댕글링 참조)
    println!("ref_x: {ref_x}");
}

• 참조형 값(참조)는 변수로부터 값을 “빌리는 것“을 말합니다.
• 러스트는 모든 참조의 수명을 추적하여 참조가 충분히 오래 살아있음(참조가 사용될때까지)을 보장합니다.
• 소유권 부분에서 “빌림“에 대해 좀 더 많은 것을 다룹니다.

• A reference is said to “borrow” the value it refers to.
• Rust is tracking the lifetimes of all references to ensure they live long enough.
• We will talk more about borrowing when we get to ownership.

역주

• 댕글링 참조: 참조 포인터가 더이상 유효하지 않은 값을 가르키게 되는 경우

Slices

슬라이스를 사용하면 큰 컬렉션의 부분만 확인할 수 있습니다.

A slice gives you a view into a larger 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]으로 수정하면 무슨 일이 있어날까요?
• Slices borrow data from the sliced type.
• Question: What happens if you modify a[3]?

String vs str

이제 러스트의 두가지 문자열 타입에 대해서 이해해 보겠습니다.:

We can now understand the two string types in Rust:

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

러스트 용어:

• &str 타입은 문자열 슬라이스의 불변참조입니다.
• String 타입은 가변 문자열 버퍼입니다.

Rust terminology:

• &str an immutable reference to a string slice.
• String a mutable string buffer.

역주

• str은 문자 리터럴, &은 참조 타입입니다.

Functions

러스트 버전의 FizzBuzz 함수입니다:

A Rust version of the famous FizzBuzz interview question:

fn main() {
    // 하단정의. 굳이 상단에 별도 선언할 필요 없음.
    // Defined below, no forward declaration needed
    fizzbuzz_to(20);   
}

fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
    if rhs == 0 {
        // 코너 케이스.
        // Corner case, early return
        return false; 
    }
    // 마지막 표현식은 반환값을 나타냅니다.
    // The last expression is the return value
    lhs % rhs == 0     
}

// `()` 반환값은 반환할 값이 없음을 나타냅니다.
// No return value means returning the unit type `()`
fn fizzbuzz(n: u32) -> () {  
    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}"),
    }
}

//반환값이 없는 경우(`-> ()`) 생략 가능합니다.
// `-> ()` is normally omitted
fn fizzbuzz_to(n: u32) {  
    for n in 1..=n {
        fizzbuzz(n);
    }
}

역주

• corner case: 복합 경계 조건. 변수와 환경적인 요소로 인해서 로직에 문제가 있는 경우. ex. 나누기 로직에서 0으로 나누는 경우.
  • edge case: 경계조건. 매개변수 값이 극단적인 최대/최소값(로직 유효범위 끝) 이상인 경우.
• fizzbuzz: 숫자를 입력받아서 n으로 나뉘면 fizz, m으로 나뉘면 buss, 둘다 나뉘면 fizzbuzz, 안나뉘면 입력값을 출력하는 테스트로 자주 쓰는 문제입니다. 예제의 n,m은 3,5

Methods

러스트는 메서드(특정 타입과 관계된 간단한 함수)를 가집니다. 메서드의 첫번째 인수는 호출부 타입의 인스턴스 입니다.(self, this)

Rust has methods, they are simply functions that are associated with a particular type. The first argument of a method is an instance of the type it is associated with:

// 구조체 선언입니다.
struct Rectangle {
    width: u32,
    height: u32,
}

// 구조체에 구현된 메서드 들입니다. 
// 구조체 자체에는 데이터만 선언이 되어 impl 키워드로 해당 구조체에 메서드를 선언/연결 해주는 문법 구조입니다.
// 첫번째 인수는 해당 구조체 자신(self)입니다.  
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 };
    // 메서드는 .으로 호출하며 area의 self.width는 10, self.height는 5입니다.
    println!("old area: {}", rect.area()); 
    rect.inc_width(5);
    println!("new area: {}", rect.area());
}

• 오늘과 내일 강의에서 더 많은 메서드 사용법을 다룰 것입니다.

• We will look much more at methods in today’s exercise and in tomorrow’s class.

Function Overloading

오버로딩은 지원되지 않습니다:

• 개별함수는 단일 구현만 갖습니다.
  • 항상 고정된 수의 매개변수만 갖습니다.
  • 항상 고정된 단일 타입 집합을 사용합니다.
• 매개변수의 기본 값은 지원되지 않습니다.
  • 모든 호출부에서는 동일한 수의 인자를 설정해야합니다.
  • 대안으로 매크로를 사용하기도 합니다.

하지만, 함수의 매개변수는 제너릭을 적용할 수 있습니다.

Overloading is not supported:

• Each function has a single implementation:
  • Always takes a fixed number of parameters.
  • Always takes a single set of parameter types.
• Default values are not supported:
  • All call sites have the same number of arguments.
  • Macros are sometimes used as an alternative.

However, function parameters can be generic:

// 제너릭
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));
}

역주

• std::process::id: OS관련 프로세스 ID를 반환하는 함수입니다.
• for js developer: :: 표현은 쉽게 말해 static 함수 호출입니다.

Day 1: Morning Exercises

이번 연습문제는 러스트의 두 부분을 알아볼 것입니다:

• 타입의 암묵적 변환
• 배열과 for loops

In these exercises, we will explore two parts of Rust:

• Implicit conversions between types.

• Arrays and for loops.

Implicit Conversions

러스트는 C++과 다르게 타입 간 _암묵적 변환_을 자동으로 적용하지 않습니다. 아래 예시를 확인해 보세요:

Rust will not automatically apply implicit conversions between types (unlike C++). You can see this in a program like this:

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));
}

러스트의 정수형 타입은 모두 From<T> 와 Into<T> 트레이트를 구현하여 둘 사이를 변환 할 수 있습니다. From<T> 트레이트는 단일 from() 메서드를 가지고 있고, Into<T>트레이트는 단일 into()메서드를 가지고 있습니다. 이러한 트레이트를 구현하는 것은 타입이 다른 타입으로 변환하는 것을 표현하는 방법입니다.

The Rust integer types all implement the From<T> and Into<T> traits to let us convert between them. The From<T> trait has a single from() method and similarly, the Into<T> trait has a single into() method. Implementing these traits is how a type expresses that it can be converted into another type.

표준 라이브러리에는 From<i8> for i16가 구현되어 있는데 이것은 우리가 i8 타입의 변수 x를 i16::from(x)를 호출하여 i16타입으로 변환할 수 있다는 의미입니다. (혹은 더 간단하게 x.into()를 사용합니다.) From<i8> for i16의 구현은 자동으로 Into<i16> for i8를 생성하기 때문입니다.

The standard library has an implementation of From<i8> for i16, which means that we can convert a variable x of type i8 to an i16 by calling i16::from(x). Or, simpler, with x.into(), because From<i8> for i16 implementation automatically create an implementation of Into<i16> for i8.

1. 위 예제코드를 실행해서 발생한 오류를 확인해 보세요
2. into() 메서드를 사용하여 코드를 수정하세요
3. x와 y를 `f32’이나 ‘bool’, ‘i128’ 등으로 바꿔서 해당 타입들로 변환이 되는지 확인해보세요

• 작은 사이즈 타입에서 큰 사이즈로 변경해보시고 그 반대로도 해보세요
• 표준 라이브러리 문서에서 시도해 본 케이스가 구현되어 있는지 확인해 보세요.

1. Execute the above program and look at the compiler error.
2. Update the code above to use into() to do the conversion.
3. Change the types of x and y to other things (such as f32, bool, i128) to see which types you can convert to which other types. Try converting small types to big types and the other way around. Check the standard library documentation to see if From<T> is implemented for the pairs you check.

Arrays and for Loops

우리는 배열을 아래와 같이 선언 할 수 있음을 보았습니다:

We saw that an array can be declared like this:

#![allow(unused)]
fn main() {
let array = [10, 20, 30];
}

배열은 {:?} 형태로 표시하여 출력할 수 있습니다.

You can print such an array by asking for its debug representation with {:?}:

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

러스트에서는 for키워드를 사용해 배열이나 범위를 반복할 수 있습니다:

Rust lets you iterate over things like arrays and ranges using the for keyword:

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함수와 행렬을 전치(행과 열을 변경)시키는 transpose함수를 작성해 보시기 바랍니다.

Use the above to write a function pretty_print which pretty-print a matrix and a function transpose which will transpose a matrix (turn rows into columns):

두 함수 모두 3×3 행렬에서 작동하도록 하드 코딩합니다.

Hard-code both functions to operate on 3 × 3 matrices.

아래 코드를 https://play.rust-lang.org/에 복사해서 구현하시면 됩니다.

Copy the code below to https://play.rust-lang.org/ and implement the functions:

// TODO: 구현이 완료되면 아래 줄은 삭제합니다.
// TODO: remove this when you're done with your implementation.
#![allow(unused_variables, dead_code)]

fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
    unimplemented!()
}

fn pretty_print(matrix: &[[i32; 3]; 3]) {
    unimplemented!()
}

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);
}

Bonus Question

하드코딩된 3×3 행렬 입력을 &[i32] 슬라이스를 통해 인수와 반환값을 정의가 가능한가요?

예컨데 &[&[i32]]는 2차원 슬라이스의 슬라이스 입니다. 가능하다면/하지 않다면 왜 그런가요?

Could you use &[i32] slices instead of hard-coded 3 × 3 matrices for your argument and return types? Something like &[&[i32]] for a two-dimensional slice-of-slices. Why or why not?

프로덕션 품질의 구현에 대해서는 ndarray 크레이트를 참조하시기 바랍니다.

See the ndarray crate for a production quality implementation.

역주

• C/C++나 js에 대해서 어느정도 지식이 있는걸 전제로 하기때문에 첫 문제부터 난이도가 조금 있지 않을까 싶습니다만..

Variables

러스트는 정적 타이핑을 통해 타입 세이프티(타입 안전)을 제공합니다. 변수 바인딩은 기본적으로 불변(immutable)합니다.

Rust provides type safety via static typing. Variable bindings are immutable by default:

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

Type Inference

러스트는 변수가 어떻게 사용되는지 확인하여 타입 추론을 제공합니다.

Rust will look at how the variable is used to determine the type:

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);
}

Static and Constant Variables

전역 상태(state) 정적 변수와 상수로 관리됩니다.

Global state is managed with static and constant variables.

const

컴파일 시점의 상수를 선언할 수 있습니다.

You can declare compile-time constants:

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:?}");
}

static

마찬가지로 정적 변수도 선언할 수 있습니다.

You can also declare static variables:

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

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

가변 정적 데이터에 대해서는 안전하지 않은 러스트 파트에서 살펴봅니다.

We will look at mutating static data in the chapter on Unsafe Rust.

Scopes and Shadowing

외부 스코프와 동일 스코프 범위의 변수를 가릴 수 있습니다.(변수 쉐도잉)

You can shadow variables, both those from outer scopes and variables from the same scope:

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

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

역주

• after의 경우 inner scope 수명이 다해서 원래 변수인 a가 표시되는 겁니다.

Memory Management

전통적으로, 프로그래밍 언어는 크게 두가지로 분류 됩니다:

• 소스레벨 메모리 관리(수동 제어): C, C++, Pascal, …
• 런타임 시 자동 메모리 관리를 통한 안전성 제공¹: Java, Python, Go, Haskell, …

Traditionally, languages have fallen into two broad categories:

• Full control via manual memory management: C, C++, Pascal, …
• Full safety via automatic memory management at runtime: Java, Python, Go, Haskell, …

러스트는 새로운 형태를 제안합니다:

컴파일 시 메모리 관리를 통한 안전성과 제어 제공

Rust offers a new mix:

Full control and safety via compile time enforcement of correct memory management.

이것은 명시적인 소유권 컨셉을 통해 이뤄집니다.

우선 메모리 관리가 이뤄지는 방식을 다시 살펴 보겠습니다.

It does this with an explicit ownership concept. First, let’s refresh how memory management works.

The Stack vs The Heap

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

  • 값은 사전 정의된 고정 크기를 갖습니다.
  • 극도로 빠름: 단지 스택 포인트만 이동됩니다.
  • 관리가 쉬움: 함수 호출을 따릅니다.
  • 메모리 인접성

• 힙: 함수 호출 외부의 값이 저장되는 곳

  • 값은 런타임 시 결정되는 동적 크기를 갖습니다.
  • 스택에 비해서는 약간 느림: 약간의 추가 기록(부기)¹이 필요함.
  • 메모리 인접성을 보장하지 않음.

• Stack: Continuous area of memory for local variables.

  • Values have fixed sizes known at compile time.
  • Extremely fast: just move a stack pointer.
  • Easy to manage: follows function calls.
  • Great memory locality.

• Heap: Storage of values outside of function calls.

  • Values have dynamic sizes determined at runtime.
  • Slightly slower than the stack: some book-keeping needed.
  • No guarantee of memory locality.

역주

Stack Memory

String 타입은 힙에 동적으로 데이터를 저장하고 크기 고정된 데이터(힙 데이터에 대한 정보)를 스택에 저장합니다.

Creating a String puts fixed-sized data on the stack and dynamically sized data on the heap:

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

Manual Memory Management

사용자가 직접 메모리를 할당, 해제 합니다.

You allocate and deallocate heap memory yourself.

C Example

malloc로 할당하는 포인터마다 free를 호출해야 합니다:

You must call free on every pointer you allocate with malloc:

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

만약malloc 과 free 사이에서 함수가 먼저 반환되면 메모리 누수가 일어납니다.
: 포인터가 손실되어 메모리 할당을 해제할 수 없게 됩니다.

Memory is leaked if the function returns early between malloc and free: the pointer is lost and we cannot deallocate the memory.

Scope-Based Memory Management

생성자와 소멸자를 사용하여 객체의 수명에 연결(hook)할 수 있습니다.

Constructors and destructors let you hook into the lifetime of an object.

포인터를 객체에 래핑하여 객체가 소멸될 때 메모리를 해제 할 수 있습니다. 컴파일러는 예외(exception)가 발생하더라도 이를 보장합니다.

By wrapping a pointer in an object, you can free memory when the object is destroyed. The compiler guarantees that this happens, even if an exception is raised.

이를 종종 RAII(Resource Acquisition Is Initialization, 리소스 획득은 초기화다)이라고 하며, RAII패턴의 스마트 포인터를 제공합니다.

This is often called resource acquisition is initialization (RAII) and gives you smart pointers.

C++ Example

void say_hello(std::unique_ptr<Person> person) {
  std::cout << "Hello " << person->name << std::endl;
}

• std::unique_ptr객체는 스택에 할당되며, 힙에 할당된 메모리를 가리킵니다(point).
• say_hello함수가 끝나면 std::unique_ptr의 소멸자가 실행됩니다.
• 소멸자는 Person 객체가 가르키는(point) 곳을 해제합니다.

• The std::unique_ptr object is allocated on the stack, and points to memory allocated on the heap.
• At the end of say_hello, the std::unique_ptr destructor will run.
• The destructor frees the Person object it points to.

특별한 이동 생성자는 소유권을 함수로 전달할때 사용됩니다.

Special move constructors are used when passing ownership to a function:

std::unique_ptr<Person> person = find_person("Carla");
say_hello(std::move(person));

역주

• C++ 지식이 짧아서 번역이 맞나 모르겠음.

Automatic Memory Management

수동, 스코프기반 메모리 관리의 대안인 자동 메모리 관리 입니다:

• 개발자는 메모리를 명시적으로 할당/해제 하지 않습니다.
• 가비지 컬렉터(GC)는 개발자 대신 사용되지 않는 메모리를 찾아 해제합니다.

An alternative to manual and scope-based memory management is automatic memory management:

• The programmer never allocates or deallocates memory explicitly.
• A garbage collector finds unused memory and deallocates it for the programmer.

Java Example

person객체는 sayHello함수 반환 후에도 해제되지 않습니다. (GC가 나중에 알아서 해제합니다.)

The person object is not deallocated after sayHello returns:

void sayHello(Person person) {
  System.out.println("Hello " + person.getName());
}

Memory Management in Rust

러스트의 메모리 관리는 이전 방식들을 혼합해서 사용합니다:

• 자바처럼 안전하고 정확합니다. 하지만 GC는 없습니다.
• C++처럼 범위(스코프)기반입니다. 하지만 컴파일러가 엄격하게 적용합니다.
• C/C++처럼 런타임 오버헤드¹가 없습니다.

이는 러스트의 명시적인 소유권 설계를 통해 이뤄집니다.

Memory management in Rust is a mix:

• Safe and correct like Java, but without a garbage collector.
• Scope-based like C++, but the compiler enforces full adherence.
• Has no runtime overhead like in C and C++.

It achieves this by modeling ownership explicitly.

역주

Comparison

메모리 관리 기술의 대략적인 비교입니다.

Here is a rough comparison of the memory management techniques.

Pros of Different Memory Management Techniques

• C와 같은 수동 관리:
  • 런타임 오버헤드가 없음.
• JAVA와 같은 자동화 관리:
  • 완전한 자동화.
  • 안전하고 정확함.
• C++과 같은 범위 기반 관리:
  • 부분 자동화
  • 런타임 오버헤드가 없음.
• 러스트와 같은 컴파일러 수행 범위 기반 관리:
  • 컴파일러에 의해 수행됩니다.
  • 런타임 오버헤드가 없습니다.
  • 안전하고 정확합니다.

• Manual like C:
  • No runtime overhead.
• Automatic like Java:
  • Fully automatic.
  • Safe and correct.
• Scope-based like C++:
  • Partially automatic.
  • No runtime overhead.
• Compiler-enforced scope-based like Rust:
  • Enforced by compiler.
  • No runtime overhead.
  • Safe and correct.

Cons of Different Memory Management Techniques

• C와 같은 수동 관리:
  • 사용 후 해제 문제
  • 이중 해제 문제
  • 메모리 누수 문제
• JAVA와 같은 자동화 관리:
  • GC의 일시중지
  • 소멸자 지연 동작
• C++과 같은 범위 기반 관리:
  • 복잡하며 개발자에 의해서 최적화가 필요함
  • 사용 후 해제 문제 가능성 있음
• 러스트와 같은 컴파일러 수행 범위 기반 관리:
  • 약간의 초기 복잡성
  • 유효한 프로그램(로직)이 거부 될 수 있음

• Manual like C:
  • Use-after-free.
  • Double-frees.
  • Memory leaks.
• Automatic like Java:
  • Garbage collection pauses.
  • Destructor delays.
• Scope-based like C++:
  • Complex, opt-in by programmer.
  • Potential for use-after-free.
• Compiler-enforced and scope-based like Rust:
  • Some upfront complexity.
  • Can reject valid programs.

Ownership

모든 변수 바인딩은 유효한 _범위_를 갖으며, 범위 밖에서 변수 사용은 오류입니다:

All variable bindings have a scope where they are valid and it is an error to use a variable outside its scope:

struct Point(i32, i32);

fn main() {
    {
        let p = Point(3, 4);
        println!("x: {}", p.0);
    } // 스코프 종료지점
    println!("y: {}", p.1);
} // main 함수의 스코프 종료지점

• 스코프가 종료되면 변수는 _삭제_되고 데이터 메모리는 해제됩니다.
• 소멸자는 여기(스코프 종료지점)에서 메모리 자원을 해제 합니다.
• 이것을 두고 변수가 값을 _소유_한다고 표현합니다.

• At the end of the scope, the variable is dropped and the data is freed.
• A destructor can run here to free up resources.
• We say that the variable owns the value.

Move Semantics

(변수의)할당은 변수 간 소유권을 이동시킵니다:

An assignment will transfer ownership between variables:

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

• s1을 s2에 할당하여 소유권을 이전시킵니다.
• 데이터는 s1에서 _이동_됩니다. 따라서 s1은 더이상 접근 할 수 없습니다.
• s1의 스코프가 종료되면 아무 일도 없습니다: 아무런 소유권이 없습니다.
• s2의 스코프가 종료되면 문자열 데이터는 해제됩니다.
• 값(데이터)의 소유권을 갖는 변수는 항상 정확히 하나 입니다.

• The assignment of s1 to s2 transfers ownership.
• The data was moved from s1 and s1 is no longer accessible.
• When s1 goes out of scope, nothing happens: it has no ownership.
• When s2 goes out of scope, the string data is freed.
• There is always exactly one variable binding which owns a value.

Moved Strings in Rust

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

• s1의 힙 데이터는 s2에서 재사용 됩니다.
• s1의 스코프가 종료되면 아무일도 일어나지 않습니다.(이미 이동되었습니다.)

• The heap data from s1 is reused for s2.
• When s1 goes out of scope, nothing happens (it has been moved from).

s2이동 전 메모리:

Before move to s2:

s2이동 후 메모리:

After move to s2:

역주

• 이동 후 메모리 그림에서 s1에서 힙으로 연결이 지워졌다고 이해해도 무방은 합니다. 컴파일러가 확인하기 위해 접근 불가 처리 한 것으로 보이긴 합니다만…

Double Frees in Modern C++

Modern C++은 이 문제를 다르게 해결합니다:

Modern C++ solves this differently:

std::string s1 = "Cpp";
std::string s2 = s1;  // Duplicate the data in s1.

• s1의 힙 데이터는 복제되고, s2는 독립적인 복사본을 얻습니다.
• s1 와 s2의 스코프가 종료되면 각각의 메모리가 해제됩니다.

• The heap data from s1 is duplicated and s2 gets its own independent copy.
• When s1 and s2 go out of scope, they each free their own memory.

Before copy-assignment:

After copy-assignment:

Moves in Function Calls

값을 함수에 전달할때, 값은 함수 매개변수에 할당됩니다. 이것은 소유권을 이동시킵니다:

When you pass a value to a function, the value is assigned to the function parameter. This transfers ownership:

fn say_hello(name: String) {
    println!("Hello {name}")
}

fn main() {
    let name = String::from("Alice");
    say_hello(name);
    // say_hello(name); // 역주: main에는 name의 소유권이 없어 재 전달이 불가
}

Copying and Cloning

의미구조(Semantics)가 이동할때, 특정 타입은 기본적으로 복사됩니다:

While move semantics are the default, certain types are copied by default:

fn main() {
    let x = 42;
    let y = x;
    println!("x: {x}");
    println!("y: {y}");
}

이러한 유형들은 Copy 트레이트를 구현합니다.

직접 만든 타입들도 Copy트레이트를 구현하여 의미복사를 할 수 있습니다:

These types implement the Copy trait.

You can opt-in your own types to use copy semantics:

#[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()를 사용하여 데이터를 복사할 수 있습니다.

• After the assignment, both p1 and p2 own their own data.
• We can also use p1.clone() to explicitly copy the data.

역주

• #[derive(Copy, Clone, Debug)]를 통해 Point 구조체가 Copy되도록 함

Borrowing

함수 호출시 값의 소유권을 이동하는 대신의 함수가 값을 _빌려_올 수 있습니다:

Instead of transferring ownership when calling a function, you can let a function borrow the value:

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

fn add(p1: &Point, p2: &Point) -> Point {
    Point(p1.0 + p2.0, p1.1 + p2.1)
}

fn main() {
    let p1 = Point(3, 4);
    let p2 = Point(10, 20);
    let p3 = add(&p1, &p2);
    println!("{p1:?} + {p2:?} = {p3:?}");
}

• add 함수는 두 Point객체 값을 _빌려_오와서 새로운 Point객체를 반환합니다.
• 호출자(main 함수)는 여전히 p1, p2의 소유권을 유지합니다.

• The add function borrows two points and returns a new point.
• The caller retains ownership of the inputs.

Shared and Unique Borrows

러스트는 값을 빌려오는 방법에 대한 제약이 존재합니다:

• 한번에 하나 이상의 &T 값을 가질 수 있습니다.(1~N개의 불변 변수)
• 또는
• 정확히 하나의 &mut T 값을 가질 수 있습니다.(1개의 가변 변수)

Rust puts constraints on the ways you can borrow values:

• You can have one or more &T values at any given time, or
• You can have exactly one &mut T value.

fn main() {
    let mut a: i32 = 10;
    let b: &i32 = &a;

    {
        let c: &mut i32 = &mut a;
        *c = 20;
    }

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

역주

• 둘 중 하나만 됩니다. 따라서 위 소스는 내부 스코프에서 1개의 불변변수, 1개의 가변변수가 존재하게 되서 오류입니다.

Lifetimes

빌려온 값은 수명 을 갖습니다:

• 수명는 생략할 수 있습니다: add(p1: &Point, p2: &Point) -> Point.
• 물론 명시할 수도 있습니다: &'a Point, &'document str.
• &'a Point 는 as a가 유효한 동안 빌려온 Point 입니다.
• 수명는 항상 컴파일러에 의해 추론됩니다.: 직접 수명을 설정할 수는 없습니다.
  • 수명 표기(')은 제약조건을 생성합니다.
  • 컴파일러는 유효한 솔루션이 있는지 검증합니다.

A borrowed value has a lifetime:

• The lifetime can be elided: add(p1: &Point, p2: &Point) -> Point.
• Lifetimes can also be explicit: &'a Point, &'document str.
• Read &'a Point as “a borrowed Point which is valid for at least the lifetime a”.
• Lifetimes are always inferred by the compiler: you cannot assign a lifetime yourself.
• Lifetime annotations create constraints; the compiler verifies that there is a valid solution.

역주

• 유효한 솔루션이 어떤의미인지 모호한데 일단 매개변수와 리턴값은 모두 같은 수명이어야 한다고 합니다.

Lifetimes in Function Calls

함수는 인수를 빌리는 것 외에도 빌린 값을 반환할 수 있습니다:

In addition to borrowing its arguments, a function can return a borrowed value:

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

fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {
    if p1.0 < p2.0 { p1 } else { p2 }
}

fn main() {
    let p1: Point = Point(10, 10);
    let p2: Point = Point(20, 20);  
    let p3: &Point = left_most(&p1, &p2);
    println!("left-most point: {:?}", p3);
}

• 'a는 제너릭 매개변수로 컴파일러로에 의해 추론됩니다.
• 수명은 ' 로 표기하며 러스트에서는 일반적으로 'a 라고 표현합니다.
• &'a Point 는 as a와 동일한 수명을 가지는 빌려온 Point 입니다.
  • 중요 : 다른 스코프에 있어도 적용 됩니다.

• 'a is a generic parameter, it is inferred by the compiler.
• Lifetimes start with ' and 'a is a typical default name.
• Read &'a Point as “a borrowed Point which is valid for at least the lifetime a”.
• The at least part is important when parameters are in different scopes.

#[derive(Debug)]
struct Point(i32, i32);
fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {
    if p1.0 < p2.0 { p1 } else { p2 }
}
fn main() {
    let p1: Point = Point(10, 10);
    let p3: &Point;
    {
        let p2: Point = Point(20, 20);
        p3 = left_most(&p1, &p2);
    }
    println!("left-most point: {:?}", p3);
}

역주

• left_most함수가 종료되더라도 리턴값 p3은 매개변수인 p1,p2와 동일한 수명이라 main에서도 유효해집니다.

Lifetimes in Data Structures

만약 빌려온 데이터를 저장하는 타입(구조체 같은)인 경우, 반드시 수명 표기를 해야합니다.

If a data type stores borrowed data, it must be annotated with a lifetime:

#[derive(Debug)]
struct Highlight<'doc>(&'doc str);

fn erase(text: String) {
    println!("Bye {text}!");
}

fn main() {
    let text = String::from("The quick brown fox jumps over the lazy dog.");
    let fox = Highlight(&text[4..19]);
    let dog = Highlight(&text[35..43]);
    // erase(text);
    println!("{fox:?}");
    println!("{dog:?}");
}

역주

• Highlight 구조체는 참조문자열(&str)을 저장합니다. 아래 출력문에서 text를 출력해도 동일하게 전부 출력됩니다.
  • 하지만 중간에 텍스트를 erase로 삭제하려고 하면 빌린(참조)가 설정되 있어서 소유권 이동이 불가하다는 에러가 발생합니다.
  • try it!

Day 1: Afternoon Exercises

이번 연습문제는 아래 두가지입니다:

• 작은 도서관
• 반복자와 소유권(어려움!)

We will look at two things:

• A small book library,
• Iterators and ownership (hard).

Designing a Library

우리는 내일 구조체와 Vec<T>에 대해 더 많은 것을 배울 것입니다.

일단 오늘은 API의 일부만 알면 됩니다:

We will learn much more about structs and the Vec<T> type tomorrow. For now, you just need to know part of its API:

fn main() {
    let mut vec = vec![10, 20];
    vec.push(30);
    println!("middle value: {}", vec[vec.len() / 2]);
    for item in vec.iter() {
        println!("item: {item}");
    }
}

도서관 프로그램을 만들기 위해 아래 코드를 https://play.rust-lang.org/에 복사해서 구현하시면 됩니다.

Use this to create a library application. Copy the code below to https://play.rust-lang.org/ and update the types to make it compile:

// TODO: remove this when you're done with your implementation.
#![allow(unused_variables, dead_code)]

struct Library {
    books: Vec<Book>,
}

struct Book {
    title: String,
    year: u16,
}

impl Book {
    // This is a constructor, used below.
    fn new(title: &str, year: u16) -> Book {
        Book {
            title: String::from(title),
            year,
        }
    }
}

// This makes it possible to print Book values with {}.
impl std::fmt::Display for Book {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{} ({})", self.title, self.year)
    }
}

impl Library {
    fn new() -> Library {
        unimplemented!()
    }

    //fn len(self) -> usize {
    //    unimplemented!()
    //}

    //fn is_empty(self) -> bool {
    //    unimplemented!()
    //}

    //fn add_book(self, book: Book) {
    //    unimplemented!()
    //}

    //fn print_books(self) {
    //    unimplemented!()
    //}

    //fn oldest_book(self) -> Option<&Book> {
    //    unimplemented!()
    //}
}

// 소스쪽 주석들을 제거하고 누락된 메서드를 구현하세요.
// 메서드 정의도 수정되어야 합니다.(self가 포함되도록)
// This shows the desired behavior. Uncomment the code below and
// implement the missing methods. You will need to update the
// method signatures, including the "self" parameter!
fn main() {
    let library = Library::new();

    //println!("Our library is empty: {}", library.is_empty());
    //
    //library.add_book(Book::new("Lord of the Rings", 1954));
    //library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
    //
    //library.print_books();
    //
    //match library.oldest_book() {
    //    Some(book) => println!("My oldest book is {book}"),
    //    None => println!("My library is empty!"),
    //}
    //
    //println!("Our library has {} books", library.len());
}

역주

• 강의를 눈으로만 보고 있었다면 헬게이트가 될 수 있습니다.
• 기본적으로 이 강의는 주어진 내용을 추가로 찾아보고 공식문서 보고 예제 이것저것 만져보고 해봐야 따라올 수 있습니다.

Iterators and Ownership

러스트의 소유권 모델은 많은 API에 영향을 줍니다.

예를들어 Iterator 와 IntoIterator 같은 트레이트가 있습니다.

The ownership model of Rust affects many APIs. An example of this is the Iterator and IntoIterator traits.

Iterator

트레이트는 타입에 대한 행동(메서드)를 설명한다는 점에서 인터페이스와 유사합니다.

Iterator는 단순히 None가 나올때까지 next를 호출하는 트레이트입니다.

Traits are like interfaces: they describe behavior (methods) for a type. The Iterator trait simply says that you can call next until you get None back:

#![allow(unused)]
fn main() {
pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}
}

Iterator트레이트는 이렇게 사용합니다:

You use this trait like this:

fn main() {
    let v: Vec<i8> = vec![10, 20, 30];
    let mut iter = v.iter();

    println!("v[0]: {:?}", iter.next());
    println!("v[1]: {:?}", iter.next());
    println!("v[2]: {:?}", iter.next());
    println!("No more items: {:?}", iter.next());
}

질문) 반복자(이터레이터)가 반환하는 타입은 무엇입니까? 아래 코드를 수정해보세요:

What is the type returned by the iterator? Test your answer here:

fn main() {
    let v: Vec<i8> = vec![10, 20, 30];
    let mut iter = v.iter();

    let v0: Option<..> = iter.next(); 
    println!("v0: {v0:?}");
}

왜 이런 것을 사용해야 합니까?

Why is this type used?

IntoIterator

Iterator 트레이트는 생성된 반복자를 “어떻게 반복 하는지” 알려줍니다.

유사한 IntoIterator 트레이트는 “반복자를 어떻게 만드는지” 알려줍니다.

The Iterator trait tells you how to iterate once you have created an iterator. The related trait IntoIterator tells you how to create the iterator:

#![allow(unused)]
fn main() {
pub trait IntoIterator {
    type Item;
    type IntoIter: Iterator<Item = Self::Item>;

    fn into_iter(self) -> Self::IntoIter;
}
}

IntoIterator의 모든 구현은 반드시 두 타입을 선언해야합니다:

• Item: i8과 같이 반복되는 요소의 유형
• IntoIter: into_iter 메서드에서 반환되는 Iterator타입

IntoIter와 Item는 링크되어 있습니다: 반복자와 Item 타입은 동일해야합니다. 즉, Option<Item>를 반환해야 합니다.

The syntax here means that every implementation of IntoIterator must declare two types:

• Item: the type we iterate over, such as i8,
• IntoIter: the Iterator type returned by the into_iter method. Note that IntoIter and Item are linked: the iterator must have the same Item type, which means that it returns Option<Item>

질문) (이전과 마찬가지로) 반복자(이터레이터)가 반환하는 타입은 무엇입니까? 아래 코드를 수정해보세요: Like before, what is the type returned by the iterator?

fn main() {
    let v: Vec<String> = vec![String::from("foo"), String::from("bar")];
    let mut iter = v.into_iter();

    let v0: Option<..> = iter.next();
    println!("v0: {v0:?}");
}

for Loops

자, 이제 우리는 Iterator와 IntoIterator를 알았으므로 for 루프를 만들 수 있습니다. for 루프는 into_iter()를 호출하여 결과를 반환하는 것을 반복합니다:

Now that we know both Iterator and IntoIterator, we can build for loops. They call into_iter() on an expression and iterates over the resulting iterator:

fn main() {
    let v: Vec<String> = vec![String::from("foo"), String::from("bar")];

    for word in &v {
        println!("word: {word}");
    }

    for word in v {
        println!("word: {word}");
    }
}

질문) 매 루프에서 word의 타입은 무엇입니까?

What is the type of word in each loop?

위 코드에서 실험 해 본 후 다음 문서를 참조해서 답변을 확인하시기 바랍니다.

• impl IntoIterator for &Vec<T>
• impl IntoIterator for Vec<T>

Experiment with the code above and then consult the documentation for impl IntoIterator for &Vec<T> and impl IntoIterator for Vec<T> to check your answers.

Welcome to Day 2

상당한 분량의 러스트에 대해 보았고, 이어서 오늘 강의를 진행하겠습니다:

• 구조체, 열거형, 메서드

• 패턴 매칭: 열거형, 구조체 그리고 배열 분해

• 흐름 제어: if, if let, while, while let, break, 그리고 continue.

• 표준 라이브러리:: String, Option 과 Result, Vec, HashMap, Rc 그리고 Arc.

• 모듈: 가시성, 경로 및 파일 시스템 계층.

Now that we have seen a fair amount of Rust, we will continue with:

• Structs, enums, methods.

• Pattern matching: destructuring enums, structs, and arrays.

• Control flow constructs: if, if let, while, while let, break, and continue.

• The Standard Library: String, Option and Result, Vec, HashMap, Rc and Arc.

• Modules: visibility, paths, and filesystem hierarchy.

Structs

C/C++과 마찬가지로 러스트는 커스텀 구조체를 지원합니다:

Like C and C++, Rust has support for custom structs:

struct Person {
    name: String,
    age: u8,
}

fn main() {
    let peter = Person {
        name: String::from("Peter"),
        age: 27,
    };

    println!("{} is {} years old", peter.name, peter.age);
}

Tuple Structs

각 값의 이름이 중요하지 않다면 튜블 구조체를 사용할 수 있습니다:

If the field names are unimportant, you can use a tuple struct:

struct Point(i32, i32);

fn main() {
    let p = Point(17, 23);
    println!("({}, {})", p.0, p.1);
}

종종 단일 필드의 래퍼(wrapper)로 사용됩니다.(러스트에서 newtypes 패턴¹이라 부릅니다):

This is often used for single-field wrappers (called newtypes):

struct PoundOfForce(f64);
struct Newtons(f64);

fn compute_thruster_force() -> PoundOfForce {
    todo!("Ask a rocket scientist at NASA")
}

fn set_thruster_force(force: Newtons) {
    // ...
}

fn main() {
    let force = compute_thruster_force();
    set_thruster_force(force);
}

역주

Field Shorthand Syntax

구조체 필드와 동일한 이름의 변수가 있다면 아래와 같이 짧은 문법 으로 구조체를 생성할 수 있습니다:

If you already have variables with the right names, then you can create the struct using a shorthand:

#[derive(Debug)]
struct Person {
    name: String,
    age: u8,
}

impl Person {
    fn new(name: String, age: u8) -> Person {
        Person { name, age } // <-- 이부분
    }
}

fn main() {
    let peter = Person::new(String::from("Peter"), 27);
    println!("{peter:?}");
}

Enums

enum 키워드는 열거형 타입을 생성합니다:

The enum keyword allows the creation of a type which has a few different variants:

fn generate_random_number() -> i32 {
    4  // Chosen by fair dice roll. Guaranteed to be random.
}

#[derive(Debug)]
enum CoinFlip {
    Heads,
    Tails,
}

fn flip_coin() -> CoinFlip {
    let random_number = generate_random_number();
    if random_number % 2 == 0 {
        return CoinFlip::Heads;
    } else {
        return CoinFlip::Tails;
    }
}

fn main() {
    println!("You got: {:?}", flip_coin());
}

역주

• variants: 열거형의 요소들을 말합니다 열거형의 값은 variants중 하나여야 합니다.

Variant Payloads

다양한 데이터를 가진 variants를 열거형에 정의하고, match 구문을 이용해 이를 추출할 수 있습니다:

You can define richer enums where the variants carry data. You can then use the match statement to extract the data from each variant:

enum WebEvent {
    PageLoad,                 // Variant without payload
    KeyPress(char),           // Tuple struct variant
    Click { x: i64, y: i64 }, // Full struct variant
}

#[rustfmt::skip]
fn inspect(event: WebEvent) {
    match event {
        WebEvent::PageLoad       => println!("page loaded"),
        WebEvent::KeyPress(c)    => println!("pressed '{c}'"),
        WebEvent::Click { x, y } => println!("clicked at x={x}, y={y}"),
    }
}

fn main() {
    let load = WebEvent::PageLoad;
    let press = WebEvent::KeyPress('x');
    let click = WebEvent::Click { x: 20, y: 80 };

    inspect(load);
    inspect(press);
    inspect(click);
}

역주

• 열거형 요소에 값을 포함하도록(예시) 선언해서 match 문에서 열거형의 타입에 따라 동작하도록 만들어진 예시입니다

Enum Sizes

러스트의 열거형은 정렬로 인한 제약을 고려하여 크기를 빽빽하게 잡습니다

Rust enums are packed tightly, taking constraints due to alignment into account:

use std::mem::{align_of, size_of};

macro_rules! dbg_size {
    ($t:ty) => {
        println!("{}: size {} bytes, align: {} bytes",
                 stringify!($t), size_of::<$t>(), align_of::<$t>());
    };
}

enum Foo {
    A,
    B,
}

fn main() {
    dbg_size!(Foo);
}

• 자세한 사항은 공식문서를 확인하세요.

• See the Rust Reference.

Methods

러스트에서 선언된 타입에 대해 impl블록에 함수를 선언하여 메서드를 연결할 수 있습니다:

Rust allows you to associate functions with your new types. You do this with an impl block:

#[derive(Debug)]
struct Person {
    name: String,
    age: u8,
}

impl Person {
    fn say_hello(&self) {
        println!("Hello, my name is {}", self.name);
    }
}

fn main() {
    let peter = Person {
        name: String::from("Peter"),
        age: 27,
    };
    peter.say_hello();
}

Method Receiver

&self는 메서드가 객체를 불변하게 빌려옴을 나타냅니다. 그 외에 메서드가 받아올 수 있는 인자는 다음과 같습니다:

• &self: 호출자로부터 불변참조객체를 빌려옴을 나타냅니다. 객체는 나중에 다시 사용 될 수 있습니다.
• &mut self: 호출자로부터 가변참조객체를 빌려옴을 나타냅니다. 객체는 나중에 다시 사용 될 수 있습니다.
• self: 호출자의 객체가 이동되어 메서드가 객체의 소유권을 가져옵니다. 따라서 명시적으로 소유권을 반환하지 않으면 (메서드 종료 후)객체는 삭제(해제)됩니다.
• 인자 없음: 구조체의 정적 메서드가 됩니다. 관습적으로 new라고 지정되는 생성자를 만들때 사용합니다.

self에 대한 variants ㅇ외에도 Box<Self>와 같이 인자 유형으로 허용되는 special wrapper types도 있습니다.

The &self above indicates that the method borrows the object immutably. There are other possible receivers for a method:

• &self: borrows the object from the caller using a shared and immutable reference. The object can be used again afterwards.
• &mut self: borrows the object from the caller using a unique and mutable reference. The object can be used again afterwards.
• self: takes ownership of the object and moves it away from the caller. The method becomes the owner of the object. The object will be dropped (deallocated) when the method returns, unless its ownership is explicitly transmitted.
• No receiver: this becomes a static method on the struct. Typically used to create constructors which are called new by convention.

Beyond variants on self, there are also special wrapper types allowed to be receiver types, such as Box<Self>.

Example

#[derive(Debug)]
struct Race {
    name: String,
    laps: Vec<i32>,
}

impl Race {
    // 이 메서드는 self가 없습니다. 이것은 정적 메서드 입니다. 
    // No receiver, a static method
    fn new(name: &str) -> Race {  
        Race { name: String::from(name), laps: Vec::new() }
    }

    // 이 메서드는 self에 대한 독점적인 읽기-쓰기 권한을 갖습니다.
    // Exclusive borrowed read-write access to self
    fn add_lap(&mut self, lap: i32) {  
        self.laps.push(lap);
    }

    // 이 메서드는 self 대한 공유 및 읽기전용 빌림 권한을 갖습니다.
    // Shared and read-only borrowed access to self
    fn print_laps(&self) {  
        println!("Recorded {} laps for {}:", self.laps.len(), self.name);
        for (idx, lap) in self.laps.iter().enumerate() {
            println!("Lap {idx}: {lap} sec");
        }
    }

    // 이 메서드는 self의 소유권을 가져옵니다. 
    // self를 반환하지 않기 때문에 이 메서드가 호출 된 후 main에서 race 재사용 할 수 없습니다.
    // Exclusive ownership of self
    fn finish(self) {  
        let total = self.laps.iter().sum::<i32>();
        println!("Race {} is finished, total lap time: {}", self.name, total);
    }
}

fn main() {
    let mut race = Race::new("Monaco Grand Prix");
    race.add_lap(70);
    race.add_lap(68);
    race.print_laps();
    race.add_lap(71);
    race.print_laps();
    race.finish();
}

Pattern Matching

match키워드는 C/C++의 switch와 유사하게 하나 이상의 패턴과 일치 시킬 수 있습니다.

비교동작은 위에서 아래로 진행되며 처음 일치하는 패턴이 실행됩니다.

The match keyword let you match a value against one or more patterns. The comparisons are done from top to bottom and the first match wins.

The patterns can be simple values, similarly to switch in C and C++:

fn main() {
    let input = 'x';

    match input {
        'q'                   => println!("Quitting"),
        'a' | 's' | 'w' | 'd' => println!("Moving around"),
        '0'..='9'             => println!("Number input"),
        _                     => println!("Something else"),
    }
}

_패턴은 어떤 패턴과도 매칭되는 와일드 카드입니다.(default)

The _ pattern is a wildcard pattern which matches any value.

Destructuring Enums

구조체의 바인딩된 값을 패턴으로 사용할 수 있습니다. 간단한 enum 타입의 예시입니다:

Patterns can also be used to bind variables to parts of your values. This is how you inspect the structure of your types. Let us start with a simple enum type:

enum Result {
    Ok(i32),
    Err(String),
}

fn divide_in_two(n: i32) -> Result {
    if n % 2 == 0 {
        Result::Ok(n / 2)
    } else {
        Result::Err(format!("cannot divide {} into two equal parts", n))
    }
}

fn main() {
    let n = 100;
    match divide_in_two(n) {
        Result::Ok(half) => println!("{n} divided in two is {half}"),
        Result::Err(msg) => println!("sorry, an error happened: {msg}"),
    }
}

위의 match구문을 divide_in_two함수에서 반환되는 Result 값을 arm¹으로 분해합니다.

• 첫번째 arm의 half는 Ok variant에 바인딩된 값입니다.(n/2)
• 두번째 amr의 msg는 Err variant에 바인딩 된 에러 메시지 입니다.

Here we have used the arms to destructure the Result value. In the first arm, half is bound to the value inside the Ok variant. In the second arm, msg is bound to the error message.

역주 ¹: match의 패턴 중 하나입니다. (switch의 case에 해당)

Destructuring Structs

구조체역시 분해할 수 있습니다:

You can also destructure structs:

struct Foo {
    x: (u32, u32),
    y: u32,
}

#[rustfmt::skip]
fn main() {
    let foo = Foo { x: (1, 2), y: 3 };
    match foo {
        Foo { x: (1, b), y } => println!("x.0 = 1, b = {b}, y = {y}"),
        Foo { y: 2, x: i }   => println!("y = 2, i = {i:?}"),
        Foo { y, .. }        => println!("y = {y}, other fields were ignored"),
    }
}

Destructuring Arrays

배역 역시 분해가 가능하고, 슬라이스를 적용할 수 있습니다.

You can destructure arrays, tuples, and slices by matching on their elements:

#[rustfmt::skip]
fn main() {
    let triple = [0, -2, 3];
    println!("Tell me about {triple:?}");
    match triple {
        [0, y, z] => println!("First is 0, y = {y}, and z = {z}"),
        [1, ..]   => println!("First is 1 and the rest were ignored"),
        _         => println!("All elements were ignored"),
    }
}

Match Guards

match를 사용할때 각 패턴에 대해서 불리언으로 반환되는 검사식(guard)를 추가할 수 있습니다.

When matching, you can add a guard to a pattern. This is an arbitrary Boolean expression which will be executed if the pattern matches:

#[rustfmt::skip]
fn main() {
    let pair = (2, -2);
    println!("Tell me about {pair:?}");
    match pair {
        (x, y) if x == y     => println!("These are twins"),
        (x, y) if x + y == 0 => println!("Antimatter, kaboom!"),
        (x, _) if x % 2 == 1 => println!("The first one is odd"),
        _                    => println!("No correlation..."),
    }
}

Day 2: Morning Exercises

이번 연습문제들은 두가지 맥락에서 메서드 구현방법을 다룹니다:

• 건강 상태 통계를 추적하는 프로그램의 간단한 구조체.
• 드로잉 라이브러리를 위한 다중 구조체 및 열거헝.

We will look at implementing methods in two contexts:

• Simple struct which tracks health statistics.
• Multiple structs and enums for a drawing library.

Health Statistics

당신은 건강 상태를 모니터링하는 시스템을 구현하는 일을 하고 있습니다. 그 일환으로 당신은 사용자의 건강 상태 통계를 추적해야합니다.

You’re working on implementing a health-monitoring system. As part of that, you need to keep track of users’ health statistics.

당신의 목표는 User구조체의 impl블록의 빈 함수fmf 구현하는 것입니다.

You’ll start with some stubbed functions in an impl block as well as a User struct definition. Your goal is to implement the stubbed out methods on the User struct defined in the impl block.

아래 코드를 https://play.rust-lang.org/에 복사해서 빠진 메서드를 구현하시면 됩니다:

Copy the code below to https://play.rust-lang.org/ and fill in the missing methods:

// TODO: remove this when you're done with your implementation.
#![allow(unused_variables, dead_code)]

struct User {
    name: String,
    age: u32,
    weight: f32,
}

impl User {
    pub fn new(name: String, age: u32, weight: f32) -> Self {
        unimplemented!()
    }

    pub fn name(&self) -> &str {
        unimplemented!()
    }

    pub fn age(&self) -> u32 {
        unimplemented!()
    }

    pub fn weight(&self) -> f32 {
        unimplemented!()
    }

    pub fn set_age(&mut self, new_age: u32) {
        unimplemented!()
    }

    pub fn set_weight(&mut self, new_weight: f32) {
        unimplemented!()
    }
}

fn main() {
    let bob = User::new(String::from("Bob"), 32, 155.2);
    println!("I'm {} and my age is {}", bob.name(), bob.age());
}

#[test]
fn test_weight() {
    let bob = User::new(String::from("Bob"), 32, 155.2);
    assert_eq!(bob.weight(), 155.2);
}

#[test]
fn test_set_age() {
    let mut bob = User::new(String::from("Bob"), 32, 155.2);
    assert_eq!(bob.age(), 32);
    bob.set_age(33);
    assert_eq!(bob.age(), 33);
}

역주

• 딱히 난이도가 없는 문제라 힌트는 없습니다.
• 플레이그라운드 기준 warning이 좀 있는데 테스트나 실행은 정상이네요

Polygon Struct

우리는 몇개의 꼭지점을 가진 다각형을 표현하는 구조체를 만들 것입니다.

아래 코드를 https://play.rust-lang.org/에 복사해서 테스트가 통과하도록 빠진 메서드를 구현하시면 됩니다:

We will create a Polygon struct which contain some points. Copy the code below to https://play.rust-lang.org/ and fill in the missing methods to make the tests pass:

// TODO: remove this when you're done with your implementation.
#![allow(unused_variables, dead_code)]

pub struct Point {
    // add fields
}

impl Point {
    // add methods
}

pub struct Polygon {
    // add fields
}

impl Polygon {
    // add methods
}

pub struct Circle {
    // add fields
}

impl Circle {
    // add methods
}

pub enum Shape {
    Polygon(Polygon),
    Circle(Circle),
}

#[cfg(test)]
mod tests {
    use super::*;

    fn round_two_digits(x: f64) -> f64 {
        (x * 100.0).round() / 100.0
    }

    #[test]
    fn test_point_magnitude() {
        let p1 = Point::new(12, 13);
        assert_eq!(round_two_digits(p1.magnitude()), 17.69);
    }

    #[test]
    fn test_point_dist() {
        let p1 = Point::new(10, 10);
        let p2 = Point::new(14, 13);
        assert_eq!(round_two_digits(p1.dist(p2)), 5.00);
    }

    #[test]
    fn test_point_add() {
        let p1 = Point::new(16, 16);
        let p2 = p1 + Point::new(-4, 3);
        assert_eq!(p2, Point::new(12, 19));
    }

    #[test]
    fn test_polygon_left_most_point() {
        let p1 = Point::new(12, 13);
        let p2 = Point::new(16, 16);

        let mut poly = Polygon::new();
        poly.add_point(p1);
        poly.add_point(p2);
        assert_eq!(poly.left_most_point(), Some(p1));
    }

    #[test]
    fn test_polygon_iter() {
        let p1 = Point::new(12, 13);
        let p2 = Point::new(16, 16);

        let mut poly = Polygon::new();
        poly.add_point(p1);
        poly.add_point(p2);

        let points = poly.iter().cloned().collect::<Vec<_>>();
        assert_eq!(points, vec![Point::new(12, 13), Point::new(16, 16)]);
    }

    #[test]
    fn test_shape_circumferences() {
        let mut poly = Polygon::new();
        poly.add_point(Point::new(12, 13));
        poly.add_point(Point::new(17, 11));
        poly.add_point(Point::new(16, 16));
        let shapes = vec![
            Shape::from(poly),
            Shape::from(Circle::new(Point::new(10, 20), 5)),
        ];
        let circumferences = shapes
            .iter()
            .map(Shape::circumference)
            .map(round_two_digits)
            .collect::<Vec<_>>();
        assert_eq!(circumferences, vec![15.48, 31.42]);
    }
}

#[allow(dead_code)]
fn main() {}

역주

• 구현체의 +(Add), -(Sub)까지 구현하게 만들었는데 난이도가 꽤 높습니다
• shape와 관련된 impl도 구현해야합니다.
• 일단 실행해서 컴파일러 오류를 잡아가는 TDD로 진행해야 그나마(…) 수월하네요

#![allow(unused)]
fn main() {
impl std::ops::Add for Point {
    type Output = Self;

    fn add(self, other: Self) -> Self::Output {
        Self {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

impl std::ops::Sub for Point {
    type Output = Self;

    fn sub(self, other: Self) -> Self::Output {
        Self {
            x: self.x - other.x,
            y: self.y - other.y,
        }
    }
}
impl From<Polygon> for Shape {
    fn from(poly: Polygon) -> Self {
        Shape::Polygon(poly)
    }
}

impl From<Circle> for Shape {
    fn from(circle: Circle) -> Self {
        Shape::Circle(circle)
    }
}
}

Control Flow

앞에서 살펴본 바와 같이 러스트의 표현식으로써 if는 두 블록 중 하나를 조건에 따라 평가(반환)하며, 블록은 if 표현식의 값이 되는 값을 가질 수 있습니다. 다른 흐름제어 표현식도 러스트에서 유사하게 작동합니다.

As we have seen, if is an expression in Rust. It is used to conditionally evaluate one of two blocks, but the blocks can have a value which then becomes the value of the if expression. Other control flow expressions work similarly in Rust.

Blocks

러스트에서 블록은 값과 타입을 갖습니다: 블록의 표현식이 값이 됩니다.

A block in Rust has a value and a type: the value is the last expression of the block:

fn main() {
    let x = {
        let y = 10;
        println!("y: {y}");
        let z = {
            let w = {
                3 + 4
            };
            println!("w: {w}");
            y * w
        };
        println!("z: {z}");
        z - y
    };
    println!("x: {x}");
}

함수에도 동일한 규칙이 적용됩니다: 함수바디의 (마지막) 값이 반환 값이 됩니다.

The same rule is used for functions: the value of the function body is the return value:

fn double(x: i32) -> i32 {
    x + x
}

fn main() {
    println!("doubled: {}", double(7));
}

역주

• 마지막 줄에 ; 없는 부분을 구문(statements)이 아니라 표현식(expressions)이라고 합니다.
• 블록에서 구문+ 마지막 표현식 인경우 해당 함수를 표현식으로 봅니다.

if expressions

if문은 다른 언어와 동일하게 사용할수 있습니다(조건의 ()는 없습니다):

You use if very similarly to how you would in other languages:

fn main() {
    let mut x = 10;
    if x % 2 == 0 {
        x = x / 2;
    } else {
        x = 3 * x + 1;
    }
}

게다가 if는 표현식(할당가능)으로 사용 될수도 있습니다. 아래 코드는 위와 동일한 결과 입니다.

In addition, you can use it as an expression. This does the same as above:

fn main() {
    let mut x = 10;
    x = if x % 2 == 0 {
        x / 2
    } else {
        3 * x + 1
    };
}

if let expressions

if let문을 사용하면 값을 패턴매칭에 사용할 수 있습니다:

If you want to match a value against a pattern, you can use if let:

fn main() {
    let arg = std::env::args().next();
    if let Some(value) = arg {
        println!("Program name: {value}");
    } else {
        println!("Missing name?");
    }
}

러스트의 패턴매칭을 참조하세요

See pattern matching for more details on patterns in Rust.

while expressions

while 역시 다른 언어와 동일한 사용법을 갖습니다:

The while keyword works very similar to other languages:

fn main() {
    let mut x = 10;
    while x != 1 {
        x = if x % 2 == 0 {
            x / 2
        } else {
            3 * x + 1
        };
    }
    println!("Final x: {x}");
}

while let expressions

if와 동일하게 while let구문 역시 패턴매칭에 사용 할 수 있습니다.

Like with if, there is a while let variant which repeatedly tests a value against a pattern:

fn main() {
    let v = vec![10, 20, 30];
    let mut iter = v.into_iter();

    while let Some(x) = iter.next() {
        println!("x: {x}");
    }
}

v.iter()가 반환한 반복자는 next()가 호출될 때마다 Option<i32>를 반환합니다. 이는 None이 호출되기 전까지 Some(x)를 반환한다는 의미로 결과적으로 while let은 반복자의 모든 아이템을 반복하도록 하게 해줍니다.

러스트의 패턴매칭을 참조하세요

Here the iterator returned by v.iter() will return a Option<i32> on every call to next(). It returns Some(x) until it is done, after which it will return None. The while let lets us keep iterating through all items.

See pattern matching for more details on patterns in Rust.

for expressions

for표현식은 while let 표현식과 매우 유사합니다. for표현식은 자동으로 into_iter()를 호출한 다음 이를 반복합니다.

The for expression is closely related to the while let expression. It will automatically call into_iter() on the expression and then iterate over it:

fn main() {
    let v = vec![10, 20, 30];

    for x in v {
        println!("x: {x}");
    }
}

역시 다른언어와 마찬가지로 break 와 continue를 사용할 수 있습니다.

You can use break and continue here as usual.

loop expressions

마지막으로 loop키워드는 무한한 루프를 생성합니다. 따라서 반드시 break 또는 return를 사용해서 루프를 정지해야 합니다:

Finally, there is a loop keyword which creates an endless loop. Here you must either break or return to stop the loop:

fn main() {
    let mut x = 10;
    loop {
        x = if x % 2 == 0 {
            x / 2
        } else {
            3 * x + 1
        };
        if x == 1 {
            break;
        }
    }
    println!("Final x: {x}");
}

match expressions

마치 if let를 여러개 적용한 것과 같이 match키워드는 하나 이상의 패턴을 찾는데 사용됩니다.

The match keyword is used to match a value against one or more patterns. In that sense, it works like a series of if let expressions:

fn main() {
    match std::env::args().next().as_deref() {
        Some("cat") => println!("Will do cat things"),
        Some("ls")  => println!("Will ls some files"),
        Some("mv")  => println!("Let's move some files"),
        Some("rm")  => println!("Uh, dangerous!"),
        None        => println!("Hmm, no program name?"),
        _           => println!("Unknown program name!"),
    }
}

if let처럼 각 매치 암(match arm)의 마지막 표현식이 타입이 되며 모든 암은 동일한 타입이어야 합니다. 위의 예제에서 타입은 ()(반환값 없음)입니다.

러스트의 패턴매칭을 참조하세요

Like if let, each match arm must have the same type. The type is the last expression of the block, if any. In the example above, the type is ().

See pattern matching for more details on patterns in Rust.

역주

• 원문이 좀 난해한데, 예시에서 각 암의 타입은 리턴 없음(출력만 하고 끝)입니다(러스트에서() 라고 합니다. 함수 소스 중간 주석 참조)
• 각 암도 블록{}으로 표현가능하고 이 역시 함수처럼 마지막 표현식으로 리턴 시킬 수 있는데 이를 각 암의 타입으로 한다는 의미.
• 예제를 여러 반환식으로 테스트 해보시기 바랍니다.

break and continue

만약 루프를 중간에 멈추고 십다면 break를, 바로 다음 반복으로 넘어가기 위해서는 continue를 사용합니다. 두 키워드 모두 중첩 루프에서 label로 표기한 인수를 취하여 제어 할 수 있습니다.

If you want to exit a loop early, use break, if you want to immediately start the next iteration use continue. Both continue and break can optionally take a label argument which is used to break out of nested loops:

fn main() {
    let v = vec![10, 20, 30];
    let mut iter = v.into_iter();
    'outer: while let Some(x) = iter.next() {
        println!("x: {x}");
        let mut i = 0;
        while i < x {
            println!("x: {x}, i: {i}");
            i += 1;
            if i == 3 {
                break 'outer;
            }
        }
    }
}

위 예제는 중접루프를 3회 반복한 후 바깥루프(‘outer’ 레이블)을 정지합니다.(종료)

In this case we break the outer loop after 3 iterations of the inner loop.

Standard Library

러스트는 러스트 라이브러리와 프로그램에서 사용되는 공통 타입을 설정하는 데 도움을 주는 표준 라이브러리와 함께 제공 됩니다. 이렇게 하면 두 라이브러리 모두 같은 String 타입을 사용하기 때문에 원활하게 함께 작동할 수 있습니다.

Rust comes with a standard library which helps establish a set of common types used by Rust library and programs. This way, two libraries can work together smoothly because they both use the same String type.

일반적인 타입은 아래와 같습니다:

The common vocabulary types include:

• Option and Result 타입: 선택적 옵션 값과 error handling에 사용됩니다.
• String: 소유 데이터에서 사용되는 기본적인 문자열 타입입니다.
• Vec: 확장가능한 표준 벡터 타입입니다.
• HashMap: 구성 가능한 해시 알고리즘을 가지는 해쉬 맵 타입입니다
• Box: 힙에 할당된 데이터에 대한 소유 포인터입니다.
• Rc: 힙에 할당된 데이터에 대한 참조 카운팅 공유 포인트입니다.

• Option and Result types: used for optional values and error handling.
• String: the default string type used for owned data.
• Vec: a standard extensible vector.
• HashMap: a hash map type with a configurable hashing algorithm.
• Box: an owned pointer for heap-allocated data.
• Rc: a shared reference-counted pointer for heap-allocated data.

String

String은 힙에 할당된 확장가능한 표준 UTF-8 문자열 버퍼입니다.

String is the standard heap-allocated growable UTF-8 string buffer:

fn main() {
    let mut s1 = String::new();
    s1.push_str("Hello");
    println!("s1: len = {}, capacity = {}", s1.len(), s1.capacity());

    let mut s2 = String::with_capacity(s1.len() + 1);
    s2.push_str(&s1);
    s2.push('!');
    println!("s2: len = {}, capacity = {}", s2.len(), s2.capacity());
}

String은 Deref<Target = str>을 구현합니다. 이는 , String에서 모든 str관련 메서드를 호출 할 수 있다는 의미 입니다.

String implements Deref<Target = str>, which means that you can call all str methods on a String.

Option and Result

이 타입은 선택가능한 데이터를 표시합니다:

The types represent optional data:

fn main() {
    let numbers = vec![10, 20, 30];
    let first: Option<&i8> = numbers.first();
    println!("first: {first:?}");

    let idx: Result<usize, usize> = numbers.binary_search(&10);
    println!("idx: {idx:?}");
}

Vec

Vec 는 힙 할당된 표준 가변크기 버퍼입니다.

Vec is the standard resizable heap-allocated buffer:

fn main() {
    let mut numbers = Vec::new();
    numbers.push(42);

    let mut v1 = Vec::new();
    v1.push(42);
    println!("v1: len = {}, capacity = {}", v1.len(), v1.capacity());

    let mut v2 = Vec::with_capacity(v1.len() + 1);
    v2.extend(v1.iter());
    v2.push(9999);
    println!("v2: len = {}, capacity = {}", v2.len(), v2.capacity());
}

Vec은 Deref<Target = [T]>를 구현합니다. 이는 Vec에서 슬라이스 메서드(배열 관련 메서드)를 호출 할 수 있다는 의미입니다.

Vec implements Deref<Target = [T]>, which means that you can call slice methods on a Vec.

HashMap

HashDoS¹ 공격으로부터 보호되는 표준 해시 맵입니다.

Standard hash map with protection against HashDoS attacks:

use std::collections::HashMap;

fn main() {
    let mut page_counts = HashMap::new();
    page_counts.insert("Adventures of Huckleberry Finn".to_string(), 207);
    page_counts.insert("Grimms' Fairy Tales".to_string(), 751);
    page_counts.insert("Pride and Prejudice".to_string(), 303);

    if !page_counts.contains_key("Les Misérables") {
        println!("We've know about {} books, but not Les Misérables.",
                 page_counts.len());
    }

    for book in ["Pride and Prejudice", "Alice's Adventure in Wonderland"] {
        match page_counts.get(book) {
            Some(count) => println!("{book}: {count} pages"),
            None => println!("{book} is unknown.")
        }
    }
}

역주

Box

Box는 힙 데이터에 대한 소유 포인터입니다:

Box is an owned pointer to data on the heap:

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

Box<T>은 Deref<Target = T>를 구현합니다. 이는 Box<T>에서 T 관련 메서드를 직접 호출 할 수 있다는 의미입니다.

Box<T> implements Deref<Target = T>, which means that you can call methods from T directly on a Box<T>.

역주

• 일종의 래핑 객체라서 타입을 담는 ‘상자’ 라는 의미인듯 합니다.

Box with Recursive Data Structures

재귀 데이터나 동적크기의 데이터 타입은 Box타입을 사용해야 합니다.

Recursive data types or data types with dynamic sizes need to use a Box:

#[derive(Debug)]
enum List<T> {
    Cons(T, Box<List<T>>),
    Nil,
}

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

Niche Optimization

#[derive(Debug)]
enum List<T> {
    Cons(T, Box<List<T>>),
    Nil,
}

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

Box는 비어있을 수 없습니다. 따라서 포인트는 항상 유효하고 null이 아닙니다. 이는 컴파일러가 메모리 레이아웃을 최적화 할 수 있게 해줍니다.

A Box cannot be empty, so the pointer is always valid and non-null. This allows the compiler to optimize the memory layout:

Rc

Rc는 참조 카운팅 공유 포인트입니다. 여러 위치의 동일한 데이터를 참조해야할 경우 사용합니다:

Rc is a reference-counted shared pointer. Use this when you need to refer to the same data from multiple places:

use std::rc::Rc;

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

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

Rc내부의 데이터를 변경해야 하는 경우, 데이터를 Cell 또는 RefCell로 래핑해야합니다. 멀티스레드인 경우 Arc 참조

If you need to mutate the data inside an Rc, you will need to wrap the data in a type such as Cell or RefCell. See Arc if you are in a multi-threaded context.

Modules

impl블록은 네임스페이스함수를 타입으로 제공합니다. mod 역시 네임스페이스 타입과 함수를 제공합니다:

We have seen how impl blocks let us namespace functions to a type. Similarly, mod lets us namespace types and functions:

mod foo {
    pub fn do_something() {
        println!("In the foo module");
    }
}

mod bar {
    pub fn do_something() {
        println!("In the bar module");
    }
}

fn main() {
    foo::do_something();
    bar::do_something();
}

Visibility

모듈의 기본 접근자는 private 입니다:

• 모듈의 항목은 기본적으로 private 입니다.(구현에서 숨겨짐)
• 부모와 이웃 항목에서는 접근 가능합니다.

Modules are a privacy boundary:

• Module items are private by default (hides implementation details).
• Parent and sibling items are always visible.

mod outer {
    fn private() {
        println!("outer::private");
    }

    pub fn public() {
        println!("outer::public");
    }

    mod inner {
        fn private() {
            println!("outer::inner::private");
        }

        pub fn public() {
            println!("outer::inner::public");
            super::private();
        }
    }
}

fn main() {
    outer::public();
}

Paths

경로는 아래와 같이 구분합니다:

1. 상대경로

• foo 또는 self::foo는 foo모듈 안에서 현재 모듈을 가리킵니다.
• super::foo는 foo모듈의 부모 모듈을 가리킵니다.

2. 절대 경로

• crate::foo는 현재 크레이트 루트의 있는 foo를 가리킵니다.
• bar::foo는 bar크레이트 안에 있는 foo를 가리킵니다.

Paths are resolved as follows:

1. As a relative path:

   • foo or self::foo refers to foo in the current module,
   • super::foo refers to foo in the parent module.

2. As an absolute path:

   • crate::foo refers to foo in the root of the current crate,
   • bar::foo refers to foo in the bar crate.

역주

• crate: 러스트의 기본 패키지 혹은 라이브러리의 단위입니다. std를 기본 라이브러리 / 기본 크레이트 라고 합니다.

Filesystem Hierarchy

모듈의 내용은 생략될 수 있습니다:

The module content can be omitted:

mod garden;

garden 모듈의 내용은 아래 위치에서 확인 할 수 있습니다.

The garden module content is found at:

• src/garden.rs (modern Rust 2018 style)
• src/garden/mod.rs (older Rust 2015 style)

유사하게 garden::vegetables 모듈은 아래 위치에서 확인할 수 있습니다.

Similarly, a garden::vegetables module can be found at:

• src/garden/vegetables.rs (modern Rust 2018 style)
• src/garden/vegetables/mod.rs (older Rust 2015 style)

crate(크레이트)의 루트는 아래 경로 입니다:

The crate root is in:

• src/lib.rs (for a library crate)
• src/main.rs (for a binary crate)

Day 2: Afternoon Exercises

이번 연습문제는 문자열과 반복자에 초점을 맞출 것입니다.

The exercises for this afternoon will focus on strings and iterators.

Luhn Algorithm

룬 알고리즘은 신용카드 번호 검증에 사용되는 알고리즘 입니다. 이 알고리즘은 신용카드 번호를 문자열로 입력받고, 아래의 순서에 따라 신용카드 번호의 유효성을 확인합니다:

The Luhn algorithm is used to validate credit card numbers. The algorithm takes a string as input and does the following to validate the credit card number:

• 모든 공백을 무시합니다, 2자리 미만 숫자는 무시합니다.
• 오른쪽에서 왼쪽으로 이동하며 2번째 자리마다 숫자를 2배 증가시킵니다. 1234에서 3과 1을 두배로 만듭니다.(2464)
• 두배로 만든 숫자가 2자리가 넘으면 각 자리를 더합니다: 7의 두배는 14이므로 5가 됩니다.
• 모든 자리의 숫자를 합합니다.
• 합계의 끝자리가 0인 경우 유효한 신용카드 번호 입니다.

• Ignore all spaces. Reject number with less than two digits.
• Moving from right to left, double every second digit: for the number 1234, we double 3 and 1.
• After doubling a digit, sum the digits. So doubling 7 becomes 14 which becomes 5.
• Sum all the undoubled and doubled digits.
• The credit card number is valid if the sum is ends with 0.

아래 코드를 https://play.rust-lang.org/에 복사하고 함수를 구현해 보시기 바랍니다.

Copy the following code to https://play.rust-lang.org/ and implement the function:

// TODO: remove this when you're done with your implementation.
#![allow(unused_variables, dead_code)]

pub fn luhn(cc_number: &str) -> bool {
    unimplemented!()
}

#[test]
fn test_non_digit_cc_number() {
    assert!(!luhn("foo"));
}

#[test]
fn test_empty_cc_number() {
    assert!(!luhn(""));
    assert!(!luhn(" "));
    assert!(!luhn("  "));
    assert!(!luhn("    "));
}

#[test]
fn test_single_digit_cc_number() {
    assert!(!luhn("0"));
}

#[test]
fn test_two_digit_cc_number() {
    assert!(luhn(" 0 0 "));
}

#[test]
fn test_valid_cc_number() {
    assert!(luhn("4263 9826 4026 9299"));
    assert!(luhn("4539 3195 0343 6467"));
    assert!(luhn("7992 7398 713"));
}

#[test]
fn test_invalid_cc_number() {
    assert!(!luhn("4223 9826 4026 9299"));
    assert!(!luhn("4539 3195 0343 6476"));
    assert!(!luhn("8273 1232 7352 0569"));
}

#[allow(dead_code)]
fn main() {}

역주

• 관련 메서드 확인을 위한 공식문서 서칭만 좀 하면 단순한 스트링 파싱 알고리즘이라…

Strings and Iterators

이번 훈련은 웹 서버의 라우팅 컴포넌트를 구현합니다. 서버는 _요청경로(request path)_와 일치하는 여러개의 _경로 접두사(path prefixes)_로 구성되어 있습니다. 경로 접두사에는 와일드카드문자를 포함할 수 있습니다. 아래 테스트 코드를 참조하세요

In this exercise, you are implementing a routing component of a web server. The server is configured with a number of path prefixes which are matched against request paths. The path prefixes can contain a wildcard character which matches a full segment. See the unit tests below.

아래 코드를 https://play.rust-lang.org/에 복사하고 테스트를 통과해 보시기 바랍니다. 중간 결과값을 Vec에 할당하지 않도록 주의 하시기 바랍니다.

Copy the following code to https://play.rust-lang.org/ and make the tests pass. Try avoiding allocating a Vec for your intermediate results:

#![allow(unused)]
fn main() {
// TODO: remove this when you're done with your implementation.
#![allow(unused_variables, dead_code)]

pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {
    unimplemented!()
}

#[test]
fn test_matches_without_wildcard() {
    assert!(prefix_matches("/v1/publishers", "/v1/publishers"));
    assert!(prefix_matches("/v1/publishers", "/v1/publishers/abc-123"));
    assert!(prefix_matches("/v1/publishers", "/v1/publishers/abc/books"));

    assert!(!prefix_matches("/v1/publishers", "/v1"));
    assert!(!prefix_matches("/v1/publishers", "/v1/publishersBooks"));
    assert!(!prefix_matches("/v1/publishers", "/v1/parent/publishers"));
}

#[test]
fn test_matches_with_wildcard() {
    assert!(prefix_matches(
        "/v1/publishers/*/books",
        "/v1/publishers/foo/books"
    ));
    assert!(prefix_matches(
        "/v1/publishers/*/books",
        "/v1/publishers/bar/books"
    ));
    assert!(prefix_matches(
        "/v1/publishers/*/books",
        "/v1/publishers/foo/books/book1"
    ));

    assert!(!prefix_matches("/v1/publishers/*/books", "/v1/publishers"));
    assert!(!prefix_matches(
        "/v1/publishers/*/books",
        "/v1/publishers/foo/booksByAuthor"
    ));
}
}

역주

• 단순 파싱인데 제약조건에 주의 하세요. (Vec 사용금지)
• match 활용인데 개인적으론 좀 낮선 방법이라 익숙해질 필요가 있습니다.

Welcome to Day 3

이번 강의는 Rust의 며가지 고급 주제를 다룹니다:

• 트레이트: 트레이트 파생(derive), 기본 메서드, 주요 표준라이브러리 트레이트
• 제너릭: 제너릭 데이터 타입, 제너릭 메서드, 단형화(monomorphization), 그리고 트레이트 객체
• 오류처리(에러 핸들링): 패닉, Result, ?연산자(시행 연산자)
• 테스트: 단위 테스트, 문서 테스트 및 통합 테스트
• 안전하지 않은 러스트: 원시(raw) 포인터, 정적 변수, 안전하지 않은 함수, 외부 함수

Today, we will cover some more advanced topics of Rust:

• Traits: deriving traits, default methods, and important standard library traits.
• Generics: generic data types, generic methods, monomorphization, and trait objects.
• Error handling: panics, Result, and the try operator ?.
• Testing: unit tests, documentation tests, and integration tests.
• Unsafe Rust: raw pointers, static variables, unsafe functions, and extern functions.

Traits

러스트는 인터페이스 처럼 트레이트가 있는 타입을 추상화 할 수 있습니다:

Rust lets you abstract over types with traits. They’re similar to interfaces:

trait Greet {
    fn say_hello(&self);
}

struct Dog {
    name: String,
}
// name 없음. 고양이는 어쨋든 반응하지 않습니다...
// No name, cats won't respond to it anyway.
struct Cat;  

impl Greet for Dog {
    fn say_hello(&self) {
        println!("Wuf, my name is {}!", self.name);
    }
}

impl Greet for Cat {
    fn say_hello(&self) {
        println!("Miau!");
    }
}

fn main() {
    let pets: Vec<Box<dyn Greet>> = vec![
        Box::new(Dog { name: String::from("Fido") }),
        Box::new(Cat),
    ];
    for pet in pets {
        pet.say_hello();
    }
}

Deriving Traits

컴차일러가 여러가지 트레이트를 파생(derive)하도록 할 수 있습니다:

You can let the compiler derive a number of traits:

#[derive(Debug, Clone, PartialEq, Eq, Default)]
struct Player {
    name: String,
    strength: u8,
    hit_points: u8,
}

fn main() {
    let p1 = Player::default();
    let p2 = p1.clone();
    println!("Is {:?}\nequal to {:?}?\nThe answer is {}!", &p1, &p2,
             if p1 == p2 { "yes" } else { "no" });
}

Default Methods

트레이트는 다른 트레이트 메서드에서의 동작을 구현할 수 있습니다.

Traits can implement behavior in terms of other trait methods:

trait Equals {
    fn equal(&self, other: &Self) -> bool;
    fn not_equal(&self, other: &Self) -> bool {
        !self.equal(other)
    }
}

#[derive(Debug)]
struct Centimeter(i16);

impl Equals for Centimeter {
    fn equal(&self, other: &Centimeter) -> bool {
        self.0 == other.0
    }
}

fn main() {
    let a = Centimeter(10);
    let b = Centimeter(20);
    println!("{a:?} equals {b:?}: {}", a.equal(&b));
    println!("{a:?} not_equals {b:?}: {}", a.not_equal(&b));
}

역주

• Equals 트레이트에서 equal은 선언만 되어있고 not_equal에서 이를 호출하고 있습니다. (추상 메서드)
• impl에서 equal 메서드를 정의하고 있어서 Centimeter에서의 equal 메서드를 구현되어 있습니다.(추상 메서드 구현)

Important Traits

러스트 표준 라이브러리의 자주 사용하는 몇가지 트레이트 예시입니다:

• Iterator와 IntoIterator 트레이트는 for 루프에서 사용됩니다.
• From과 Into 트레이트는 타입변환시 사용됩니다.
• Read와 Write 트레이트는 I/O에 사용됩니다.
• Add, Mul 등의 트레이트들은 연산자 오버로딩(overloading)에 사용됩니다.
• Drop 트레이트는 소멸자 정의에 사용됩니다.

We will now look at some of the most common traits of the Rust standard library:

• Iterator and IntoIterator used in for loops,
• From and Into used to convert values,
• Read and Write used for IO,
• Add, Mul, … used for operator overloading, and
• Drop used for defining destructors.

Iterators

Iterator를 커스텀 타입에 구현할 수 있습니다:

You can implement the Iterator trait on your own types:

struct Fibonacci {
    curr: u32,
    next: u32,
}

impl Iterator for Fibonacci {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        let new_next = self.curr + self.next;
        self.curr = self.next;
        self.next = new_next;
        Some(self.curr)
    }
}

fn main() {
    let fib = Fibonacci { curr: 0, next: 1 };
    for (i, n) in fib.enumerate().take(5) {
        println!("fib({i}): {n}");
    }
}

역주

• 이터레이터 트레이트의 next()를 오버로딩한 예제

From and Into

타입은 용이한 형변환을 위해 From과 Into를 구현합니다:

Types implement From and Into to facilitate type conversions:

fn main() {
    let s = String::from("hello");
    let addr = std::net::Ipv4Addr::from([127, 0, 0, 1]);
    let one = i16::from(true);
    let bigger = i32::from(123i16);
    println!("{s}, {addr}, {one}, {bigger}");
}

From이 구현되면 Into 역시 자동으로 구현됩니다:

Into is automatically implemented when From is implemented:

fn main() {
    let s: String = "hello".into();
    let addr: std::net::Ipv4Addr = [127, 0, 0, 1].into();
    let one: i16 = true.into();
    let bigger: i32 = 123i16.into();
    println!("{s}, {addr}, {one}, {bigger}");
}

Read and Write

Read와 BufRead를 사용하면 u8 소스로부터 읽을 수 있습니다:

Using Read and BufRead, you can abstract over u8 sources:

use std::io::{BufRead, BufReader, Read, Result};

fn count_lines<R: Read>(reader: R) -> usize {
    let buf_reader = BufReader::new(reader);
    buf_reader.lines().count()
}

fn main() -> Result<()> {
    let slice: &[u8] = b"foo\nbar\nbaz\n";
    println!("lines in slice: {}", count_lines(slice));

    let file = std::fs::File::open(std::env::current_exe()?)?;
    println!("lines in file: {}", count_lines(file));
    Ok(())
}

유사하게 Write를 통해 u8소스로 출력할 수 있습니다:

Similarly, Write lets you abstract over u8 sinks:

use std::io::{Result, Write};

fn log<W: Write>(writer: &mut W, msg: &str) -> Result<()> {
    writer.write_all(msg.as_bytes())?;
    writer.write_all("\n".as_bytes())
}

fn main() -> Result<()> {
    let mut buffer = Vec::new();
    log(&mut buffer, "Hello")?;
    log(&mut buffer, "World")?;
    println!("Logged: {:?}", buffer);
    Ok(())
}

Add, Mul, …

연산자 오버로드는 std::ops 트레이트을 통해 구현됩니다:

Operator overloading is implemented via traits in std::ops:

#[derive(Debug, Copy, Clone)]
struct Point { x: i32, y: i32 }

// + 연산자 오버로딩
impl std::ops::Add for Point {
    type Output = Self;

    fn add(self, other: Self) -> Self {
        Self {x: self.x + other.x, y: self.y + other.y}
    }
}

fn main() {
    let p1 = Point { x: 10, y: 20 };
    let p2 = Point { x: 100, y: 200 };
    println!("{:?} + {:?} = {:?}", p1, p2, p1 + p2);
}

The Drop Trait

Drop트레이트는 값이 스코프 밖으로 나갈때 실행하는 코드를 작성할 수 있습니다:

Values which implement Drop can specify code to run when they go out of scope:

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

Generics

러스트는 제너릭을 지원하여 정렬과 같은 알고리즘에 적용되는 타입을 추상화 할 수 있습니다.

Rust support generics, which lets you abstract an algorithm (such as sorting) over the types used in the algorithm.

Generic Data Types

제너릭을 사용하여 구체적인 타입을 추상화할 수 있습니다:

You can use generics to abstract over the concrete field type:

#[derive(Debug)]
struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
    println!("{integer:?} and {float:?}");
}

Generic Methods

impl 블록에서도 제너릭 타입을 선언할 수 있습니다:

You can declare a generic type on your impl block:

#[derive(Debug)]
struct Point<T>(T, T);

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.0  // + 10
    }

    // fn set_x(&mut self, x: T)
}

fn main() {
    let p = Point(5, 10);
    println!("p.x = {}", p.x());
}

Trait Bounds

T: or impl 트레이트를 사용하여 제너릭을 사용할 때 타입을 제한할 수 있습니다:

When working with generics, you often want to limit the types. You can do this with T: Trait or impl Trait:

fn duplicate<T: Clone>(a: T) -> (T, T) {
    (a.clone(), a.clone())
}

// struct NotClonable;

fn main() {
    let foo = String::from("foo");
    let pair = duplicate(foo);
}

impl Trait

트레이트 바운드와 유사하게 impl트레이트 문법은 함수의 인자와 반환값에 적용 가능합니다:

Similar to trait bounds, an impl Trait syntax can be used in function arguments and return values:

use std::fmt::Display;

fn get_x(name: impl Display) -> impl Display {
    format!("Hello {name}")
}

fn main() {
    let x = get_x("foo");
    println!("{x}");
}

• impl 트레이트는 터보피쉬문법(::<>)에는 사용할 수 없습니다.
• impl 트레이트는 익명타입과 사용할 수 있습니다.

• impl Trait cannot be used with the ::<> turbo fish syntax.
• impl Trait allows you to work with types which you cannot name.

Closures

클로저 혹은 람다표현식은 익명타입입니다. 이들은 Fn, FnMut, FnOnce 라는 특별한 트레이트를 구현합니다.

Closures or lambda expressions have types which cannot be named. However, they implement special Fn, FnMut, and FnOnce traits:

fn apply_with_log(func: impl FnOnce(i32) -> i32, input: i32) -> i32 {
    println!("Calling function on {input}");
    func(input)
}

fn main() {
    let add_3 = |x| x + 3;
    let mul_5 = |x| x * 5;

    println!("add_3: {}", apply_with_log(add_3, 10));
    println!("mul_5: {}", apply_with_log(mul_5, 20));
}

Monomorphization1

제너릭 코드는 호출부에서 비 제너릭 코드로 전환됩니다:

Generic code is turned into non-generic code based on the call sites:

fn main() {
    let integer = Some(5);
    let float = Some(5.0);
}

위 코드는 아래와 같이 동작합니다.

behaves as if you wrote

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

이것은 코스트가 들지 않는 추상화¹입니다: 추상화 없이 직접 코딩한 것과 정확히 같은 결과입니다.

This is a zero-cost abstraction: you get exactly the same result as if you had hand-coded the data structures without the abstraction.

역주

Trait Objects

트레이트를 구현할 때 인수를 취하는 방법:

We’ve seen how a function can take arguments which implement a trait:

use std::fmt::Display;

fn print<T: Display>(x: T) {
    println!("Your value: {}", x);
}

fn main() {
    print(123);
    print("Hello");
}

아래와 같이 여러가지 타입을 혼합하여 인수로 받려면 어떻게 해야 합니까?

However, how can we store a collection of mixed types which implement Display?

fn main() {
    let xs = vec![123, "Hello"];
}

이를 위해서 _트레이트 객체_가 필요합니다:

For this, we need trait objects:

use std::fmt::Display;

fn main() {
    let xs: Vec<Box<dyn Display>> = vec![Box::new(123), Box::new("Hello")];
    for x in xs {
        println!("x: {x}");
    }
}

xs가 할당될때 메모리 레이아웃:

Memory layout after allocating xs:

마찬가지로 트레이트를 구현한 다른 값을 반환할 때도 트레이트 객체가 필요합니다:

Similarly, you need a trait object if you want to return different values implementing a trait:

fn numbers(n: i32) -> Box<dyn Iterator<Item=i32>> {
    if n > 0 {
        Box::new(0..n)
    } else {
        Box::new((n..0).rev())
    }
}

fn main() {
    println!("{:?}", numbers(-5).collect::<Vec<_>>());
    println!("{:?}", numbers(5).collect::<Vec<_>>());
}

Day 3: Morning Exercises

이번 연습문제에서는 트레이트와 트레이트 객체를 통해 고전적인 GUI라이브러리를 설계할 것입니다.

We will design a classical GUI library traits and trait objects.

A Simple GUI Library

트레이트와 트레이트 객체 지식을 활용하여 고전적인 GUI 라이브러리를 설계합니다. 라이브러리에는 몇가지 위젯이 있습니다:

• Window: title 속성과 다른 위젯이 포함됩니다.
• Button: label위젯과 버튼이 눌렸을때 실행되는 콜백 함수가 있습니다.
• Label: label 위젯 입니다. 위젯은 Widget 트레이트를 구현합니다. 아래 코드를 참조하세요

아래 코드를 https://play.rust-lang.org/에 복사하고 누락된 draw_into메서드를 채워 넣어 Widget 트레이트를 완성해봅시다:

Let us design a classical GUI library using our new knowledge of traits and trait objects. We will have a number of widgets in our library:

• Window: has a title and contains other widgets.
• Button: has a label and a callback function which is invoked when the button is pressed.
• Label: has a label.

The widgets will implement a Widget trait, see below.
Copy the code below to https://play.rust-lang.org/, fill in the missing draw_into methods so that you implement the Widget trait:

// TODO: remove this when you're done with your implementation.
#![allow(unused_imports, unused_variables, dead_code)]

pub trait Widget {
    /// Natural width of `self`.
    fn width(&self) -> usize;

    /// Draw the widget into a buffer.
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);

    /// Draw the widget on standard output.
    fn draw(&self) {
        let mut buffer = String::new();
        self.draw_into(&mut buffer);
        println!("{}", &buffer);
    }
}

pub struct Label {
    label: String,
}

impl Label {
    fn new(label: &str) -> Label {
        Label {
            label: label.to_owned(),
        }
    }
}

pub struct Button {
    label: Label,
    callback: Box<dyn FnMut()>,
}

impl Button {
    fn new(label: &str, callback: Box<dyn FnMut()>) -> Button {
        Button {
            label: Label::new(label),
            callback,
        }
    }
}

pub struct Window {
    title: String,
    widgets: Vec<Box<dyn Widget>>,
}

impl Window {
    fn new(title: &str) -> Window {
        Window {
            title: title.to_owned(),
            widgets: Vec::new(),
        }
    }

    fn add_widget(&mut self, widget: Box<dyn Widget>) {
        self.widgets.push(widget);
    }
}


impl Widget for Label {
    fn width(&self) -> usize {
        unimplemented!()
    }

    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        unimplemented!()
    }
}

impl Widget for Button {
    fn width(&self) -> usize {
        unimplemented!()
    }

    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        unimplemented!()
    }
}

impl Widget for Window {
    fn width(&self) -> usize {
        unimplemented!()
    }

    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        unimplemented!()
    }
}

fn main() {
    let mut window = Window::new("Rust GUI Demo 1.23");
    window.add_widget(Box::new(Label::new("This is a small text GUI demo.")));
    window.add_widget(Box::new(Button::new(
        "Click me!",
        Box::new(|| println!("You clicked the button!")),
    )));
    window.draw();
}

위 프로그램의 출력은 아래와 같습니다:

The output of the above program can be something simple like this:

========
Rust GUI Demo 1.23
========

This is a small text GUI demo.

| Click me! |

정력된 글자를 그리기 위해서는 fill/alignment 를 참조하시기 바랍니다. 특수 문자(여기서는 ‘/’)로 패딩을 주는 방법과 정렬을 제어하는 방법을 확인하시기 바랍니다.

If you want to draw aligned text, you can use the fill/alignment formatting operators. In particular, notice how you can pad with different characters (here a '/') and how you can control alignment:

fn main() {
    let width = 10;
    println!("left aligned:  |{:/<width$}|", "foo");
    println!("centered:      |{:/^width$}|", "foo");
    println!("right aligned: |{:/>width$}|", "foo");
}

위의 정렬 트릭을 사용하여 다음과 같은 출력을 생성할 수 있습니다.

Using such alignment tricks, you can for example produce output like this:

+--------------------------------+
|       Rust GUI Demo 1.23       |
+================================+
| This is a small text GUI demo. |
| +-----------+                  |
| | Click me! |                  |
| +-----------+                  |
+--------------------------------+

역주

• 추가 구현할 함수는 없고 impl Widget for ~ 의 두 메서드들만 구현하면 됩니다.
• label에 줄바꿈(개행)문자도 포함될 수 있습니다.\n

Error Handling

러스트의 오류 처리는 명시적인 흐름제어로 처리됩니다:

• 오류를 발생할 수 있는 함수는 반환 타입에 명시합니다.
• 예외는 없습니다.

Error handling in Rust is done using explicit control flow:

• Functions that can have errors list this in their return type,
• There are no exceptions.

Panics

러스트는 런타임에서 치명적인 오류를 만나면 패닉을 발생할 것입니다:

Rust will trigger a panic if a fatal error happens at runtime:

fn main() {
    let v = vec![10, 20, 30];
    println!("v[100]: {}", v[100]);
}

• 패닉은 복구할 수 없고 예상치 못한 오류입니다.
  • 패닉은 프로그램 버그의 증상입니다.
• 충돌(크래시)를 허용하지 않아야 하는 경우 패닉을 유발하지 않는(non-panicking) API를 사용합니다.(Vec::get 등)

• Panics are for unrecoverable and unexpected errors.
  • Panics are symptoms of bugs in the program.
• Use non-panicking APIs (such as Vec::get) if crashing is not acceptable.

역주

• 위 예제에서 v[100]을 v.get(100) 으로 대체해보세요

Catching the Stack Unwinding

기본적으로, 패닉이 발생하면 스택은 해제됩니다. 스택 해제는 다음과 같이 캐치가 가능합니다:

By default, a panic will cause the stack to unwind. The unwinding can be caught:

#![allow(unused)]
fn main() {
use std::panic;

let result = panic::catch_unwind(|| {
    println!("hello!");
});
assert!(result.is_ok());

let result = panic::catch_unwind(|| {
    panic!("oh no!");
});
assert!(result.is_err());
}

• 이것은 단일 요청이 크래시 되더라도 계속 실행되야 하는 서버에 유용합니다.
• Cargo.toml설정파일에 panic = abort을 설정하면 동작하지 않습니다.

• This can be useful in servers which should keep running even if a single request crashes.
• This does not work if panic = abort is set in your Cargo.toml.

Structured Error Handling with Result

Result enum은 흔히 오류를 예상되는 경우 사용됩니다:

We have already seen the Result enum. This is used pervasively when errors are expected as part of normal operation:

use std::fs::File;
use std::io::Read;

fn main() {
    let file = File::open("diary.txt");
    match file {
        Ok(mut file) => {
            let mut contents = String::new();
            file.read_to_string(&mut contents);
            println!("Dear diary: {contents}");
        },
        Err(err) => {
            println!("The diary could not be opened: {err}");
        }
    }
}

Propagating Errors with ?

시도(시행)연산자 ?는 호출자에게 오류를 반환할 때 사용합니다.

The try-operator ? is used to return errors to the caller. It lets you turn the common

match some_expression {
    Ok(value) => value,
    Err(err) => return Err(err),
}

훨씬 간단한 방식으로

into the much simpler

some_expression?

이를 사용하면 오류를 처리할 수 단순화 할 수 있습니다:

We can use this to simplify our error handing code:

use std::fs;
use std::io::{self, Read};

fn read_username(path: &str) -> Result<String, io::Error> {
    let username_file_result = fs::File::open(path);

    let mut username_file = match username_file_result {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut username = String::new();

    match username_file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(e) => Err(e),
    }
}

fn main() {
    //fs::write("config.dat", "alice").unwrap();
    let username = read_username("config.dat");
    println!("username: {username:?}");
}

Converting Error Types

?의 효과적인 적용은 좀 더 복잡하긴 합니다:

The effective expansion of ? is a little more complicated than previously indicated:

expression?

위 표현은 아래와 같습니다.

works the same as

match expression {
    Ok(value) => value,
    Err(err)  => return Err(From::from(err)),
}

From::from 호출은 오류타입을 함수에서 반환하는 타입으로 변환합니다:

The From::from call here means we attempt to convert the error type to the type returned by the function:

use std::{fs, io};
use std::io::Read;

#[derive(Debug)]
enum ReadUsernameError {
    IoError(io::Error),
    EmptyUsername(String),
}

impl From<io::Error> for ReadUsernameError {
    fn from(err: io::Error) -> ReadUsernameError {
        ReadUsernameError::IoError(err)
    }
}

fn read_username(path: &str) -> Result<String, ReadUsernameError> {
    let mut username = String::with_capacity(100);
    fs::File::open(path)?.read_to_string(&mut username)?;
    if username.is_empty() {
        return Err(ReadUsernameError::EmptyUsername(String::from(path)));
    }
    Ok(username)
}

fn main() {
    //fs::write("config.dat", "").unwrap();
    let username = read_username("config.dat");
    println!("username: {username:?}");
}

Deriving Error Enums

thiserror 크레이트는 전페이지에서 처럼 오류 enum을 만드는 일반적인 방법입니다.

The thiserror crate is a popular way to create an error enum like we did on the previous page:

use std::{fs, io};
use std::io::Read;
use thiserror::Error;

#[derive(Error, Debug)]
enum ReadUsernameError {
    #[error("Could not read: {0}")]
    IoError(#[from] io::Error),
    #[error("Found no username in {0}")]
    EmptyUsername(String),
}

fn read_username(path: &str) -> Result<String, ReadUsernameError> {
    let mut username = String::with_capacity(100);
    fs::File::open(path)?.read_to_string(&mut username)?;
    if username.is_empty() {
        return Err(ReadUsernameError::EmptyUsername(String::from(path)));
    }
    Ok(username)
}

fn main() {
    //fs::write("config.dat", "").unwrap();
    match read_username("config.dat") {
        Ok(username) => println!("Username: {username}"),
        Err(err)     => println!("Error: {err}"),
    }
}

Adding Context to Errors

anyhow 크레이트는 오류에 대한 상황정보를 추가하기 위해 널리 사용되며 사용자 정의 오류 유형을 줄일 수 있습니다:

The widely used anyhow crate can help you add contextual information to your errors and allows you to have fewer custom error types:

use std::{fs, io};
use std::io::Read;
use thiserror::Error;
use anyhow::{Context, Result};

#[derive(Error, Debug)]
enum ReadUsernameError {
    #[error("Found no username in {0}")]
    EmptyUsername(String),
}

fn read_username(path: &str) -> Result<String> {
    let mut username = String::with_capacity(100);
    fs::File::open(path)
        .context(format!("Failed to open {path}"))?
        .read_to_string(&mut username)
        .context("Failed to read")?;
    if username.is_empty() {
        return Err(ReadUsernameError::EmptyUsername(String::from(path)))?;
    }
    Ok(username)
}

fn main() {
    //fs::write("config.dat", "").unwrap();
    match read_username("config.dat") {
        Ok(username) => println!("Username: {username}"),
        Err(err)     => println!("Error: {err:?}"),
    }
}

Testing

러스트와 카고(cargo)는 간단한 테스트 프레임워크와 함께 제공됩니다:

• 단위 테스트는 코드 전반에서 지원됩니다.
• 통합테스트는 test/ 폴더를 통해 지원됩니다.

Rust and Cargo come with a simple unit test framework:

• Unit tests are supported throughout your code.
• Integration tests are supported via the tests/ directory.

Unit Tests

단위 테스트는 #[test] 표기로 이뤄집니다:

Mark unit tests with #[test]:

fn first_word(text: &str) -> &str {
    match text.find(' ') {
        Some(idx) => &text[..idx],
        None => &text,
    }
}

#[test]
fn test_empty() {
    assert_eq!(first_word(""), "");
}

#[test]
fn test_single_word() {
    assert_eq!(first_word("Hello"), "Hello");
}

#[test]
fn test_multiple_words() {
    assert_eq!(first_word("Hello World"), "Hello");
}

cargo test 커맨드를 사용하면 단위 테스트를 찾아서 실행합니다.

Use cargo test to find and run the unit tests.

Test Modules

단위 테스트는 종종 중첩 모듈 안에 존재합니다. 플레이그라운드에서 실행하시기 바랍니다)
–> 단위 테스트는 모듈로 분리해서 선언 가능합니다.

Unit tests are often put in a nested module (run tests on the Playground)

fn helper(a: &str, b: &str) -> String {
    format!("{a} {b}")
}

pub fn main() {
    println!("{}", helper("Hello", "World"));
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_helper() {
        assert_eq!(helper("foo", "bar"), "foo bar");
    }
}

• 개별화된 헬퍼모듈을 통해 단위테스트를 수행할 수 있습니다.
• #[cfg(test)] 속성은 오직 cargo test 커맨드 실행인 경우에만 동작합니다.

• This lets you unit test private helpers.
• The #[cfg(test)] attribute is only active when you run cargo test.

Documentation Tests

러스트는 문서화 테스트를 내장하여 제공합니다:

Rust has built-in support for documentation tests:

#![allow(unused)]
fn main() {
/// Shorten string will trip the string to the given length.
///
/// ```
/// use playground::shorten_string;
/// assert_eq!(shorten_string("Hello World", 5), "Hello");
/// assert_eq!(shorten_string("Hello World", 20), "Hello World");
/// ```
pub fn shorten_string(s: &str, length: usize) -> &str {
    &s[..std::cmp::min(length, s.len())]
}
}

• /// 주석은 자동으로 러스트 코드로 표시됩니다.
• 이 코드는 cargo test 커맨드 구동시 컴파일되고 실행됩니다.
• 위 코드를 테스트 해 보시기 바랍니다.Rust Playground.

• Code blocks in /// comments are automatically seen as Rust code.
• The code will be compiled and executed as part of cargo test.
• Test the above code on the Rust Playground.

Integration Tests

라이브러리를 실제 테스트 하기위한 통합테스트는 test/ 폴더 내에 .rs를 작성하여 수행합니다:

If you want to test your library as a client, use an integration test. Create a .rs file under tests/:

use my_library::init;

#[test]
fn test_init() {
    assert!(init().is_ok());
}

이 테스트는 크레이트의 공개 API에만 접근할 수 있습니다.

These tests only have access to the public API of your crate.

Unsafe Rust

러스트의 문법은 크게 두가지 부분으로 나뉩니다:

• 안전한 러스트: 안전한 메모리, 정의되지 않은 동작 가능성 없음.
• 안전하지 않은 러스트: 사전 조건을 위반하는 경우 정의되지 않은 동작을 수행할 수 있습니다.

이 강의는 대부분 안전한 러스트에 대해 다루지만 안전하지 않은 러스트가 무엇인지 알아 두어야 합니다.

안전하지 않은 러스트는 다음과 같은 5가지 새로운 기능을 제공합니다:

• 원시포인트 역참조
• 정적 가변변수 접근 및 수정
• union 필드 접근
• extern함수를 포함한 unsafe 함수 호출
• unsafe 트레이트 구현

위 기능에 대해 간략히 살펴보겠습니다. 자세한 내용은 Chapter 19.1 in the Rust Book 와 Rustonomicon를 참조하세요

The Rust language has two parts:

• Safe Rust: memory safe, no undefined behavior possible.
• Unsafe Rust: can trigger undefined behavior if preconditions are violated.

We will be seeing mostly safe Rust in this course, but it’s important to know what Unsafe Rust is.

Unsafe Rust gives you access to five new capabilities:

• Dereference raw pointers.
• Access or modify mutable static variables.
• Access union fields.
• Call unsafe functions, including extern functions.
• Implement unsafe traits.

We will briefly cover these capabilities next. For full details, please see Chapter 19.1 in the Rust Book and the Rustonomicon.

Dereferencing Raw Pointers

포인트 생성은 안전합니다. 하지만 역참조할 경우 unsafe가 필요합니다:

Creating pointers is safe, but dereferencing them requires unsafe:

fn main() {
    let mut num = 5;

    let r1 = &mut num as *mut i32;
    let r2 = &num as *const i32;

    unsafe {
        println!("r1 is: {}", *r1);
        // 만약 r1이 동시 쓰기가 되면 데이터 레이스가 발생합니다!
        *r1 = 10;  // Data race if r1 is being written concurrently!
        println!("r2 is: {}", *r2);
    }
}

Mutable Static Variables

불변 정적변수를 읽는 것은 ’안전’합니다:

It is safe to read an immutable static variable:

static HELLO_WORLD: &str = "Hello, world!";

fn main() {
    println!("name is: {}", HELLO_WORLD);
}

하지만, 데이터 레이스가 발생할 수 있으므로 정적 가변변수를 읽고 쓰는 것은 ‘안전하지 않습니다’:

However, since data races can occur, it is unsafe to read and write mutable static variables:

static mut COUNTER: u32 = 0;

fn add_to_counter(inc: u32) {
    // 데이터 레이스 가능성 있음
    unsafe { COUNTER += inc; }  // Potential data race!
}

fn main() {
    add_to_counter(42);
    // 데이터 레이스 가능성 있음
    unsafe { println!("COUNTER: {}", COUNTER); }  // Potential data race!
}

Calling Unsafe Functions

다음과 같은 추가 전제 조건이 있는 경우 함수나 메서드는 unsafe 표시할 수 있습니다:

A function or method can be marked unsafe if it has extra preconditions you must uphold:

fn main() {
    let emojis = "🗻∈🌏";
    unsafe {
        // 인덱스가 UTF-8 시퀀스 경계에 있지 않은경우 정의되지 않은 동작입니다.
        // Undefined behavior if indices do not lie on UTF-8 sequence boundaries.
        println!("{}", emojis.get_unchecked(0..4));
        println!("{}", emojis.get_unchecked(4..7));
        println!("{}", emojis.get_unchecked(7..11));
    }
}

Calling External Code

다른 언어의 함수는 러스트의 보증을 위반할 수 있습니다. 따라서 이를 호출하는 것은 ‘안전하지 않습니다’:

Functions from other languages might violate the guarantees of Rust. Calling them is thus unsafe:

extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        // Abs가 오동작하는 경우 정의되지 않은 동작이 됩니다.
        // Undefined behavior if abs misbehaves.
        println!("Absolute value of -3 according to C: {}", abs(-3));
    }
}

Unions

유니온타입은 열거형(enum)과 같지만 직접 활성 필드를 추척해야 합니다:

Unions are like enums, but you need to track the active field yourself:

#[repr(C)]
union MyUnion {
    i: u8,
    b: bool,
}

fn main() {
    let u = MyUnion { i: 42 };
    println!("int: {}", unsafe { u.i });
    // b는 정의 되지 않았습니다!
    println!("bool: {}", unsafe { u.b });  // Undefined behavior!
}

Day 3: Afternoon Exercises

이번 연습문제에서는 파일 폴더를 안전하게 읽을 수 있는 래퍼를 만들어 봅니다.

Let us build a safe wrapper for reading directory content!

Safe FFI Wrapper

러스트는 _외부 기능 호출(FFI)_을 지원합니다. 이를 이용하여 C에서 사용할 폴더 내 파일이름을 읽어오는 glibc함수를 만들 것입니다.

아래 리눅스 메뉴얼 문서들을 참조하시기 바랍니다:

• opendir(3)
• readdir(3)
• closedir(3)

아래 코드를 https://play.rust-lang.org/에 복사하고 빠진 함수와 메서드를 채워봅니다.

Rust has great support for calling functions through a foreign function interface (FFI). We will use this to build a safe wrapper the glibc functions you would use from C to read the filenames of a directory.

You will want to consult the manual pages:

• opendir(3)
• readdir(3)
• closedir(3)

You will also want to browse the std::ffi module, particular for CStr and CString types which are used to hold NUL-terminated strings coming from C. The Nomicon also has a very useful chapter about FFI.

Copy the code below to https://play.rust-lang.org/ and fill in the missing functions and methods:

// TODO: remove this when you're done with your implementation.
#![allow(unused_imports, unused_variables, dead_code)]

mod ffi {
    use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};

    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.
    #[repr(C)]
    pub struct DIR {
        _data: [u8; 0],
        _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
    }

    // Layout as per readdir(3) and definitions in /usr/include/x86_64-linux-gnu.
    #[repr(C)]
    pub struct dirent {
        pub d_ino: c_long,
        pub d_off: c_ulong,
        pub d_reclen: c_ushort,
        pub d_type: c_char,
        pub d_name: [c_char; 256],
    }

    extern "C" {
        pub fn opendir(s: *const c_char) -> *mut DIR;
        pub fn readdir(s: *mut DIR) -> *const dirent;
        pub fn closedir(s: *mut DIR) -> c_int;
    }
}

use std::ffi::{CStr, CString, OsStr, OsString};
use std::os::unix::ffi::OsStrExt;

#[derive(Debug)]
struct DirectoryIterator {
    path: CString,
    dir: *mut ffi::DIR,
}

impl DirectoryIterator {
    fn new(path: &str) -> Result<DirectoryIterator, String> {
        // Call opendir and return a Ok value if that worked,
        // otherwise return Err with a message.
        unimplemented!()
    }
}

impl Iterator for DirectoryIterator {
    type Item = OsString;
    fn next(&mut self) -> Option<OsString> {
        // Keep calling readdir until we get a NULL pointer back.
        unimplemented!()
    }
}

impl Drop for DirectoryIterator {
    fn drop(&mut self) {
        // Call closedir as needed.
        unimplemented!()
    }
}

fn main() -> Result<(), String> {
    let iter = DirectoryIterator::new(".")?;
    println!("files: {:#?}", iter.collect::<Vec<_>>());
    Ok(())
}

역주

• DirectoryIterator, Iterator, Drop impl 블록을 채우면 됩니다.
• 참조문서를 싹 훝어도 어려운데(…)

Welcome to Day 4

오늘 강의는 두가지 주제를 다룹니다:

• 동시성: 쓰레드, 채널, 상태 공유(쉐어 스테이트), Send와 Sync
• 안드로이드: 바이너리와 라이브러리 작성, AIDL 사용, 로깅과 C/C++, 자바와의 상호 운용성

우리는 오늘 당신의 프로젝트를 호출해볼 것입니다. 따라서 가지고 있는 코드 중에 작은 부분을 찾아보세요 종속성이 적고 특이 타입이 적을 수록 좋습니다. raw byte를 분석하는 종류의 것이 이상적입니다.

Today we will look at two main topics:

• Concurrency: threads, channels, shared state, Send and Sync.

• Android: building binaries and libraries, using AIDL, logging, and interoperability with C, C++, and Java.

We will attempt to call Rust from one of your own projects today. So try to find a little corner of your code base where we can move some lines of code to Rust. The fewer dependencies and “exotic” types the better. Something that parses some raw bytes would be ideal.

Fearless Concurrency

러스트는 뮤텍스와 채널이 있는 OS 스레드를 사용하여 동시성을 완전히 지원합니다. 러스트의 타입 시스템은 많은 동시성 버그가 컴파일 시 버그를 일으키는 중요한 역할을 합니다. 이는 컴파일러를 사용하여 런타임의 정확성을 보장할 수 있기 때문에 종종 _겁없는 동시성(fearless concurrency)_라고 합니다.

Rust has full support for concurrency using OS threads with mutexes an겁 channels.

The Rust type system plays an important role in making many concurrency bugs compile time bugs. This is often referred to as fearless concurrency since you can rely on the compiler to ensure correctness at runtime.

역주

• 두번째 문장이 미묘한데 런타임이 아니라 컴파일시 체크될 수 있게 해줘서 (런타임시)정확성을 보장해준다로 이해됩니다.

Threads

러스트의 스레드는 다른 언어의 스레드와 유사하게 동작합니다:

Rust threads work similarly to threads in other languages:

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..10 {
            println!("Count in thread: {i}!");
            thread::sleep(Duration::from_millis(5));
        }
    });

    for i in 1..5 {
        println!("Main thread: {i}");
        thread::sleep(Duration::from_millis(5));
    }
}

• 스레드는 모두 데몬 스레드¹입니다. 따라서 주 스레드는 이를 기다리지 않습니다.
• 스레드의 패닉은 서로 독립적으로 발생합니다.
  • (스레드의) 패닉은 (주 스레드에게) 페이로드를 전달하고, 이는 downcast_ref로 풀어볼 수 있습니다.

• Threads are all daemon threads, the main thread does not wait for them.
• Thread panics are independent of each other.
  • Panics can carry a payload, which can be unpacked with downcast_ref.

역주

• 다른언어의 스레드 === js만 했으면 헬게이트 열리는 장입니다(…)

Scoped Threads

일반 스레드는 그들의 환경(주 스레드)에서 빌릴수 없습니다:

Normal threads cannot borrow from their environment:

use std::thread;

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

    thread::spawn(|| {
        println!("Length: {}", s.len());
    });
}

하지만, scoped thread에서는 가능합니다: However, you can use a scoped thread for this:

use std::thread;

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

    thread::scope(|scope| {
        scope.spawn(|| {
            println!("Length: {}", s.len());
        });
    });
}

Channels

러스트의 채널은 Sender 와Receiver` 두 부분으로 구성됩니다. 두 부분은 채널을 통해 연결되지만 우리는 종단만을 확인할 수 있습니다.

Rust channels have two parts: a Sender<T> and a Receiver<T>. The two parts are connected via the channel, but you only see the end-points.

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    tx.send(10).unwrap();
    tx.send(20).unwrap();

    println!("Received: {:?}", rx.recv());
    println!("Received: {:?}", rx.recv());

    let tx2 = tx.clone();
    tx2.send(30).unwrap();
    println!("Received: {:?}", rx.recv());
}

역주

• 메세지 패싱하는 transmitter(tx)와 receiver(rx) 입니다. 보통 예시는 흐르는 개울(채널) 상류(tx)에 띄운 고무 오리가 하류(rx)로 가는 흐름을 생각하시면 됩니다.

Unbounded Channels

mpsc::channel()함수는 무제한, 비동기 채널을 생성합니다:

You get an unbounded and asynchronous channel with mpsc::channel():

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let thread_id = thread::current().id();
        for i in 1..10 {
            tx.send(format!("Message {i}")).unwrap();
            println!("{thread_id:?}: sent Message {i}");
        }
        println!("{thread_id:?}: done");
    });
    thread::sleep(Duration::from_millis(100));

    for msg in rx.iter() {
        println!("Main: got {}", msg);
    }
}

Bounded Channels

경계가 있는 동기 채널은 send가 주 스레드를 차단하도록 만듭니다:

Bounded and synchronous channels make send block the current thread:

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::sync_channel(3);

    thread::spawn(move || {
        let thread_id = thread::current().id();
        for i in 1..10 {
            tx.send(format!("Message {i}")).unwrap();
            println!("{thread_id:?}: sent Message {i}");
        }
        println!("{thread_id:?}: done");
    });
    thread::sleep(Duration::from_millis(100));

    for msg in rx.iter() {
        println!("Main: got {}", msg);
    }
}

Shared State

러스트는 주로 아래 두 가지 타입 시스템을 이용해서 공유 데이터 동기화를 수행합니다:

Rust uses the type system to enforce synchronization of shared data. This is primarily done via two types:

• Arc<T>, atomic¹ 참조 카운트 T: 스레드 사이의 공유를 담당하고, 마지막 스레드 종료시 T를 해제합니다.
• Mutex<T>: T값에 대한 상호배제 엑세스를 보장합니다.

• Arc<T>, atomic reference counted T: handled sharing between threads and takes care to deallocate T when the last thread exits,
• Mutex<T>: ensures mutual exclusion access to the T value.

역주

Arc

Arc<T>는 clone 메서드를 통해 읽기전용 접근을 허용합니다:

Arc<T> allows shared read-only access via its clone method:

use std::thread;
use std::sync::Arc;

fn main() {
    let v = Arc::new(vec![10, 20, 30]);
    let mut handles = Vec::new();
    for _ in 1..5 {
        let v = v.clone();
        handles.push(thread::spawn(move || {
            let thread_id = thread::current().id();
            println!("{thread_id:?}: {v:?}");
        }));
    }

    handles.into_iter().for_each(|h| h.join().unwrap());
    println!("v: {v:?}");
}

Mutex

Mutex<T>는 상호배제를 보장하고, 일기전용 인터페이스 뒤에서 T에 대한 가변 접근을 허용합니다:

Mutex<T> ensures mutual exclusion and allows mutable access to T behind a read-only interface:

use std::sync::Mutex;

fn main() {
    let v: Mutex<Vec<i32>> = Mutex::new(vec![10, 20, 30]);
    println!("v: {:?}", v.lock().unwrap());

    {
        let v: &Mutex<Vec<i32>> = &v;
        let mut guard = v.lock().unwrap();
        guard.push(40);
    }

    println!("v: {:?}", v.lock().unwrap());
}

impl<T: Send> Sync for Mutex<T>를 참조하시기 바랍니다

Notice how we have a impl<T: Send> Sync for Mutex<T> blanket implementation.

Example

Arc와 Mutex의 동작을 살펴봅니다:

Let us see Arc and Mutex in action:

use std::thread;
// use std::sync::{Arc, Mutex};

fn main() {
    let mut v = vec![10, 20, 30];
    let handle = thread::spawn(|| {
        v.push(10);
    });
    v.push(1000);

    handle.join().unwrap();
    println!("v: {v:?}");
}

역주

• 위 코드를 동작하게 수정해보세요.

Send and Sync

러스트는 아래 두가지 트레이트를 이용하여 스레드 간 공유 접근을 금지된 것을 알 수 있습니다:

• Send: T가 스레드 간 이동이 안전하다면, T의 타입은 Send입니다.
• Sync: &T가 스레드 간 이동이 안전하다면, &T의 타입은 Sync입니다.

How does Rust know to forbid shared access across thread? The answer is in two traits:

• Send: a type T is Send if it is safe to move a T across a thread boundary.
• Sync: a type T is Sync if it is safe to move a &T across a thread boundary.

Send

T가 스레드 간 이동이 안전하다면, T의 타입은 Send입니다.

A type T is Send if it is safe to move a T value to another thread.

소유권을 다른 스레드로 이동하면 소멸자가 해당 스레드에서 실행됩니다.

여기서 의문은 언제 한 스레드에서 값을 할당하고 다른 스레드에서 값을 할당 해제할 수 있는가 입니다.

The effect of moving ownership to another thread is that destructors will run in that thread. So the question is when you can allocate a value in one thread and deallocate it in another.

Sync

&T가 여러 스레드에서 접근이 안전하다면, &T의 타입은 Sync입니다.

A type T is Sync if it is safe to access a T value from multiple threads at the same time.

좀 더 정확한 정의는 다음과 같습니다:

More precisely, the definition is:

&T만 Send인 경우, T의 타입은 Sync입니다.

T is Sync if and only if &T is Send

Examples

Send + Sync

대부분의 타입은 Send + Sync입니다:

• i8, f32, bool, char, &str, …
• (T1, T2), [T; N], &[T], struct { x: T }, …
• String, Option<T>, Vec<T>, Box<T>, …
• Arc<T>: atomic 참조 카운트로 명시적 스레드-세이프.
• Mutex<T>: 내부 잠금을 통해 명시적 스레드-세이프.
• AtomicBool, AtomicU8, …: 특별한 atomic 명령을 사용합니다.

Most types you come across are Send + Sync:

• i8, f32, bool, char, &str, …
• (T1, T2), [T; N], &[T], struct { x: T }, …
• String, Option<T>, Vec<T>, Box<T>, …
• Arc<T>: Explicitly thread-safe via atomic reference count.
• Mutex<T>: Explicitly thread-safe via internal locking.
• AtomicBool, AtomicU8, …: Uses special atomic instructions.

제너릭 타입은 일반적으로 타입파라메터가 Send + Sync이면 Send + Sync 입니다.

The generic types are typically Send + Sync when the type parameters are Send + Sync.

Send + !Sync

아래 타입들은 일반적으로 내부 가변성으로 인해 다른 스레드로 이동될 수 있지만 스레드-세이프 하지 않습니다.

These types can be moved to other threads, but they’re not thread-safe. Typically because of interior mutability:

• mpsc::Sender<T>
• mpsc::Receiver<T>
• Cell<T>
• RefCell<T>

!Send + Sync

아래 타입들은 스레드-세이프 하지만 다른 스레드로 이동될 수 없습니다:

• MutexGuard<T>: OS레벨에서 생성한 스레드에서 할당해제해야합니다

These types are thread-safe, but they cannot be moved to another thread:

• MutexGuard<T>: Uses OS level primitives which must be deallocated on the thread which created them.

!Send + !Sync

아래 타입들은 스레드-세이프 하지도 않고 다른 스레드로 이동될 수도 없습니다:

• Rc<T>: 각 Rc<T> 는 비 atomic 참조 카운트를 포함하는 RcBox<T>를 참조합니다.
• *const T, *mut T: 러스트는 raw 포인터가 특별한 동시성 고려사항을 가질 수 있다고 가정합니다.

These types are not thread-safe and cannot be moved to other threads:

• Rc<T>: each Rc<T> has a reference to an RcBox<T>, which contains a non-atomic reference count.
• *const T, *mut T: Rust assumes raw pointers may have special concurrency considerations.

Exercises

이번 훈련에서는 동시성 기술을 연습합니다:

• 식사하는 철학자 문제: 고적적인 동시성 문제입니다.
• 멀티 스레드 링크 검사: 카고를 사용하여 종속성을 다운로드하면서 링크를 체크하는 큰 프로젝트입니다

Let us practice our new concurrency skills with

• Dining philosophers: a classic problem in concurrency.

• Multi-threaded link checker: a larger project where you’ll use Cargo to download dependencies and then check links in parallel.

Dining Philosophers

식사하는 철학자 문제는 동시성에 있어서 고전적인 문제입니다:

5명의 철학자가 원탁에서 식사를 하고 있습니다. 철학자는 원탁에서 자신의 자리에 앉아있습니다. 포크는 각 접시 사이에 있습니다. 제공되는 요리를 먹기 위해서는 2개의 포크를 모두 사용해야합니다. 철학자는 생각을 하다가 배가 고프면 자신의 좌우의 포크를 들어 요리를 먹습니다. 철학자는 요리를 먹은 후에는 포크를 다시 자리에 내려놓습니다. 철학자는 자신의 좌,우에 포크가 있을때만 요리를 먹을 수 있습니다. 따라서 두개의 포크는 오직 자신의 좌,우 철학자가 생각을 할 때만 사용할 수 있습니다.

이번 훈련에서는 로컬 카고 설치가 필요합니다. 아래 코드를 복사해서 src/main.rs에 붙여놓고 빈 부분을 채우고, cargo run 커맨드로 테스트 해서 교착상태(데드락)이 되지 않는지 확인합니다:

The dining philosophers problem is a classic problem in concurrency:

Five philosophers dine together at the same table. Each philosopher has their own place at the table. There is a fork between each plate. The dish served is a kind of spaghetti which has to be eaten with two forks. Each philosopher can only alternately think and eat. Moreover, a philosopher can only eat their spaghetti when they have both a left and right fork. Thus two forks will only be available when their two nearest neighbors are thinking, not eating. After an individual philosopher finishes eating, they will put down both forks.

You will need a local Cargo installation for this exercise. Copy the code below to src/main.rs file, fill out the blanks, and test that cargo run does not deadlock:

use std::sync::mpsc;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

struct Fork;

struct Philosopher {
    name: String,
    // left_fork: ...
    // right_fork: ...
    // thoughts: ...
}

impl Philosopher {
    fn think(&self) {
        self.thoughts
            .send(format!("Eureka! {} has a new idea!", &self.name))
            .unwrap();
    }

    fn eat(&self) {
        // Pick up forks...
        println!("{} is eating...", &self.name);
        thread::sleep(Duration::from_millis(10));
    }
}

static PHILOSOPHERS: &[&str] =
    &["Socrates", "Plato", "Aristotle", "Thales", "Pythagoras"];

fn main() {
    // Create forks

    // Create philosophers

    // Make them think and eat

    // Output their thoughts
}

역주

• 로컬에서 cargo new dining-philosopher로 프로젝트를 생성해서 위 코드 붙여넣고 시작하면 됩니다.
• 데드락 회피 알고리즘 자체를 테스트 하는건 아니니 구글 서칭 go.
  • 역자는 위치에 따라(홀짝) 드는 포크 순서를 바꾸는 방식으로 했습니다.

Multi-threaded Link Checker

새로 배운것들을 활용해서 멀티 스레드 링크 검사기를 만듭니다. 검사기는 웹페이지가 유효한지 확인합니다. 그리고 재귀적으로 동일 도메인의 다른 모든 페이지가 유효한지 확인합니다.

이를 위해서 reqwest와 같은 HTTP 클라이언트가 필요합니다. 새로운 로컬 프로젝트를 만들고 reqwest를 종속성에 추가하십시요

Let us use our new knowledge to create a multi-threaded link checker. It should start at a webpage and check that links on the page are valid. It should recursively check other pages on the same domain and keep doing this until all pages have been validated.

For this, you will need an HTTP client such as reqwest. Create a new Cargo project and reqwest it as a dependency with:

$ cargo new link-checker
$ cd link-checker
$ cargo add --features blocking, rustls-tls reqwest

만일 cargo add 커맨드가 error: no such subcommand 로 실패한다면 Cargo.toml 파일을 직접 수정해도 됩니다. 아래에 전체 종속성 내용이 있습니다.

링크를 찾기 위해서 scraper도 추가합니다:

If cargo add fails with error: no such subcommand, then please edit the Cargo.toml file by hand. Add the dependencies listed below.

You will also need a way to find links. We can use scraper for that:

$ cargo add scraper

마지막으로 오류 처리하는 방법으로 thiserror도 추가합니다:

Finally, we’ll need some way of handling errors. We thiserror for that:

$ cargo add thiserror

모든 cargo add이 끝나면 Cargo.toml에 아래 내용이 추가 되있습니다:

The cargo add calls will update the Cargo.toml file to look like this:

# 실습 시 버전은 다를 수 있습니다.
[dependencies]
reqwest = { version = "0.11.12", features = ["blocking", "rustls-tls"] }
scraper = "0.13.0"
thiserror = "1.0.37"

이제 https://www.google.org/ 같은 웹 페이지를 탐색할 수 있습니다.

You can now download the start page. Try with a small site such as https://www.google.org/.

rc/main.rs파일은 아래와 같습니다:

Your src/main.rs file should look something like this:

use reqwest::blocking::{get, Response};
use reqwest::Url;
use scraper::{Html, Selector};
use thiserror::Error;

#[derive(Error, Debug)]
enum Error {
    #[error("request error: {0}")]
    ReqwestError(#[from] reqwest::Error),
}

fn extract_links(response: Response) -> Result<Vec<Url>, Error> {
    let base_url = response.url().to_owned();
    let document = response.text()?;
    let html = Html::parse_document(&document);
    let selector = Selector::parse("a").unwrap();

    let mut valid_urls = Vec::new();
    for element in html.select(&selector) {
        if let Some(href) = element.value().attr("href") {
            match base_url.join(href) {
                Ok(url) => valid_urls.push(url),
                Err(err) => {
                    println!("On {base_url}: could not parse {href:?}: {err} (ignored)",);
                }
            }
        }
    }

    Ok(valid_urls)
}

fn main() {
    let start_url = Url::parse("https://www.google.org").unwrap();
    let response = get(start_url).unwrap();
    match extract_links(response) {
        Ok(links) => println!("Links: {links:#?}"),
        Err(err) => println!("Could not extract links: {err:#}"),
    }
}

아래 커맨드로 소스를 실행합니다:

Run the code in src/main.rs with

$ cargo run

Tasks

• 스레드를 사용하여 링크를 병렬로 확인합니다: URL을 채널로 보내서 몇 개의 스레드가 URL을 병렬로 체크하도록 합니다.
• www.google.org도메인의 모든 페이지를 재귀적으로 확인하기 위해 코드를 확장해서 작성합니다: 사이트에 의해 차단되지 않도록 100페이지 정도로 제한을 두시기 바랍니다.

• Use threads to check the links in parallel: send the URLs to be checked to a channel and let a few threads check the URLs in parallel.
• Extend this to recursively extract links from all pages on the www.google.org domain. Put an upper limit of 100 pages or so so that you don’t end up being blocked by the site.

역주

• 기본 소스는 한번에 한 링크씩 확인하는 소스 입니다.
• 이를 스레드를 사용하여 병렬화 하는 코드를 작성하시면 됩니다.

Android

러스트는 안드로이드 네이티브 플랫폼 개발을 지원합니다. 즉, 기존 서비스를 확장 할 뿐 아니라 새로운 OS서비스를 작성할 수 있음을 뜻합니다.

Rust is supported for native platform development on Android. This means that you can write new operating system services in Rust, as well as extending existing services.

Setup

Android Virtual Device를 사용하여 코드를 테스트합니다. 액세스 권한이 있는지 확인하거나 다음을 사용하여 새 액세스 권한을 만드십시오:

We will be using an Android Virtual Device to test our code. Make sure you have access to one or create a new one with:

$ source build/envsetup.sh
$ lunch aosp_cf_x86_64_phone-userdebug
$ acloud create

자세한 내용은 Android Developer Codelab을 참조하십시오.

Please see the Android Developer Codelab for details.

Build Rules

안드로이드 빌드 시스템(Soong)은 다음과 같은 여러 모듈을 통해 러스트를 지원한다:

다음은 rust_binary와 rust_library를 살펴봅니다.

The Android build system (Soong) supports Rust via a number of modules:

Module Type	Description
rust_binary	Produces a Rust binary.
rust_library	Produces a Rust library, and provides both rlib and dylib variants.
rust_ffi	Produces a Rust C library usable by cc modules, and provides both static and shared variants.
rust_proc_macro	Produces a proc-macro Rust library. These are analogous to compiler plugins.
rust_test	Produces a Rust test binary that uses the standard Rust test harness.
rust_fuzz	Produces a Rust fuzz binary leveraging libfuzzer.
rust_protobuf	Generates source and produces a Rust library that provides an interface for a particular protobuf.
rust_bindgen	Generates source and produces a Rust library containing Rust bindings to C libraries.

We will look at rust_binary and rust_library next.

Rust Binaries

간단한 응용 프로그램으로 시작해 보겠습니다. AOSP 체크아웃의 루트에서 다음 파일을 생성합니다:

Let us start with a simple application. At the root of an AOSP checkout, create the following files:

hello_rust/Android.bp:

rust_binary {
    name: "hello_rust",
    crate_name: "hello_rust",
    srcs: ["src/main.rs"],
}

hello_rust/src/main.rs:

//! Rust demo.

/// Prints a greeting to standard output.
fn main() {
    println!("Hello from Rust!");
}

이제 바이너리를 빌드, 푸시, 실행할 수 있습니다:

You can now build, push, and run the binary:

$ m hello_rust
$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust /data/local/tmp
$ adb shell /data/local/tmp/hello_rust
Hello from Rust!

Rust Libraries

rust_library를 사용하여 Android용 새 Rust 라이브러리를 만듭니다.

여기서 2개의 라이브러리 의존성을 설언합니다.

• 아래에 정의한 libgreeting
• external/rust/crates/에 존재하는 libtextwrap

You use rust_library to create a new Rust library for Android.

Here we declare a dependency on two libraries:

• libgreeting, which we define below,
• libtextwrap, which is a crate already vendored in external/rust/crates/.

hello_rust/Android.bp:

rust_binary {
    name: "hello_rust_with_dep",
    crate_name: "hello_rust_with_dep",
    srcs: ["src/main.rs"],
    rustlibs: [
        "libgreetings",
        "libtextwrap",
    ],
    prefer_rlib: true,
}

rust_library {
    name: "libgreetings",
    crate_name: "greetings",
    srcs: ["src/lib.rs"],
}

hello_rust/src/main.rs:

//! Rust demo.

use greetings::greeting;
use textwrap::fill;

/// Prints a greeting to standard output.
fn main() {
    println!("{}", fill(&greeting("Bob"), 24));
}

hello_rust/src/lib.rs:

//! Greeting library.

/// Greet `name`.
pub fn greeting(name: &str) -> String {
    format!("Hello {name}, it is very nice to meet you!")
}

이제 이전과 같이 바이너리를 빌드, 푸시, 실행할 수 있습니다: You build, push, and run the binary like before:

$ m hello_rust_with_dep
$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep /data/local/tmp
$ adb shell /data/local/tmp/hello_rust_with_dep
Hello Bob, it is very
nice to meet you!

AIDL

러스트는 안드로이드 인터페이스 정의 언어(AIDL)을 지원합니다:

• 러스트 코드는 기존 AIDL 서버를 호출 할 수 있습니다.
• 러스트에서 새로운 AIDL 서버를 생성할 수 있습니다.

The Android Interface Definition Language (AIDL) is supported in Rust:

• Rust code can call existing AIDL servers,
• You can create new AIDL servers in Rust.

AIDL Interfaces

AIDL 인터페이스를 이용해서 서비스의 API를 선언합니다:

You declare the API of your service using an AIDL interface:

birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl:

package com.example.birthdayservice;

/** Birthday service interface. */
interface IBirthdayService {
    /** Generate a Happy Birthday message. */
    String wishHappyBirthday(String name, int years);
}

birthday_service/aidl/Android.bp:

aidl_interface {
    name: "com.example.birthdayservice",
    srcs: ["com/example/birthdayservice/*.aidl"],
    unstable: true,
    backend: {
        rust: { // Rust is not enabled by default
            enabled: true,
        },
    },
}

AIDL 파일이 벤더 파티션의 바이너리에서 사용되는 경우 vendor_available: true를 추가합니다.

Add vendor_available: true if your AIDL file is used by a binary in the vendor partition.

Service Implementation

이제 AIDL서비스를 구현할 수 있습니다:

We can now implement the AIDL service:

birthday_service/src/lib.rs:

//! Implementation of the `IBirthdayService` AIDL interface.
use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::IBirthdayService;
use com_example_birthdayservice::binder;

/// The `IBirthdayService` implementation.
pub struct BirthdayService;

impl binder::Interface for BirthdayService {}

impl IBirthdayService for BirthdayService {
    fn wishHappyBirthday(&self, name: &str, years: i32) -> binder::Result<String> {
        Ok(format!(
            "Happy Birthday {name}, congratulations with the {years} years!"
        ))
    }
}

birthday_service/Android.bp:

rust_library {
    name: "libbirthdayservice",
    srcs: ["src/lib.rs"],
    crate_name: "birthdayservice",
    rustlibs: [
        "com.example.birthdayservice-rust",
        "libbinder_rs",
    ],
}

AIDL Server

마지막으로 서비스를 제공하는 서버를 만들 수 있습니다:

Finally, we can create a server which exposes the service:

birthday_service/src/server.rs:

//! Birthday service.
use birthdayservice::BirthdayService;
use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::BnBirthdayService;
use com_example_birthdayservice::binder;

const SERVICE_IDENTIFIER: &str = "birthdayservice";

/// Entry point for birthday service.
fn main() {
    let birthday_service = BirthdayService;
    let birthday_service_binder = BnBirthdayService::new_binder(
        birthday_service,
        binder::BinderFeatures::default(),
    );
    binder::add_service(SERVICE_IDENTIFIER, birthday_service_binder.as_binder())
        .expect("Failed to register service");
    binder::ProcessState::join_thread_pool()
}

birthday_service/Android.bp:

rust_binary {
    name: "birthday_server",
    crate_name: "birthday_server",
    srcs: ["src/server.rs"],
    rustlibs: [
        "com.example.birthdayservice-rust",
        "libbinder_rs",
        "libbirthdayservice",
    ],
    prefer_rlib: true,
}

Deploy

서비스를 빌드, 푸시, 시작 할 수 있습니다:

We can now build, push, and start the service:

$ m birthday_server
$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/tmp
$ adb shell /data/local/tmp/birthday_server

다른 터미널에서 서비스 구동을 확인합니다:

In another terminal, check that the service runs:

$ adb shell service check birthdayservice
Service birthdayservice: found

service call로 서비스를 호출할 수도 있습니다:

You can also call the service with service call:

$ $ adb shell service call birthdayservice 1 s16 Bob i32 24
Result: Parcel(
  0x00000000: 00000000 00000036 00610048 00700070 '....6...H.a.p.p.'
  0x00000010: 00200079 00690042 00740072 00640068 'y. .B.i.r.t.h.d.'
  0x00000020: 00790061 00420020 0062006f 0020002c 'a.y. .B.o.b.,. .'
  0x00000030: 006f0063 0067006e 00610072 00750074 'c.o.n.g.r.a.t.u.'
  0x00000040: 0061006c 00690074 006e006f 00200073 'l.a.t.i.o.n.s. .'
  0x00000050: 00690077 00680074 00740020 00650068 'w.i.t.h. .t.h.e.'
  0x00000060: 00320020 00200034 00650079 00720061 ' .2.4. .y.e.a.r.'
  0x00000070: 00210073 00000000                   's.!.....        ')

AIDL Client

마지막으로, 새로운 서비스를 위한 러스트 클라이언트를 만들 수 있습니다.

Finally, we can create a Rust client for our new service.

birthday_service/src/client.rs:

//! Birthday service.
use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::IBirthdayService;
use com_example_birthdayservice::binder;

const SERVICE_IDENTIFIER: &str = "birthdayservice";

/// Connect to the BirthdayService.
pub fn connect() -> Result<binder::Strong<dyn IBirthdayService>, binder::StatusCode> {
    binder::get_interface(SERVICE_IDENTIFIER)
}

/// Call the birthday service.
fn main() -> Result<(), binder::Status> {
    let name = std::env::args()
        .nth(1)
        .unwrap_or_else(|| String::from("Bob"));
    let years = std::env::args()
        .nth(2)
        .and_then(|arg| arg.parse::<i32>().ok())
        .unwrap_or(42);

    binder::ProcessState::start_thread_pool();
    let service = connect().expect("Failed to connect to BirthdayService");
    let msg = service.wishHappyBirthday(&name, years)?;
    println!("{msg}");
    Ok(())
}

birthday_service/Android.bp:

rust_binary {
    name: "birthday_client",
    crate_name: "birthday_client",
    srcs: ["src/client.rs"],
    rustlibs: [
        "com.example.birthdayservice-rust",
        "libbinder_rs",
    ],
    prefer_rlib: true,
}

클라이언트는 libbirthdayservice에 의존하지 않습니다.

장치에서 빌드, 푸시, 실행합니다:

Notice that the client does not depend on libbirthdayservice.

Build, push, and run the client on your device:

$ m birthday_client
$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/tmp
$ adb shell /data/local/tmp/birthday_client Charlie 60
Happy Birthday Charlie, congratulations with the 60 years!

Changing API

API를 확장하여 더 많은 기능을 제공합니다. 클라이언트가 생일 카드에 대한 줄 목록을 지정할 수 있도록 합니다:

Let us extend the API with more functionality: we want to let clients specify a l> ist of lines for the birthday card:

package com.example.birthdayservice;

/** Birthday service interface. */
interface IBirthdayService {
    /** Generate a Happy Birthday message. */
    String wishHappyBirthday(String name, int years, in String[] text);
}

Logging

log크레이트를 사용하여 logcat(장치)나 stdout(호스트)에서 자동으로 로그를 기록하도록 합니다:

You should use the log crate to automatically log to logcat (on-device) or stdout (on-host):

hello_rust_logs/Android.bp:

rust_binary {
    name: "hello_rust_logs",
    crate_name: "hello_rust_logs",
    srcs: ["src/main.rs"],
    rustlibs: [
        "liblog_rust",
        "liblogger",
    ],
    prefer_rlib: true,
    host_supported: true,
}

hello_rust_logs/src/main.rs:

//! Rust logging demo.

use log::{debug, error};

/// Logs a greeting.
fn main() {
    logger::init(
        logger::Config::default()
            .with_tag_on_device("rust")
            .with_min_level(log::Level::Trace),
    );
    debug!("Starting program.");
    error!("Something went wrong!");
}

장치에서 바이너리를 빌드, 푸시, 실행합니다:

Build, push, and run the binary on your device:

$ m hello_rust_logs
$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/tmp
$ adb shell /data/local/tmp/hello_rust_logs

adb logcat커맨드로 로그를 확인합니다:

The logs show up in adb logcat:

$ adb logcat -s rust
09-08 08:38:32.454  2420  2420 D rust: hello_rust_logs: Starting program.
09-08 08:38:32.454  2420  2420 I rust: hello_rust_logs: Things are going fine.
09-08 08:38:32.454  2420  2420 E rust: hello_rust_logs: Something went wrong!

Interoperability

러스트는 다른 언어와의 상호운용성을 훌륭히 지원합니다. 즉, 다음을 수행할 수 있습니다:

• 타 언어에서 rust 함수를 호출합니다.
• 타 언어의 함수를 러스트에서 호출합니다.

타 언어의 함수를 호출해서 사용하는 것을 FFI(foreign function interface)라고 합니다.

Rust has excellent support for interoperability with other languages. This means that you can:

• Call Rust functions from other languages.
• Call functions written in other languages from Rust.

When you call functions in a foreign language we say that you’re using a foreign function interface, also known as FFI.

Interoperability with C

러스트는 C 호출규약과 함께 객체 파일을 연결하는 것을 완벽하게 지원합니다. 반대로 러스트 함수를 내보내서 C에서 호출 할 수 있습니다.

원하는 경우 직접 코딩할 수 있습니다:

Rust has full support for linking object files with a C calling convention. Similarly, you can export Rust functions and call them from C.

You can do it by hand if you want:

extern "C" {
    fn abs(x: i32) -> i32;
}

fn main() {
    let x = -42;
    let abs_x = unsafe { abs(x) };
    println!("{x}, {abs_x}");
}

우리는 이미Safe FFI 래퍼 연습문제에서 이를 다루었습니다.

이는 대상 플랫폼에 대한 완전한 지식을 전제로 합니다. 실 제품에는 권장하진 않습니다.

다음으로 좀 더 나은 옵션을 살펴보겠습니다.

We already saw this in the Safe FFI Wrapper exercise.

This assumes full knowledge of the target platform. Not recommended for production.

We will look at better options next.

Using Bindgen

bindgen는 C 헤더파일에서 자동으로 생성하는 도구입니다.

The bindgen tool can auto-generate bindings from a C header file.

작은 C라이브러리를 생성합니다:

First create a small C library:

interoperability/bindgen/libbirthday.h:

typedef struct card {
  const char* name;
  int years;
} card;

void print_card(const card* card);

interoperability/bindgen/libbirthday.c:

#include <stdio.h>
#include "libbirthday.h"

void print_card(const card* card) {
  printf("+--------------\n");
  printf("| Happy Birthday %s!\n", card->name);
  printf("| Congratulations with the %i years!\n", card->years);
  printf("+--------------\n");
}

Android.bp 파일에 아래를 추가합니다:

Add this to your Android.bp file:

interoperability/bindgen/Android.bp:

cc_library {
    name: "libbirthday",
    srcs: ["libbirthday.c"],
}

라이브러리에 대한 래퍼 헤더 파일을 만듭니다(이 예시에서는 필요하지 않습니다):

Create a wrapper header file for the library (not strictly needed in this example):

interoperability/bindgen/libbirthday_wrapper.h:

#include "libbirthday.h"

이제 바인딩을 자동으로 생성할 수 있습니다:

You can now auto-generate the bindings:

interoperability/bindgen/Android.bp:

rust_bindgen {
    name: "libbirthday_bindgen",
    crate_name: "birthday_bindgen",
    wrapper_src: "libbirthday_wrapper.h",
    source_stem: "bindings",
    static_libs: ["libbirthday"],
}

마침내, 러스트 프로그램에서 바인딩을 사용할 수 있습니다:

Finally, we can use the bindings in our Rust program:

interoperability/bindgen/Android.bp:

rust_binary {
    name: "print_birthday_card",
    srcs: ["main.rs"],
    rustlibs: ["libbirthday_bindgen"],
}

interoperability/bindgen/main.rs:

//! Bindgen demo.

use birthday_bindgen::{card, print_card};

fn main() {
    let name = std::ffi::CString::new("Peter").unwrap();
    let card = card {
        name: name.as_ptr(),
        years: 42,
    };
    unsafe {
        print_card(&card as *const card);
    }
}

Build, push, and run the binary on your device:

$ m print_birthday_card
$ adb push $ANDROID_PRODUCT_OUT/system/bin/print_birthday_card /data/local/tmp
$ adb shell /data/local/tmp/print_birthday_card

마지막으로, 바인딩이 작동하는지 자동생성 테스트를 실행할 수 있습니다:

Finally, we can run auto-generated tests to ensure the bindings work:

interoperability/bindgen/Android.bp:

rust_test {
    name: "libbirthday_bindgen_test",
    srcs: [":libbirthday_bindgen"],
    crate_name: "libbirthday_bindgen_test",
    test_suites: ["general-tests"],
    auto_gen_config: true,
    clippy_lints: "none", // Generated file, skip linting
    lints: "none",
}

$ atest libbirthday_bindgen_test

Calling Rust

러스트에서 타입과 함수를 C로 내보내는 것은 간단합니다:

Exporting Rust functions and types to C is easy:

interoperability/rust/libanalyze/analyze.rs

//! Rust FFI demo.
#![deny(improper_ctypes_definitions)]

use std::os::raw::c_int;

/// Analyze the numbers.
#[no_mangle]
pub extern "C" fn analyze_numbers(x: c_int, y: c_int) {
    if x < y {
        println!("x ({x}) is smallest!");
    } else {
        println!("y ({y}) is probably larger than x ({x})");
    }
}

interoperability/rust/libanalyze/analyze.h

#ifndef ANALYSE_H
#define ANALYSE_H

extern "C" {
void analyze_numbers(int x, int y);
}

#endif

interoperability/rust/libanalyze/Android.bp

rust_ffi {
    name: "libanalyze_ffi",
    crate_name: "analyze_ffi",
    srcs: ["analyze.rs"],
    include_dirs: ["."],
}

이제 C바이너리에서 호출할 수 있습니다:

We can now call this from a C binary:

interoperability/rust/analyze/main.c

#include "analyze.h"

int main() {
  analyze_numbers(10, 20);
  analyze_numbers(123, 123);
  return 0;
}

interoperability/rust/analyze/Android.bp

cc_binary {
    name: "analyze_numbers",
    srcs: ["main.c"],
    static_libs: ["libanalyze_ffi"],
}

장치에서 바이너리를 빌드, 푸시, 실행해봅니다:

Build, push, and run the binary on your device:

$ m analyze_numbers
$ adb push $ANDROID_PRODUCT_OUT/system/bin/analyze_numbers /data/local/tmp
$ adb shell /data/local/tmp/analyze_numbers

With C++

CXX 크레이트는 러스트와 C++ 사이의 안전한 상호운용성을 가능하게 해줍니다.

전체적인 접근 방법은 다음과 같습니다.

The CXX crate makes it possible to do safe interoperability between Rust and C++.

The overall approach looks like this:

사용하는 방법에 대해서는CXX 튜토리얼 를 참조합니다.

See the CXX tutorial for an full example of using this.

Interoperability with Java

자바는 Java Native Interface(JNI)를 통해 공유 객체를 로드할 수 있습니다. jni 크레이트를 사용하여 호환 라이브러리를 만들 수 있습니다.

Java can load shared objects via Java Native Interface (JNI). The jni crate allows you to create a compatible library.

먼저, 자바로 내보낼 러스트 함수를 생성합니다:

First, we create a Rust function to export to Java:

interoperability/java/src/lib.rs:

#![allow(unused)]
fn main() {
//! Rust <-> Java FFI demo.

use jni::objects::{JClass, JString};
use jni::sys::jstring;
use jni::JNIEnv;

/// HelloWorld::hello method implementation.
#[no_mangle]
pub extern "system" fn Java_HelloWorld_hello(
    env: JNIEnv,
    _class: JClass,
    name: JString,
) -> jstring {
    let input: String = env.get_string(name).unwrap().into();
    let greeting = format!("Hello, {input}!");
    let output = env.new_string(greeting).unwrap();
    output.into_inner()
}
}

interoperability/java/Android.bp:

rust_ffi_shared {
    name: "libhello_jni",
    crate_name: "hello_jni",
    srcs: ["src/lib.rs"],
    rustlibs: ["libjni"],
}

마침내, 자바에서 이 함수를 호출 할 수 있습니다:

Finally, we can call this function from Java:

interoperability/java/HelloWorld.java:

class HelloWorld {
    private static native String hello(String name);

    static {
        System.loadLibrary("hello_jni");
    }

    public static void main(String[] args) {
        String output = HelloWorld.hello("Alice");
        System.out.println(output);
    }
}

interoperability/java/Android.bp:

java_binary {
    name: "helloworld_jni",
    srcs: ["HelloWorld.java"],
    main_class: "HelloWorld",
    required: ["libhello_jni"],
}

마지막으로 바이너리를 빌드, 싱크, 실행합니다:

Finally, you can build, sync, and run the binary:

$ m helloworld_jni
$ adb sync  # requires adb root && adb remount
$ adb shell /system/bin/helloworld_jni

Exercises

마지막 연습문제는 당신의 프로젝트 중 하나를 FFI로 러스트와 연계 해보는 것입니다. 몇가지 예시입니다:

• 당신의 AIDL서비스를 러스트 클라이언트에서 호출해봅니다.
• 당신의 프로젝트의 함수를 러스트로 옮기고 호출해봅니다.

For the last exercise, we will look at one of the projects you work with. Let us group up and do this together. Some suggestions:

• Call your AIDL service with a client written in Rust.

• Move a function from your project to Rust and call it.

Thanks!

Comprehensive Rust 🦀를 이용해 주셔서 감사합니다. 즐겁고 유익한 시간이었기를 바랍니다.

강의가 완벽하진 않으니 실수나 개선점이 있다면 언제든지 깃허브로 연락주세요

Thank you for taking Comprehensive Rust 🦀! We hope you enjoyed it and that it was useful.

We’ve had a lot of fun putting the course together. The course is not perfect, so if you spotted any mistakes or have ideas for improvements, please get in contact with us on GitHub. We would love to hear from you.

Other Rust Resources

러스트 커뮤니티는 온라인에서 고품질의 무료 소스를 만들었습니다.

The Rust community has created a wealth of high-quality and free resources online.

Official Documentation

러스트 프로젝트는 여러 리소스를 호스팅합니다. 일반적인 내용을 다루는 몇가지입니다:

The Rust project hosts many resources. These cover Rust in general:

• The Rust Programming Language: 러스트에 대한 무료 표준 서적입니다. 언어에 대한 자세한 설명과 사람들이 빌드 할수 있는 몇가지 프로젝트를 포함합니다.
• Rust By Example: 여러 예제를 통해 러스트의 문법을 보여주며 때때로 코드를 확장하는 약간의 연습문제들이 포함되어 있습니다.
• Rust Standard Library: 러스트 표준 라이브러리 전체 문서입니다.
• The Rust Reference: 메모리 모델링과 러스트 문법을 설명하는 문서입니다.(아직 불완전하다함)

• The Rust Programming Language: the canonical free book about Rust. Covers the language in detail and includes a few projects for people to build.
• Rust By Example: covers the Rust syntax via a series of examples which showcase different constructs. Sometimes includes small exercises where you are asked to expand on the code in the examples.
• Rust Standard Library: full documentation of the standard library for Rust.
• The Rust Reference: an incomplete book which describes the Rust grammar and memory model.

좀 더 전문적인 공식 가이드입니다:

More specialized guides hosted on the official Rust site:

• The Rustonomicon: 안전하지 않은 러스트, FFI, raw포인터 작업을 다룹니다.
• Asynchronous Programming in Rust: 러스트 북이 작성 된 이후 도입된 새로운 비동기 프로그래밍 모델을 다룹니다.
• The Embedded Rust Book: 운영체제가 없는 임베디드 장치에서의 러스트 사용법을 소개합니다.

• The Rustonomicon: covers unsafe Rust, including working with raw pointers and interfacing with other languages (FFI).
• Asynchronous Programming in Rust: covers the new asynchronous programming model which was introduced after the Rust Book was written.
• The Embedded Rust Book: an introduction to using Rust on embedded devices without an operating system.

Unofficial Learning Material

러스트에 대한 기타 안내서와 튜토리얼의 일부입니다:

A small selection of other guides and tutorial for Rust:

• Learn Rust the Dangerous Way: C언어 프로그래머 관점에서 러스트를 다룹니다.
• Rust for Embedded C Programmers: 임베디드 C개발자(펌웨어 개발자)를 위한 러스트 가이드입니다.
• Rust for professionals: 다른 언어(C/C++, Java, Python, Javascript)와의 병렬비교를 사용하여 러스트 문법을 다룹니다.
• Rust on Exercism: 러스트를 배우는데 도움이 되는 100개 이상의 연습문제
• Ferrous Teaching Material: 러스트 언어의 기본부터 고급을 전부 다루는 일련의 작은 프레젠테이션, 웹 어셈블리, async/await 같은 부분도 함께 다룹니다.
• Beginner’s Series to Rust, Take your first steps with Rust: 첫번째는 35개의 시리즈 영상이며 두번째는 러스트의 문법과 구조를 다루는 11개의 모듈 세트입니다.

Little Book of Rust Books에서 더 많은 러스트 북을 확인해보세요.

• Learn Rust the Dangerous Way: covers Rust from the perspective of low-level C programmers.
• Rust for Embedded C Programmers: covers Rust from the perspective of developers who write firmware in C.
• Rust for professionals: covers the syntax of Rust using side-by-side comparisons with other languages such as C, C++, Java, JavaScript, and Python.
• Rust on Exercism: 100+ exercises to help you learn Rust.
• Ferrous Teaching Material: a series of small presentations covering both basic and advanced part of the Rust language. Other topics such as WebAssembly, and async/await are also covered.
• Beginner’s Series to Rust and Take your first steps with Rust: two Rust guides aimed at new developers. The first is a set of 35 videos and the second is a set of 11 modules which covers Rust syntax and basic constructs.

Please see the Little Book of Rust Books for even more Rust books.

Credits

이 자료는 많은 훌륭한 러스트 문서들의 도움을 받아 작성되었습니다. 유용한 자료의 전체 목록은 other resources에서 살펴보시기 바랍니다.

The material here builds on top of the many great sources of Rust documentation. See the page on other resources for a full list of useful resources.

Comprehensive Rust의 자료는 Apache 2.0 라이선스를 따릅니다. 자세한건 LICENSE.txt 확인해 보시기 바랍니다. The material of Comprehensive Rust is licensed under the terms of the Apache 2.0 license, please see LICENSE.txt for details.

Rust by Example

일부 예제와 연습문제(훈련)은Rust by Example을 참조하였습니다. 라이선스 조항을 포함하여 저장소의 third_party/rust-by-example/ 폴더를 참조하시기 바랍니다.

Some examples and exercises have been copied and adapted from Rust by Example. Please see the third_party/rust-by-example/ directory for details, including the license terms.

Rust on Exercism

일부 연습문제(훈련)은 Rust on Exercism을 참조하였습니다. 라이선스 조항을 포함하여 저장소의 third_party/rust-on-exercism/폴더를 참조하시기 바랍니다.

Some exercises have been copied and adapted from Rust on Exercism. Please see the third_party/rust-on-exercism/ directory for details, including the license terms.

CXX

4일차 오후 강의 중 Interoperability with C++에서는 CXX의 이미지를 사용하였습니다. 라이선스 조항을 포함하여 저장소의 third_party/cxx/폴더를 참조하시기 바랍니다.

The Interoperability with C++ section uses an image from CXX. Please see the third_party/cxx/ directory for details, including the license terms.

Solutions

연습문제(훈련)의 정답은 다음 페이지에서 확인할 수 있습니다. 깃허브에서 이에 대해 자유롭게 질문하시고 더 나은 솔루션이 있다면 알려주시기 바랍니다.

You will find solutions to the exercises on the following pages.

Feel free to ask questions about the solutions on GitHub. Let us know if you have a different or better solution than what is presented here.

참고: // ANCHOR: label과 // ANCHOR_END: label 주석은 문제를 구성하기 위한 메타 주석으로 무시하시면 됩니다.

Note: Please ignore the // ANCHOR: label and // ANCHOR_END: label comments you see in the solutions. They are there to make it possible to re-use parts of the solutions as the exercises.

Day 1 Morning Exercises

Arrays and for Loops

(back to exercise)

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ANCHOR: transpose
fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
    // ANCHOR_END: transpose
    let mut result = [[0; 3]; 3];
    for i in 0..3 {
        for j in 0..3 {
            result[j][i] = matrix[i][j];
        }
    }
    return result;
}

// ANCHOR: pretty_print
fn pretty_print(matrix: &[[i32; 3]; 3]) {
    // ANCHOR_END: pretty_print
    for row in matrix {
        println!("{row:?}");
    }
}

// ANCHOR: tests
#[test]
fn test_transpose() {
    let matrix = [
        [101, 102, 103], //
        [201, 202, 203],
        [301, 302, 303],
    ];
    let transposed = transpose(matrix);
    assert_eq!(
        transposed,
        [
            [101, 201, 301], //
            [102, 202, 302],
            [103, 203, 303],
        ]
    );
}
// ANCHOR_END: tests

// ANCHOR: main
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);
}

Bonus question

사실 잘 동작하진 않습니다. slice-of-slices (&[&[i32]])을 입력 타입으로 사용하여 모든 크기의 행렬을 처리할 수 있습니다. 하지만 리턴 값을 소유해야 하기때문에 &[&[i32]] 타입을 사용할 순 없습니다.

Vec<Vec<i32>>와 같은 타입을 사용하려고 시도할 수도 있지만 역시 잘 동작하진 않습니다: Vec<Vec<i32>> 타입을 &[&[i32]]로 변환하는 것이 어렵기 때문에 pretty_print을 사용하는데 어려움이 있습니다.

It honestly doesn’t work so well. It might seem that we could use a slice-of-slices (&[&[i32]]) as the input type to transpose and thus make our function handle any size of matrix. However, this quickly breaks down: the return type cannot be &[&[i32]] since it needs to own the data you return.

You can attempt to use something like Vec<Vec<i32>>, but this doesn’t work very well either: it’s hard to convert from Vec<Vec<i32>> to &[&[i32]] so now you cannot easily use pretty_print either.

Day 1 Afternoon Exercises

Designing a Library

(back to exercise)

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ANCHOR: setup
struct Library {
    books: Vec<Book>,
}

struct Book {
    title: String,
    year: u16,
}

impl Book {
    // This is a constructor, used below.
    fn new(title: &str, year: u16) -> Book {
        Book {
            title: String::from(title),
            year,
        }
    }
}

// This makes it possible to print Book values with {}.
impl std::fmt::Display for Book {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{} ({})", self.title, self.year)
    }
}
// ANCHOR_END: setup

// ANCHOR: Library_new
impl Library {
    fn new() -> Library {
        // ANCHOR_END: Library_new
        Library { books: Vec::new() }
    }

    // ANCHOR: Library_len
    //fn len(self) -> usize {
    //    unimplemented!()
    //}
    // ANCHOR_END: Library_len
    fn len(&self) -> usize {
        self.books.len()
    }

    // ANCHOR: Library_is_empty
    //fn is_empty(self) -> bool {
    //    unimplemented!()
    //}
    // ANCHOR_END: Library_is_empty
    fn is_empty(&self) -> bool {
        self.books.is_empty()
    }

    // ANCHOR: Library_add_book
    //fn add_book(self, book: Book) {
    //    unimplemented!()
    //}
    // ANCHOR_END: Library_add_book
    fn add_book(&mut self, book: Book) {
        self.books.push(book)
    }

    // ANCHOR: Library_print_books
    //fn print_books(self) {
    //    unimplemented!()
    //}
    // ANCHOR_END: Library_print_books
    fn print_books(&self) {
        for book in &self.books {
            println!("{}", book);
        }
    }

    // ANCHOR: Library_oldest_book
    //fn oldest_book(self) -> Option<&Book> {
    //    unimplemented!()
    //}
    // ANCHOR_END: Library_oldest_book
    fn oldest_book(&self) -> Option<&Book> {
        self.books.iter().min_by_key(|book| book.year)
    }
}

// ANCHOR: main
// 소스쪽 주석들을 제거하고 누락된 메서드를 구현하세요.
// 메서드 정의도 수정되어야 합니다.(self가 포함되도록)
// This shows the desired behavior. Uncomment the code below and
// implement the missing methods. You will need to update the
// method signatures, including the "self" parameter!
fn main() {
    let library = Library::new();

    //println!("Our library is empty: {}", library.is_empty());
    //
    //library.add_book(Book::new("Lord of the Rings", 1954));
    //library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
    //
    //library.print_books();
    //
    //match library.oldest_book() {
    //    Some(book) => println!("My oldest book is {book}"),
    //    None => println!("My library is empty!"),
    //}
    //
    //println!("Our library has {} books", library.len());
}
// ANCHOR_END: main

#[test]
fn test_library_len() {
    let mut library = Library::new();
    assert_eq!(library.len(), 0);
    assert!(library.is_empty());

    library.add_book(Book::new("Lord of the Rings", 1954));
    library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
    assert_eq!(library.len(), 2);
    assert!(!library.is_empty());
}

#[test]
fn test_library_is_empty() {
    let mut library = Library::new();
    assert!(library.is_empty());

    library.add_book(Book::new("Lord of the Rings", 1954));
    assert!(!library.is_empty());
}

#[test]
fn test_library_print_books() {
    let mut library = Library::new();
    library.add_book(Book::new("Lord of the Rings", 1954));
    library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
    // We could try and capture stdout, but let us just call the
    // method to start with.
    library.print_books();
}

#[test]
fn test_library_oldest_book() {
    let mut library = Library::new();
    assert!(library.oldest_book().is_none());

    library.add_book(Book::new("Lord of the Rings", 1954));
    assert_eq!(
        library.oldest_book().map(|b| b.title.as_str()),
        Some("Lord of the Rings")
    );

    library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
    assert_eq!(
        library.oldest_book().map(|b| b.title.as_str()),
        Some("Alice's Adventures in Wonderland")
    );
}

Day 2 Morning Exercises

Points and Polygons

(back to exercise)

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
// ANCHOR: Point
pub struct Point {
    // ANCHOR_END: Point
    x: i32,
    y: i32,
}

// ANCHOR: Point-impl
impl Point {
    // ANCHOR_END: Point-impl
    pub fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }

    pub fn magnitude(self) -> f64 {
        f64::from(self.x.pow(2) + self.y.pow(2)).sqrt()
    }

    pub fn dist(self, other: Point) -> f64 {
        (self - other).magnitude()
    }
}

impl std::ops::Add for Point {
    type Output = Self;

    fn add(self, other: Self) -> Self::Output {
        Self {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

impl std::ops::Sub for Point {
    type Output = Self;

    fn sub(self, other: Self) -> Self::Output {
        Self {
            x: self.x - other.x,
            y: self.y - other.y,
        }
    }
}

// ANCHOR: Polygon
pub struct Polygon {
    // ANCHOR_END: Polygon
    points: Vec<Point>,
}

// ANCHOR: Polygon-impl
impl Polygon {
    // ANCHOR_END: Polygon-impl
    pub fn new() -> Polygon {
        Polygon { points: Vec::new() }
    }

    pub fn add_point(&mut self, point: Point) {
        self.points.push(point);
    }

    pub fn left_most_point(&self) -> Option<Point> {
        self.points.iter().min_by_key(|p| p.x).copied()
    }

    pub fn iter(&self) -> impl Iterator<Item = &Point> {
        self.points.iter()
    }

    pub fn length(&self) -> f64 {
        if self.points.is_empty() {
            return 0.0;
        }

        let mut result = 0.0;
        let mut last_point = self.points[0];
        for point in &self.points[1..] {
            result += last_point.dist(*point);
            last_point = *point;
        }
        result += last_point.dist(self.points[0]);
        result
    }
}

// ANCHOR: Circle
pub struct Circle {
    // ANCHOR_END: Circle
    center: Point,
    radius: i32,
}

// ANCHOR: Circle-impl
impl Circle {
    // ANCHOR_END: Circle-impl
    pub fn new(center: Point, radius: i32) -> Circle {
        Circle { center, radius }
    }

    pub fn circumference(&self) -> f64 {
        2.0 * std::f64::consts::PI * f64::from(self.radius)
    }

    pub fn dist(&self, other: &Self) -> f64 {
        self.center.dist(other.center)
    }
}

// ANCHOR: Shape
pub enum Shape {
    Polygon(Polygon),
    Circle(Circle),
}
// ANCHOR_END: Shape

impl From<Polygon> for Shape {
    fn from(poly: Polygon) -> Self {
        Shape::Polygon(poly)
    }
}

impl From<Circle> for Shape {
    fn from(circle: Circle) -> Self {
        Shape::Circle(circle)
    }
}

impl Shape {
    pub fn circumference(&self) -> f64 {
        match self {
            Shape::Polygon(poly) => poly.length(),
            Shape::Circle(circle) => circle.circumference(),
        }
    }
}

// ANCHOR: unit-tests
#[cfg(test)]
mod tests {
    use super::*;

    fn round_two_digits(x: f64) -> f64 {
        (x * 100.0).round() / 100.0
    }

    #[test]
    fn test_point_magnitude() {
        let p1 = Point::new(12, 13);
        assert_eq!(round_two_digits(p1.magnitude()), 17.69);
    }

    #[test]
    fn test_point_dist() {
        let p1 = Point::new(10, 10);
        let p2 = Point::new(14, 13);
        assert_eq!(round_two_digits(p1.dist(p2)), 5.00);
    }

    #[test]
    fn test_point_add() {
        let p1 = Point::new(16, 16);
        let p2 = p1 + Point::new(-4, 3);
        assert_eq!(p2, Point::new(12, 19));
    }

    #[test]
    fn test_polygon_left_most_point() {
        let p1 = Point::new(12, 13);
        let p2 = Point::new(16, 16);

        let mut poly = Polygon::new();
        poly.add_point(p1);
        poly.add_point(p2);
        assert_eq!(poly.left_most_point(), Some(p1));
    }

    #[test]
    fn test_polygon_iter() {
        let p1 = Point::new(12, 13);
        let p2 = Point::new(16, 16);

        let mut poly = Polygon::new();
        poly.add_point(p1);
        poly.add_point(p2);

        let points = poly.iter().cloned().collect::<Vec<_>>();
        assert_eq!(points, vec![Point::new(12, 13), Point::new(16, 16)]);
    }

    #[test]
    fn test_shape_circumferences() {
        let mut poly = Polygon::new();
        poly.add_point(Point::new(12, 13));
        poly.add_point(Point::new(17, 11));
        poly.add_point(Point::new(16, 16));
        let shapes = vec![
            Shape::from(poly),
            Shape::from(Circle::new(Point::new(10, 20), 5)),
        ];
        let circumferences = shapes
            .iter()
            .map(Shape::circumference)
            .map(round_two_digits)
            .collect::<Vec<_>>();
        assert_eq!(circumferences, vec![15.48, 31.42]);
    }
}
// ANCHOR_END: unit-tests

#[allow(dead_code)]
fn main() {}

Day 2 Afternoon Exercises

Luhn Algorithm

(back to exercise)

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ANCHOR: luhn
pub fn luhn(cc_number: &str) -> bool {
    // ANCHOR_END: luhn
    let mut digits_seen = 0;
    let mut sum = 0;
    for (i, ch) in cc_number.chars().rev().filter(|&ch| ch != ' ').enumerate() {
        match ch.to_digit(10) {
            Some(d) => {
                sum += if i % 2 == 1 {
                    let dd = d * 2;
                    dd / 10 + dd % 10
                } else {
                    d
                };
                digits_seen += 1;
            }
            None => return false,
        }
    }

    if digits_seen < 2 {
        return false;
    }

    sum % 10 == 0
}

fn main() {
    let cc_number = "1 0";
    println!(
        "Is {} a valid credit card number? {}",
        cc_number,
        if luhn(cc_number) { "yes" } else { "no" }
    );
}

// ANCHOR: unit-tests
#[test]
fn test_non_digit_cc_number() {
    assert!(!luhn("foo"));
}

#[test]
fn test_empty_cc_number() {
    assert!(!luhn(""));
    assert!(!luhn(" "));
    assert!(!luhn("  "));
    assert!(!luhn("    "));
}

#[test]
fn test_single_digit_cc_number() {
    assert!(!luhn("0"));
}

#[test]
fn test_two_digit_cc_number() {
    assert!(luhn(" 0 0 "));
}

#[test]
fn test_valid_cc_number() {
    assert!(luhn("4263 9826 4026 9299"));
    assert!(luhn("4539 3195 0343 6467"));
    assert!(luhn("7992 7398 713"));
}

#[test]
fn test_invalid_cc_number() {
    assert!(!luhn("4223 9826 4026 9299"));
    assert!(!luhn("4539 3195 0343 6476"));
    assert!(!luhn("8273 1232 7352 0569"));
}
// ANCHOR_END: unit-tests

Strings and Iterators

(back to exercise)

#![allow(unused)]
fn main() {
// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ANCHOR: prefix_matches
pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {
    // ANCHOR_END: prefix_matches
    let mut prefixes = prefix.split('/');
    let request_paths = request_path
        .split('/')
        .map(|p| Some(p))
        .chain(std::iter::once(None));

    for (prefix, request_path) in prefixes.zip(request_paths) {
        match request_path {
            Some(request_path) => {
                if (prefix != "*") && (prefix != request_path) {
                    return false;
                }
            }
            None => return false,
        }
    }
    true
}

// ANCHOR: unit-tests
#[test]
fn test_matches_without_wildcard() {
    assert!(prefix_matches("/v1/publishers", "/v1/publishers"));
    assert!(prefix_matches("/v1/publishers", "/v1/publishers/abc-123"));
    assert!(prefix_matches("/v1/publishers", "/v1/publishers/abc/books"));

    assert!(!prefix_matches("/v1/publishers", "/v1"));
    assert!(!prefix_matches("/v1/publishers", "/v1/publishersBooks"));
    assert!(!prefix_matches("/v1/publishers", "/v1/parent/publishers"));
}

#[test]
fn test_matches_with_wildcard() {
    assert!(prefix_matches(
        "/v1/publishers/*/books",
        "/v1/publishers/foo/books"
    ));
    assert!(prefix_matches(
        "/v1/publishers/*/books",
        "/v1/publishers/bar/books"
    ));
    assert!(prefix_matches(
        "/v1/publishers/*/books",
        "/v1/publishers/foo/books/book1"
    ));

    assert!(!prefix_matches("/v1/publishers/*/books", "/v1/publishers"));
    assert!(!prefix_matches(
        "/v1/publishers/*/books",
        "/v1/publishers/foo/booksByAuthor"
    ));
}
// ANCHOR_END: unit-tests
}

Day 3 Morning Exercise

A Simple GUI Library

(back to exercise)

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ANCHOR: setup
pub trait Widget {
    /// Natural width of `self`.
    fn width(&self) -> usize;

    /// Draw the widget into a buffer.
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);

    /// Draw the widget on standard output.
    fn draw(&self) {
        let mut buffer = String::new();
        self.draw_into(&mut buffer);
        println!("{}", &buffer);
    }
}

pub struct Label {
    label: String,
}

impl Label {
    fn new(label: &str) -> Label {
        Label {
            label: label.to_owned(),
        }
    }
}

pub struct Button {
    label: Label,
    callback: Box<dyn FnMut()>,
}

impl Button {
    fn new(label: &str, callback: Box<dyn FnMut()>) -> Button {
        Button {
            label: Label::new(label),
            callback,
        }
    }
}

pub struct Window {
    title: String,
    widgets: Vec<Box<dyn Widget>>,
}

impl Window {
    fn new(title: &str) -> Window {
        Window {
            title: title.to_owned(),
            widgets: Vec::new(),
        }
    }

    fn add_widget(&mut self, widget: Box<dyn Widget>) {
        self.widgets.push(widget);
    }
}

// ANCHOR_END: setup

// ANCHOR: Window-width
impl Widget for Window {
    fn width(&self) -> usize {
        // ANCHOR_END: Window-width
        std::cmp::max(
            self.title.chars().count(),
            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),
        )
    }

    // ANCHOR: Window-draw_into
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        // ANCHOR_END: Window-draw_into
        let mut inner = String::new();
        for widget in &self.widgets {
            widget.draw_into(&mut inner);
        }

        let window_width = self.width();

        // TODO: after learning about error handling, you can change
        // draw_into to return Result<(), std::fmt::Error>. Then use
        // the ?-operator here instead of .unwrap().
        writeln!(buffer, "+-{:-<window_width$}-+", "").unwrap();
        writeln!(buffer, "| {:^window_width$} |", &self.title).unwrap();
        writeln!(buffer, "+={:=<window_width$}=+", "").unwrap();
        for line in inner.lines() {
            writeln!(buffer, "| {:window_width$} |", line).unwrap();
        }
        writeln!(buffer, "+-{:-<window_width$}-+", "").unwrap();
    }
}

// ANCHOR: Button-width
impl Widget for Button {
    fn width(&self) -> usize {
        // ANCHOR_END: Button-width
        self.label.width() + 8 // add a bit of padding
    }

    // ANCHOR: Button-draw_into
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        // ANCHOR_END: Button-draw_into
        let width = self.width();
        let mut label = String::new();
        self.label.draw_into(&mut label);

        writeln!(buffer, "+{:-<width$}+", "").unwrap();
        for line in label.lines() {
            writeln!(buffer, "|{:^width$}|", &line).unwrap();
        }
        writeln!(buffer, "+{:-<width$}+", "").unwrap();
    }
}

// ANCHOR: Label-width
impl Widget for Label {
    fn width(&self) -> usize {
        // ANCHOR_END: Label-width
        self.label
            .lines()
            .map(|line| line.chars().count())
            .max()
            .unwrap_or(0)
    }

    // ANCHOR: Label-draw_into
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        // ANCHOR_END: Label-draw_into
        writeln!(buffer, "{}", &self.label).unwrap();
    }
}

// ANCHOR: main
fn main() {
    let mut window = Window::new("Rust GUI Demo 1.23");
    window.add_widget(Box::new(Label::new("This is a small text GUI demo.")));
    window.add_widget(Box::new(Button::new(
        "Click me!",
        Box::new(|| println!("You clicked the button!")),
    )));
    window.draw();
}
// ANCHOR_END: main

Day 3 Afternoon Exercises

Safe FFI Wrapper

(back to exercise)

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ANCHOR: ffi
mod ffi {
    use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};

    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.
    #[repr(C)]
    pub struct DIR {
        _data: [u8; 0],
        _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
    }

    // Layout as per readdir(3) and definitions in /usr/include/x86_64-linux-gnu.
    #[repr(C)]
    pub struct dirent {
        pub d_ino: c_long,
        pub d_off: c_ulong,
        pub d_reclen: c_ushort,
        pub d_type: c_char,
        pub d_name: [c_char; 256],
    }

    extern "C" {
        pub fn opendir(s: *const c_char) -> *mut DIR;
        pub fn readdir(s: *mut DIR) -> *const dirent;
        pub fn closedir(s: *mut DIR) -> c_int;
    }
}

use std::ffi::{CStr, CString, OsStr, OsString};
use std::os::unix::ffi::OsStrExt;

#[derive(Debug)]
struct DirectoryIterator {
    path: CString,
    dir: *mut ffi::DIR,
}
// ANCHOR_END: ffi

// ANCHOR: DirectoryIterator
impl DirectoryIterator {
    fn new(path: &str) -> Result<DirectoryIterator, String> {
        // Call opendir and return a Ok value if that worked,
        // otherwise return Err with a message.
        // ANCHOR_END: DirectoryIterator
        let path = CString::new(path).map_err(|err| format!("Invalid path: {err}"))?;
        // SAFETY: path.as_ptr() cannot be NULL.
        let dir = unsafe { ffi::opendir(path.as_ptr()) };
        if dir.is_null() {
            Err(format!("Could not open {:?}", path))
        } else {
            Ok(DirectoryIterator { path, dir })
        }
    }
}

// ANCHOR: Iterator
impl Iterator for DirectoryIterator {
    type Item = OsString;
    fn next(&mut self) -> Option<OsString> {
        // Keep calling readdir until we get a NULL pointer back.
        // ANCHOR_END: Iterator
        // SAFETY: self.dir is never NULL.
        let dirent = unsafe { ffi::readdir(self.dir) };
        if dirent.is_null() {
            // We have reached the end of the directory.
            return None;
        }
        // SAFETY: dirent is not NULL and dirent.d_name is NUL
        // terminated.
        let d_name = unsafe { CStr::from_ptr((*dirent).d_name.as_ptr()) };
        let os_str = OsStr::from_bytes(d_name.to_bytes());
        Some(os_str.to_owned())
    }
}

// ANCHOR: Drop
impl Drop for DirectoryIterator {
    fn drop(&mut self) {
        // Call closedir as needed.
        // ANCHOR_END: Drop
        if !self.dir.is_null() {
            // SAFETY: self.dir is not NULL.
            if unsafe { ffi::closedir(self.dir) } != 0 {
                panic!("Could not close {:?}", self.path);
            }
        }
    }
}

// ANCHOR: main
fn main() -> Result<(), String> {
    let iter = DirectoryIterator::new(".")?;
    println!("files: {:#?}", iter.collect::<Vec<_>>());
    Ok(())
}
// ANCHOR_END: main

Day 4 Morning Exercise

Dining Philosophers

(back to exercise)

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ANCHOR: Philosopher
use std::sync::mpsc;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

struct Fork;

struct Philosopher {
    name: String,
    // ANCHOR_END: Philosopher
    left_fork: Arc<Mutex<Fork>>,
    right_fork: Arc<Mutex<Fork>>,
    thoughts: mpsc::SyncSender<String>,
}

// ANCHOR: Philosopher-think
impl Philosopher {
    fn think(&self) {
        self.thoughts
            .send(format!("Eureka! {} has a new idea!", &self.name))
            .unwrap();
    }
    // ANCHOR_END: Philosopher-think

    // ANCHOR: Philosopher-eat
    fn eat(&self) {
        // ANCHOR_END: Philosopher-eat
        println!("{} is trying to eat", &self.name);
        let left = self.left_fork.lock().unwrap();
        let right = self.right_fork.lock().unwrap();

        // ANCHOR: Philosopher-eat-end
        println!("{} is eating...", &self.name);
        thread::sleep(Duration::from_millis(10));
    }
}

static PHILOSOPHERS: &[&str] =
    &["Socrates", "Plato", "Aristotle", "Thales", "Pythagoras"];

fn main() {
    // ANCHOR_END: Philosopher-eat-end
    let (tx, rx) = mpsc::sync_channel(10);

    let forks = (0..PHILOSOPHERS.len())
        .map(|_| Arc::new(Mutex::new(Fork)))
        .collect::<Vec<_>>();

    for i in 0..forks.len() {
        let tx = tx.clone();
        let mut left_fork = forks[i].clone();
        let mut right_fork = forks[(i + 1) % forks.len()].clone();

        // To avoid a deadlock, we have to break the symmetry
        // somewhere. This will swap the forks without deinitializing
        // either of them.
        if i == forks.len() - 1 {
            std::mem::swap(&mut left_fork, &mut right_fork);
        }

        let philosopher = Philosopher {
            name: PHILOSOPHERS[i].to_string(),
            thoughts: tx,
            left_fork,
            right_fork,
        };

        thread::spawn(move || {
            for _ in 0..100 {
                philosopher.eat();
                philosopher.think();
            }
        });
    }

    drop(tx);
    for thought in rx {
        println!("{}", thought);
    }
}