การใช้งาน Functional programming ในภาษา Rust แบบง่ายๆ พร้อมตัวอย่าง

# การใช้งาน Functional programming ในภาษา Rust แบบง่ายๆ

โลกของการเขียนโปรแกรมนั้นมีการตื่นตัวอยู่ตลอดเวลา ด้วยแนวคิดใหม่ๆ ที่ถูกคิดค้นขึ้น สำหรับประเภทของการเขียนโปรแกรม (programming paradigms) หนึ่งที่ได้รับความสนใจอย่างมากคือการเขียนโปรแกรมแบบฟังก์ชันนาล (Functional programming) ซึ่งให้ความสำคัญกับการเปลี่ยนแปลงที่ไม่เกิดผลกระทบต่อข้อกำหนดระบบอื่น (side effects) และอาศัยความจำพิเศษ (pure functions) ภาษา Rust ซึ่งเป็นภาษาที่ออกแบบมาเพื่อความปลอดภัยเมื่อเรื่องของหน่วยความจำและการจัดการข้อผิดพลาด ก็สนับสนุนการเขียนโปรแกรมแบบฟังก์ชันนาลในระดับหนึ่งเช่นกัน

Functional Programming: คืออะไร?

ก่อนที่เราจะไปพูดถึงในด้านของ Rust เรามาทำความเข้าใจกันก่อนว่า Functional Programming คืออะไร ภายใต้แนวคิดนี้ พื้นฐานสำคัญอยู่ที่ฟังก์ชัน "อันบริสุทธิ์" ซึ่งเป็นฟังก์ชันที่ไม่มี side effects กล่าวคือ ผลลัพธ์ของฟังก์ชันจะถูกกำหนดเฉพาะอย่างยิ่งโดยอาร์กิวเมนท์ที่มันรับ นอกจากนี้ยังมีการทำงานแบบ "immutable" หมายถึง ไม่มีการเปลี่ยนแปลงสถานะภายในของข้อมูล

ตอนนี้ เรามาดูกันว่าภาษา Rust รองรับแนวคิดเหล่านี้อย่างไรบ้างผ่านตัวอย่างโค้ดเฉพาะ:

ตัวอย่างโค้ดที่ 1: การใช้งาน Closure

Closure เป็นฟังก์ชันที่สามารถเก็บสถานะของตัวแปรที่อยู่ใกล้เคียงไว้ภายในตัวมันเองได้ ใน Rust นั้น closures คือ first-class functions ที่สามารถใช้คุณสมบัติเหล่านี้ได้

 fn main() {
    let add_nums = |num1: i32, num2: i32| num1 + num2;
    println!("ผลบวกคือ: {}", add_nums(1, 2)); // ผลลัพธ์คือ 3
}

ในตัวอย่างนี้ closure `add_nums` เป็นฟังก์ชันที่รับค่าสองตัวและคืนค่าผลบวกของมันเป็นผลลัพธ์ เมื่อเราเรียกใช้ `add_nums(1, 2)`, เราได้รับผลลัพธ์คือ 3.

ตัวอย่างโค้ดที่ 2: การใช้งาน Iterator Adaptors

Iterator adaptors เป็นวิธีที่ให้เราขยายและแปลง iterator ใน Rust ด้วยการใช้งานเมธอดต่างๆที่ให้พลังแบบ functional programming.

 fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let doubled: Vec<i32> = numbers.iter().map(|&x| x * 2).collect();
    println!("ตัวเลขหลังการคูณสอง: {:?}", doubled); // ผลลัพธ์คือ [2, 4, 6, 8, 10]
}

ในตัวอย่างนี้เราใช้ method `map` เพื่อสร้าง iterator ใหม่ที่แต่ละอีลิเมนต์เป็นผลลัพธ์จากการคูณด้วยสอง หลังจากนั้น เราใช้ `collect` เพื่อเปลี่ยน iterator กลับคืนมาเป็น `Vec`.

ตัวอย่างโค้ดที่ 3: Pattern Matching

Pattern matching เป็นฟีเจอร์ที่ทรงพลังใน Rust ที่ใช้ในการตรวจสอบโครงสร้างของข้อมูลการใช้งานคล้ายกับการทำงานของฟังก์ชัน.

 fn main() {
    let value = Some(2);

    match value {
        Some(x) if x > 1 => println!("มากกว่า 1"),
        Some(_) => println!("เท่ากับหรือน้อยกว่า 1"),
        None => println!("ไม่มีค่า"),
    }
}

ตัวอย่างนี้แสดงถึงการใช้ `match` เพื่อตรวจสอบ `Option` ว่ามีค่าข้างในหรือไม่ และแยกกรณีตามค่าที่ได้รับ

Usecase ในโลกจริง

Functional programming ใน Rust มีประโยชน์มากในการพัฒนาการคำนวณข้อมูลในระบบที่ต้องการความแม่นยำและประสิทธิภาพสูง เช่น ระบบการจัดการฐานข้อมูล, algorithm ที่สลับซับซ้อน, หรือการทำงานกับข้อมูลขนาดใหญ่โดยใช้ iterator อย่างมีประสิทธิภาพ ทีมพัฒนาสามารถเข้าถึงข้อมูลได้อย่างน่าเชื่อถือและมีการใช้ memory ที่เหมาะสม

สรุป

การเขียนโปรแกรมแบบฟังก์ชันนาลใน Rust เป็นอีกหนึ่งประเด็นที่เราไม่ควรมองข้าม บทความนี้ได้นำเสนอการใช้งาน functional programming ใน Rust ผ่านตัวอย่างโค้ดสามตัวอย่าง ทั้งนี้หากคุณต้องการศึกษาการเขียนโปรแกรมและเทคนิคใหม่ๆ ในการพัฒนาซอฟต์แวร์ทั้งในด้านทฤษฎีและปฏิบัติ EPT (Expert-Programming-Tutor) มีคอร์สที่เน้นการสอนการเขียนโปรแกรมที่ทันสมัยพร้อมด้วยโค้ชที่มีประสบการณ์พร้อมที่จะช่วยให้คุณไปถึงเป้าหมายในโลกของการเขียนโปรแกรมได้อย่างมั่นใจ ไม่ว่าคุณจะสนใจในการเขียนโปรแกรมด้วยภาษา Rust หรือภาษาอื่นๆ EPT พร้อมที่จะเป็นทางเลือกในการสื่อสานความรู้ให้แก่คุณ!

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