พาธสำหรับอ้างถึงรายการในแผนผังมอดูล
เพื่อที่จะบอกให้ Rust รู้ว่าจะค้นหาไอเทมใดๆ ในต้นไม้มอดูล (module tree) ได้จากที่ไหน เราจะใช้สิ่งที่เรียกว่า พาธ (path) ในลักษณะเดียวกับที่เราใช้พาธในการค้นหาไฟล์ในระบบไฟล์ของคอมพิวเตอร์ และหากเราต้องการเรียกใช้งานฟังก์ชันใดๆ เราก็จำเป็นต้องรู้พาธที่ชี้ไปยังฟังก์ชันนั้นเสียก่อน
พาธใน Rust สามารถเขียนได้ 2 รูปแบบ ได้แก่:
- พาธแบบสัมบูรณ์ (Absolute path): คือพาธแบบเต็มที่เริ่มต้นนับจากรากของเครต (crate root) สำหรับโค้ดที่มาจากเครตภายนอก พาธแบบสัมบูรณ์จะขึ้นต้นด้วยชื่อของเครตนั้นๆ ส่วนโค้ดที่อยู่ภายในเครตปัจจุบัน พาธจะขึ้นต้นด้วยคำว่า
crateเสมอ - พาธแบบสัมพัทธ์ (Relative path): คือพาธที่เริ่มต้นนับจากมอดูลปัจจุบัน โดยจะขึ้นต้นด้วย
self,superหรือชื่อของไอเทมที่อยู่ในมอดูลปัจจุบัน
ทั้งพาธแบบสัมบูรณ์และพาธแบบสัมพัทธ์จะตามด้วยตัวระบุชื่อไอเทมหนึ่งตัวขึ้นไป โดยคั่นด้วยเครื่องหมายโคลอนคู่ (::)
ย้อนกลับไปดูในลิสติ้ง 7-1 สมมติว่าเราต้องการเรียกใช้งานฟังก์ชัน add_to_waitlist นั่นก็เหมือนกับการตั้งคำถามว่า: พาธของฟังก์ชัน add_to_waitlist คืออะไร? ลิสติ้ง 7-3 ด้านล่างนี้คือโค้ดจากลิสติ้ง 7-1 ที่เราได้ตัดมอดูลและฟังก์ชันบางส่วนออกไปเพื่อให้เห็นภาพชัดเจนขึ้น
เราจะมาแสดงให้ดู 2 วิธีในการเรียกใช้ฟังก์ชัน add_to_waitlist จากฟังก์ชันใหม่ชื่อ eat_at_restaurant ซึ่งนิยามไว้ที่รากของเครต ทั้งสองพาธนี้เป็นพาธที่ถูกต้องตามหลักไวยากรณ์ แต่ยังมีปัญหาอีกประการหนึ่งที่ทำให้โค้ดตัวอย่างนี้ยังคอมไพล์ไม่ผ่านในตอนนี้ ซึ่งเราจะมาอธิบายเหตุผลกันในอีกสักครู่
ฟังก์ชัน eat_at_restaurant ถือเป็นส่วนหนึ่งของ API สาธารณะ (public API) ของเครตไลบรารีของเรา เราจึงกำกับไว้ด้วยคีย์เวิร์ด pub ซึ่งในหัวข้อ “การเปิดเผยพาธด้วยคำสงวน pub” เราจะมาลงลึกในรายละเอียดเกี่ยวกับ pub กันต่อไป
mod front_of_house {
mod hosting {
fn add_to_waitlist() {}
}
}
pub fn eat_at_restaurant() {
// Absolute path
crate::front_of_house::hosting::add_to_waitlist();
// Relative path
front_of_house::hosting::add_to_waitlist();
}
การเรียกฟังก์ชัน add_to_waitlist ครั้งแรกใน eat_at_restaurant เราใช้พาธแบบสัมบูรณ์ เนื่องจากฟังก์ชัน add_to_waitlist ถูกนิยามไว้ในเครตเดียวกับ eat_at_restaurant เราจึงสามารถใช้คีย์เวิร์ด crate เป็นจุดเริ่มต้นของพาธแบบสัมบูรณ์ได้ จากนั้นเราจะระบุชื่อมอดูลแต่ละชั้นไล่เรียงกันไปเรื่อยๆ จนกระทั่งถึง add_to_waitlist คุณสามารถจินตนาการเปรียบเทียบกับระบบไฟล์ที่มีโครงสร้างแบบเดียวกันได้: นั่นคือเราจะระบุพาธเป็น /front_of_house/hosting/add_to_waitlist เพื่อสั่งรันโปรแกรม add_to_waitlist การใช้คำว่า crate เพื่อเริ่มต้นจากรากของเครต จึงเปรียบเสมือนการใช้เครื่องหมาย / เพื่อเริ่มต้นจากรากของระบบไฟล์ (root directory) ในเชลล์นั่นเอง
ส่วนการเรียกฟังก์ชัน add_to_waitlist ครั้งที่สองใน eat_at_restaurant เราเปลี่ยนมาใช้พาธแบบสัมพัทธ์ โดยพาธนี้จะเริ่มต้นด้วย front_of_house ซึ่งเป็นชื่อของมอดูลที่ถูกนิยามไว้ในระดับเดียวกันกับ eat_at_restaurant ในต้นไม้มอดูล หากเทียบเคียงกับระบบไฟล์ก็คือการใช้พาธ front_of_house/hosting/add_to_waitlist การเริ่มต้นด้วยชื่อมอดูลโดยตรงจึงบ่งบอกว่าพาธนั้นเป็นพาธแบบสัมพัทธ์
การตัดสินใจว่าจะเลือกใช้พาธแบบสัมพัทธ์หรือแบบสัมบูรณ์นั้นขึ้นอยู่กับการออกแบบโปรเจกต์ของคุณ และขึ้นอยู่กับว่า ในอนาคตคุณมีแนวโน้มที่จะย้ายโค้ดส่วนที่นิยามไอเทมแยกขาดจากกัน หรือย้ายไปพร้อมกันกับโค้ดส่วนที่เรียกใช้ไอเทมนั้นมากกว่า ตัวอย่างเช่น หากเราย้ายมอดูล front_of_house และฟังก์ชัน eat_at_restaurant ไปไว้ด้วยกันในมอดูลใหม่ชื่อ customer_experience เราจะต้องปรับแก้พาธแบบสัมบูรณ์ไปยัง add_to_waitlist แต่พาธแบบสัมพัทธ์จะยังคงใช้งานได้เหมือนเดิมโดยไม่ต้องแก้ไขใดๆ ในทางกลับกัน หากเราย้ายเฉพาะฟังก์ชัน eat_at_restaurant แยกออกไปไว้ในมอดูลชื่อ dining พาธแบบสัมบูรณ์ที่เรียกไปยัง add_to_waitlist จะยังคงเหมือนเดิมทุกประการ แต่พาธแบบสัมพัทธ์จะต้องได้รับการอัปเดต โดยทั่วไปแล้ว เรามักนิยมใช้พาธแบบสัมบูรณ์มากกว่า เพราะมีความเป็นไปได้สูงกว่าที่เราอาจต้องการย้ายนิยามของโค้ดและส่วนที่เรียกใช้งานไอเทมอย่างเป็นอิสระต่อกัน
ลองมาคอมไพล์โค้ดในลิสติ้ง 7-3 เพื่อดูว่าทำไมมันจึงยังคอมไพล์ไม่ผ่านกัน! ข้อผิดพลาดที่คอมไพเลอร์รายงานออกมาแสดงไว้ในลิสติ้ง 7-4
$ cargo build
Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: module `hosting` is private
--> src/lib.rs:9:28
|
9 | crate::front_of_house::hosting::add_to_waitlist();
| ^^^^^^^ --------------- function `add_to_waitlist` is not publicly re-exported
| |
| private module
|
note: the module `hosting` is defined here
--> src/lib.rs:2:5
|
2 | mod hosting {
| ^^^^^^^^^^^
error[E0603]: module `hosting` is private
--> src/lib.rs:12:21
|
12 | front_of_house::hosting::add_to_waitlist();
| ^^^^^^^ --------------- function `add_to_waitlist` is not publicly re-exported
| |
| private module
|
note: the module `hosting` is defined here
--> src/lib.rs:2:5
|
2 | mod hosting {
| ^^^^^^^^^^^
For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` (lib) due to 2 previous errors
ข้อความแสดงข้อผิดพลาดระบุว่า มอดูล hosting เป็นแบบส่วนตัว (private) กล่าวอีกนัยหนึ่งคือ เราเขียนพาธชี้ไปยังมอดูล hosting และฟังก์ชัน add_to_waitlist ได้ถูกต้องแล้ว แต่ Rust ไม่อนุญาตให้เราเรียกใช้งาน เพราะเราไม่มีสิทธิ์เข้าถึงส่วนที่เป็นการทำงานภายในแบบส่วนตัว โดยในภาษา Rust นั้น ทุกไอเทม (ไม่ว่าจะเป็นฟังก์ชัน, เมธอด, struct, enum, มอดูล ตลอดจนค่าคงที่) จะมีสถานะเป็นแบบส่วนตัว (private) ต่อมอดูลแม่โดยปริยายเสมอ หากคุณต้องการทำให้ไอเทมใดๆ มีสถานะเป็นส่วนตัว คุณก็เพียงแค่นำมันไปวางไว้ภายในมอดูล
ไอเทมที่อยู่ในมอดูลแม่จะไม่สามารถเรียกใช้ไอเทมที่เป็นแบบส่วนตัวที่อยู่ภายในมอดูลลูกได้ แต่ไอเทมในมอดูลลูกจะสามารถเข้าถึงและเรียกใช้ไอเทมที่อยู่ในมอดูลบรรพบุรุษ (ancestor modules) ของมันได้เสมอ สาเหตุที่เป็นเช่นนี้ก็เพราะว่ามอดูลลูกทำหน้าที่ห่อหุ้มและซ่อนรายละเอียดการทำงานภายในเอาไว้ แต่มอดูลลูกเองสามารถมองเห็นบริบทแวดล้อมที่มันถูกนิยามขึ้นมาได้ หากเปรียบเทียบกับภาพร้านอาหารเดิม ก็เหมือนกับห้องทำงานส่วนตัวของผู้จัดการร้าน: ลูกค้าทั่วไปไม่มีสิทธิ์เข้าไปยุ่มย่ามภายในห้องนั้น แต่ผู้จัดการร้านที่อยู่ในห้องสามารถมองเห็นและทำทุกอย่างในร้านอาหารที่ตนเองดูแลได้ทั้งหมด
Rust เลือกออกแบบให้ระบบมอดูลทำงานในลักษณะนี้ เพื่อให้การซ่อนรายละเอียดการทำงานภายในเป็นค่าเริ่มต้นโดยอัตโนมัติ ซึ่งจะช่วยให้คุณรู้ได้อย่างมั่นใจว่า โค้ดส่วนภายในจุดใดบ้างที่คุณสามารถปรับปรุงแก้ไขได้โดยไม่ต้องกังวลว่าจะส่งผลกระทบทำให้โค้ดภายนอกพังเสียหาย อย่างไรก็ตาม Rust ก็ยังเปิดโอกาสให้คุณเปิดเผยส่วนการทำงานภายในของมอดูลลูกให้มอดูลบรรพบุรุษภายนอกเข้าถึงได้ โดยการใช้คีย์เวิร์ด pub เพื่อกำหนดให้ไอเทมนั้นกลายเป็นสาธารณะ (public)
การเปิดเผยพาธด้วยคำสงวน pub
กลับมาดูข้อผิดพลาดในลิสติ้ง 7-4 ที่แจ้งว่ามอดูล hosting เป็นแบบส่วนตัว ในกรณีนี้เราต้องการให้ฟังก์ชัน eat_at_restaurant ซึ่งอยู่ในมอดูลแม่สามารถเข้าถึงฟังก์ชัน add_to_waitlist ที่อยู่ในมอดูลลูกได้ เราจึงใส่คีย์เวิร์ด pub หน้ามอดูล hosting ดังที่แสดงในลิสติ้ง 7-5
mod front_of_house {
pub mod hosting {
fn add_to_waitlist() {}
}
}
// -- snip --
pub fn eat_at_restaurant() {
// Absolute path
crate::front_of_house::hosting::add_to_waitlist();
// Relative path
front_of_house::hosting::add_to_waitlist();
}
แต่น่าเสียดายที่โค้ดในลิสติ้ง 7-5 ก็ยังคงคอมไพล์ไม่ผ่านอยู่ดี ดังข้อผิดพลาดที่แสดงในลิสติ้ง 7-6
$ cargo build
Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: function `add_to_waitlist` is private
--> src/lib.rs:10:37
|
10 | crate::front_of_house::hosting::add_to_waitlist();
| ^^^^^^^^^^^^^^^ private function
|
note: the function `add_to_waitlist` is defined here
--> src/lib.rs:3:9
|
3 | fn add_to_waitlist() {}
| ^^^^^^^^^^^^^^^^^^^^
error[E0603]: function `add_to_waitlist` is private
--> src/lib.rs:13:30
|
13 | front_of_house::hosting::add_to_waitlist();
| ^^^^^^^^^^^^^^^ private function
|
note: the function `add_to_waitlist` is defined here
--> src/lib.rs:3:9
|
3 | fn add_to_waitlist() {}
| ^^^^^^^^^^^^^^^^^^^^
For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` (lib) due to 2 previous errors
เกิดอะไรขึ้นกันแน่? การเติมคีย์เวิร์ด pub ไว้หน้า mod hosting ทำให้มอดูลกลายเป็นสาธารณะก็จริง ซึ่งช่วยให้เราสามารถเข้าถึง hosting ได้หากเราเข้าถึง front_of_house ได้แล้ว แต่_เนื้อหาภายใน_ของ hosting ยังคงมีสถานะเป็นแบบส่วนตัวอยู่ดี! การทำให้มอดูลเป็นสาธารณะไม่ได้ส่งผลให้ไอเทมข้างในกลายเป็นสาธารณะตามไปด้วย คีย์เวิร์ด pub บนตัวมอดูลเพียงแค่อนุญาตให้โค้ดในมอดูลบรรพบุรุษสามารถอ้างอิงถึงตัวมอดูลนั้นได้เท่านั้น แต่ยังไม่ให้สิทธิ์เข้าถึงเนื้อหาข้างใน และเนื่องจากมอดูลทำหน้าที่เป็นเพียงกล่องบรรจุ การเปิดมอดูลให้เป็นสาธารณะเพียงอย่างเดียวจึงยังทำอะไรไม่ได้มากนัก เราจำเป็นต้องลงลึกไปอีกขั้นด้วยการเลือกกำหนดให้ไอเทมภายในมอดูลนั้นเป็นสาธารณะด้วยเช่นกัน
ข้อความผิดพลาดในลิสติ้ง 7-6 ระบุชัดเจนว่า ฟังก์ชัน add_to_waitlist เป็นแบบส่วนตัว เพราะกฎเรื่องการเข้าถึง (privacy rules) จะบังคับใช้กับทั้ง struct, enum, ฟังก์ชัน, เมธอด รวมถึงตัวมอดูลเองอย่างเท่าเทียมกัน
ดังนั้น เรามาทำให้ฟังก์ชัน add_to_waitlist เป็นสาธารณะด้วยการเติมคีย์เวิร์ด pub ไว้หน้าคำประกาศฟังก์ชันกัน ดังแสดงในลิสติ้ง 7-7
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
// -- snip --
pub fn eat_at_restaurant() {
// Absolute path
crate::front_of_house::hosting::add_to_waitlist();
// Relative path
front_of_house::hosting::add_to_waitlist();
}
คราวนี้โค้ดก็สามารถคอมไพล์ผ่านได้อย่างสมบูรณ์! เพื่อให้เห็นภาพชัดเจนขึ้นว่าเหตุใดการเติมคีย์เวิร์ด pub จึงทำให้เราเรียกใช้พาธเหล่านี้ใน eat_at_restaurant ได้โดยถูกต้องตามกฎการเข้าถึง เราลองมาพิจารณาทีละขั้นตอนทั้งพาธแบบสัมบูรณ์และแบบสัมพัทธ์กัน
สำหรับพาธแบบสัมบูรณ์ เราเริ่มต้นจาก crate ซึ่งเป็นรากของต้นไม้มอดูลในเครตของเรา มอดูล front_of_house ถูกนิยามขึ้นที่รากของเครตนี้ และแม้ว่า front_of_house จะไม่ได้เปิดเป็นสาธารณะ แต่เนื่องจากฟังก์ชัน eat_at_restaurant ถูกนิยามอยู่ในมอดูลระดับเดียวกันกับ front_of_house (นั่นคือ eat_at_restaurant และ front_of_house เป็นมอดูลพี่น้องกัน) เราจึงมีสิทธิ์อ้างอิงถึง front_of_house จาก eat_at_restaurant ได้ ถัดมาคือมอดูล hosting ซึ่งถูกทำเครื่องหมายด้วย pub เอาไว้ และเนื่องจากเราสามารถเข้าถึงมอดูลแม่ของ hosting ได้ เราจึงเข้าถึงตัว hosting ได้ด้วยเช่นกัน และสุดท้ายคือฟังก์ชัน add_to_waitlist ซึ่งถูกทำเครื่องหมายด้วย pub ไว้เช่นกัน และเราก็เข้าถึงมอดูลแม่ของมันได้ การเรียกใช้งานฟังก์ชันผ่านพาธแบบสัมบูรณ์นี้จึงทำงานได้อย่างถูกต้องสมบูรณ์!
ส่วนพาธแบบสัมพัทธ์ ตรรกะการทำงานก็เหมือนกับพาธแบบสัมบูรณ์ทุกประการ ยกเว้นเพียงขั้นตอนแรก: พาธนี้ไม่ได้เริ่มต้นจากรากของเครต แต่เริ่มต้นจาก front_of_house ทันที และเนื่องจากมอดูล front_of_house นิยามอยู่ในมอดูลระดับเดียวกับ eat_at_restaurant พาธแบบสัมพัทธ์ที่เริ่มจากจุดที่ eat_at_restaurant นิยามอยู่จึงใช้งานได้ และต่อจากนั้น ด้วยความที่ทั้ง hosting และ add_to_waitlist ต่างถูกกำกับไว้ด้วย pub ส่วนที่เหลือของพาธจึงถูกต้อง และส่งผลให้การเรียกใช้ฟังก์ชันนี้สำเร็จลุล่วงด้วยดี!
หากคุณวางแผนที่จะแบ่งปันเครตไลบรารีของคุณเพื่อให้โปรเจกต์อื่นๆ นำโค้ดไปใช้งาน ตัว public API ของคุณก็เปรียบเสมือนพันธสัญญา (contract) ระหว่างคุณกับผู้ใช้งานเครต ซึ่งเป็นตัวกำหนดว่าพวกเขาจะสามารถมีปฏิสัมพันธ์กับโค้ดของคุณได้อย่างไรบ้าง และยังมีข้อควรคำนึงอีกมากมายเกี่ยวกับการจัดการความเปลี่ยนแปลงที่จะเกิดขึ้นกับ public API เพื่อให้ผู้ใช้งานสามารถพึ่งพาเครตของคุณได้อย่างราบรื่น ซึ่งเรื่องเหล่านี้อยู่นอกเหนือขอบเขตของหนังสือเล่มนี้ หากคุณสนใจในหัวข้อนี้ สามารถศึกษาเพิ่มเติมได้ที่ แนวทางปฏิบัติสำหรับ API ของ Rust
แนวปฏิบัติที่ดีสำหรับแพ็กเกจที่มีทั้งไบนารีและไลบรารี
เราได้กล่าวไปแล้วว่า แพ็กเกจหนึ่งๆ สามารถมีได้ทั้งรากของเครตไบนารีใน src/main.rs และรากของเครตไลบรารีใน src/lib.rs โดยค่าเริ่มต้นแล้ว เครตทั้งสองจะมีชื่อเดียวกับชื่อแพ็กเกจ โดยทั่วไป แพ็กเกจที่ใช้รูปแบบการมีทั้งไลบรารีและไบนารีอยู่ร่วมกัน จะเขียนโค้ดในเครตไบนารีไว้เพียงเท่าที่จำเป็นสำหรับการเริ่มต้นโปรแกรมเพื่อไปเรียกใช้ฟังก์ชันที่นิยามไว้ในเครตไลบรารีเท่านั้น วิธีนี้จะช่วยให้โปรเจกต์อื่นๆ สามารถใช้ประโยชน์จากฟังก์ชันการทำงานส่วนใหญ่ของแพ็กเกจได้เต็มที่ เพราะโค้ดในเครตไลบรารีสามารถนำไปแบ่งปันและเรียกใช้ซ้ำได้
โครงสร้างต้นไม้มอดูลควรถูกนิยามไว้ภายในไฟล์ src/lib.rs จากนั้นไอเทมสาธารณะใดๆ ก็สามารถถูกเรียกใช้ในเครตไบนารีได้โดยเขียนพาธเริ่มต้นด้วยชื่อของแพ็กเกจ ส่งผลให้เครตไบนารีกลายเป็นผู้ใช้งานเครตไลบรารีเสมือนเป็นเครตภายนอกตัวหนึ่ง นั่นคือสามารถเรียกใช้ได้เฉพาะ public API เท่านั้น ซึ่งการออกแบบลักษณะนี้จะช่วยให้คุณออกแบบ API ได้ดียิ่งขึ้น เพราะคุณไม่ได้เป็นเพียงแค่ผู้เขียนโค้ดเท่านั้น แต่คุณยังทำหน้าที่เป็นผู้ใช้งานโค้ดของตัวเองไปด้วยในเวลาเดียวกัน!
ใน บทที่ 12 เราจะสาธิตแนวปฏิบัติด้านการจัดโครงสร้างนี้อย่างเป็นรูปธรรมผ่านการสร้างโปรแกรมบรรทัดคำสั่งที่ประกอบด้วยทั้งเครตไบนารีและเครตไลบรารีควบคู่กัน
การเริ่มพาธแบบสัมพัทธ์ด้วย super
เราสามารถสร้างพาธแบบสัมพัทธ์ที่เริ่มต้นจากมอดูลแม่ แทนที่จะเริ่มจากมอดูลปัจจุบันหรือรากของเครตได้ โดยการใส่คำว่า super ไว้ที่จุดเริ่มต้นของพาธ ซึ่งเปรียบเสมือนการเริ่มพาธในระบบไฟล์ด้วยสัญลักษณ์ .. เพื่อถอยกลับไปยังไดเรกทอรีแม่ การใช้ super ช่วยให้เราสามารถอ้างอิงถึงไอเทมที่เรารู้อยู่แล้วว่าอยู่ในมอดูลแม่ ซึ่งจะทำให้การปรับเปลี่ยนโครงสร้างต้นไม้มอดูลในอนาคตทำได้ง่ายขึ้น โดยเฉพาะอย่างยิ่งเมื่อมอดูลลูกมีความสัมพันธ์ใกล้ชิดกับมอดูลแม่ แต่มอดูลแม่นั้นอาจถูกย้ายตำแหน่งไปอยู่ที่อื่นในต้นไม้มอดูลในภายหลัง
ลองพิจารณาโค้ดในลิสติ้ง 7-8 ที่จำลองสถานการณ์ที่เชฟปรุงอาหารผิดแล้วต้องแก้ไขออร์เดอร์นั้น พร้อมกับนำอาหารจานที่แก้ไขแล้วออกไปเสิร์ฟให้ลูกค้าด้วยตัวเอง ฟังก์ชัน fix_incorrect_order ซึ่งนิยามอยู่ในมอดูล back_of_house จะเรียกใช้ฟังก์ชัน deliver_order ที่นิยามอยู่ในมอดูลแม่ โดยระบุพาธไปยัง deliver_order ที่ขึ้นต้นด้วย super
fn deliver_order() {}
mod back_of_house {
fn fix_incorrect_order() {
cook_order();
super::deliver_order();
}
fn cook_order() {}
}
ฟังก์ชัน fix_incorrect_order อยู่ภายในมอดูล back_of_house เราจึงใช้ super เพื่อถอยกลับไปยังมอดูลแม่ของ back_of_house ซึ่งในกรณีนี้ก็คือมอดูลราก crate จากจุดนั้น เรามองหาฟังก์ชัน deliver_order แล้วก็พบ สำเร็จ! เราเล็งเห็นว่ามอดูล back_of_house และฟังก์ชัน deliver_order น่าจะยังคงความสัมพันธ์ระหว่างกันเช่นนี้ต่อไป และน่าจะถูกย้ายไปด้วยกันหากในอนาคตเราตัดสินใจปรับโครงสร้างต้นไม้มอดูลของเครตใหม่ การใช้ super จึงช่วยลดจำนวนจุดที่ต้องตามแก้โค้ดลงไปได้ หากโค้ดชุดนี้ถูกย้ายไปอยู่ภายใต้มอดูลอื่นในวันข้างหน้า
การทำให้ struct และ enum เป็นแบบสาธารณะ
เรายังสามารถใช้ pub เพื่อกำหนดให้ struct และ enum กลายเป็นสาธารณะได้เช่นกัน แต่การใช้ pub กับ struct และ enum จะมีรายละเอียดปลีกย่อยเพิ่มเติมเล็กน้อย หากเราใส่ pub ไว้ข้างหน้านิยามของ struct ตัว struct นั้นจะกลายเป็นสาธารณะก็จริง แต่ฟิลด์ต่างๆ ภายใน struct จะยังคงเป็นแบบส่วนตัว (private) อยู่ โดยเราสามารถเลือกกำหนดให้แต่ละฟิลด์เปิดเป็นสาธารณะหรือไม่เป็นแบบรายฟิลด์ได้ ในลิสติ้ง 7-9 เราได้นิยาม struct สาธารณะชื่อ back_of_house::Breakfast โดยกำหนดให้ฟิลด์ toast เป็นสาธารณะ แต่ฟิลด์ seasonal_fruit เป็นแบบส่วนตัว ซึ่งจำลองสถานการณ์ในร้านอาหารที่ลูกค้าสามารถเลือกชนิดของขนมปังปิ้งที่เสิร์ฟพร้อมมื้ออาหารได้ แต่ผลไม้ตามฤดูกาลนั้นเชฟจะเป็นผู้เลือกให้ตามวัตถุดิบที่มีในสต็อกและตามฤดูกาล และเนื่องจากชนิดของผลไม้หมุนเวียนเปลี่ยนแปลงบ่อย ลูกค้าจึงไม่สามารถเลือกผลไม้เองได้ และไม่สามารถมองเห็นล่วงหน้าได้ด้วยซ้ำว่าจะได้ผลไม้ชนิดใด
mod back_of_house {
pub struct Breakfast {
pub toast: String,
seasonal_fruit: String,
}
impl Breakfast {
pub fn summer(toast: &str) -> Breakfast {
Breakfast {
toast: String::from(toast),
seasonal_fruit: String::from("peaches"),
}
}
}
}
pub fn eat_at_restaurant() {
// Order a breakfast in the summer with Rye toast.
let mut meal = back_of_house::Breakfast::summer("Rye");
// Change our mind about what bread we'd like.
meal.toast = String::from("Wheat");
println!("I'd like {} toast please", meal.toast);
// The next line won't compile if we uncomment it; we're not allowed
// to see or modify the seasonal fruit that comes with the meal.
// meal.seasonal_fruit = String::from("blueberries");
}
เนื่องจากฟิลด์ toast ใน struct back_of_house::Breakfast เป็นสาธารณะ เราจึงสามารถอ่านและเขียนค่าลงในฟิลด์ toast จากภายในฟังก์ชัน eat_at_restaurant ได้โดยใช้เครื่องหมายจุด (.) แต่โปรดสังเกตว่าเราไม่สามารถเข้าถึงฟิลด์ seasonal_fruit ใน eat_at_restaurant ได้เลย เพราะฟิลด์นั้นเป็นแบบส่วนตัว ลองเปิดคอมเมนต์ในบรรทัดที่พยายามแก้ไขค่าของ seasonal_fruit ดู แล้วคุณจะเห็นข้อผิดพลาดที่คอมไพเลอร์แจ้งเตือนขึ้นมา!
นอกจากนี้ ขอให้สังเกตว่าเนื่องจาก back_of_house::Breakfast มีฟิลด์ที่เป็นส่วนตัว ตัว struct จึงจำเป็นต้องเตรียมฟังก์ชันประจำชนิดข้อมูล (associated function) ที่เป็นสาธารณะขึ้นมาเพื่อใช้สร้างอินสแตนซ์ของ Breakfast (ซึ่งในที่นี้เราตั้งชื่อว่า summer) หาก Breakfast ไม่มีฟังก์ชันดังกล่าวเตรียมไว้ เราก็จะไม่สามารถสร้างอินสแตนซ์ของ Breakfast ใน eat_at_restaurant ได้เลย เพราะเราไม่สามารถกำหนดค่าเริ่มต้นให้กับฟิลด์ส่วนตัวอย่าง seasonal_fruit ได้โดยตรงจากภายนอก
ในทางตรงกันข้าม หากเราประกาศให้ enum เป็นสาธารณะ วาเรียนต์ทั้งหมดของ enum นั้นจะกลายเป็นสาธารณะโดยอัตโนมัติ เราเพียงแค่ใส่ pub ไว้หน้าคำว่า enum เท่านั้น ดังที่แสดงในลิสติ้ง 7-10
mod back_of_house {
pub enum Appetizer {
Soup,
Salad,
}
}
pub fn eat_at_restaurant() {
let order1 = back_of_house::Appetizer::Soup;
let order2 = back_of_house::Appetizer::Salad;
}
เนื่องจากเราประกาศให้ enum Appetizer เป็นสาธารณะ เราจึงสามารถเรียกใช้วาเรียนต์ Soup และ Salad ภายในฟังก์ชัน eat_at_restaurant ได้ทันที
โดยธรรมชาติแล้ว enum จะไม่ค่อยมีประโยชน์เท่าใดนักหากวาเรียนต์ของมันไม่เปิดเป็นสาธารณะ และคงเป็นเรื่องน่ารำคาญไม่น้อยหากต้องคอยใส่ pub กำกับหน้าทุกๆ วาเรียนต์ของ enum ทุกกรณี ดังนั้นค่าเริ่มต้นของวาเรียนต์ใน enum จึงถูกกำหนดให้เป็นสาธารณะเสมอ ในขณะที่ struct มักจะมีประโยชน์ได้แม้ว่าฟิลด์ต่างๆ จะไม่ได้เปิดเป็นสาธารณะ ฟิลด์ของ struct จึงยึดตามกฎทั่วไปที่ว่า ทุกสิ่งทุกอย่างจะเป็นแบบส่วนตัวโดยปริยาย เว้นแต่จะระบุ pub ไว้อย่างชัดเจน
ยังมีอีกหนึ่งสถานการณ์ที่เกี่ยวข้องกับ pub ที่เรายังไม่ได้พูดถึง นั่นคือฟีเจอร์สุดท้ายของระบบมอดูล: คีย์เวิร์ด use ซึ่งเราจะมาเรียนรู้การใช้งาน use แบบเดี่ยวๆ กันก่อน จากนั้นจึงค่อยดูวิธีการนำ pub และ use มารวมพลังใช้งานร่วมกัน