[Devcon 2024] Rust는 어떻게 안전한 프로그래밍을 이뤄내는가?

fn main() { let mut a = 10; let b = &a; // 불변 참조. b는 a의 값의 읽기 권한만 가능 // Error: cannot borrow `a` as mutable because // it is also borrowed as immutable { let c = &mut a; // 불변참조가 가능한 상태에서 가변 참조를 만드려고 함 -> 불가능 *c = 20; } println!("a : {a}"); println!("b : {b}"); }

fn main() { let a = 10; let b = 30.4; // Error: mismatched types // let c = a + b; // Use explicit type conversion let c = a as f64 + b; println!("{c}"); }

enum Status { Idle, Run(i32), Attack { damage: i32 }, Defend { defense: i32 }, } fn main() { let mut status = Status::Idle; status = Status::Run(10); status = Status::Attack { damage: 20 }; status = Status::Defend { defense: 5 }; }

enum Option<T> { Some(T), None, } fn main() { let x: Option<i32> = Some(5); let y: Option<i32> = None; println!("{:?}", x); println!("{:?}", y); println!("{}", x.unwrap_or(0)); match y { Option::Some(v) => println!("Value: {}", v), Option::None => println!("No value"), } }

enum Result<T, E> { Ok(T), Err(E), } fn square_if_even(num: i32) -> Result<i32, String> { if num % 2 == 0 { Ok(num * num) } else { Err(String::from("Not even")) } } fn main() { let num1 = 4; let num2 = 5; match square_if_even(num1) { Ok(v) => println!("Result: {}", v), Err(e) => println!("Error: {}", e), } match square_if_even(num2) { Ok(v) => println!("Result: {}", v), Err(e) => println!("Error: {}", e), } }

fn main() { let num = 100; match num { 0 => println!("Zero"), 1 | 3 | 5 | 7 | 9 => println!("1-digit Odd"), 2..=8 => println!("1-digit Even"), num @ 10..=99 => println!("2-digit: {num}"), _ => println!("3-digit or more"), } }

int main() { SpreadSheet sheet1(1, 10, 5); { SpreadSheet sheet2(sheet1); sheet1.SetCell(0, 0, 42); // sheet2.GetCell(0, 0) == 42 std::cout << sheet2.GetCell(0, 0) << '\n'; } // sheet1.GetCell(0, 0) == 42 std::cout << sheet1.GetCell(0, 0) << '\n'; return 0; }

SpreadSheet(const SpreadSheet &src) : SpreadSheet(src.m_id, src.m_rows, src.m_cols) { for (int i = 0; i < m_rows; ++i) { for (int j = 0; j < m_cols; ++j) { m_data[i][j] = src.m_data[i][j]; } } }

fn hello(name: String) { println!("Hello, {name}"); } fn square(num: i32) -> i32 { num * num } fn main() { // Only implement Clone trait, not Copy let name = String::from("Chris"); hello(name.clone()); hello(name); // Implement Copy and Clone traits let num = 5; println!("square({num}): {}", square(num)); println!("square({}): {}", num + 5, square(num + 5)); }

fn call_twice<F>(closure: F) where F: Fn() { closure(); closure(); } fn main() { let name = String::from("Chris"); let hello = || { println!("Hello, {name}"); drop(name); }; call_twice(hello); }

error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce` --> .\14_closure.rs:8:17 | 8 | let hello = || { | ^^ this closure implements `FnOnce`, not `Fn` 9 | println!("Hello, {name}"); 10| drop(name); | ---- closure is `FnOnce` because it moves the variable `name` out of its environment ... 13| call_twice(hello); | ------------ the requirement to implement `Fn` derives from here | | required by a bound in `call_twice` --> .\14_closure.rs:1:39 | 1 | fn call_twice<F>(closure: F) where F: Fn() { | ^^^ required by this bound in `call_twice` error: aborting due to 1 previous error