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

RefCell<T> และแพตเทิร์นการเปลี่ยนแปลงค่าภายใน

ความสามารถในการเปลี่ยนแปลงค่าภายใน (interior mutability) เป็นรูปแบบการออกแบบ (design pattern) ใน Rust ที่ช่วยให้คุณสามารถแก้ไขข้อมูลได้ แม้ว่าจะมีเรเฟอเรนซ์แบบแก้ไขไม่ได้ (immutable references) ชี้ไปยังข้อมูลนั้นอยู่ก็ตาม ซึ่งตามปกติแล้วการกระทำเช่นนี้จะถูกห้ามโดยกฎการยืม ในการแก้ไขข้อมูล รูปแบบนี้จะใช้โค้ด unsafe ภายในโครงสร้างข้อมูลเพื่อผ่อนปรนกฎเกณฑ์ตามปกติของ Rust ที่ควบคุมการแก้ไขข้อมูลและการยืม โค้ด unsafe จะเป็นการส่งสัญญาณบอกคอมไพเลอร์ว่าเรากำลังตรวจสอบกฎเกณฑ์ต่าง ๆ ด้วยตนเอง แทนที่จะพึ่งพาให้คอมไพเลอร์ตรวจสอบให้เรา โดยเราจะพูดถึงโค้ด unsafe กันอย่างละเอียดมากขึ้นในบทที่ 20

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

เรามาลองสำรวจแนวคิดนี้ผ่านชนิดข้อมูล RefCell<T> ซึ่งนำรูปแบบการเปลี่ยนแปลงค่าภายในมาใช้งานกัน

การบังคับใช้กฎการยืมตอนรันไทม์

สิ่งที่ต่างจาก Rc<T> คือ ชนิดข้อมูล RefCell<T> แสดงถึงความเป็นเจ้าของเพียงรายเดียว (single ownership) เหนือข้อมูลที่มันถืออยู่ แล้วอะไรที่ทำให้ RefCell<T> แตกต่างจากชนิดข้อมูลอย่าง Box<T>? ลองนึกย้อนกลับไปถึงกฎการยืมที่คุณได้เรียนรู้ในบทที่ 4:

  • ในเวลาใดเวลาหนึ่ง คุณสามารถมีเรเฟอเรนซ์แบบแก้ไขได้เพียงหนึ่งตัว หรือ เรเฟอเรนซ์แบบแก้ไขไม่ได้กี่ตัวก็ได้ (แต่ต้องไม่ใช่ทั้งสองแบบพร้อมกัน)
  • เรเฟอเรนซ์ต้องถูกต้องและชี้ไปยังข้อมูลที่ยังมีอยู่เสมอ (valid)

สำหรับเรเฟอเรนซ์ทั่วไปและ Box<T> เงื่อนไขคงที่ (invariants) ของกฎการยืมจะถูกบังคับใช้ตั้งแต่ตอนคอมไพล์ แต่สำหรับ RefCell<T> เงื่อนไขเหล่านี้จะถูกตรวจสอบและบังคับใช้_ในขณะรันไทม์_ หากคุณละเมิดกฎเหล่านี้เมื่อใช้เรเฟอเรนซ์ทั่วไป คุณจะได้รับข้อผิดพลาดจากคอมไพเลอร์ แต่หากคุณละเมิดกฎเหล่านี้เมื่อใช้ RefCell<T> โปรแกรมของคุณจะแพนิก (panic!) และยุติการทำงานลงทันที

ข้อดีของการตรวจสอบกฎการยืมในขั้นตอนคอมไพล์คือ ข้อผิดพลาดจะถูกตรวจพบได้อย่างรวดเร็วตั้งแต่ในกระบวนการพัฒนา และไม่มีต้นทุนสูญเปล่าด้านประสิทธิภาพในขณะรันไทม์ เพราะการวิเคราะห์ทั้งหมดได้เสร็จสิ้นล่วงหน้าไปแล้ว ด้วยเหตุผลเหล่านี้ การตรวจสอบกฎการยืมตอนคอมไพล์จึงเป็นทางเลือกที่ดีที่สุดในกรณีส่วนใหญ่ และเป็นเหตุผลว่าทำไม Rust จึงกำหนดให้สิ่งนี้เป็นพฤติกรรมเริ่มต้น

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

