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

ปฏิบัติกับสมาร์ตพอยน์เตอร์เหมือนเรเฟอเรนซ์ทั่วไป

การอิมพลีเมนต์เทรต Deref ช่วยให้คุณสามารถปรับแต่งพฤติกรรมของ_ตัวดำเนินการดีเรเฟอเรนซ์ (dereference operator)_ * ได้ (อย่าสับสนกับตัวดำเนินการคูณหรือตัวดำเนินการ glob) การอิมพลีเมนต์ Deref ในลักษณะที่ทำให้สมาร์ตพอยน์เตอร์ (smart pointer) ถูกปฏิบัติเสมือนเป็นเรเฟอเรนซ์ (reference) ทั่วไป จะช่วยให้คุณเขียนโค้ดที่ทำงานร่วมกับเรเฟอเรนซ์ และนำโค้ดนั้นไปใช้งานกับสมาร์ตพอยน์เตอร์ได้ด้วยเช่นกัน

ก่อนอื่น เราจะมาดูกันว่าตัวดำเนินการดีเรเฟอเรนซ์ทำงานกับเรเฟอเรนซ์ทั่วไปอย่างไร จากนั้น เราจะลองนิยามชนิดข้อมูลแบบกำหนดเองที่ทำงานคล้าย Box<T> แล้วดูว่าเหตุใดตัวดำเนินการดีเรเฟอเรนซ์จึงยังไม่ทำงานเสมือนเรเฟอเรนซ์บนชนิดข้อมูลที่เพิ่งสร้างขึ้นใหม่นี้ ถัดมา เราจะไปสำรวจว่าการอิมพลีเมนต์เทรต Deref ช่วยให้สมาร์ตพอยน์เตอร์ทำงานคล้ายเรเฟอเรนซ์ได้อย่างไร และท้ายที่สุด เราจะศึกษาฟีเจอร์การแปลงชนิดข้อมูลด้วยการดีเรฟ หรือ การบังคับดีเรฟ (deref coercion) ของ Rust พร้อมดูว่ามันช่วยให้เราทำงานร่วมกับทั้งเรเฟอเรนซ์หรือสมาร์ตพอยน์เตอร์ได้อย่างไร

การตามเรเฟอเรนซ์ไปยังค่า

เรเฟอเรนซ์ทั่วไปเป็นพอยน์เตอร์ชนิดหนึ่ง ซึ่งวิธีทำความเข้าใจพอยน์เตอร์วิธีหนึ่งก็คือการมองว่ามันเป็นลูกศรที่ชี้ไปยังค่าซึ่งถูกจัดเก็บไว้ที่อื่น ในลิสติ้ง 15-6 เราได้สร้างเรเฟอเรนซ์ที่ชี้ไปยังค่า i32 จากนั้นจึงใช้ตัวดำเนินการดีเรเฟอเรนซ์เพื่อตามเรเฟอเรนซ์ไปยังค่านั้น

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

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

ตัวแปร x เก็บค่า i32 ซึ่งก็คือ 5 และเรากำหนดให้ y มีค่าเท่ากับเรเฟอเรนซ์ที่ชี้ไปยัง x เราสามารถยืนยันได้ว่า x มีค่าเท่ากับ 5 อย่างไรก็ตาม หากเราต้องการสร้างเงื่อนไขยืนยัน (assertion) เกี่ยวกับค่าใน y เราจำเป็นต้องใช้ *y เพื่อตามเรเฟอเรนซ์ไปยังค่าที่มันชี้ไป (จึงเรียกว่า_การดีเรเฟอเรนซ์_) เพื่อให้คอมไพเลอร์สามารถเปรียบเทียบค่าจริงได้ เมื่อเราดีเรเฟอเรนซ์ y แล้ว เราจะเข้าถึงค่าจำนวนเต็มที่ y กำลังชี้อยู่ ซึ่งสามารถนำมาเปรียบเทียบกับ 5 ได้

หากเราลองเขียน assert_eq!(5, y); แทน เราจะได้รับข้อผิดพลาดในขั้นตอนคอมไพล์นี้:

