Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

โครงสร้างควบคุมโฟลว์ match

Rust มีโครงสร้างควบคุมการทำงาน (control flow construct) ที่ทรงพลังอย่างยิ่งชื่อ match ซึ่งช่วยให้เราสามารถนำค่าหนึ่งค่าไปเปรียบเทียบกับชุดของรูปแบบหรือแพตเทิร์น (patterns) ต่างๆ แล้วสั่งให้โค้ดทำงานตามแพตเทิร์นที่จับคู่ได้ถูกต้อง ตัวแพตเทิร์นนั้นสามารถประกอบขึ้นจากค่าลิเทอรัล (literal values), ชื่อตัวแปร, ไวลด์การ์ด (wildcards) และสิ่งอื่นๆ อีกมากมาย โดยใน บทที่ 19 จะอธิบายเรื่องแพตเทิร์นชนิดต่างๆ ทั้งหมดอย่างละเอียด พลังที่แท้จริงของ match นั้นมาจากความยืดหยุ่นในการสื่อความหมายของแพตเทิร์น ร่วมกับการที่คอมไพเลอร์ช่วยตรวจสอบให้มั่นใจว่าเราได้จัดการกรณีที่เป็นไปได้ทั้งหมดอย่างครบถ้วนแล้ว

ลองจินตนาการว่านิพจน์ match นั้นเหมือนกับเครื่องคัดแยกเหรียญ โดยเหรียญจะไหลไปตามรางที่มีรูขนาดต่างๆ เจาะไว้ และเหรียญแต่ละเหรียญจะตกลงไปในรูแรกที่มีขนาดพอดีกับมัน ในทำนองเดียวกัน ข้อมูลหรือค่าต่างๆ จะไหลผ่านแต่ละแพตเทิร์นในคำสั่ง match และเมื่อเจอแพตเทิร์นแรกที่ค่านั้น “เข้ากันได้พอดี” ค่านั้นก็จะตกลงไปยังบล็อกโค้ดที่เชื่อมโยงกับแพตเทิร์นดังกล่าวเพื่อทำงานต่อไป

และเมื่อพูดถึงเหรียญแล้ว เราลองมาใช้เหรียญเป็นตัวอย่างในการใช้งาน match กันดู! เราสามารถเขียนฟังก์ชันที่รับเหรียญสหรัฐฯ ที่ไม่ทราบชนิดเข้ามา จากนั้นให้ฟังก์ชันตรวจสอบว่าเหรียญนั้นคือเหรียญอะไร และส่งค่ามูลค่าของเหรียญกลับมาเป็นหน่วยเซนต์ คล้ายกับการทำงานของเครื่องคัดแยกเหรียญ ดังที่แสดงในลิสติ้ง 6-3

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {}

เราลองมาแยกดูองค์ประกอบของ match ในฟังก์ชัน value_in_cents กัน เริ่มแรก เราจะระบุคีย์เวิร์ด match ตามด้วยนิพจน์ ซึ่งในที่นี้ก็คือค่า coin โครงสร้างนี้อาจดูคล้ายกับนิพจน์แบบมีเงื่อนไขที่ใช้กับคำสั่ง if มาก แต่มีข้อแตกต่างที่สำคัญคือ: สำหรับ if เงื่อนไขจะต้องประเมินค่าออกมาเป็นบูลีน (Boolean) เสมอ แต่สำหรับ match ค่านั้นจะเป็นชนิดข้อมูลใดก็ได้ โดยชนิดข้อมูลของ coin ในตัวอย่างนี้ก็คือ enum Coin ที่เราได้นิยามไว้ในบรรทัดแรก

ถัดมาคือส่วนที่เรียกว่า อาร์ม (arms) ของ match โดยในแต่ละอาร์มจะประกอบด้วยสองส่วน ได้แก่: แพตเทิร์น และโค้ดที่จะให้ทำงาน อาร์มแรกในตัวอย่างนี้มีแพตเทิร์นเป็นค่า Coin::Penny ตามด้วยตัวดำเนินการ => ซึ่งทำหน้าที่คั่นระหว่างตัวแพตเทิร์นกับโค้ดที่จะทำงาน โค้ดในกรณีนี้เป็นเพียงแค่ค่า 1 โดดๆ และแต่ละอาร์มจะถูกคั่นออกจากกันด้วยเครื่องหมายจุลภาค (,)