เนื่องจากการวิเคราะห์บางอย่างเป็นไปไม่ได้ในทางทฤษฎี หากคอมไพเลอร์ของ Rust ไม่มั่นใจว่าโค้ดนั้นปฏิบัติตามกฎความเป็นเจ้าของอย่างสมบูรณ์ มันก็อาจจะปฏิเสธโปรแกรมที่เขียนมาอย่างถูกต้องได้ ซึ่งในแง่นี้ถือว่าคอมไพเลอร์เลือกที่จะปลอดภัยไว้ก่อน เพราะหาก Rust ยอมรับโปรแกรมที่มีข้อผิดพลาด ผู้ใช้ก็จะไม่สามารถเชื่อถือการรับประกันความปลอดภัยของ Rust ได้อีกต่อไป ทว่าหาก Rust ปฏิเสธโปรแกรมที่ทำงานถูกต้อง แม้นักพัฒนาจะรู้สึกไม่สะดวกสบาย แต่ก็ไม่มีความเสียหายร้ายแรงใด ๆ เกิดขึ้นกับระบบ ชนิดข้อมูล RefCell<T> จึงมีประโยชน์อย่างยิ่งเมื่อคุณมั่นใจว่าโค้ดของคุณปฏิบัติตามกฎการยืมอย่างแน่นอน แต่คอมไพเลอร์ไม่ฉลาดพอที่จะเข้าใจและรับประกันสิ่งนั้นให้คุณได้

เช่นเดียวกับ Rc<T> ชนิดข้อมูล RefCell<T> มีไว้สำหรับใช้งานในบริบทแบบเธรดเดียว (single-threaded) เท่านั้น และจะเกิดข้อผิดพลาดในการคอมไพล์ทันทีหากคุณพยายามนำมันไปใช้ในงานแบบหลายเธรด โดยเราจะพูดถึงวิธีการนำความสามารถของ RefCell<T> ไปใช้ในโปรแกรมแบบหลายเธรดในบทที่ 16

นี่คือข้อสรุปในการเลือกระหว่าง Box<T>, Rc<T> หรือ RefCell<T>:

  • Rc<T> เปิดให้ข้อมูลเดียวกันมีเจ้าของได้หลายราย ส่วน Box<T> และ RefCell<T> มีเจ้าของได้เพียงรายเดียว
  • Box<T> อนุญาตให้มีการยืมแบบแก้ไขไม่ได้หรือแก้ไขได้ โดยตรวจสอบในขั้นตอนคอมไพล์ ส่วน Rc<T> อนุญาตเฉพาะการยืมแบบแก้ไขไม่ได้ที่ตรวจสอบตอนคอมไพล์ และ RefCell<T> อนุญาตให้มีการยืมแบบแก้ไขไม่ได้หรือแก้ไขได้ โดยตรวจสอบในขณะรันไทม์
  • เนื่องจาก RefCell<T> อนุญาตให้มีการยืมแบบแก้ไขได้ที่ตรวจสอบในขณะรันไทม์ คุณจึงสามารถแก้ไขค่าที่อยู่ภายใน RefCell<T> ได้ แม้ว่าตัวแปร RefCell<T> นั้นจะมีสถานะเป็นค่าที่แก้ไขไม่ได้ก็ตาม

การแก้ไขค่าที่อยู่ภายในค่าที่ไม่สามารถแก้ไขได้นี้ก็คือ รูปแบบความสามารถในการเปลี่ยนแปลงค่าภายใน (interior mutability pattern) เรามาดูสถานการณ์ที่รูปแบบนี้มีประโยชน์และศึกษาว่ามันทำงานได้อย่างไร

การใช้การเปลี่ยนแปลงค่าภายใน

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

fn main() {
    let x = 5;
    let y = &mut x;
}

หากคุณลองคอมไพล์โค้ดนี้ คุณจะพบกับข้อผิดพลาดต่อไปนี้:

