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

การนิยาม enum

ในขณะที่ struct เป็นเครื่องมือสำหรับจัดกลุ่มฟิลด์และข้อมูลที่เกี่ยวข้องกันเข้าไว้ด้วยกัน เช่น Rectangle ที่มี width และ height แต่ enum กลับเป็นเครื่องมือที่ใช้สำหรับบ่งบอกว่า ค่าหนึ่งๆ นั้นเป็นหนึ่งในกลุ่มของค่าที่เป็นไปได้ ตัวอย่างเช่น เราอาจต้องการระบุว่า Rectangle เป็นหนึ่งในรูปทรงเรขาคณิตที่เป็นไปได้ ซึ่งประกอบด้วย Circle และ Triangle ด้วย เป็นต้น และเพื่อรองรับการทำงานในลักษณะนี้ Rust จึงอนุญาตให้เราเขียนแทนความเป็นไปได้เหล่านี้ด้วย enum

ลองมาดูสถานการณ์ตัวอย่างจริงในโค้ด เพื่อทำความเข้าใจว่าทำไม enum จึงมีประโยชน์และเหมาะสมกว่า struct ในบางกรณี สมมติว่าเราต้องเขียนโปรแกรมจัดการกับที่อยู่ไอพี (IP address) ซึ่งในปัจจุบันมีมาตรฐานหลักอยู่ 2 แบบ คือ IPv4 และ IPv6 และเนื่องจากความเป็นไปได้ของที่อยู่ไอพีที่โปรแกรมของเราจะต้องพบเจอมีเพียง 2 แบบนี้เท่านั้น เราจึงสามารถ แจกแจง (enumerate) วาเรียนต์ (variant) ที่เป็นไปได้ทั้งหมดออกมาได้ ซึ่งนี่คือที่มาของคำว่า enumeration หรือ enum นั่นเอง

ที่อยู่ไอพีใดๆ ย่อมสามารถเป็นได้เพียง IPv4 หรือ IPv6 อย่างใดอย่างหนึ่งเท่านั้น แต่ไม่สามารถเป็นทั้งสองอย่างพร้อมกันได้ในเวลาเดียวกัน คุณลักษณะนี้ตรงกับธรรมชาติของโครงสร้างข้อมูลแบบ enum อย่างสมบูรณ์แบบ เพราะค่าของ enum หนึ่งๆ จะสามารถเป็นได้เพียงหนึ่งในวาเรียนต์ของมันเท่านั้นในขณะใดขณะหนึ่ง อย่างไรก็ตาม ทั้งที่อยู่ IPv4 และ IPv6 ต่างก็ยังคงถือเป็นที่อยู่ไอพีเหมือนกันในระดับพื้นฐาน ดังนั้นพวกมันจึงควรถูกปฏิบัติเหมือนเป็นชนิดข้อมูลเดียวกันเมื่อโค้ดกำลังทำงานในส่วนที่ใช้ได้กับที่อยู่ไอพีทุกประเภท

เราสามารถเขียนแทนแนวคิดนี้ในโค้ดได้โดยการนิยาม enum ชื่อ IpAddrKind แล้วระบุชนิดของที่อยู่ไอพีที่เป็นไปได้ นั่นคือ V4 และ V6 ซึ่งสิ่งเหล่านี้เรียกว่าเป็น วาเรียนต์ (variant) ของ enum:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

ในตอนนี้ IpAddrKind ได้กลายเป็นชนิดข้อมูลกำหนดเองที่เราสามารถนำไปใช้งานในส่วนอื่นๆ ของโค้ดได้แล้ว

ค่าของ enum

เราสามารถสร้างอินสแตนซ์ของแต่ละวาเรียนต์ใน IpAddrKind ได้ดังนี้:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

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

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

และเราสามารถเรียกใช้ฟังก์ชันนี้ได้ด้วยวาเรียนต์ใดก็ได้:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

การใช้ enum ยังมีข้อได้เปรียบมากกว่านั้นอีก เมื่อเราคิดต่อยอดเรื่องการเก็บข้อมูลที่อยู่ไอพี ในตอนนี้เรายังไม่ได้จัดเก็บ ข้อมูล ของที่อยู่ไอพีจริงๆ เลย เราเพียงแต่รู้ว่ามันเป็นไอพี ชนิด ใด และเนื่องจากคุณเพิ่งเรียนรู้เรื่อง struct มาในบทที่ 5 คุณจึงอาจอยากนำ struct มาแก้ปัญหานี้ ดังแสดงในลิสติ้ง 6-1