เมื่อนิพจน์ match เริ่มทำงาน มันจะนำค่าที่ได้ไปเปรียบเทียบกับแพตเทิร์นของแต่ละอาร์มตามลำดับ หากแพตเทิร์นใดจับคู่กับค่านั้นได้พอดี โค้ดที่เชื่อมโยงกับแพตเทิร์นนั้นก็จะถูกเรียกทำงาน แต่ถ้าแพตเทิร์นนั้นไม่ตรงกับค่า โปรแกรมก็จะข้ามไปตรวจสอบอาร์มถัดไป คล้ายกับหลักการของเครื่องคัดแยกเหรียญ โดยเราสามารถกำหนดจำนวนอาร์มได้มากเท่าที่ต้องการ: อย่างในลิสติ้ง 6-3 นิพจน์ match ของเราก็มีทั้งหมด 4 อาร์ม

โค้ดที่เชื่อมโยงกับแต่ละอาร์มจะถือเป็นนิพจน์ (expression) และค่าผลลัพธ์ของนิพจน์ในอาร์มที่จับคู่ได้สำเร็จนั้น ก็คือค่าที่จะถูกส่งกลับออกมาเป็นผลลัพธ์ของนิพจน์ match ทั้งหมด

โดยปกติแล้ว เราไม่จำเป็นต้องใช้วงเล็บปีกกาถ้าโค้ดในอาร์มนั้นสั้น เหมือนในลิสติ้ง 6-3 ที่แต่ละอาร์มเพียงแค่ส่งค่ากลับออกมาเท่านั้น แต่หากต้องการรันคำสั่งหลายบรรทัดในอาร์มของ match เราก็จำเป็นต้องใช้วงเล็บปีกกาครอบไว้ และในกรณีนี้เครื่องหมายจุลภาคที่ต่อท้ายอาร์มก็จะไม่จำเป็นต้องใส่ก็ได้ ตัวอย่างเช่น โค้ดด้านล่างนี้จะพิมพ์ข้อความ “Lucky penny!” ออกมาทุกครั้งที่ฟังก์ชันถูกเรียกด้วย Coin::Penny แต่ยังคงส่งค่าสุดท้ายของบล็อกคือ 1 กลับออกมาเช่นเดิม:

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {}

แพตเทิร์นที่ผูกกับค่า

คุณสมบัติที่มีประโยชน์อีกประการหนึ่งของอาร์มใน match คือความสามารถในการผูกค่า (bind) เข้ากับส่วนประกอบต่างๆ ของข้อมูลที่ตรงกับแพตเทิร์นนั้น ซึ่งนี่คือวิธีที่เราใช้ในการสกัดเอาค่าที่อยู่ภายในวาเรียนต์ของ enum ออกมาใช้งาน

ตัวอย่างเช่น ลองมาแก้ไขวาเรียนต์หนึ่งของ enum ให้สามารถเก็บข้อมูลไว้ข้างในได้ ในช่วงปี 1999 ถึง 2008 ประเทศสหรัฐอเมริกาได้ผลิตเหรียญควอเตอร์ (25 เซนต์) ที่มีลวดลายด้านหลังแตกต่างกันสำหรับทั้ง 50 รัฐ โดยไม่มีเหรียญชนิดอื่นที่มีลวดลายประจำรัฐเลย ดังนั้นจึงมีเพียงเหรียญควอเตอร์เท่านั้นที่มีข้อมูลพิเศษนี้ เราสามารถเพิ่มข้อมูลนี้เข้าไปใน enum ของเราได้โดยปรับเปลี่ยนวาเรียนต์ Quarter ให้เก็บค่า UsState ไว้ภายใน ดังที่แสดงในลิสติ้ง 6-4

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {}