$ cargo run
   Compiling borrowing v0.1.0 (file:///projects/borrowing)
error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
 --> src/main.rs:3:13
  |
3 |     let y = &mut x;
  |             ^^^^^^ cannot borrow as mutable
  |
help: consider changing this to be mutable
  |
2 |     let mut x = 5;
  |         +++

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

อย่างไรก็ตาม มีบางสถานการณ์ที่จะเป็นประโยชน์อย่างมากหากค่าหนึ่งสามารถปรับปรุงแก้ไขตัวเองภายในเมธอดของมันได้ แต่ยังคงแสดงตัวเป็นค่าที่แก้ไขไม่ได้ต่อโค้ดภายนอก โดยโค้ดภายนอกจะไม่สามารถแก้ไขค่านั้นได้เลย การใช้ RefCell<T> เป็นวิธีหนึ่งที่ช่วยให้ได้มาซึ่งความสามารถในการเปลี่ยนแปลงค่าภายในนี้ แต่ RefCell<T> ก็ไม่ได้หลบเลี่ยงกฎการยืมอย่างสิ้นเชิง ตัวตรวจสอบการยืม (borrow checker) ในคอมไพเลอร์จะยอมผ่อนปรนให้เกิดการเปลี่ยนแปลงค่าภายในได้ และกฎการยืมจะถูกนำไปตรวจสอบในขณะรันไทม์แทน หากคุณละเมิดกฎ คุณจะได้รับคำสั่ง panic! แทนที่จะเป็นข้อผิดพลาดจากคอมไพเลอร์

เรามาลองดูตัวอย่างการใช้งานจริงที่เราสามารถใช้ RefCell<T> เพื่อแก้ไขค่าที่ไม่สามารถแก้ไขได้ และดูว่าทำไมสิ่งนี้จึงมีประโยชน์

การทดสอบด้วยม็อกออบเจกต์

บางครั้งในระหว่างการทดสอบ นักพัฒนามักจะใช้ชนิดข้อมูลจำลองขึ้นมาแทนที่ชนิดข้อมูลจริง เพื่อคอยสังเกตพฤติกรรมเฉพาะเจาะจงและตรวจสอบยืนยันว่าโค้ดได้รับการอิมพลีเมนต์อย่างถูกต้อง ชนิดข้อมูลตัวแทนนี้เรียกว่า ตัวแทนทดสอบ (test double) เปรียบได้กับตัวแสดงแทน (stunt double) ในการถ่ายทำภาพยนตร์ ที่จะมีคนเข้ามาแสดงแทนดารานำในฉากที่ยากหรืออันตรายเป็นพิเศษ ตัวแทนทดสอบจะทำหน้าที่เป็นตัวแสดงแทนให้กับชนิดข้อมูลอื่น ๆ เมื่อเรารันการทดสอบ โดย ม็อกออบเจกต์ (mock object) เป็นชนิดหนึ่งของตัวแทนทดสอบที่คอยบันทึกสิ่งที่เกิดขึ้นระหว่างการทดสอบ เพื่อให้คุณสามารถตรวจสอบยืนยันได้ว่าการทำงานต่าง ๆ เกิดขึ้นอย่างถูกต้องตรงตามที่คาดหมาย

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

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

ไลบรารีของเราจะทำหน้าที่เฉพาะการติดตามดูว่าค่าตัวเลขใกล้ถึงค่าสูงสุดเพียงใด และควรส่งข้อความอะไรในเวลาใด โดยแอปพลิเคชันที่นำไลบรารีของเราไปใช้จะต้องเป็นผู้จัดเตรียมกลไกในการส่งข้อความจริงเอง เช่น แอปพลิเคชันอาจแสดงข้อความบนหน้าจอ, ส่งอีเมล, ส่งข้อความ SMS หรืออื่น ๆ โดยที่ไลบรารีไม่จำเป็นต้องรับรู้รายละเอียดเหล่านั้น สิ่งที่ไลบรารีต้องการมีเพียงแค่บางสิ่งที่อิมพลีเมนต์เทรตที่เราเตรียมไว้ให้ ซึ่งมีชื่อว่า Messenger โดยลิสติ้ง 15-20 แสดงโค้ดของไลบรารีนี้

pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

หัวใจสำคัญส่วนหนึ่งของโค้ดนี้คือ เทรต Messenger จะมีเมธอดหนึ่งตัวชื่อ send ซึ่งรับเรเฟอเรนซ์แบบแก้ไขไม่ได้ที่ชี้ไปยัง self และข้อความที่จะส่ง เทรตนี้ทำหน้าที่เป็นอินเทอร์เฟซที่ม็อกออบเจกต์ของเราต้องอิมพลีเมนต์ เพื่อให้สามารถนำม็อกไปใช้งานได้ในลักษณะเดียวกับออบเจกต์จริง ส่วนสำคัญอีกประการคือ เราต้องการทดสอบพฤติกรรมของเมธอด set_value บน LimitTracker ซึ่งแม้ว่าเราจะสามารถเปลี่ยนค่าตัวเลขที่ส่งเข้าไปในพารามิเตอร์ value ได้ แต่ set_value ก็ไม่ได้ส่งคืนค่าใด ๆ ออกมาให้เราตรวจสอบเงื่อนไข (assertion) ได้โดยตรง สิ่งที่เราต้องการยืนยันก็คือ หากเราสร้าง LimitTracker ขึ้นมาโดยใช้บางสิ่งที่อิมพลีเมนต์เทรต Messenger และระบุค่า max ไว้ เมื่อเราส่งตัวเลข value ในระดับต่าง ๆ เข้าไป ตัวเมสเซนเจอร์จะถูกสั่งให้ส่งข้อความแจ้งเตือนที่ถูกต้องเหมาะสมออกมาหรือไม่

เราจึงต้องการม็อกออบเจกต์ที่เมื่อถูกเรียกใช้เมธอด send แทนที่จะส่งอีเมลหรือข้อความ SMS จริง ๆ มันจะทำเพียงแค่คอยบันทึกข้อความที่ได้รับคำสั่งให้ส่งเอาไว้ เราสามารถสร้างอินสแตนซ์ใหม่ของม็อกออบเจกต์, สร้าง LimitTracker ที่เรียกใช้ม็อกออบเจกต์นั้น, เรียกเมธอด set_value บน LimitTracker แล้วจึงตรวจสอบว่าม็อกออบเจกต์มีข้อความบันทึกไว้ตรงตามที่เราคาดหวังหรือไม่ ลิสติ้ง 15-21 แสดงความพยายามในการสร้างม็อกออบเจกต์ดังกล่าว แต่ตัวตรวจสอบการยืมของ Rust จะไม่อนุญาตให้โค้ดนี้ผ่านได้

pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

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

    struct MockMessenger {
        sent_messages: Vec<String>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger {
                sent_messages: vec![],
            }
        }
    }

    impl Messenger for MockMessenger {
        fn send(&self, message: &str) {
            self.sent_messages.push(String::from(message));
        }
    }

    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);

        limit_tracker.set_value(80);

        assert_eq!(mock_messenger.sent_messages.len(), 1);
    }
}

