โคลเชอร์
โคลเชอร์ (closure) ในภาษา Rust คือฟังก์ชันแบบไม่ระบุชื่อ (anonymous function) ที่คุณสามารถจัดเก็บไว้ในตัวแปร หรือส่งเป็นอาร์กิวเมนต์ไปยังฟังก์ชันอื่นได้ คุณสามารถนิยามโคลเชอร์ขึ้นมาที่จุดหนึ่ง แล้วนำไปเรียกประมวลผลที่จุดอื่นในบริบทที่แตกต่างออกไปได้ นอกจากนี้ โคลเชอร์ยังมีความพิเศษต่างจากฟังก์ชันทั่วไปตรงที่มันสามารถจับค่า (capture) จากสโคปที่มันถูกสร้างขึ้นมาได้ด้วย เราจะมาดูกันว่าฟีเจอร์เหล่านี้ของโคลเชอร์ช่วยให้เราสามารถนำโค้ดกลับมาใช้ซ้ำ (code reuse) และปรับแต่งพฤติกรรมการทำงานได้อย่างไร
การจับสภาพแวดล้อม
อันดับแรก เราจะมาดูวิธีใช้โคลเชอร์เพื่อจับค่าจากสภาพแวดล้อมที่มันถูกนิยามขึ้นมาสำหรับนำไปใช้งานในภายหลัง ลองพิจารณาสถานการณ์จำลองนี้: ในบางโอกาส บริษัทเสื้อยืดของเราจะแจกเสื้อรุ่นพิเศษแบบลิมิเต็ดเอดิชันให้กับผู้โชคดีในรายชื่ออีเมลของเราเพื่อการส่งเสริมการขาย โดยผู้รับอีเมลสามารถเลือกใส่สีเสื้อที่ตนชอบลงในโปรไฟล์ได้ตามความสมัครใจ หากผู้โชคดีที่ได้รับรางวัลได้ระบุสีโปรดไว้ พวกเขาก็จะได้เสื้อสีนั้นไป แต่หากไม่ได้ระบุสีโปรดไว้ พวกเขาจะได้เสื้อสีที่ทางบริษัทมีอยู่ในสต็อกมากที่สุดในขณะนั้นแทน
เราสามารถพัฒนาโจทย์นี้ได้หลากหลายวิธี สำหรับตัวอย่างนี้ เราจะใช้ enum ชื่อ ShirtColor ซึ่งมีวาเรียนต์ Red และ Blue (เพื่อความเรียบง่าย เราจะจำกัดไว้เพียงสองสี) เราจะจำลองคลังสินค้าของบริษัทด้วย struct ชื่อ Inventory ที่มีฟิลด์ shirts เก็บข้อมูลชนิด Vec<ShirtColor> แทนสีของเสื้อที่ยังมีอยู่ในสต็อกปัจจุบัน ส่วนเมธอด giveaway ที่นิยามบน Inventory จะรับค่าความชอบเรื่องสีเสื้อของผู้โชคดี (ซึ่งอาจระบุหรือไม่ระบุก็ได้) และจะส่งคืนสีเสื้อที่คนนั้นจะได้รับ โครงสร้างทั้งหมดนี้แสดงไว้ในลิสติ้ง 13-1
#[derive(Debug, PartialEq, Copy, Clone)]
enum ShirtColor {
Red,
Blue,
}
struct Inventory {
shirts: Vec<ShirtColor>,
}
impl Inventory {
fn giveaway(&self, user_preference: Option<ShirtColor>) -> ShirtColor {
user_preference.unwrap_or_else(|| self.most_stocked())
}
fn most_stocked(&self) -> ShirtColor {
let mut num_red = 0;
let mut num_blue = 0;
for color in &self.shirts {
match color {
ShirtColor::Red => num_red += 1,
ShirtColor::Blue => num_blue += 1,
}
}
if num_red > num_blue {
ShirtColor::Red
} else {
ShirtColor::Blue
}
}
}
fn main() {
let store = Inventory {
shirts: vec![ShirtColor::Blue, ShirtColor::Red, ShirtColor::Blue],
};
let user_pref1 = Some(ShirtColor::Red);
let giveaway1 = store.giveaway(user_pref1);
println!(
"The user with preference {:?} gets {:?}",
user_pref1, giveaway1
);
let user_pref2 = None;
let giveaway2 = store.giveaway(user_pref2);
println!(
"The user with preference {:?} gets {:?}",
user_pref2, giveaway2
);
}
ตัวแปร store ที่สร้างขึ้นในฟังก์ชัน main มีเสื้อสีน้ำเงิน 2 ตัวและเสื้อสีแดง 1 ตัวเหลืออยู่สำหรับแจกในแคมเปญนี้ เราได้เรียกใช้เมธอด giveaway กับผู้ใช้ที่ระบุว่าชอบเสื้อสีแดง และผู้ใช้ที่ไม่ได้ระบุความชอบใดๆ
เช่นเดิม โค้ดนี้สามารถเขียนได้หลายแบบ แต่เพื่อให้เรามุ่งเน้นไปที่เรื่องโคลเชอร์ เราจึงเลือกใช้แนวคิดพื้นฐานที่คุณคุ้นเคยกันดีอยู่แล้ว ยกเว้นเนื้อในเมธอด giveaway ที่นำโคลเชอร์เข้ามาช่วย ในเมธอด giveaway เราได้รับความชอบของผู้ใช้ผ่านพารามิเตอร์ชนิด Option<ShirtColor> แล้วเรียกเมธอด unwrap_or_else บน user_preference โดยเมธอด unwrap_or_else บน Option<T> นี้ถูกนิยามไว้ในไลบรารีมาตรฐาน ซึ่งรับอาร์กิวเมนต์หนึ่งตัวเป็นโคลเชอร์ที่ไม่ต้องรับพารามิเตอร์ใดๆ แต่ส่งคืนค่าชนิด T ออกมา (ซึ่งเป็นชนิดเดียวกับที่เก็บอยู่ในวาเรียนต์ Some ของ Option<T> ซึ่งในที่นี้ก็คือ ShirtColor) หาก Option<T> เป็นวาเรียนต์ Some เมธอด unwrap_or_else จะดึงค่าที่อยู่ข้างใน Some ออกมาส่งกลับให้ทันที แต่ถ้า Option<T> เป็นวาเรียนต์ None เมธอด unwrap_or_else จะเรียกสั่งรันโคลเชอร์ แล้วนำค่าที่โคลเชอร์ส่งกลับมานั้นมาส่งคืนต่อไป
เราระบุนิพจน์ของโคลเชอร์เป็น || self.most_stocked() ส่งเป็นอาร์กิวเมนต์ให้กับ unwrap_or_else โคลเชอร์นี้เป็นโคลเชอร์ที่ไม่รับพารามิเตอร์ใดๆ เลย (หากโคลเชอร์มีพารามิเตอร์ พารามิเตอร์เหล่านั้นจะอยู่ระหว่างเส้นขีดแนวตั้งหรือเครื่องหมายไปป์ | | สองอัน) และบอดี้ของโคลเชอร์จะสั่งเรียก self.most_stocked() ตรงนี้เราแค่นิยามโคลเชอร์เตรียมไว้ แล้วการทำงานภายในของ unwrap_or_else จะเป็นฝ่ายเรียกประเมินผลโคลเชอร์นี้ในภายหลังเมื่อมีความจำเป็นต้องใช้ผลลัพธ์เท่านั้น
การรันโค้ดนี้จะแสดงผลลัพธ์ต่อไปนี้:
$ cargo run
Compiling shirt-company v0.1.0 (file:///projects/shirt-company)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.27s
Running `target/debug/shirt-company`
The user with preference Some(Red) gets Red
The user with preference None gets Blue
จุดที่น่าสนใจเป็นพิเศษตรงนี้คือ เราได้ส่งโคลเชอร์ที่เรียกคำสั่ง self.most_stocked() บนอินสแตนซ์ Inventory ปัจจุบันเข้าไป โดยที่ไลบรารีมาตรฐานไม่จำเป็นต้องรู้จักชนิดข้อมูล Inventory หรือ ShirtColor ที่เรานิยามขึ้นเอง หรือตรรกะเฉพาะทางในสถานการณ์นี้เลยแม้แต่น้อย โคลเชอร์นี้จะจับเรเฟอเรนซ์แบบเปลี่ยนแปลงค่าไม่ได้ (immutable reference) ของอินสแตนซ์ self ซึ่งเป็น Inventory เอาไว้ แล้วส่งต่อเรเฟอเรนซ์นั้นพร้อมกับบล็อกโค้ดที่เรากำหนดไปยังเมธอด unwrap_or_else ซึ่งฟังก์ชันธรรมดาทั่วไปไม่สามารถจับค่าจากสภาพแวดล้อมในลักษณะนี้ได้
การอนุมานและการระบุชนิดของโคลเชอร์
ยังมีข้อแตกต่างอื่นๆ ระหว่างฟังก์ชันกับโคลเชอร์อีก โดยทั่วไปแล้วโคลเชอร์ไม่จำเป็นต้องให้คุณระบุชนิดข้อมูล (type annotation) ของพารามิเตอร์หรือค่าที่ส่งกลับเหมือนกับฟังก์ชัน fn เหตุผลที่ฟังก์ชันจำเป็นต้องระบุชนิดข้อมูลกำกับไว้เสมอ เพราะชนิดข้อมูลเป็นส่วนหนึ่งของอินเทอร์เฟซสาธารณะที่เปิดเผยต่อผู้เรียกใช้งาน การกำหนดอินเทอร์เฟซนี้ไว้อย่างชัดเจนและตายตัวจึงมีความสำคัญต่อการรับประกันว่าทุกคนเข้าใจตรงกันว่าฟังก์ชันนั้นรับและส่งกลับข้อมูลชนิดใด ในทางกลับกัน โคลเชอร์ไม่ได้ถูกนำไปใช้งานเป็นอินเทอร์เฟซที่เปิดเผยภายนอกเช่นนั้น โดยมากมันจะถูกจัดเก็บไว้ในตัวแปร และถูกเรียกใช้งานเฉพาะจุดโดยไม่ต้องตั้งชื่อหรือเปิดเผยให้ผู้ใช้ไลบรารีเห็น
โคลเชอร์มักจะมีขนาดสั้นและเกี่ยวข้องอยู่เฉพาะในบริบทที่แคบ แทนที่จะเป็นบริบทกว้างๆ ทั่วไป ภายในขอบเขตจำกัดเหล่านี้ คอมไพเลอร์จึงสามารถอนุมาน (infer) ชนิดข้อมูลของพารามิเตอร์และชนิดของค่าที่ส่งกลับได้เอง คล้ายกับวิธีที่มันอนุมานชนิดของตัวแปรส่วนใหญ่ (แม้ว่าจะมีกรณีที่พบได้ยากอยู่บ้างที่คอมไพเลอร์ต้องการให้ระบุชนิดของโคลเชอร์ด้วยเช่นกัน)
เช่นเดียวกับตัวแปร หากเราต้องการเพิ่มความชัดเจนให้เห็นอย่างชัดเจน เราก็สามารถเขียนระบุชนิดข้อมูลกำกับไว้ได้ แม้จะต้องแลกมาด้วยความยาวของโค้ดที่มากกว่าที่จำเป็นก็ตาม การระบุชนิดข้อมูลให้โคลเชอร์จะมีหน้าตาดังแสดงในลิสติ้ง 13-2 ซึ่งในตัวอย่างนี้ เราจะนิยามโคลเชอร์แล้วเก็บไว้ในตัวแปร แทนที่จะนิยามตรงจุดที่ส่งเป็นอาร์กิวเมนต์แบบที่เราทำในลิสติ้ง 13-1
use std::thread;
use std::time::Duration;
fn generate_workout(intensity: u32, random_number: u32) {
let expensive_closure = |num: u32| -> u32 {
println!("calculating slowly...");
thread::sleep(Duration::from_secs(2));
num
};
if intensity < 25 {
println!("Today, do {} pushups!", expensive_closure(intensity));
println!("Next, do {} situps!", expensive_closure(intensity));
} else {
if random_number == 3 {
println!("Take a break today! Remember to stay hydrated!");
} else {
println!(
"Today, run for {} minutes!",
expensive_closure(intensity)
);
}
}
}
fn main() {
let simulated_user_specified_value = 10;
let simulated_random_number = 7;
generate_workout(simulated_user_specified_value, simulated_random_number);
}
เมื่อใส่การระบุชนิดข้อมูลเข้าไปแล้ว ไวยากรณ์ของโคลเชอร์จะดูคล้ายกับไวยากรณ์ของฟังก์ชันมากยิ่งขึ้น ในตัวอย่างนี้ เราจะนิยามฟังก์ชันที่บวกค่า 1 ให้กับพารามิเตอร์ เทียบกับโคลเชอร์ที่มีพฤติกรรมเดียวกันเพื่อเปรียบเทียบให้เห็นชัดเจน โดยเราได้เว้นวรรคช่องว่างบางส่วนเพื่อให้ส่วนที่ตรงกันวางเรียงตรงกันพอดี ซึ่งจะแสดงให้เห็นว่าไวยากรณ์ของโคลเชอร์คล้ายกับฟังก์ชันเพียงใด ยกเว้นการเปลี่ยนมาใช้เครื่องหมายไปป์และปริมาณไวยากรณ์ที่เป็นทางเลือก:
fn add_one_v1 (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x| { x + 1 };
let add_one_v4 = |x| x + 1 ;
บรรทัดแรกแสดงการนิยามฟังก์ชัน ส่วนบรรทัดที่สองแสดงการนิยามโคลเชอร์แบบระบุชนิดข้อมูลอย่างสมบูรณ์ ในบรรทัดที่สาม เราตัดการระบุชนิดข้อมูลออกจากโคลเชอร์ และในบรรทัดที่สี่ เราตัดเครื่องหมายปีกกาออกด้วย ซึ่งสามารถทำได้เนื่องจากบอดี้ของโคลเชอร์มีเพียงนิพจน์เดียว ทั้งหมดนี้ถือเป็นนิยามที่ถูกต้องตามไวยากรณ์และจะให้ผลลัพธ์เหมือนกันทุกประการเมื่อถูกเรียกใช้งาน สำหรับบรรทัด add_one_v3 และ add_one_v4 นั้น จำเป็นต้องมีการเรียกใช้งานโคลเชอร์ในโค้ดด้วยจึงจะคอมไพล์ผ่าน เพราะคอมไพเลอร์จำเป็นต้องอนุมานชนิดข้อมูลจากการนำไปใช้งานจริง ซึ่งคล้ายกับคำสั่ง let v = Vec::new(); ที่จำเป็นต้องมี type annotation หรือต้องมีการเพิ่มสมาชิกบางชนิดเข้าไปใน Vec ก่อน เพื่อให้ Rust อนุมานชนิดข้อมูลที่แน่นอนได้
สำหรับการนิยามโคลเชอร์ คอมไพเลอร์จะอนุมานชนิดข้อมูลที่เป็นรูปธรรม (concrete type) เพียงชนิดเดียวให้กับแต่ละพารามิเตอร์และค่าที่ส่งกลับ ตัวอย่างเช่น ลิสติ้ง 13-3 แสดงการนิยามโคลเชอร์สั้นๆ ที่ทำหน้าที่เพียงส่งค่าพารามิเตอร์ที่ได้รับกลับไปทันที โคลเชอร์นี้ไม่ได้มีประโยชน์ในทางปฏิบัติมากนักนอกจากใช้เป็นตัวอย่างประกอบ โปรดสังเกตว่าเราไม่ได้ระบุชนิดข้อมูลกำกับไว้เลย ซึ่งหมายความว่าเราสามารถเรียกใช้โคลเชอร์นี้กับข้อมูลชนิดใดก็ได้ โดยในการเรียกครั้งแรกเราได้ส่งค่า String เข้าไป แต่หากหลังจากนั้นเราพยายามเรียก example_closure ซ้ำด้วยตัวเลขจำนวนเต็ม เราจะพบกับข้อผิดพลาด
fn main() {
let example_closure = |x| x;
let s = example_closure(String::from("hello"));
let n = example_closure(5);
}
คอมไพเลอร์จะแจ้งข้อผิดพลาดดังนี้:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
error[E0308]: mismatched types
--> src/main.rs:5:29
|
5 | let n = example_closure(5);
| --------------- ^ expected `String`, found integer
| |
| arguments to this function are incorrect
|
note: expected because the closure was earlier called with an argument of type `String`
--> src/main.rs:4:29
|
4 | let s = example_closure(String::from("hello"));
| --------------- ^^^^^^^^^^^^^^^^^^^^^ expected because this argument is of type `String`
| |
| in this closure call
note: closure parameter defined here
--> src/main.rs:2:28
|
2 | let example_closure = |x| x;
| ^
help: try using a conversion method
|
5 | let n = example_closure(5.to_string());
| ++++++++++++
For more information about this error, try `rustc --explain E0308`.
error: could not compile `closure-example` (bin "closure-example") due to 1 previous error
ในการเรียกใช้งาน example_closure ครั้งแรกด้วยค่า String คอมไพเลอร์จะอนุมานให้ชนิดข้อมูลของ x และค่าที่ส่งกลับของโคลเชอร์กลายเป็น String และชนิดข้อมูลดังกล่าวจะถูกล็อกเข้ากับโคลเชอร์ในตัวแปร example_closure นั้นทันที ทำให้เราได้รับข้อผิดพลาดเรื่องชนิดข้อมูลหากพยายามนำข้อมูลชนิดอื่นมาใช้กับโคลเชอร์เดิมในครั้งถัดไป
การจับเรเฟอเรนซ์หรือการย้ายความเป็นเจ้าของ
โคลเชอร์สามารถจับค่าจากสภาพแวดล้อมได้ 3 วิธี ซึ่งสอดคล้องกับ 3 วิธีที่ฟังก์ชันรับพารามิเตอร์โดยตรง ได้แก่: การยืมแบบเปลี่ยนแปลงไม่ได้ การยืมแบบเปลี่ยนแปลงได้ และการรับสิทธิ์ความเป็นเจ้าของ (ownership) โดยโคลเชอร์จะตัดสินใจเองว่าจะใช้วิธีใด ขึ้นอยู่กับสิ่งที่โค้ดภายในบอดี้ของมันกระทำกับค่าที่ถูกจับมา
ในลิสติ้ง 13-4 เรานิยามโคลเชอร์ที่จับเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ของเวกเตอร์ชื่อ list เนื่องจากมันต้องการเพียงเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้เพื่อพิมพ์ค่าออกมา
fn main() {
let list = vec![1, 2, 3];
println!("Before defining closure: {list:?}");
let only_borrows = || println!("From closure: {list:?}");
println!("Before calling closure: {list:?}");
only_borrows();
println!("After calling closure: {list:?}");
}
ตัวอย่างนี้ยังแสดงให้เห็นด้วยว่า ตัวแปรสามารถผูกกับนิยามของโคลเชอร์ได้ และเราสามารถเรียกใช้โคลเชอร์ได้ในภายหลังโดยใช้ชื่อตัวแปรนั้นตามด้วยวงเล็บ เสมือนว่าชื่อตัวแปรนั้นเป็นชื่อฟังก์ชัน
เนื่องจากเราสามารถมีเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้หลายตัวชี้ไปยัง list พร้อมกันได้ ตัวแปร list จึงยังคงเข้าถึงได้จากโค้ดทั้งก่อนนิยามโคลเชอร์, หลังนิยามโคลเชอร์แต่ก่อนเรียกใช้งาน และหลังจากที่โคลเชอร์ถูกเรียกใช้งานแล้ว โค้ดนี้สามารถคอมไพล์ รัน และพิมพ์ผลลัพธ์ออกมาดังนี้:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
Running `target/debug/closure-example`
Before defining closure: [1, 2, 3]
Before calling closure: [1, 2, 3]
From closure: [1, 2, 3]
After calling closure: [1, 2, 3]
ถัดมาในลิสติ้ง 13-5 เราเปลี่ยนบอดี้ของโคลเชอร์ให้เพิ่มสมาชิกเข้าไปในเวกเตอร์ list ซึ่งตอนนี้โคลเชอร์จะจับเรเฟอเรนซ์แบบเปลี่ยนแปลงได้แทน
fn main() {
let mut list = vec![1, 2, 3];
println!("Before defining closure: {list:?}");
let mut borrows_mutably = || list.push(7);
borrows_mutably();
println!("After calling closure: {list:?}");
}
โค้ดนี้สามารถคอมไพล์ รัน และพิมพ์ผลลัพธ์ออกมาดังนี้:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
Running `target/debug/closure-example`
Before defining closure: [1, 2, 3]
After calling closure: [1, 2, 3, 7]
โปรดสังเกตว่าไม่มีคำสั่ง println! คั่นระหว่างจุดที่นิยามกับการเรียกใช้งานโคลเชอร์ borrows_mutably อีกต่อไปแล้ว: ทันทีที่ borrows_mutably ถูกนิยาม มันจะจับเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ (mutable reference) ของ list เอาไว้ และเนื่องจากเราไม่ได้เรียกใช้โคลเชอร์นั้นอีกหลังจากการเรียกใช้งานครั้งแรก การยืมแบบเปลี่ยนแปลงได้จึงสิ้นสุดลงตรงจุดนั้น แต่ในช่วงระหว่างการนิยามโคลเชอร์ไปจนถึงการเรียกใช้งาน เราจะไม่สามารถยืมแบบเปลี่ยนแปลงไม่ได้เพื่อพิมพ์ค่าออกมาได้เลย เนื่องจากกฎการยืมของ Rust ไม่อนุญาตให้มีการยืมอื่นใดเกิดขึ้นในขณะที่มีการยืมแบบเปลี่ยนแปลงได้คงอยู่ ลองเพิ่ม println! ในจุดดังกล่าวดูเพื่อศึกษาข้อความแสดงข้อผิดพลาดที่คอมไพเลอร์จะแจ้งเตือน!
หากคุณต้องการบังคับให้โคลเชอร์รับสิทธิ์ความเป็นเจ้าของในค่าที่มันใช้ในสภาพแวดล้อม แม้ว่าบอดี้ของโคลเชอร์จะไม่จำเป็นต้องใช้ความเป็นเจ้าของอย่างเคร่งครัดก็ตาม คุณสามารถใช้คำสงวน move หน้ารายการพารามิเตอร์ได้
เทคนิคนี้มีประโยชน์อย่างยิ่งเมื่อต้องส่งโคลเชอร์ไปยังเธรดใหม่ เพื่อย้ายข้อมูลไปให้เธรดใหม่เป็นเจ้าของ เราจะพูดคุยถึงเธรดและเหตุผลที่คุณอาจต้องการใช้มันโดยละเอียดในบทที่ 16 เมื่อเราพูดคุยถึงการทำงานพร้อมกัน แต่สำหรับตอนนี้ มาสำรวจอย่างสั้นๆ เกี่ยวกับการสร้างเธรดใหม่โดยใช้โคลเชอร์ที่ต้องใช้คำสงวน move ลิสติ้ง 13-6 แสดงลิสติ้ง 13-4 ที่ถูกแก้ไขให้พิมพ์เวกเตอร์ในเธรดใหม่แทนที่จะเป็นในเธรดหลัก
use std::thread;
fn main() {
let list = vec![1, 2, 3];
println!("Before defining closure: {list:?}");
thread::spawn(move || println!("From thread: {list:?}"))
.join()
.unwrap();
}
เราสร้างเธรดใหม่ขึ้นมา โดยส่งโคลเชอร์ที่จะให้รันเป็นอาร์กิวเมนต์แก่เธรด บอดี้ของโคลเชอร์พิมพ์รายการออกมา ในลิสติ้ง 13-4 โคลเชอร์จะจับ list ด้วยเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้เท่านั้น เนื่องจากนั่นเป็นระดับการเข้าถึงน้อยที่สุดที่จำเป็นต่อการพิมพ์ค่าออกมา แต่ในตัวอย่างนี้ แม้ว่าบอดี้ของโคลเชอร์จะต้องการเพียงเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ แต่เราจำเป็นต้องระบุให้ย้ายความเป็นเจ้าของ list เข้าไปไว้ในโคลเชอร์อย่างชัดเจน โดยวางคำสงวน move ไว้หน้าการนิยามโคลเชอร์ เหตุผลคือหากเธรดหลักทำงานอื่นต่อไปก่อนที่จะเรียก join เธรดใหม่อาจทำงานเสร็จก่อน หรือเธรดหลักอาจทำงานเสร็จก่อนและจบการทำงานลง ซึ่งหากเธรดหลักยังคงถือสิทธิ์ความเป็นเจ้าของ list อยู่แล้วจบการทำงานไปก่อน ข้อมูลใน list ก็จะถูกทิ้ง (drop) ไป ส่งผลให้เรเฟอเรนซ์ในเธรดใหม่กลายเป็นเรเฟอเรนซ์ที่ไม่ถูกต้องทันที ด้วยเหตุนี้ คอมไพเลอร์จึงบังคับให้ต้องย้าย list เข้าไปอยู่ในโคลเชอร์ของเธรดใหม่ เพื่อรับประกันว่าข้อมูลจะยังมีชีวิตอยู่ตราบเท่าที่เธรดใหม่ทำงาน ลองทดสอบโดยลบคำสงวน move ออก หรือลองเรียกใช้ list ในเธรดหลักหลังการนิยามโคลเชอร์ดู เพื่อศึกษาข้อความแสดงข้อผิดพลาดที่คอมไพเลอร์แจ้งเตือน!
การย้ายค่าที่ถูกจับออกจากโคลเชอร์
เมื่อโคลเชอร์ได้จับเรเฟอเรนซ์หรือรับสิทธิ์ความเป็นเจ้าของในค่าต่างๆ จากสภาพแวดล้อมที่มันถูกนิยาม (ซึ่งส่งผลต่อสิ่งที่จะถูกย้าย_เข้าไป_ในโคลเชอร์ หากมี) โค้ดในบอดี้ของโคลเชอร์จะเป็นตัวกำหนดต่อไปว่า จะเกิดอะไรขึ้นกับเรเฟอเรนซ์หรือค่านั้นเมื่อโคลเชอร์ถูกประเมินค่าในภายหลัง (ซึ่งส่งผลต่อสิ่งที่จะถูกย้าย_ออกจาก_โคลเชอร์ หากมี)
บอดี้ของโคลเชอร์สามารถกระทำการอย่างใดอย่างหนึ่งต่อไปนี้ได้: ย้ายค่าที่ถูกจับออกจากโคลเชอร์, เปลี่ยนแปลงค่าที่ถูกจับ, ไม่ย้ายและไม่เปลี่ยนแปลงค่า หรือไม่จับสิ่งใดจากสภาพแวดล้อมมาตั้งแต่แรก
วิธีที่โคลเชอร์จับและจัดการค่าจากสภาพแวดล้อมจะส่งผลต่อว่าโคลเชอร์นั้นอิมพลีเมนต์เทรต (trait) ใด และเทรตคือวิธีที่ฟังก์ชันและ struct ระบุได้ว่ามันรองรับการใช้งานโคลเชอร์ชนิดใดได้บ้าง โดยโคลเชอร์จะอิมพลีเมนต์เทรตกลุ่ม Fn หนึ่งตัว สองตัว หรือทั้งสามตัวนี้โดยอัตโนมัติ ในลักษณะเพิ่มพูนสะสม ขึ้นอยู่กับว่าบอดี้ของโคลเชอร์จัดการกับค่านั้นอย่างไร:
FnOnceใช้กับโคลเชอร์ที่เรียกได้ครั้งเดียว โคลเชอร์ทั้งหมดจะอิมพลีเมนต์เทรตนี้เป็นอย่างน้อย เพราะโคลเชอร์ทั้งหมดสามารถถูกเรียกได้ โคลเชอร์ที่ย้ายค่าที่ถูกจับออกจากบอดี้ของมันจะอิมพลีเมนต์เพียงFnOnceและไม่อิมพลีเมนต์เทรตFnอื่นๆ เลย เพราะมันสามารถเรียกได้เพียงครั้งเดียวเท่านั้นFnMutใช้กับโคลเชอร์ที่ไม่ย้ายค่าที่ถูกจับออกจากบอดี้ของมัน แต่อาจเปลี่ยนแปลงค่าที่ถูกจับได้ โคลเชอร์เหล่านี้สามารถเรียกได้มากกว่าหนึ่งครั้งFnใช้กับโคลเชอร์ที่ไม่ย้ายค่าที่ถูกจับออกจากบอดี้ของมันและไม่เปลี่ยนแปลงค่าที่ถูกจับ รวมถึงโคลเชอร์ที่ไม่จับสิ่งใดจากสภาพแวดล้อมของมันเลย โคลเชอร์เหล่านี้สามารถเรียกได้มากกว่าหนึ่งครั้งโดยไม่เปลี่ยนแปลงสภาพแวดล้อม ซึ่งมีความสำคัญอย่างยิ่งในกรณีเช่นการเรียกใช้โคลเชอร์หลายครั้งพร้อมกัน
มาดูนิยามของเมธอด unwrap_or_else บน Option<T> ที่เราใช้ในลิสติ้ง 13-1:
impl<T> Option<T> {
pub fn unwrap_or_else<F>(self, f: F) -> T
where
F: FnOnce() -> T
{
match self {
Some(x) => x,
None => f(),
}
}
}
ย้อนนึกว่า T คือชนิดข้อมูลแบบเจเนอริก (generic) ที่เป็นตัวแทนของชนิดค่าภายในวาเรียนต์ Some ของ Option ชนิด T นั้นยังเป็นชนิดที่ส่งกลับของฟังก์ชัน unwrap_or_else ด้วย: ตัวอย่างเช่น โค้ดที่เรียก unwrap_or_else บน Option<String> จะได้ String ออกมา
ต่อไป โปรดสังเกตว่าฟังก์ชัน unwrap_or_else มีพารามิเตอร์ชนิดข้อมูลแบบเจเนอริกเพิ่มเติมคือ F ซึ่งชนิด F คือชนิดของพารามิเตอร์ชื่อ f อันเป็นโคลเชอร์ที่เราส่งเข้าไปเมื่อเรียกใช้ unwrap_or_else
ข้อกำหนดเทรต (trait bound) ที่ระบุบนชนิดเจเนอริก F คือ FnOnce() -> T ซึ่งหมายความว่า F ต้องสามารถถูกเรียกได้หนึ่งครั้ง ไม่รับอาร์กิวเมนต์ และส่งกลับค่าชนิด T การใช้ FnOnce ในข้อกำหนดเทรตเป็นการระบุข้อจำกัดว่า unwrap_or_else จะไม่เรียก f มากกว่าหนึ่งครั้งแน่นอน ในบอดี้ของ unwrap_or_else เราจะเห็นว่าหาก Option เป็น Some ตัวฟังก์ชัน f จะไม่ถูกเรียกเลย แต่หาก Option เป็น None ตัวฟังก์ชัน f จะถูกเรียกทำงานหนึ่งครั้ง และเนื่องจากโคลเชอร์ทั้งหมดอิมพลีเมนต์ FnOnce อยู่แล้ว เมธอด unwrap_or_else จึงยอมรับโคลเชอร์ได้ทั้งสามชนิดและมีความยืดหยุ่นสูงสุดเท่าที่จะเป็นไปได้
หมายเหตุ: หากสิ่งที่เราต้องการทำไม่จำเป็นต้องจับค่าจากสภาพแวดล้อม เราสามารถใช้ชื่อของฟังก์ชันธรรมดาแทนโคลเชอร์ในจุดที่ต้องการบางสิ่งที่อิมพลีเมนต์เทรต
Fnตัวใดตัวหนึ่งได้ ตัวอย่างเช่น บนค่าOption<Vec<T>>เราสามารถเรียกunwrap_or_else(Vec::new)เพื่อสร้างเวกเตอร์ใหม่ที่ว่างเปล่าหากค่าเป็นNoneโดยคอมไพเลอร์จะอิมพลีเมนต์เทรตFnตัวใดก็ตามที่เข้ากันได้กับนิยามของฟังก์ชันนั้นให้โดยอัตโนมัติ
ตอนนี้ มาดูเมธอด sort_by_key ของไลบรารีมาตรฐาน ซึ่งนิยามไว้บนสไลซ์ เพื่อดูว่ามันแตกต่างจาก unwrap_or_else อย่างไร และเพราะเหตุใด sort_by_key จึงใช้ FnMut แทน FnOnce สำหรับข้อกำหนดเทรต โดยโคลเชอร์จะได้รับอาร์กิวเมนต์หนึ่งตัวในรูปของเรเฟอเรนซ์ไปยังสมาชิกปัจจุบันในสไลซ์ที่กำลังพิจารณา และจะส่งกลับค่าชนิด K ที่สามารถนำไปจัดเรียงลำดับได้ ฟังก์ชันนี้มีประโยชน์มากเมื่อคุณต้องการเรียงลำดับสมาชิกในสไลซ์ตามคุณลักษณะเฉพาะอย่างของแต่ละสมาชิก ในลิสติ้ง 13-7 เรามีรายการของอินสแตนซ์ Rectangle และเราใช้ sort_by_key เพื่อจัดเรียงพวกมันตามคุณลักษณะ width จากน้อยไปมาก
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let mut list = [
Rectangle { width: 10, height: 1 },
Rectangle { width: 3, height: 5 },
Rectangle { width: 7, height: 12 },
];
list.sort_by_key(|r| r.width);
println!("{list:#?}");
}
โค้ดนี้พิมพ์:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.41s
Running `target/debug/rectangles`
[
Rectangle {
width: 3,
height: 5,
},
Rectangle {
width: 7,
height: 12,
},
Rectangle {
width: 10,
height: 1,
},
]
เหตุผลที่ sort_by_key ถูกนิยามให้รับโคลเชอร์ที่อิมพลีเมนต์ FnMut เป็นเพราะมันจำเป็นต้องเรียกโคลเชอร์หลายครั้ง: ครั้งละหนึ่งรอบต่อสมาชิกแต่ละตัวในสไลซ์ โคลเชอร์ |r| r.width ไม่ได้จับ ไม่ได้เปลี่ยนแปลง และไม่ได้ย้ายสิ่งใดออกจากสภาพแวดล้อมของมัน มันจึงสอดคล้องกับเงื่อนไขของข้อกำหนดเทรตทุกประการ
ในทางตรงกันข้าม ลิสติ้ง 13-8 แสดงตัวอย่างของโคลเชอร์ที่อิมพลีเมนต์ได้เพียงเทรต FnOnce เพราะมันย้ายค่าออกจากสภาพแวดล้อม คอมไพเลอร์จึงไม่อนุญาตให้เรานำโคลเชอร์นี้ไปใช้กับ sort_by_key
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let mut list = [
Rectangle { width: 10, height: 1 },
Rectangle { width: 3, height: 5 },
Rectangle { width: 7, height: 12 },
];
let mut sort_operations = vec![];
let value = String::from("closure called");
list.sort_by_key(|r| {
sort_operations.push(value);
r.width
});
println!("{list:#?}");
}
นี่เป็นตัวอย่างการเขียนโค้ดที่ตั้งใจสร้างขึ้นมา (และใช้งานไม่ได้จริง) เพื่อพยายามนับจำนวนครั้งที่ sort_by_key เรียกสั่งรันโคลเชอร์ขณะจัดเรียงสมาชิกใน list โค้ดนี้พยายามนับจำนวนรอบโดยการพุช (push) ค่า value ซึ่งเป็น String จากสภาพแวดล้อมเข้าไปในเวกเตอร์ sort_operations ในกรณีนี้ โคลเชอร์จะจับ value และย้าย value นั้นออกจากโคลเชอร์โดยโอนสิทธิ์ความเป็นเจ้าของไปให้เวกเตอร์ sort_operations ส่งผลให้โคลเชอร์นี้สามารถถูกเรียกใช้งานได้เพียงครั้งเดียวเท่านั้น หากพยายามเรียกซ้ำเป็นครั้งที่สองย่อมทำไม่ได้ เพราะค่า value ไม่ได้คงอยู่ในสภาพแวดล้อมให้พุชเข้าไปใน sort_operations ได้อีกต่อไป! ดังนั้น โคลเชอร์นี้จึงอิมพลีเมนต์ได้เพียงเทรต FnOnce และเมื่อเราพยายามคอมไพล์โค้ดนี้ เราจึงได้รับข้อผิดพลาดแจ้งว่า value ไม่สามารถย้ายออกจากโคลเชอร์ได้ เนื่องจาก sort_by_key กำหนดให้โคลเชอร์ต้องอิมพลีเมนต์เทรต FnMut:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
error[E0507]: cannot move out of `value`, a captured variable in an `FnMut` closure
--> src/main.rs:18:30
|
15 | let value = String::from("closure called");
| ----- ------------------------------ move occurs because `value` has type `String`, which does not implement the `Copy` trait
| |
| captured outer variable
16 |
17 | list.sort_by_key(|r| {
| --- captured by this `FnMut` closure
18 | sort_operations.push(value);
| ^^^^^ `value` is moved here
|
help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
--> /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/alloc/src/slice.rs:249:11
help: consider cloning the value if the performance cost is acceptable
|
18 | sort_operations.push(value.clone());
| ++++++++
For more information about this error, try `rustc --explain E0507`.
error: could not compile `rectangles` (bin "rectangles") due to 1 previous error
ข้อความแสดงข้อผิดพลาดชี้ไปยังบรรทัดในบอดี้ของโคลเชอร์ที่ย้าย value ออกจากสภาพแวดล้อม เพื่อแก้ไขปัญหานี้ เราจำเป็นต้องปรับเปลี่ยนโค้ดภายในบอดี้ของโคลเชอร์ไม่ให้ย้ายค่าออกจากสภาพแวดล้อม การสร้างตัวแปรนับจำนวน (counter) ไว้ในสภาพแวดล้อมแล้วเพิ่มค่าของมันภายในโคลเชอร์ถือเป็นวิธีที่ตรงไปตรงมาและเหมาะสมกว่าสำหรับการนับจำนวนรอบที่โคลเชอร์ถูกเรียก โคลเชอร์ในลิสติ้ง 13-9 สามารถทำงานร่วมกับ sort_by_key ได้อย่างราบรื่น เพราะมันจับเพียงเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ของตัวแปรนับ num_sort_operations จึงสามารถถูกเรียกใช้งานซ้ำได้หลายครั้ง
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let mut list = [
Rectangle { width: 10, height: 1 },
Rectangle { width: 3, height: 5 },
Rectangle { width: 7, height: 12 },
];
let mut num_sort_operations = 0;
list.sort_by_key(|r| {
num_sort_operations += 1;
r.width
});
println!("{list:#?}, sorted in {num_sort_operations} operations");
}
เทรตกลุ่ม Fn มีความสำคัญอย่างยิ่งทั้งในการนิยามและการเรียกใช้ฟังก์ชันหรือชนิดข้อมูลที่ทำงานร่วมกับโคลเชอร์ ในหัวข้อถัดไป เราจะได้เรียนรู้เกี่ยวกับตัววนซ้ำหรืออิเทอเรเตอร์ (iterators) ซึ่งเมธอดของอิเทอเรเตอร์จำนวนมากจะรับอาร์กิวเมนต์เป็นโคลเชอร์ ดังนั้นขอให้จดจำรายละเอียดเกี่ยวกับโคลเชอร์เหล่านี้ไว้เพื่อนำไปต่อยอดในหัวข้อถัดไปครับ!