ลองจินตนาการว่า มีเพื่อนคนหนึ่งกำลังพยายามสะสมเหรียญควอเตอร์ให้ครบทั้ง 50 รัฐ ในขณะที่เรากำลังคัดแยกเหรียญตามชนิดของเหรียญ เราก็อยากจะขานชื่อรัฐที่อยู่บนเหรียญควอเตอร์แต่ละเหรียญออกมาด้วย เพื่อที่ว่าหากเป็นเหรียญที่เพื่อนคนนั้นยังไม่มี เขาก็จะได้นำไปเพิ่มเข้าคอลเลกชันของเขาได้

ในนิพจน์ match ของโค้ดนี้ เราได้เพิ่มตัวแปรชื่อ state เข้าไปในแพตเทิร์นที่ใช้จับคู่วาเรียนต์ Coin::Quarter และเมื่อเกิดการจับคู่ตรงกับ Coin::Quarter ตัวแปร state ดังกล่าวจะถูกผูกเข้ากับค่าของรัฐที่บรรจุอยู่ในเหรียญควอเตอร์นั้นโดยอัตโนมัติ จากนั้นเราก็สามารถนำตัวแปร state มาใช้งานในโค้ดของอาร์มนั้นได้ ดังนี้:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {state:?}!");
            25
        }
    }
}

fn main() {
    value_in_cents(Coin::Quarter(UsState::Alaska));
}

หากเราเรียกใช้ value_in_cents(Coin::Quarter(UsState::Alaska)) ค่าของ coin ก็จะเป็น Coin::Quarter(UsState::Alaska) และเมื่อนำค่านั้นไปเปรียบเทียบกับอาร์มแต่ละอาร์มใน match ก็จะไม่มีอาร์มใดตรงเลยจนกระทั่งมาถึง Coin::Quarter(state) ซึ่ง ณ จุดนั้น การผูกค่าของตัวแปร state จะมีค่าเท่ากับ UsState::Alaska เราจึงสามารถนำค่านั้นไปใช้งานในคำสั่ง println! ได้ และนี่คือวิธีที่เราดึงค่าที่อยู่ภายในวาเรียนต์ Quarter ของ enum Coin ออกมาใช้งาน

แพตเทิร์น match ของ Option<T>

ในหัวข้อก่อนหน้านี้ เราต้องการดึงค่า T ที่อยู่ภายในกรณี Some เมื่อใช้งาน Option<T> ซึ่งเราสามารถจัดการกับ Option<T> โดยใช้คำสั่ง match ได้เช่นกัน เหมือนกับที่เราทำกับ enum Coin! เพียงแต่เปลี่ยนจากการเปรียบเทียบเหรียญมาเป็นการเปรียบเทียบวาเรียนต์ต่างๆ ของ Option<T> แทน แต่วิธีการทำงานของนิพจน์ match นั้นยังคงเหมือนเดิมทุกประการ

สมมติว่าเราต้องการเขียนฟังก์ชันที่รับพารามิเตอร์ชนิด Option<i32> เข้ามา และหากมีค่าอยู่ภายใน ก็ให้บวกค่านั้นเพิ่มขึ้นอีก 1 แต่ถ้าไม่มีค่าอยู่ภายใน ฟังก์ชันก็ควรส่งค่า None กลับไปโดยไม่ต้องดำเนินการคำนวณใดๆ ทั้งสิ้น

ฟังก์ชันนี้สามารถเขียนได้ง่ายดายมากด้วยการใช้ match ดังที่แสดงในลิสติ้ง 6-5

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

มาดูรายละเอียดการทำงานของฟังก์ชัน plus_one เมื่อถูกเรียกใช้งานครั้งแรกกัน เมื่อเราเรียก plus_one(five) ตัวแปร x ภายในตัวฟังก์ชันจะมีค่าเป็น Some(5) จากนั้นโปรแกรมจะนำค่านั้นไปเปรียบเทียบกับแต่ละอาร์มของ match:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