โค้ดทดสอบนี้กำหนด struct MockMessenger ที่มีฟิลด์ sent_messages เป็นชนิด Vec<String> เพื่อคอยบันทึกข้อความที่ได้รับคำสั่งให้ส่ง นอกจากนี้เรายังนิยามฟังก์ชันที่สัมพันธ์กัน (associated function) new เพื่ออำนวยความสะดวกในการสร้างอินสแตนซ์ของ MockMessenger ใหม่ที่เริ่มต้นด้วยเวกเตอร์ว่างเปล่า จากนั้นเราอิมพลีเมนต์เทรต Messenger ให้กับ MockMessenger เพื่อให้สามารถส่ง MockMessenger ให้กับ LimitTracker ได้ และในการนิยามเมธอด send เรานำข้อความที่ส่งเข้ามาเป็นพารามิเตอร์ไปจัดเก็บไว้ในลิสต์ sent_messages ของ MockMessenger

ในส่วนของการทดสอบ เรากำลังทดสอบสถานการณ์ที่ LimitTracker ได้รับคำสั่งให้ตั้งค่า value เป็นค่าที่มากกว่า 75 เปอร์เซ็นต์ของค่า max ขั้นแรกเราสร้าง MockMessenger ตัวใหม่ขึ้นมา ซึ่งจะเริ่มต้นด้วยรายการข้อความที่ว่างเปล่า จากนั้นเราสร้าง LimitTracker ตัวใหม่โดยส่งเรเฟอเรนซ์ของ MockMessenger ใหม่นั้น และกำหนดค่า max เป็น 100 แล้วจึงเรียกเมธอด set_value บน LimitTracker ด้วยค่า 80 ซึ่งมากกว่า 75 เปอร์เซ็นต์ของ 100 หลังจากนั้นเราทำการยืนยันเงื่อนไข (assert) ว่ารายการข้อความที่ MockMessenger บันทึกไว้นั้นควรจะมีข้อความอยู่หนึ่งข้อความ

