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

ฟังก์ชันและโคลเชอร์ขั้นสูง

หัวข้อนี้จะพาไปสำรวจฟีเจอร์ขั้นสูงที่เกี่ยวข้องกับฟังก์ชันและโคลเชอร์ (closure) ซึ่งรวมถึงพอยน์เตอร์ฟังก์ชัน (function pointers) และการคืนค่าโคลเชอร์จากฟังก์ชัน

พอยน์เตอร์ฟังก์ชัน

เราได้พูดคุยถึงวิธีส่งโคลเชอร์เข้าไปเป็นอาร์กิวเมนต์ของฟังก์ชันกันไปแล้ว คุณยังสามารถส่งฟังก์ชันปกติเข้าไปยังฟังก์ชันอื่นได้ด้วยเช่นกัน! เทคนิคนี้มีประโยชน์อย่างยิ่งเมื่อคุณต้องการส่งฟังก์ชันที่นิยามไว้อยู่แล้วเข้าไป แทนที่จะต้องนิยามโคลเชอร์ใหม่ โดยฟังก์ชันปกติสามารถแปลงชนิดข้อมูลแบบบังคับ (coerce) ไปเป็นชนิด fn (เขียนด้วยตัวอักษร f พิมพ์เล็ก) ซึ่งต้องระวังอย่าสับสนกับเทรตโคลเชอร์ Fn โดยชนิด fn นี้จะเรียกว่า พอยน์เตอร์ฟังก์ชัน (function pointer) การส่งฟังก์ชันผ่านพอยน์เตอร์ฟังก์ชันช่วยให้คุณสามารถนำฟังก์ชันไปใช้เป็นอาร์กิวเมนต์ของฟังก์ชันอื่นได้

ไวยากรณ์สำหรับระบุว่าพารามิเตอร์เป็นพอยน์เตอร์ฟังก์ชันนั้นมีความคล้ายคลึงกับไวยากรณ์ของโคลเชอร์ ดังที่แสดงในลิสติ้ง 20-28 ซึ่งเรานิยามฟังก์ชัน add_one ที่ทำหน้าที่บวก 1 ให้กับพารามิเตอร์ ส่วนฟังก์ชัน do_twice รับพารามิเตอร์สองตัว ได้แก่: พอยน์เตอร์ฟังก์ชันที่ชี้ไปยังฟังก์ชันใด ๆ ที่รับพารามิเตอร์ชนิด i32 และคืนค่าเป็น i32 กับค่า i32 อีกหนึ่งค่า โดยฟังก์ชัน do_twice จะเรียกฟังก์ชัน f สองครั้งพร้อมส่งค่า arg เข้าไป แล้วนำผลลัพธ์จากการเรียกฟังก์ชันทั้งสองมารวมกัน ในฟังก์ชัน main มีการเรียกใช้ do_twice โดยส่งอาร์กิวเมนต์เป็น add_one และ 5

fn add_one(x: i32) -> i32 {
    x + 1
}

fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
    f(arg) + f(arg)
}

fn main() {
    let answer = do_twice(add_one, 5);

    println!("The answer is: {answer}");
}

โค้ดนี้จะพิมพ์ The answer is: 12 ออกมา เราระบุว่าพารามิเตอร์ f ใน do_twice มีชนิดเป็น fn ที่รับพารามิเตอร์หนึ่งตัวชนิด i32 และคืนค่าเป็น i32 จากนั้นเราจึงสามารถเรียกใช้ f ภายในบอดี้ของ do_twice ได้ ในฟังก์ชัน main เราสามารถส่งชื่อฟังก์ชัน add_one เป็นอาร์กิวเมนต์ตัวแรกให้กับ do_twice ได้โดยตรง

สิ่งที่แตกต่างจากโคลเชอร์คือ fn เป็นชนิดข้อมูล ไม่ใช่เทรต เราจึงสามารถระบุ fn เป็นชนิดของพารามิเตอร์ได้โดยตรง แทนที่จะต้องประกาศพารามิเตอร์เจเนอริกแล้วกำกับด้วยเทรตตระกูล Fn เป็นข้อกำหนดเทรต (trait bound)

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

อย่างไรก็ตาม ตัวอย่างสถานการณ์ที่คุณต้องการรับเฉพาะ fn และไม่รับโคลเชอร์ คือการเชื่อมต่อกับโค้ดภายนอกที่ไม่มีแนวคิดเรื่องโคลเชอร์ เช่น ฟังก์ชันของภาษา C สามารถรับฟังก์ชันเป็นอาร์กิวเมนต์ได้ แต่ภาษา C ไม่มีโคลเชอร์