ค่า Some(5) ไม่ตรงกับแพตเทิร์น None โปรแกรมจึงข้ามไปยังอาร์มถัดไป:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

แล้ว Some(5) ตรงกับ Some(i) หรือไม่? คำตอบคือตรงกัน! เพราะทั้งสองเป็นวาเรียนต์ชนิดเดียวกัน ตัวแปร i จึงถูกผูกเข้ากับค่าที่บรรจุอยู่ภายใน Some ส่งผลให้ i มีค่าเท่ากับ 5 จากนั้นโค้ดในอาร์มนี้จะทำงาน โดยนำค่าของ i ไปบวกเพิ่ม 1 แล้วสร้างค่า Some ตัวใหม่ที่บรรจุผลลัพธ์ 6 เอาไว้ภายใน

คราวนี้ลองมาดูการเรียก plus_one ครั้งที่สองในลิสติ้ง 6-5 กันบ้าง ซึ่งในรอบนี้ตัวแปร x มีค่าเป็น None โปรแกรมจะเข้าสู่นิพจน์ match แล้วเปรียบเทียบกับอาร์มแรก:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

ผลปรากฏว่าตรงกัน! และเนื่องจากไม่มีค่าให้ต้องนำไปบวกเพิ่ม โปรแกรมจึงหยุดการตรวจสอบและส่งค่า None ทางด้านขวาของเครื่องหมาย => กลับออกไปทันที และเนื่องจากอาร์มแรกจับคู่ตรงกันแล้ว อาร์มอื่นๆ จึงไม่ต้องถูกนำมาเปรียบเทียบอีก

การใช้งาน match ร่วมกับ enum นั้นมีประโยชน์ในหลายๆ สถานการณ์ และคุณจะพบเห็นรูปแบบการเขียนแบบนี้บ่อยมากในโค้ด Rust: นั่นคือการใช้ match กับ enum, ผูกตัวแปรเข้ากับข้อมูลภายใน, แล้วสั่งให้โค้ดทำงานตามข้อมูลที่ได้ ในช่วงแรกอาจรู้สึกแปลกใหม่และต้องปรับตัวบ้าง แต่เมื่อคุณเริ่มคุ้นเคยแล้ว คุณจะอยากให้ภาษาอื่นๆ มีฟีเจอร์นี้เช่นกัน ซึ่งฟีเจอร์นี้มักเป็นหนึ่งในฟีเจอร์โปรดของเหล่านักพัฒนา Rust เสมอมา

การจับคู่ต้องครบถ้วนทุกกรณี

ยังมีอีกแง่มุมหนึ่งของ match ที่จำเป็นต้องพูดถึง: นั่นคือแพตเทิร์นของอาร์มทั้งหมดจะต้องครอบคลุมทุกกรณีที่เป็นไปได้ (exhaustive) ลองพิจารณาฟังก์ชัน plus_one ในเวอร์ชันนี้ ซึ่งมีบั๊กซ่อนอยู่และจะคอมไพล์ไม่ผ่าน:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

เนื่องจากเราไม่ได้จัดการกรณี None ไว้ โค้ดนี้จึงอาจก่อให้เกิดบั๊กขึ้นได้ แต่โชคดีที่บั๊กประเภทนี้ Rust สามารถตรวจจับได้ตั้งแต่ตอนคอมไพล์ หากเราพยายามคอมไพล์โค้ดดังกล่าว เราจะได้รับข้อผิดพลาดดังนี้:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
 --> src/main.rs:3:15
  |