อย่างไรก็ตาม เกิดปัญหาขึ้นกับเทสต์นี้ ดังที่แสดงในข้อผิดพลาดต่อไปนี้:

$ cargo test
   Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
error[E0596]: cannot borrow `self.sent_messages` as mutable, as it is behind a `&` reference
  --> src/lib.rs:58:13
   |
58 |             self.sent_messages.push(String::from(message));
   |             ^^^^^^^^^^^^^^^^^^ `self` is a `&` reference, so it cannot be borrowed as mutable
   |
help: consider changing this to be a mutable reference in the `impl` method and the `trait` definition
   |
 2 ~     fn send(&mut self, msg: &str);
 3 | }
...
56 |     impl Messenger for MockMessenger {
57 ~         fn send(&mut self, message: &str) {
   |

For more information about this error, try `rustc --explain E0596`.
error: could not compile `limit-tracker` (lib test) due to 1 previous error

เราไม่สามารถแก้ไขข้อมูลใน MockMessenger เพื่อบันทึกข้อความได้ เพราะเมธอด send รับเรเฟอเรนซ์แบบแก้ไขไม่ได้ที่ชี้ไปยัง self และเราก็ไม่สามารถทำตามคำแนะนำของข้อความผิดพลาดที่บอกให้เปลี่ยนไปใช้ &mut self ได้เช่นกัน เพราะนั่นจะต้องเปลี่ยนทั้งในบล็อก impl และในนิยามของเทรต ซึ่งเราไม่ต้องการแก้ไขนิยามของเทรต Messenger เพียงเพื่อการเขียนเทสต์เท่านั้น แต่เราจำเป็นต้องหาวิธีทำให้โค้ดทดสอบทำงานร่วมกับโครงสร้างเดิมที่มีอยู่ให้ได้

นี่แหละคือสถานการณ์ที่ความสามารถในการเปลี่ยนแปลงค่าภายในสามารถช่วยเราได้! โดยเราจะนำ sent_messages ไปเก็บไว้ภายใน RefCell<T> ซึ่งจะทำให้เมธอด send สามารถปรับปรุงแก้ไขข้อมูลใน sent_messages เพื่อบันทึกข้อความที่ได้รับเข้ามาได้ ลิสติ้ง 15-22 แสดงให้เห็นว่าโครงสร้างใหม่นี้มีหน้าตาเป็นอย่างไร

pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

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

    struct MockMessenger {
        sent_messages: RefCell<Vec<String>>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger {
                sent_messages: RefCell::new(vec![]),
            }
        }
    }

    impl Messenger for MockMessenger {
        fn send(&self, message: &str) {
            self.sent_messages.borrow_mut().push(String::from(message));
        }
    }

    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        // --snip--
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);

        limit_tracker.set_value(80);

        assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
    }
}

ตอนนี้ฟิลด์ sent_messages จะเปลี่ยนเป็นชนิด RefCell<Vec<String>> แทนที่จะเป็น Vec<String> และในฟังก์ชัน new เราจะสร้างอินสแตนซ์ของ RefCell<Vec<String>> ครอบเวกเตอร์ที่ว่างเปล่าเอาไว้

สำหรับการอิมพลีเมนต์เมธอด send พารามิเตอร์ตัวแรกยังคงเป็นการยืม self แบบแก้ไขไม่ได้เหมือนเดิม ซึ่งตรงกับนิยามของเทรตทุกประการ แต่เราจะเรียกใช้เมธอด borrow_mut บน RefCell<Vec<String>> ใน self.sent_messages เพื่อขอเรเฟอเรนซ์แบบแก้ไขได้ที่ชี้ไปยังค่าภายใน RefCell<Vec<String>> ซึ่งก็คือเวกเตอร์ จากนั้นเราจึงสามารถเรียกใช้ push บนเรเฟอเรนซ์แบบแก้ไขได้ของเวกเตอร์นั้น เพื่อบันทึกข้อความที่ถูกส่งเข้ามาในระหว่างการทดสอบได้

การเปลี่ยนแปลงจุดสุดท้ายที่เราต้องทำก็คือในขั้นตอนการยืนยันเงื่อนไข (assertion): ในการตรวจสอบจำนวนสมาชิกในเวกเตอร์ภายใน เราจะเรียกใช้เมธอด borrow บน RefCell<Vec<String>> เพื่อขอเรเฟอเรนซ์แบบแก้ไขไม่ได้ที่ชี้ไปยังเวกเตอร์นั้น