เพื่อเป็นตัวอย่างแสดงจุดที่คุณสามารถเลือกใช้ได้ทั้งโคลเชอร์ที่นิยามแบบอินไลน์หรือฟังก์ชันที่มีชื่อ ลองมาดูการเรียกใช้เมธอด map จากเทรต Iterator ในไลบรารีมาตรฐาน หากต้องการใช้เมธอด map เพื่อแปลงเวกเตอร์ (vector) ของตัวเลขให้กลายเป็นเวกเตอร์ของสตริง เราสามารถเขียนโดยใช้โคลเชอร์ได้ดังในลิสติ้ง 20-29

fn main() {
    let list_of_numbers = vec![1, 2, 3];
    let list_of_strings: Vec<String> =
        list_of_numbers.iter().map(|i| i.to_string()).collect();
}

หรือเราจะส่งชื่อฟังก์ชันเข้าไปเป็นอาร์กิวเมนต์ของ map แทนการใช้โคลเชอร์ก็ได้ ลิสติ้ง 20-30 แสดงให้เห็นว่าโค้ดจะมีลักษณะอย่างไร

fn main() {
    let list_of_numbers = vec![1, 2, 3];
    let list_of_strings: Vec<String> =
        list_of_numbers.iter().map(ToString::to_string).collect();
}

โปรดสังเกตว่าเราต้องใช้ไวยากรณ์แบบระบุชื่อเต็ม (fully qualified syntax) ตามที่เราได้พูดคุยกันในหัวข้อ“เทรตขั้นสูง” เนื่องจากมีฟังก์ชันชื่อ to_string หลายตัวให้เลือกใช้งาน

ในที่นี้ เรากำลังเรียกใช้ฟังก์ชัน to_string ที่นิยามไว้ในเทรต ToString ซึ่งไลบรารีมาตรฐานได้อิมพลีเมนต์ให้กับทุกชนิดข้อมูลที่อิมพลีเมนต์ Display ไว้แล้ว

ย้อนนึกถึงหัวข้อ“ค่าของ enum” ในบทที่ 6 ซึ่งระบุว่าชื่อของแต่ละวาเรียนต์ (variant) ของ enum ที่เรานิยามไว้ จะทำหน้าที่เป็นฟังก์ชันตัวเริ่มต้น (initializer function) ได้ด้วย เราสามารถนำฟังก์ชันตัวเริ่มต้นเหล่านี้มาใช้เป็นพอยน์เตอร์ฟังก์ชันที่อิมพลีเมนต์เทรตโคลเชอร์ได้ ซึ่งหมายความว่าเราสามารถส่งฟังก์ชันตัวเริ่มต้นเป็นอาร์กิวเมนต์ให้กับเมธอดที่รับโคลเชอร์ได้เช่นกัน ดังที่แสดงในลิสติ้ง 20-31

fn main() {
    enum Status {
        Value(u32),
        Stop,
    }

    let list_of_statuses: Vec<Status> = (0u32..20).map(Status::Value).collect();
}

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

การคืนค่าโคลเชอร์

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

ในทางปฏิบัติ คุณมักจะใช้ไวยากรณ์ impl Trait ตามที่เราได้เรียนรู้กันไปในบทที่ 10 คุณสามารถคืนค่าฟังก์ชันชนิดใดก็ได้โดยระบุ Fn, FnOnce หรือ FnMut ตัวอย่างเช่น โค้ดในลิสติ้ง 20-32 จะสามารถคอมไพล์ผ่านได้อย่างราบรื่น

#![allow(unused)]
fn main() {
fn returns_closure() -> impl Fn(i32) -> i32 {
    |x| x + 1
}
}

อย่างไรก็ตาม ดังที่เราได้ตั้งข้อสังเกตไว้ในหัวข้อ“การอนุมานและการระบุชนิดของโคลเชอร์” ในบทที่ 13 ว่าโคลเชอร์แต่ละตัวจะมีชนิดข้อมูลเฉพาะตัวที่ไม่ซ้ำกัน หากคุณจำเป็นต้องทำงานกับฟังก์ชันหลายตัวที่มีซิกเนเจอร์เหมือนกันแต่มีการอิมพลีเมนต์แตกต่างกัน คุณจะต้องใช้เทรตออบเจกต์ (trait object) เข้ามาช่วย ลองพิจารณาสิ่งที่จะเกิดขึ้นหากคุณเขียนโค้ดดังที่แสดงในลิสติ้ง 20-33