fn main() {
    enum IpAddrKind {
        V4,
        V6,
    }

    struct IpAddr {
        kind: IpAddrKind,
        address: String,
    }

    let home = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
    };

    let loopback = IpAddr {
        kind: IpAddrKind::V6,
        address: String::from("::1"),
    };
}

ในตัวอย่างนี้ เราได้นิยาม struct IpAddr ที่มี 2 ฟิลด์ ได้แก่ ฟิลด์ kind ซึ่งมีชนิดข้อมูลเป็น IpAddrKind (enum ที่เรานิยามไว้ก่อนหน้า) และฟิลด์ address ซึ่งมีชนิดข้อมูลเป็น String และเราได้สร้างอินสแตนซ์ขึ้นมา 2 ตัว ตัวแรกคือ home ซึ่งมี kind เป็น IpAddrKind::V4 และมีข้อมูลที่อยู่คือ 127.0.0.1 ส่วนตัวที่สองคือ loopback ซึ่งมี kind เป็น IpAddrKind::V6 และมีข้อมูลที่อยู่คือ ::1 เราใช้ struct เพื่อรวมค่า kind และ address เข้าไว้ด้วยกัน ทำให้ตอนนี้แต่ละวาเรียนต์มีข้อมูลที่อยู่ผูกติดอยู่ด้วยแล้ว

อย่างไรก็ดี เราสามารถเขียนแทนแนวคิดเดียวกันนี้ด้วย enum เพียงอย่างเดียวได้อย่างกระชับและสง่างามกว่ามาก แทนที่จะต้องนำ enum ไปซ้อนอยู่ใน struct เราสามารถแนบข้อมูลเข้าไปในแต่ละวาเรียนต์ของ enum ได้โดยตรง นิยามใหม่ของ enum IpAddr ต่อไปนี้ระบุว่า ทั้งวาเรียนต์ V4 และ V6 จะมีค่า String ผูกติดอยู่ด้วย:

fn main() {
    enum IpAddr {
        V4(String),
        V6(String),
    }

    let home = IpAddr::V4(String::from("127.0.0.1"));

    let loopback = IpAddr::V6(String::from("::1"));
}

เราแนบข้อมูลเข้ากับแต่ละวาเรียนต์ของ enum ได้โดยตรง จึงไม่จำเป็นต้องสร้าง struct เพิ่มเติมอีกเลย นอกจากนี้ยังช่วยให้เห็นรายละเอียดการทำงานของ enum ชัดเจนขึ้นด้วย นั่นคือ ชื่อของแต่ละวาเรียนต์ใน enum จะกลายเป็นฟังก์ชันคอนสตรัคเตอร์สำหรับสร้างอินสแตนซ์ของ enum นั้นโดยอัตโนมัติ กล่าวคือ IpAddr::V4() จะทำหน้าที่เป็นฟังก์ชันที่รับอาร์กิวเมนต์ชนิด String แล้วส่งคืนอินสแตนซ์ของชนิด IpAddr ออกมา ซึ่งฟังก์ชันคอนสตรัคเตอร์นี้จะถูกสร้างขึ้นให้อัตโนมัติทันทีที่เรานิยาม enum

การใช้ enum ยังมีข้อได้เปรียบเหนือกว่า struct อีกประการหนึ่งคือ: แต่ละวาเรียนต์สามารถมีชนิดข้อมูลและจำนวนข้อมูลที่ผูกติดอยู่แตกต่างกันได้อย่างอิสระ สำหรับที่อยู่ IPv4 จะประกอบด้วยตัวเลข 4 ส่วนที่มีค่าระหว่าง 0 ถึง 255 เสมอ หากเราต้องการจัดเก็บที่อยู่ V4 เป็นตัวเลข u8 จำนวน 4 ค่า แต่ยังคงต้องการจัดเก็บที่อยู่ V6 เป็นสตริง String เพียงค่าเดียว เราจะไม่สามารถทำได้สะดวกด้วย struct แต่สำหรับ enum แล้ว สามารถจัดการกรณีนี้ได้อย่างง่ายดาย:

fn main() {
    enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
    }

    let home = IpAddr::V4(127, 0, 0, 1);

    let loopback = IpAddr::V6(String::from("::1"));
}

