흐름 μ œμ–΄

Rustμ—λŠ” λ‹€λ₯Έ μ–Έμ–΄μ™€λŠ” λ‹€λ₯Έ λͺ‡ κ°€μ§€ μ œμ–΄ 흐름 ꡬ쑰가 있으며 νŒ¨ν„΄ μΌμΉ˜μ— μ‚¬μš©λ©λ‹ˆλ‹€.

  • if let ν‘œν˜„μ‹
  • while let expressions
  • match ν‘œν˜„μ‹

if let ν‘œν˜„μ‹

if let ν‘œν˜„μ‹μ„ μ‚¬μš©ν•˜λ©΄ 값이 νŒ¨ν„΄κ³Ό μΌμΉ˜ν•˜λŠ”μ§€μ— 따라 λ‹€λ₯Έ μ½”λ“œλ₯Ό μ‹€ν–‰ν•  수 μžˆμŠ΅λ‹ˆλ‹€:

fn sleep_for(secs: f32) {
    let dur = if let Ok(dur) = std::time::Duration::try_from_secs_f32(secs) {
        dur
    } else {
        std::time::Duration::from_millis(500)
    };
    std::thread::sleep(dur);
    println!("{:?} λ™μ•ˆ μž λ“€μ—ˆμŠ΅λ‹ˆλ‹€.", dur);
}

fn main() {
    sleep_for(-10.0);
    sleep_for(0.8);
}

let else expressions

νŒ¨ν„΄μ„ μΌμΉ˜μ‹œν‚€κ³  ν•¨μˆ˜μ—μ„œ λ°˜ν™˜ν•˜λŠ” 일반적인 κ²½μš°μ—λŠ” let elseλ₯Ό μ‚¬μš©ν•©λ‹ˆλ‹€. β€˜else’ μ‚¬λ‘€λŠ” ν•΄λ‹Ή μ½”λ“œλ₯Ό λ²—μ–΄λ‚˜μ•Ό ν•©λ‹ˆλ‹€ (return, break λ˜λŠ” νŒ¨λ‹‰ - λΈ”λ‘μ˜ λ‹€μŒ μœ„μΉ˜λ‘œ μ΄λ™ν•˜λŠ” κ²ƒλ§Œ μ•„λ‹ˆλ©΄ λ©λ‹ˆλ‹€).

fn hex_or_die_trying(maybe_string: Option<String>) -> Result<u32, String> {
    let s = if let Some(s) = maybe_string {
        s
    } else {
        return Err(String::from("None을 κ°€μ Έμ˜΄"));
    };

    let first_byte_char = if let Some(first_byte_char) = s.chars().next() {
        first_byte_char
    } else {
        return Err(String::from("got empty string"));
    };

    if let Some(digit) = first_byte_char.to_digit(16) {
        Ok(digit)
    } else {
        Err(String::from("16μ§„μˆ˜κ°€ μ•„λ‹˜"))
    }
}

fn main() {
    println!("κ²°κ³Ό: {:?}", hex_or_die_trying(Some(String::from("foo"))));
}

λ§ˆμ§€λ§‰μœΌλ‘œ, λ¬΄ν•œ 루프λ₯Ό λ§Œλ“œλŠ” loop ν‚€μ›Œλ“œκ°€ μžˆμŠ΅λ‹ˆλ‹€:

fn main() {
    let mut name = String::from("Comprehensive Rust πŸ¦€");
    while let Some(c) = name.pop() {
        println!("character: {c}");
    }
    // (There are more efficient ways to reverse a string!)
}

Here String::pop returns Some(c) until the string is empty, after which it will return None. The while let lets us keep iterating through all items.

This slide should take about 10 minutes.

if-let

  • if let이 match보닀 더 κ°„κ²°ν•  수 μžˆμŠ΅λ‹ˆλ‹€(예: ν•œκ°€μ§€ 브랜치만 ν₯미둜운 경우). 이와 달리 matchμ—μ„œλŠ” λͺ¨λ“  λΈŒλžœμΉ˜κ°€ μ²˜λ¦¬λ˜μ–΄μ•Ό ν•©λ‹ˆλ‹€.
  • 일반적 μ‚¬μš©λ²•μ€ Option을 μ‚¬μš©ν•  λ•Œ Some 값을 μ²˜λ¦¬ν•˜λŠ” κ²ƒμž…λ‹ˆλ‹€.
  • match와 달리 if let은 νŒ¨ν„΄ 일치λ₯Ό μœ„ν•œ 보호 μ ˆμ„ μ§€μ›ν•˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€.

let-else

μœ„μ—μ„œ λ³Έ κ²ƒμ²˜λŸΌ if-let은 쀑첩할 수 μžˆμŠ΅λ‹ˆλ‹€. let-else κ΅¬μ‘°λŠ” 이 μ€‘μ²©λœ μ½”λ“œμ˜ 평면화λ₯Ό μ§€μ›ν•©λ‹ˆλ‹€. μ½”λ“œκ°€ μ–΄λ–»κ²Œ λ³€ν™”ν•˜λŠ”μ§€ 학생듀이 λ³Ό 수 μžˆλ„λ‘ μ–΄μƒ‰ν•œ 버전을 λ‹€μ‹œ μž‘μ„±ν•˜μ„Έμš”.

λ‹€μ‹œ μž‘μ„±λœ 버전은 λ‹€μŒκ³Ό κ°™μŠ΅λ‹ˆλ‹€.

#![allow(unused)]
fn main() {
fn hex_or_die_trying(maybe_string: Option<String>) -> Result<u32, String> {
    let Some(s) = maybe_string else {
        return Err(String::from("None을 κ°€μ Έμ˜΄"));
    };

    let Some(first_byte_char) = s.chars().next() else {
        return Err(String::from("got empty string"));
    };

    let Some(digit) = first_byte_char.to_digit(16) else {
        return Err(String::from("16μ§„μˆ˜κ°€ μ•„λ‹˜"));
    };

    return Ok(digit);
}
}

while-let

  • while let은 값이 νŒ¨ν„΄μ— λ§€μΉ˜λ˜λŠ” λ™μ•ˆ κ³„μ†λ©λ‹ˆλ‹€.
  • You could rewrite the while let loop as an infinite loop with an if statement that breaks when there is no value to unwrap for name.pop(). The while let provides syntactic sugar for the above scenario.