fn main() {
    let handlers = vec![returns_closure(), returns_initialized_closure(123)];
    for handler in handlers {
        let output = handler(5);
        println!("{output}");
    }
}

fn returns_closure() -> impl Fn(i32) -> i32 {
    |x| x + 1
}

fn returns_initialized_closure(init: i32) -> impl Fn(i32) -> i32 {
    move |x| x + init
}

ในที่นี้เรามีฟังก์ชันสองตัวคือ returns_closure และ returns_initialized_closure ซึ่งต่างก็คืนค่าเป็น impl Fn(i32) -> i32 โปรดสังเกตว่าโคลเชอร์ที่ทั้งสองฟังก์ชันคืนกลับมานั้นเป็นคนละตัวกัน แม้ว่าจะอิมพลีเมนต์ชนิดข้อมูลเดียวกันก็ตาม หากเราพยายามคอมไพล์โค้ดนี้ Rust จะแจ้งให้เราทราบว่าไม่สามารถทำงานได้:

$ cargo build
   Compiling functions-example v0.1.0 (file:///projects/functions-example)
error[E0308]: mismatched types
  --> src/main.rs:2:44
   |
 2 |     let handlers = vec![returns_closure(), returns_initialized_closure(123)];
   |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected opaque type, found a different opaque type
...
 9 | fn returns_closure() -> impl Fn(i32) -> i32 {
   |                         ------------------- the expected opaque type
...
13 | fn returns_initialized_closure(init: i32) -> impl Fn(i32) -> i32 {
   |                                              ------------------- the found opaque type
   |
   = note: expected opaque type `impl Fn(i32) -> i32`
              found opaque type `impl Fn(i32) -> i32`
   = note: distinct uses of `impl Trait` result in different opaque types

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

ข้อความแจ้งข้อผิดพลาดอธิบายว่า ทุกครั้งที่เราคืนค่า impl Trait คอมไพเลอร์ Rust จะสร้าง ชนิดข้อมูลแบบทึบแสง (opaque type) ที่มีเอกลักษณ์เฉพาะตัวขึ้นมา ซึ่งเป็นชนิดข้อมูลที่เราไม่สามารถมองเห็นรายละเอียดภายในที่ Rust สร้างขึ้น และไม่สามารถคาดเดาชนิดข้อมูลที่ Rust สร้างขึ้นเพื่อเขียนระบุด้วยตนเองได้ ดังนั้น แม้ว่าฟังก์ชันเหล่านี้จะคืนค่าโคลเชอร์ที่อิมพลีเมนต์เทรตเดียวกันคือ Fn(i32) -> i32 แต่ชนิดข้อมูลทึบแสงที่ Rust สร้างขึ้นสำหรับแต่ละตัวกลับแตกต่างกัน (ลักษณะนี้คล้ายคลึงกับวิธีที่ Rust สร้างชนิดข้อมูลรูปธรรมที่ต่างกันให้กับบล็อก async คนละบล็อก แม้ว่าจะมีชนิดข้อมูลเอาต์พุตเดียวกัน ดังที่เราเห็นใน“ชนิด Pin และเทรต Unpin” ในบทที่ 17) เราเคยเห็นทางออกสำหรับปัญหานี้มาแล้วหลายครั้ง นั่นคือการนำเทรตออบเจกต์มาใช้งาน ดังที่แสดงในลิสติ้ง 20-34

fn main() {
    let handlers = vec![returns_closure(), returns_initialized_closure(123)];
    for handler in handlers {
        let output = handler(5);
        println!("{output}");
    }
}

fn returns_closure() -> Box<dyn Fn(i32) -> i32> {
    Box::new(|x| x + 1)
}

fn returns_initialized_closure(init: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |x| x + init)
}

โค้ดนี้จะสามารถคอมไพล์ผ่านได้อย่างราบรื่น สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเทรตออบเจกต์ สามารถย้อนกลับไปดูหัวข้อ“การใช้เทรตออบเจกต์เพื่อนามธรรมพฤติกรรมร่วม” ในบทที่ 18 ได้

ต่อไป มาสำรวจเรื่องมาโคร (macros) กัน!