เมื่อคุณได้เห็นวิธีการใช้งาน RefCell<T> ไปแล้ว ต่อไปเรามาเจาะลึกกันว่ากลไกการทำงานภายในของมันเป็นอย่างไร!

การติดตามการยืมตอนรันไทม์

เมื่อเราต้องการสร้างเรเฟอเรนซ์แบบแก้ไขไม่ได้และแบบแก้ไขได้ เราจะใช้ไวยากรณ์ & และ &mut ตามลำดับ แต่สำหรับ RefCell<T> เราจะใช้เมธอด borrow และ borrow_mut ซึ่งเป็นส่วนหนึ่งของ API ที่ปลอดภัยของ RefCell<T> โดยเมธอด borrow จะส่งคืนสมาร์ตพอยน์เตอร์ชนิด Ref<T> และ borrow_mut จะส่งคืนสมาร์ตพอยน์เตอร์ชนิด RefMut<T> ซึ่งทั้งสองชนิดต่างอิมพลีเมนต์เทรต Deref จึงทำให้เราสามารถปฏิบัติต่อพวกมันได้เสมือนเป็นเรเฟอเรนซ์ทั่วไป

ตัว RefCell<T> จะคอยติดตามอยู่ตลอดเวลาว่ามีสมาร์ตพอยน์เตอร์ Ref<T> และ RefMut<T> กำลังทำงานอยู่จำนวนเท่าใด ทุกครั้งที่เราเรียกใช้ borrow ทาง RefCell<T> จะเพิ่มตัวนับการยืมแบบแก้ไขไม่ได้ที่กำลังทำงานอยู่ขึ้นหนึ่ง และเมื่อค่า Ref<T> หลุดออกจากขอบเขต ตัวนับการยืมแบบแก้ไขไม่ได้ก็จะลดลงหนึ่ง และเช่นเดียวกับกฎการยืมในขั้นตอนคอมไพล์ RefCell<T> จะอนุญาตให้เรามีการยืมแบบแก้ไขไม่ได้หลายตัวพร้อมกัน หรือมีการยืมแบบแก้ไขได้เพียงตัวเดียว ณ ช่วงเวลาใดเวลาหนึ่งเท่านั้น

หากเราพยายามละเมิดกฎเหล่านี้ แทนที่จะได้รับข้อผิดพลาดจากคอมไพเลอร์เหมือนตอนใช้เรเฟอเรนซ์ทั่วไป ตัว RefCell<T> จะสั่งให้โปรแกรมแพนิก (panic!) ในขณะรันไทม์ทันที ลิสติ้ง 15-23 แสดงการปรับปรุงโค้ดเมธอด send จากลิสติ้ง 15-22 โดยเราจงใจสร้างการยืมแบบแก้ไขได้สองตัวพร้อมกันในขอบเขตเดียวกัน เพื่อแสดงให้เห็นว่า RefCell<T> จะป้องกันไม่ให้เราทำเช่นนั้นในขณะรันไทม์ได้อย่างไร

pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

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

    struct MockMessenger {
        sent_messages: RefCell<Vec<String>>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger {
                sent_messages: RefCell::new(vec![]),
            }
        }
    }

    impl Messenger for MockMessenger {
        fn send(&self, message: &str) {
            let mut one_borrow = self.sent_messages.borrow_mut();
            let mut two_borrow = self.sent_messages.borrow_mut();

            one_borrow.push(String::from(message));
            two_borrow.push(String::from(message));
        }
    }

    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);

        limit_tracker.set_value(80);

        assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
    }
}

เราสร้างตัวแปร one_borrow เพื่อเก็บสมาร์ตพอยน์เตอร์ RefMut<T> ที่ได้จาก borrow_mut จากนั้นเราสร้างการยืมแบบแก้ไขได้อีกตัวหนึ่งด้วยวิธีเดียวกันในตัวแปร two_borrow การทำเช่นนี้ทำให้มีเรเฟอเรนซ์แบบแก้ไขได้สองตัวอยู่ในขอบเขตเดียวกัน ซึ่งเป็นสิ่งที่ไม่ได้รับอนุญาต เมื่อเรารันการทดสอบของไลบรารี โค้ดในลิสติ้ง 15-23 จะคอมไพล์ผ่านได้โดยไม่มีข้อผิดพลาดใด ๆ แต่การทดสอบจะล้มเหลว:

$ cargo test
   Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.91s
     Running unittests src/lib.rs (target/debug/deps/limit_tracker-e599811fa246dbde)

running 1 test
test tests::it_sends_an_over_75_percent_warning_message ... FAILED

failures:

---- tests::it_sends_an_over_75_percent_warning_message stdout ----

thread 'tests::it_sends_an_over_75_percent_warning_message' (6028024) panicked at src/lib.rs:60:53:
RefCell already borrowed
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::it_sends_an_over_75_percent_warning_message

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

โปรดสังเกตว่าโปรแกรมเกิดการแพนิกพร้อมข้อความ already borrowed: BorrowMutError นี่คือกลไกที่ RefCell<T> ใช้จัดการกับการละเมิดกฎการยืมในขณะรันไทม์

การเลือกที่จะตรวจจับข้อผิดพลาดของการยืมในขณะรันไทม์แทนที่จะเป็นตอนคอมไพล์ดังที่เราทำในตัวอย่างนี้ หมายความว่าคุณอาจจะตรวจพบข้อผิดพลาดในโค้ดล่าช้ากว่าเดิมในกระบวนการพัฒนา ซึ่งอาจตรวจไม่พบจนกระทั่งโค้ดถูกนำไปใช้งานจริงบนระบบโปรดักชัน นอกจากนี้ โค้ดของคุณจะต้องแบกรับภาระด้านประสิทธิภาพ (runtime performance penalty) เล็กน้อยจากการที่ต้องคอยติดตามการยืมในขณะรันไทม์ อย่างไรก็ตาม การใช้ RefCell<T> ช่วยให้เราสามารถสร้างม็อกออบเจกต์ที่สามารถแก้ไขข้อมูลตัวเองเพื่อบันทึกข้อความที่ตรวจพบได้ ในขณะที่ตัวมันเองถูกนำไปใช้งานในบริบทที่อนุญาตเฉพาะค่าที่แก้ไขไม่ได้เท่านั้น คุณจึงสามารถเลือกใช้ RefCell<T> แม้จะมีข้อแลกเปลี่ยนเหล่านี้ เพื่อให้ได้มาซึ่งฟังก์ชันการทำงานที่ยืดหยุ่นกว่าที่เรเฟอเรนซ์ทั่วไปมอบให้ได้

การอนุญาตเจ้าของหลายรายของข้อมูลที่เปลี่ยนแปลงได้

วิธีหนึ่งที่นิยมใช้ RefCell<T> กันมากคือการนำไปใช้งานร่วมกับ Rc<T> จำได้ไหมว่า Rc<T> ช่วยให้ข้อมูลชิ้นหนึ่งสามารถมีเจ้าของได้หลายราย แต่จะให้สิทธิ์การเข้าถึงข้อมูลนั้นแบบอ่านได้อย่างเดียว (immutable) เท่านั้น หากคุณมี Rc<T> ที่ถือครอง RefCell<T> อยู่ข้างใน คุณก็จะได้ค่าข้อมูลที่สามารถมีเจ้าของได้หลายราย และ สามารถแก้ไขข้อมูลนั้นได้ด้วยพร้อมกัน!

ตัวอย่างเช่น ลองนึกย้อนกลับไปถึงตัวอย่าง cons list ในลิสติ้ง 15-18 ที่เราใช้ Rc<T> เพื่อให้ลิสต์หลายชุดแชร์ความเป็นเจ้าของลิสต์อีกชุดหนึ่งร่วมกัน เนื่องจาก Rc<T> เก็บได้เฉพาะค่าที่ไม่สามารถแก้ไขได้ เราจึงไม่สามารถเปลี่ยนแปลงค่าใด ๆ ในลิสต์ได้เลยหลังจากสร้างมันขึ้นมาแล้ว คราวนี้เราจะนำ RefCell<T> เข้ามาเสริมเพื่อเพิ่มความสามารถในการแก้ไขค่าในลิสต์ ลิสติ้ง 15-24 แสดงให้เห็นว่าการใช้ RefCell<T> ในนิยามของ Cons ช่วยให้เราสามารถปรับปรุงแก้ไขค่าที่จัดเก็บอยู่ในลิสต์ทั้งหมดได้