3 |         match x {
  |               ^ pattern `None` not covered
  |
note: `Option<i32>` defined here
 --> /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/option.rs:598:0
 ::: /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/option.rs:602:4
  |
  = note: not covered
  = note: the matched value is of type `Option<i32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
4 ~             Some(i) => Some(i + 1),
5 ~             None => todo!(),
  |

For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Rust ทราบดีว่าเรายังไม่ได้ครอบคลุมทุกกรณีที่เป็นไปได้ และยังบอกได้ด้วยซ้ำว่าเราลืมแพตเทิร์นใดไป! การจับคู่ด้วย match ในภาษา Rust นั้นต้อง_ครบถ้วนทุกกรณี_ (exhaustive): เราจะต้องแจกแจงทุกกรณีที่เป็นไปได้อย่างหมดจด โค้ดจึงจะถือว่าถูกต้องสมบูรณ์ โดยเฉพาะอย่างยิ่งในกรณีของ Option<T> การที่ Rust บังคับไม่ให้เราลืมจัดการกรณี None จะช่วยป้องกันไม่ให้เราเผลอทึกทักเอาเองว่ามีค่าอยู่เสมอ ทั้งที่ในความเป็นจริงอาจเป็นค่า null ซึ่งการตรวจสอบนี้ช่วยขจัด “ความผิดพลาดมูลค่าพันล้านดอลลาร์” ที่เราพูดถึงไปก่อนหน้านี้ให้เป็นไปไม่ได้เลย

แพตเทิร์นแบบครอบคลุมทั้งหมดและตัวยึดตำแหน่ง _

เมื่อใช้ enum เรายังสามารถกำหนดการทำงานแบบพิเศษให้กับค่าเฉพาะเจาะจงบางค่าได้ ในขณะที่ค่าอื่นๆ ทั้งหมดที่เหลือ ให้ไปทำงานตามการกระทำเริ่มต้น (default action) เพียงแบบเดียว ลองจินตนาการว่าเรากำลังพัฒนาเกมกระดานเกมหนึ่ง ซึ่งหากคุณทอยลูกเต๋าได้แต้ม 3 ตัวละครจะไม่เดิน แต่จะได้หมวกใบใหม่สุดเท่แทน หากทอยได้แต้ม 7 ตัวละครจะเสียหมวกใบเท่ไปหนึ่งใบ ส่วนกรณีที่ทอยได้แต้มอื่นๆ ทั้งหมด ตัวละครจะเดินไปข้างหน้าตามจำนวนช่องเท่ากับแต้มที่ทอยได้ ด้านล่างนี้คือนิพจน์ match ที่จำลองตรรกะดังกล่าว โดยเราจะฮาร์ดโค้ดผลลัพธ์ของการทอยลูกเต๋าไว้แทนที่จะเป็นการสุ่มค่า และตรรกะอื่นๆ จะเขียนแทนด้วยฟังก์ชันเปล่าๆ เนื่องจากรายละเอียดการทำงานจริงนั้นอยู่นอกเหนือขอบเขตของตัวอย่างนี้:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        other => move_player(other),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
    fn move_player(num_spaces: u8) {}
}

สำหรับสองอาร์มแรก แพตเทิร์นคือค่าลิเทอรัล 3 และ 7 ส่วนอาร์มสุดท้ายที่ทำหน้าที่ครอบคลุมค่าอื่นๆ ที่เป็นไปได้ทั้งหมดนั้น เราใช้แพตเทิร์นเป็นตัวแปรที่เราตั้งชื่อว่า other โดยโค้ดที่จะทำงานในอาร์ม other จะนำตัวแปรนี้ไปส่งต่อให้กับฟังก์ชัน move_player

โค้ดนี้คอมไพล์ผ่าน แม้ว่าเราจะไม่ได้แจกแจงค่าทั้งหมดที่ชนิดข้อมูล u8 สามารถเป็นไปได้ก็ตาม เพราะแพตเทิร์นสุดท้ายจะจับคู่กับค่าทั้งหมดที่ไม่ได้ระบุไว้ในอาร์มก่อนหน้า ซึ่งแพตเทิร์นแบบครอบคลุมทั้งหมด (catch-all pattern) นี้ช่วยตอบสนองข้อกำหนดของ match ที่จะต้องครอบคลุมทุกกรณีได้เป็นอย่างดี อย่างไรก็ตาม โปรดสังเกตว่าเราจำเป็นต้องวางอาร์มแบบครอบคลุมทั้งหมดนี้ไว้เป็นลำดับสุดท้ายเสมอ เนื่องจากแพตเทิร์นจะถูกตรวจสอบเรียงตามลำดับจากบนลงล่าง หากเรานำอาร์มแบบครอบคลุมทั้งหมดไปวางไว้ก่อน อาร์มอื่นๆ ที่อยู่ถัดไปจะไม่มีทางถูกเรียกทำงานเลย ซึ่ง Rust จะแจ้งเตือน (warning) ทันทีหากเราเขียนอาร์มใดๆ ต่อท้ายอาร์มแบบครอบคลุมทั้งหมด!

นอกจากนี้ Rust ยังมีแพตเทิร์นสำหรับกรณีที่เราต้องการครอบคลุมค่าที่เหลือทั้งหมด แต่_ไม่ต้องการนำค่า_เหล่านั้นมาใช้งาน: โดยตัวสัญลักษณ์ _ เป็นแพตเทิร์นพิเศษที่จะจับคู่กับค่าใดๆ ก็ได้โดยไม่มีการผูกค่านั้นเข้ากับตัวแปร ซึ่งเป็นการบอก Rust อย่างชัดเจนว่าเราไม่ได้คิดจะนำค่านั้นไปใช้ และคอมไพเลอร์ก็จะไม่แจ้งเตือนเรื่องตัวแปรที่ไม่ได้ใช้งานด้วย

คราวนี้ลองเปลี่ยนกฎของเกมกันดู: หากคุณทอยลูกเต๋าได้แต้มอื่นที่ไม่ใช่ 3 หรือ 7 คุณจะต้องทอยลูกเต๋าใหม่อีกครั้ง ในกรณีนี้เราไม่จำเป็นต้องนำค่าแต้มที่ทอยได้ไปใช้งานแล้ว เราจึงสามารถปรับโค้ดมาใช้ _ แทนตัวแปรชื่อ other ได้ดังนี้:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => reroll(),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
    fn reroll() {}
}

ตัวอย่างนี้ยังคงตอบสนองข้อกำหนดเรื่องความครอบคลุมทุกกรณีได้เช่นเดิม เพราะเราได้ระบุอย่างชัดเจนในอาร์มสุดท้ายว่าจะละเว้นค่าอื่นๆ ทั้งหมดที่เหลือ จึงมั่นใจได้ว่าเราไม่ได้หลงลืมกรณีใดไป

และสุดท้ายนี้ หากเราเปลี่ยนกฎของเกมอีกรอบหนึ่งเป็นว่า เมื่อทอยได้แต้มอื่นนอกจาก 3 หรือ 7 จะไม่มีอะไรเกิดขึ้นเลยในตานั้น เราก็สามารถสื่อความหมายดังกล่าวได้โดยใช้ค่ายูนิต (unit value - ซึ่งก็คือชนิดทูเพิลว่างเปล่าที่เราได้กล่าวถึงในหัวข้อ “ชนิดทูเพิล”) มาใส่เป็นบล็อกโค้ดในอาร์ม _:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => (),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
}

ในตัวอย่างนี้ เรากำลังบอก Rust อย่างตรงไปตรงมาว่า เราจะไม่นำค่าอื่นๆ ที่ไม่ตรงกับแพตเทิร์นในอาร์มก่อนหน้ามาใช้งาน และเราก็ไม่ต้องการให้โค้ดส่วนใดทำงานเลยในกรณีนี้

ยังมีรายละเอียดเกี่ยวกับแพตเทิร์นและการจับคู่รูปแบบ (pattern matching) อีกมากมายที่เราจะได้เรียนรู้กันใน บทที่ 19 แต่สำหรับตอนนี้ เราจะไปต่อกันที่โครงสร้างไวยากรณ์ if let ซึ่งจะมีประโยชน์อย่างยิ่งในสถานการณ์ที่การใช้นิพจน์ match อาจดูเยิ่นเย้อเกินไป