เราได้เห็นวิธีต่างๆ ในการจัดโครงสร้างข้อมูลเพื่อจัดเก็บที่อยู่ไอพีทั้งแบบ IPv4 และ IPv6 กันไปแล้ว อย่างไรก็ดี ความต้องการในการจัดเก็บที่อยู่ไอพีพร้อมระบุเวอร์ชันนั้นเป็นเรื่องที่พบได้บ่อยมากในทางปฏิบัติ จนกระทั่ง ไลบรารีมาตรฐานมีนิยามของ IpAddr เตรียมไว้ให้เราใช้งานได้ทันที! ลองมาดูกันว่าในไลบรารีมาตรฐานนิยาม IpAddr ไว้อย่างไร ซึ่งโครงสร้างมีลักษณะเหมือนกับที่เราเขียนไว้ทุกประการ เพียงแต่ข้อมูลของที่อยู่ถูกฝังไว้ในรูปของ struct 2 ตัวที่แยกกันสำหรับแต่ละวาเรียนต์:

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}
}

โค้ดนี้แสดงให้เห็นว่าคุณสามารถใส่ข้อมูลชนิดใดก็ได้ไว้ในวาเรียนต์ของ enum ไม่ว่าจะเป็นสตริง, ตัวเลข, struct หรือแม้กระทั่งใส่ enum อีกตัวซ้อนเข้าไปข้างในก็ทำได้เช่นกัน! และชนิดข้อมูลต่างๆ ในไลบรารีมาตรฐานก็มักจะไม่ได้ซับซ้อนไปกว่าสิ่งที่คุณสามารถออกแบบขึ้นมาเองได้เลย

โปรดสังเกตว่าแม้ไลบรารีมาตรฐานจะมีนิยามของ IpAddr อยู่แล้ว เราก็ยังคงสามารถสร้างและใช้งานนิยาม IpAddr ของเราเองได้โดยไม่เกิดข้อขัดแย้งใดๆ เนื่องจากเรายังไม่ได้นำ (import) นิยามของไลบรารีมาตรฐานเข้ามาในขอบเขต (scope) ของโปรแกรม ซึ่งเราจะพูดถึงการนำชนิดข้อมูลเข้าสู่ขอบเขตการใช้งานอย่างละเอียดในบทที่ 7

ลองมาดูอีกตัวอย่างหนึ่งของ enum ในลิสติ้ง 6-2 ซึ่งแต่ละวาเรียนต์จะจัดเก็บข้อมูลที่มีความหลากหลายของชนิดข้อมูลไว้:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {}

enum นี้มี 4 วาเรียนต์ที่มีรูปแบบข้อมูลแตกต่างกัน:

  • Quit: ไม่มีข้อมูลใดๆ แนบมาด้วยเลย
  • Move: มีฟิลด์ข้อมูลที่มีชื่อกำกับเหมือนกับใน struct
  • Write: แนบข้อมูลชนิด String มาหนึ่งค่า
  • ChangeColor: แนบข้อมูลตัวเลขชนิด i32 มาสามค่า

การนิยาม enum ที่มีวาเรียนต์หลากหลายแบบเช่นในลิสติ้ง 6-2 คล้ายกับการนิยาม struct หลายๆ ตัวแยกกัน เพียงแต่ enum ไม่ต้องใช้คีย์เวิร์ด struct ซ้ำๆ และวาเรียนต์ทั้งหมดจะถูกจัดกลุ่มรวมกันอยู่ภายใต้ชนิดข้อมูลเดียวกันคือ Message หากเราลองเขียนข้อมูลเหล่านี้ด้วย struct แยกกัน จะมีหน้าตาดังนี้:

struct QuitMessage; // unit struct
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct

fn main() {}

แต่หากเราใช้ struct แยกกันแบบนี้ ซึ่งแต่ละตัวเป็นคนละชนิดข้อมูลกัน เราจะไม่สามารถเขียนฟังก์ชันที่พร้อมรับข้อความชนิดใดก็ได้เหล่านี้ได้อย่างสะดวกและง่ายดายเหมือนกับการใช้ enum Message ในลิสติ้ง 6-2 ซึ่งรวมทุกรูปแบบไว้เป็นชนิดข้อมูลเดียวกัน

นอกจากนี้ ยังมีความคล้ายคลึงกันอีกประการหนึ่งระหว่าง enum กับ struct คือ เช่นเดียวกับที่เราสามารถนิยามเมธอดให้กับ struct ผ่านบล็อก impl ได้ เราก็สามารถนิยามเมธอดให้กับ enum ได้ในลักษณะเดียวกัน นี่คือตัวอย่างการนิยามเมธอดชื่อ call บน enum Message:

fn main() {
    enum Message {
        Quit,
        Move { x: i32, y: i32 },
        Write(String),
        ChangeColor(i32, i32, i32),
    }

    impl Message {
        fn call(&self) {
            // method body would be defined here
        }
    }

    let m = Message::Write(String::from("hello"));
    m.call();
}