#[derive(Debug)]
enum List {
    Cons(Rc<RefCell<i32>>, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let value = Rc::new(RefCell::new(5));

    let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));

    let b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a));
    let c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a));

    *value.borrow_mut() += 10;

    println!("a after = {a:?}");
    println!("b after = {b:?}");
    println!("c after = {c:?}");
}

เราสร้างค่าอินสแตนซ์ของ Rc<RefCell<i32>> แล้วเก็บไว้ในตัวแปรชื่อ value เพื่อให้เราสามารถเข้าถึงมันได้โดยตรงในภายหลัง จากนั้นเราสร้าง List ในตัวแปร a ด้วยวาเรียนต์ Cons ที่ถือครอง value ไว้ โดยเราจำเป็นต้องทำการโคลน value เพื่อให้ทั้ง a และ value ต่างมีสิทธิ์ความเป็นเจ้าของในค่า 5 ที่อยู่ภายใน แทนที่จะเป็นการโอนย้ายสิทธิ์ความเป็นเจ้าของจาก value ไปให้ a หรือให้ a ยืมจาก value

เราห่อหุ้มลิสต์ a ไว้ใน Rc<T> เพื่อให้เมื่อเราสร้างลิสต์ b และ c ทั้งสองลิสต์จะสามารถอ้างอิงมายัง a ได้ เช่นเดียวกับที่เราเคยทำในลิสติ้ง 15-18

หลังจากที่เราสร้างลิสต์ใน a, b และ c เรียบร้อยแล้ว เราต้องการบวก 10 เพิ่มเข้าไปในค่าของ value เราทำสิ่งนี้ได้โดยการเรียก borrow_mut บน value ซึ่งจะใช้ฟีเจอร์การดีเรเฟอเรนซ์อัตโนมัติ (automatic dereferencing) ที่เราเคยพูดถึงในหัวข้อ “ตัวดำเนินการ -> อยู่ที่ไหน?” ในบทที่ 5 เพื่อทำการดีเรเฟอเรนซ์ Rc<T> ไปยังค่า RefCell<T> ที่อยู่ภายใน เมธอด borrow_mut จะส่งคืนสมาร์ตพอยน์เตอร์ RefMut<T> ออกมา แล้วเราจึงใช้ตัวดำเนินการดีเรเฟอเรนซ์กับมันเพื่อแก้ไขค่าที่อยู่ข้างใน

เมื่อเราพิมพ์ค่าของ a, b และ c ออกมาดู เราจะพบว่าทั้งหมดมีค่าที่ได้รับการแก้ไขเป็น 15 แทนที่จะเป็น 5 ตามเดิม:

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.63s
     Running `target/debug/cons-list`
a after = Cons(RefCell { value: 15 }, Nil)
b after = Cons(RefCell { value: 3 }, Cons(RefCell { value: 15 }, Nil))
c after = Cons(RefCell { value: 4 }, Cons(RefCell { value: 15 }, Nil))

เทคนิคนี้ยอดเยี่ยมมาก! การใช้ RefCell<T> ช่วยให้เรามีค่า List ที่ภายนอกดูเหมือนแก้ไขไม่ได้ แต่เราสามารถเรียกใช้เมธอดบน RefCell<T> ที่เปิดทางให้เข้าถึงความสามารถในการเปลี่ยนแปลงค่าภายใน เพื่อแก้ไขข้อมูลตามที่ต้องการได้ การตรวจสอบกฎการยืมในขณะรันไทม์ช่วยปกป้องเราจากการแย่งชิงข้อมูล (data race) และในบางครั้งการยอมแลกความเร็วเล็กน้อยเพื่อให้ได้มาซึ่งความยืดหยุ่นของโครงสร้างข้อมูลเช่นนี้ก็ถือว่าคุ้มค่ามาก อย่างไรก็ตาม โปรดทราบว่า RefCell<T> ไม่สามารถใช้งานร่วมกับโค้ดที่ทำงานแบบหลายเธรดได้! โดยชนิดข้อมูล Mutex<T> จะเป็นเวอร์ชันที่ปลอดภัยต่อเธรด (thread-safe) ของ RefCell<T> ซึ่งเราจะได้พูดคุยกันถึง Mutex<T> ในบทที่ 16