$ cargo run
   Compiling deref-example v0.1.0 (file:///projects/deref-example)
error[E0277]: can't compare `{integer}` with `&{integer}`
 --> src/main.rs:6:5
  |
6 |     assert_eq!(5, y);
  |     ^^^^^^^^^^^^^^^^ no implementation for `{integer} == &{integer}`
  |
  = help: the trait `PartialEq<&{integer}>` is not implemented for `{integer}`
  = help: the following other types implement trait `PartialEq<Rhs>`:
            f128
            f16
            f32
            f64
            i128
            i16
            i32
            i64
          and 8 others

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

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

การใช้ Box<T> เหมือนเรเฟอเรนซ์

เราสามารถเขียนโค้ดในลิสติ้ง 15-6 ขึ้นมาใหม่โดยใช้ Box<T> แทนเรเฟอเรนซ์ได้ ซึ่งตัวดำเนินการดีเรเฟอเรนซ์ที่นำมาใช้กับ Box<T> ในลิสติ้ง 15-7 จะทำงานในลักษณะเดียวกับตัวดำเนินการดีเรเฟอเรนซ์ที่ใช้กับเรเฟอเรนซ์ในลิสติ้ง 15-6 ทุกประการ

fn main() {
    let x = 5;
    let y = Box::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

ความแตกต่างหลักระหว่างลิสติ้ง 15-7 กับลิสติ้ง 15-6 ก็คือ ในตัวอย่างนี้เรากำหนดให้ y เป็นอินสแตนซ์ของบ็อกซ์ที่ชี้ไปยังสำเนาค่าของ x แทนที่จะเป็นเรเฟอเรนซ์ที่ชี้ไปยังค่าของ x และในบรรทัด assertion สุดท้าย เราสามารถใช้ตัวดำเนินการดีเรเฟอเรนซ์เพื่อตามพอยน์เตอร์ของบ็อกซ์ได้ในลักษณะเดียวกับตอนที่ y เป็นเรเฟอเรนซ์ ลำดับถัดไป เราจะมาสำรวจกันว่ามีอะไรพิเศษใน Box<T> ที่ทำให้เราสามารถใช้ตัวดำเนินการดีเรเฟอเรนซ์ได้ โดยเราจะลองสร้างชนิดข้อมูลบ็อกซ์ขึ้นมาด้วยตัวเอง

การนิยามสมาร์ตพอยน์เตอร์ของเราเอง

มาลองสร้างชนิดข้อมูลแบบห่อหุ้ม (wrapper type) ที่คล้ายคลึงกับชนิดข้อมูล Box<T> ในไลบรารีมาตรฐาน เพื่อสัมผัสด้วยตนเองว่าชนิดข้อมูลสมาร์ตพอยน์เตอร์มีพฤติกรรมแตกต่างจากเรเฟอเรนซ์ตามค่าเริ่มต้นอย่างไร จากนั้นเราจะดูวิธีเพิ่มความสามารถในการใช้งานตัวดำเนินการดีเรเฟอเรนซ์เข้าไป

หมายเหตุ: มีความแตกต่างสำคัญประการหนึ่งระหว่างชนิดข้อมูล MyBox<T> ที่เรากำลังจะสร้างขึ้น กับ Box<T> ของจริง นั่นคือ เวอร์ชันของเราจะไม่เก็บข้อมูลไว้บนฮีป เนื่องจากเรามุ่งเน้นตัวอย่างนี้ไปที่เรื่อง Deref ดังนั้นสถานที่ที่เก็บข้อมูลจริงจึงมีความสำคัญน้อยกว่าพฤติกรรมที่เสมือนพอยน์เตอร์

แท้จริงแล้วชนิดข้อมูล Box<T> ถูกนิยามขึ้นในรูปแบบทูเพิลสตรัค (tuple struct) ที่มีสมาชิกเพียงตัวเดียว ลิสติ้ง 15-8 จึงนิยามชนิดข้อมูล MyBox<T> ในรูปแบบเดียวกัน นอกจากนี้เรายังจะนิยามฟังก์ชัน new เพื่อให้สอดคล้องกับฟังก์ชัน new ของ Box<T> ด้วย

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn main() {}

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

คราวนี้มาลองนำฟังก์ชัน main จากลิสติ้ง 15-7 มาใส่ในลิสติ้ง 15-8 แล้วเปลี่ยนมาใช้ชนิดข้อมูล MyBox<T> ที่เรานิยามขึ้นแทนที่ Box<T> โค้ดในลิสติ้ง 15-9 จะคอมไพล์ไม่ผ่าน เนื่องจาก Rust ยังไม่รู้วิธีดีเรเฟอเรนซ์ MyBox

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn main() {
    let x = 5;
    let y = MyBox::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

ผลลัพธ์ข้อผิดพลาดจากการคอมไพล์มีดังนี้:

$ cargo run
   Compiling deref-example v0.1.0 (file:///projects/deref-example)
error[E0614]: type `MyBox<{integer}>` cannot be dereferenced
  --> src/main.rs:14:19
   |
14 |     assert_eq!(5, *y);
   |                   ^^ can't be dereferenced

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

ชนิดข้อมูล MyBox<T> ของเราไม่สามารถดีเรเฟอเรนซ์ได้ เนื่องจากเรายังไม่ได้อิมพลีเมนต์ความสามารถดังกล่าวให้กับชนิดข้อมูลนี้ และเพื่อเปิดใช้งานการดีเรเฟอเรนซ์ด้วยตัวดำเนินการ * เราจึงจำเป็นต้องอิมพลีเมนต์เทรต Deref

การอิมพลีเมนต์เทรต Deref

ดังที่ได้พูดคุยกันใน “การอิมพลีเมนต์เทรตบนชนิดข้อมูล” ในบทที่ 10 ในการอิมพลีเมนต์เทรต เราจำเป็นต้องจัดเตรียมโค้ดการทำงานสำหรับเมธอดที่เทรตนั้นกำหนดไว้ โดยเทรต Deref ที่ไลบรารีมาตรฐานจัดเตรียมไว้ให้นั้น กำหนดให้เราต้องอิมพลีเมนต์เมธอดหนึ่งตัวชื่อ deref ซึ่งจะทำการยืม self และคืนค่าเป็นเรเฟอเรนซ์ที่ชี้ไปยังข้อมูลภายใน ลิสติ้ง 15-10 แสดงการอิมพลีเมนต์ Deref เพื่อนำไปเพิ่มเข้ากับนิยามของ MyBox<T>

use std::ops::Deref;

impl<T> Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn main() {
    let x = 5;
    let y = MyBox::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

ไวยากรณ์ type Target = T; เป็นการนิยามชนิดข้อมูลที่เกี่ยวข้อง (associated type) ให้เทรต Deref นำไปใช้งาน โดยชนิดข้อมูลที่เกี่ยวข้องเป็นอีกวิธีหนึ่งในการประกาศพารามิเตอร์เจเนอริก ซึ่งคุณยังไม่ต้องกังวลกับมันในตอนนี้ เพราะเราจะไปเจาะลึกรายละเอียดกันในบทที่ 20

เราเขียนเนื้อหาภายในเมธอด deref ด้วย &self.0 เพื่อให้ deref คืนเรเฟอเรนซ์ที่ชี้ไปยังค่าที่เราต้องการเข้าถึงด้วยตัวดำเนินการ * (จำได้ไหมว่าจากหัวข้อ “การสร้างชนิดข้อมูลที่แตกต่างกันด้วยทูเพิล struct” ในบทที่ 5 การใช้ .0 เป็นการเข้าถึงค่าตัวแรกในทูเพิลสตรัค) เมื่อเพิ่มโค้ดนี้แล้ว ฟังก์ชัน main ในลิสติ้ง 15-9 ที่เรียกใช้ * บนค่า MyBox<T> ก็จะคอมไพล์ผ่าน และการยืนยันเงื่อนไขทั้งหมดก็ทำงานได้อย่างถูกต้อง!

หากไม่มีเทรต Deref คอมไพเลอร์จะสามารถดีเรเฟอเรนซ์ได้เฉพาะเรเฟอเรนซ์ & เท่านั้น แต่เมธอด deref ได้มอบความสามารถให้คอมไพเลอร์สามารถรับค่าของชนิดข้อมูลใด ๆ ที่อิมพลีเมนต์ Deref แล้วเรียกเมธอด deref เพื่อแปลงให้กลายเป็นเรเฟอเรนซ์ที่คอมไพเลอร์รู้วิธีดีเรเฟอเรนซ์ได้

เมื่อเราเขียน *y ในลิสติ้ง 15-9 แท้จริงแล้วเบื้องหลัง Rust ได้รันโค้ดต่อไปนี้:

*(y.deref())

Rust จะแทนที่ตัวดำเนินการ * ด้วยการเรียกเมธอด deref แล้วตามด้วยการดีเรเฟอเรนซ์แบบธรรมดาหนึ่งครั้ง ทำให้เราไม่จำเป็นต้องมาคอยพะวงว่าเมื่อใดจะต้องเรียกใช้เมธอด deref ด้วยตนเอง ฟีเจอร์นี้ของ Rust ช่วยให้เราสามารถเขียนโค้ดที่ทำงานได้เหมือนกันทุกประการ ไม่ว่าเราจะส่งเรเฟอเรนซ์ธรรมดา หรือส่งชนิดข้อมูลที่อิมพลีเมนต์ Deref มาให้ก็ตาม

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

โปรดสังเกตว่า ทุกครั้งที่เราใช้ * ในโค้ด ตัวดำเนินการ * จะถูกแทนที่ด้วยการเรียกเมธอด deref ตามด้วยการใช้ตัวดำเนินการ * อีกเพียงหนึ่งครั้งเท่านั้น และเนื่องจากการแทนที่ตัวดำเนินการ * นี้ไม่ได้เกิดการเรียกซ้ำอย่างไม่สิ้นสุด เราจึงได้ข้อมูลชนิด i32 ซึ่งตรงกับค่า 5 ในคำสั่ง assert_eq! ของลิสติ้ง 15-9 ในที่สุด

การใช้การบังคับดีเรฟในฟังก์ชันและเมธอด

การบังคับดีเรฟ (deref coercion) คือการแปลงเรเฟอเรนซ์ของชนิดข้อมูลที่อิมพลีเมนต์เทรต Deref ให้กลายเป็นเรเฟอเรนซ์ของอีกชนิดข้อมูลหนึ่ง ตัวอย่างเช่น การบังคับดีเรฟสามารถแปลง &String ให้เป็น &str ได้ เนื่องจาก String ได้อิมพลีเมนต์เทรต Deref ในรูปแบบที่คืนค่าเป็น &str การบังคับดีเรฟเป็นคุณสมบัติอำนวยความสะดวกที่ Rust จัดการให้อัตโนมัติกับอาร์กิวเมนต์ที่ส่งให้กับฟังก์ชันและเมธอด และจะทำงานเฉพาะกับชนิดข้อมูลที่อิมพลีเมนต์เทรต Deref เท่านั้น โดยจะเกิดขึ้นโดยอัตโนมัติเมื่อเราส่งเรเฟอเรนซ์ของชนิดข้อมูลหนึ่งเป็นอาร์กิวเมนต์ให้กับฟังก์ชันหรือเมธอด แต่ชนิดของมันไม่ตรงกับชนิดของพารามิเตอร์ที่นิยามไว้ ซึ่งชุดการเรียกเมธอด deref อย่างต่อเนื่องจะช่วยแปลงชนิดข้อมูลที่เราส่งเข้าไปให้ตรงกับชนิดข้อมูลที่พารามิเตอร์ต้องการ

ฟีเจอร์การบังคับดีเรฟถูกเพิ่มเข้ามาใน Rust เพื่อให้นักพัฒนาที่เขียนโค้ดเรียกใช้ฟังก์ชันและเมธอดไม่ต้องมาคอยใส่การอ้างอิงและการดีเรเฟอเรนซ์ด้วย & และ * อย่างโจ่งแจ้งมากเกินไป นอกจากนี้ ฟีเจอร์ดังกล่าวยังช่วยให้เราเขียนโค้ดที่สามารถนำไปประยุกต์ใช้ได้ทั้งกับเรเฟอเรนซ์และสมาร์ตพอยน์เตอร์ได้มากยิ่งขึ้น

เพื่อให้เห็นภาพการบังคับดีเรฟในการใช้งานจริง เราจะนำชนิดข้อมูล MyBox<T> ที่เรานิยามไว้ในลิสติ้ง 15-8 ร่วมกับการอิมพลีเมนต์ Deref ในลิสติ้ง 15-10 มาใช้งาน โดยลิสติ้ง 15-11 แสดงนิยามของฟังก์ชันที่มีพารามิเตอร์เป็นสตริงสไลซ์ (string slice)

fn hello(name: &str) {
    println!("Hello, {name}!");
}

fn main() {}

เราสามารถเรียกฟังก์ชัน hello โดยส่งสตริงสไลซ์เป็นอาร์กิวเมนต์ เช่น hello("Rust"); ได้ และด้วยการบังคับดีเรฟนี้เอง เราจึงสามารถเรียกใช้ hello โดยส่งเรเฟอเรนซ์ที่ชี้ไปยังค่าชนิด MyBox<String> ได้เช่นกัน ดังที่แสดงในลิสติ้ง 15-12

use std::ops::Deref;

impl<T> Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn hello(name: &str) {
    println!("Hello, {name}!");
}

fn main() {
    let m = MyBox::new(String::from("Rust"));
    hello(&m);
}

ในที่นี้เราเรียกฟังก์ชัน hello ด้วยอาร์กิวเมนต์ &m ซึ่งเป็นเรเฟอเรนซ์ไปยังค่า MyBox<String> และเนื่องจากเราได้อิมพลีเมนต์เทรต Deref ให้กับ MyBox<T> ไว้ในลิสติ้ง 15-10 ทาง Rust จึงสามารถแปลง &MyBox<String> ให้เป็น &String ได้ด้วยการเรียกใช้ deref นอกจากนี้ ไลบรารีมาตรฐานยังมีการอิมพลีเมนต์ Deref ให้กับ String ซึ่งจะคืนค่าเป็นสตริงสไลซ์ (มีระบุไว้ในเอกสาร API ของ Deref) Rust จึงเรียก deref อีกหนึ่งครั้งเพื่อแปลง &String ให้กลายเป็น &str ซึ่งตรงกับนิยามของฟังก์ชัน hello พอดี

หาก Rust ไม่ได้รองรับการบังคับดีเรฟ เราจะต้องเขียนโค้ดดังในลิสติ้ง 15-13 แทนโค้ดในลิสติ้ง 15-12 เพื่อเรียกใช้ hello ด้วยค่าชนิด &MyBox<String>

use std::ops::Deref;

impl<T> Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn hello(name: &str) {
    println!("Hello, {name}!");
}

fn main() {
    let m = MyBox::new(String::from("Rust"));
    hello(&(*m)[..]);
}

นิพจน์ (*m) จะทำการดีเรเฟอเรนซ์ MyBox<String> ให้กลายเป็น String จากนั้น & และ [..] จะดึงสตริงสไลซ์ของ String ทั้งข้อความออกมาเพื่อให้ตรงกับลายเซ็น (signature) ของฟังก์ชัน hello โค้ดที่ไม่มีการบังคับดีเรฟเช่นนี้จะอ่าน เขียน และทำความเข้าใจได้ยากกว่ามากเพราะเต็มไปด้วยสัญลักษณ์ต่าง ๆ การบังคับดีเรฟจึงช่วยให้ Rust สามารถจัดการการแปลงชนิดข้อมูลเหล่านี้แทนเราได้อย่างราบรื่นและเป็นอัตโนมัติ

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

การจัดการการบังคับดีเรฟกับเรเฟอเรนซ์แบบเปลี่ยนแปลงได้

ในทำนองเดียวกับที่คุณใช้เทรต Deref เพื่อเขียนทับพฤติกรรม (override) ของตัวดำเนินการ * บนเรเฟอเรนซ์แบบแก้ไขไม่ได้ (immutable reference) คุณก็สามารถใช้เทรต DerefMut เพื่อเขียนทับพฤติกรรมของตัวดำเนินการ * บนเรเฟอเรนซ์แบบแก้ไขได้ (mutable reference) ได้เช่นกัน

Rust จะดำเนินการบังคับดีเรฟเมื่อพบชนิดข้อมูลและการอิมพลีเมนต์เทรตใน 3 กรณีต่อไปนี้:

  1. จาก &T ไปยัง &U เมื่อ T: Deref<Target=U>
  2. จาก &mut T ไปยัง &mut U เมื่อ T: DerefMut<Target=U>
  3. จาก &mut T ไปยัง &U เมื่อ T: Deref<Target=U>

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

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