ภายในเนื้อหาของเมธอด เราจะใช้ self เพื่อเข้าถึงค่าของอินสแตนซ์ที่เรียกใช้เมธอดนั้น ในตัวอย่างนี้ เราได้สร้างตัวแปร m ที่มีค่าเป็น Message::Write(String::from("hello")) ซึ่งค่านี้ก็คือสิ่งที่ตัวแปร self จะได้รับภายในเมธอด call เมื่อคำสั่ง m.call() ทำงาน

คราวนี้เราลองมาดู enum อีกตัวหนึ่งในไลบรารีมาตรฐานที่มีการใช้งานบ่อยมากและทรงพลังอย่างยิ่ง นั่นคือ Option

enum Option

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

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

ในการออกแบบภาษาโปรแกรม สิ่งที่ถูกใส่เข้ามามีความสำคัญฉันใด สิ่งที่ถูกตัดออกไปก็มีความสำคัญไม่ยิ่งหย่อนไปกว่ากัน โดยในภาษา Rust ไม่มีแนวคิดเรื่อง null เหมือนอย่างที่ภาษาโปรแกรมส่วนใหญ่มี Null คือค่าพิเศษที่บ่งบอกว่าไม่มีค่าอยู่ตรงนั้น ซึ่งในภาษาที่มี null ตัวแปรจะสามารถตกอยู่ในสถานะใดสถานะหนึ่งจากสองสถานะนี้เสมอ คือ เป็น null หรือ ไม่เป็น null

ในการนำเสนอเมื่อปี 2009 ในหัวข้อ “Null References: The Billion Dollar Mistake” Tony Hoare ผู้คิดค้นแนวคิดเรื่อง null ได้กล่าวไว้ว่า:

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

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

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

ปัญหาจึงไม่ได้อยู่ที่ตัวแนวคิด แต่อยู่ที่วิธีการอิมพลีเมนต์ที่ผิดพลาด ด้วยเหตุนี้ Rust จึงไม่มีค่า null แต่หันมาใช้ enum ในการเข้ารหัสแนวคิดของค่าที่มีอยู่หรือไม่มีอยู่แทน ซึ่ง enum ตัวนี้ก็คือ Option<T> โดย ไลบรารีมาตรฐานได้นิยามไว้ ดังนี้:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

enum Option<T> มีประโยชน์และใช้งานบ่อยมากจนกระทั่งถูกรวมไว้ในพรีลูด (prelude) ของภาษา ทำให้คุณสามารถเรียกใช้งานได้ทันทีโดยไม่ต้องนำเข้าสโคปด้วยตนเอง และวาเรียนต์ของมันก็ถูกรวมไว้ในพรีลูดเช่นกัน คุณจึงสามารถเขียน Some และ None ได้โดยตรงโดยไม่ต้องมีคำนำหน้า Option:: ทั้งนี้ Option<T> ก็ยังคงเป็น enum ธรรมดาตัวหนึ่ง และ Some(T) กับ None ก็ยังคงเป็นวาเรียนต์ของชนิดข้อมูล Option<T>

ไวยากรณ์ <T> เป็นฟีเจอร์ของ Rust ที่เรายังไม่ได้พูดถึงในรายละเอียด มันคือพารามิเตอร์ชนิดข้อมูลแบบเจเนอริก (generic type parameter) ซึ่งเราจะได้เรียนรู้เรื่องเจเนอริกอย่างเจาะลึกในบทที่ 10 สำหรับตอนนี้ สิ่งที่คุณต้องเข้าใจคือ <T> หมายความว่า วาเรียนต์ Some ของ enum Option สามารถจัดเก็บข้อมูลชนิดใดก็ได้หนึ่งชิ้น และเมื่อนำชนิดข้อมูลจริงมาแทนที่ T ก็จะทำให้ Option<T> กลายเป็นชนิดข้อมูลที่มีความเฉพาะเจาะจงแตกต่างกันไป ตัวอย่างการนำ Option ไปจัดเก็บตัวเลขและอักขระมีดังนี้:

fn main() {
    let some_number = Some(5);
    let some_char = Some('e');

    let absent_number: Option<i32> = None;
}

ชนิดข้อมูลของ some_number คือ Option<i32> ส่วนของ some_char คือ Option<char> ซึ่งทั้งสองเป็นคนละชนิดข้อมูลกัน Rust สามารถอนุมานชนิดข้อมูลเหล่านี้ได้จากค่าที่เราใส่ไว้ในวาเรียนต์ Some ส่วนในกรณีของ absent_number เราจำเป็นต้องระบุชนิดข้อมูลของ Option ให้ Rust ทราบอย่างชัดเจน เนื่องจากคอมไพเลอร์ไม่สามารถอนุมานได้ว่าวาเรียนต์ Some ที่คู่กันควรจะเก็บชนิดข้อมูลใดหากมองเห็นเพียงแค่ค่า None ดังนั้นเราจึงบอก Rust ให้ชัดเจนว่า absent_number มีชนิดข้อมูลเป็น Option<i32>

เมื่อเรามีค่า Some เราจะมั่นใจได้ว่ามีข้อมูลอยู่จริง และข้อมูลนั้นบรรจุอยู่ภายใน Some และเมื่อเราได้ค่า None มันจะมีความหมายเทียบเท่ากับ null นั่นคือไม่มีข้อมูลที่ถูกต้องอยู่ แล้วทำไมการใช้ Option<T> จึงปลอดภัยและดีกว่าการใช้ null ล่ะ?

คำตอบสั้นๆ ก็คือ เนื่องจาก Option<T> และ T (โดยที่ T คือชนิดข้อมูลใดๆ) เป็นคนละชนิดข้อมูลกันโดยสิ้นเชิง คอมไพเลอร์จึงจะไม่อนุญาตให้เรานำค่าของ Option<T> ไปใช้งานเสมือนเป็นค่า T ที่ถูกต้องโดยตรงได้เลย ตัวอย่างเช่น โค้ดต่อไปนี้จะไม่สามารถคอมไพล์ผ่านได้ เพราะพยายามนำตัวเลข i8 ไปบวกเข้ากับ Option<i8>:

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let sum = x + y;
}

เมื่อสั่งรันโค้ดนี้ จะพบกับข้อความแจ้งเตือนข้อผิดพลาดดังนี้:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
 --> src/main.rs:5:17
  |
5 |     let sum = x + y;
  |                 ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`
help: the following other types implement trait `Add<Rhs>`
 --> /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/ops/arith.rs:98:8
  |
  = note: `i8` implements `Add`
 ::: /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/ops/arith.rs:113:0
  |
  = note: in this macro invocation
 --> /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/internal_macros.rs:22:8
  |
  = note: `&i8` implements `Add<i8>`
 ::: /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/internal_macros.rs:33:8
  |
  = note: `i8` implements `Add<&i8>`
 ::: /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/internal_macros.rs:44:8
  |
  = note: `&i8` implements `Add`
  = note: this error originates in the macro `add_impl` (in Nightly builds, run with -Z macro-backtrace for more info)

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

ชัดเจนและรัดกุมมาก! ใจความของข้อผิดพลาดนี้คือ Rust ไม่สามารถนำ i8 มาบวกกับ Option<i8> ได้ เพราะทั้งสองเป็นคนละชนิดข้อมูลกัน เมื่อเรามีค่าที่เป็นชนิด i8 ปกติใน Rust คอมไพเลอร์จะรับประกันเสมอว่าค่านั้นมีตัวตนอยู่จริงและถูกต้องแน่นอน เราจึงสามารถเขียนโค้ดนำค่านั้นไปคำนวณต่อได้อย่างมั่นใจ 100% โดยไม่ต้องคอยตรวจสอบเงื่อนไขว่าเป็น null หรือไม่ก่อนใช้งาน แต่หากตัวแปรนั้นเป็นชนิด Option<i8> (หรือชนิดข้อมูลใดๆ ที่อยู่ใน Option) นั่นคือจุดเดียวที่เราจะต้องตระหนักว่าค่านั้นอาจจะไม่มีอยู่จริง และคอมไพเลอร์จะบังคับให้เราต้องเขียนโค้ดจัดการกรณีที่ไม่มีค่านั้นก่อนเสมอ จึงจะสามารถดึงค่านั้นออกมาใช้งานได้

กล่าวอีกนัยหนึ่ง คุณจำเป็นต้องแปลง Option<T> ให้กลายเป็น T เสียก่อน จึงจะสามารถดำเนินการต่างๆ ในแบบของ T กับมันได้ ซึ่งกลไกนี้ช่วยกำจัดปัญหาคลาสสิกของ null ไปได้อย่างสิ้นเชิง นั่นคือปัญหาของการเผลอทึกทักเอาเองว่าตัวแปรมีค่าอยู่จริง ทั้งที่ในความจริงแล้วมันเป็น null

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

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

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