ชุมชนโปรแกรมเมอร์กำลังมีการถกเถียงอย่างเข้มข้นเกี่ยวกับ algebraic types ซึ่งเป็นแนวคิดพื้นฐานในการเขียนโปรแกรมที่รวมชนิดข้อมูลต่างๆ เข้าด้วยกันในรูปแบบที่มีประโยชน์ แม้ว่าบทความต้นฉบับจะอ้างว่าชนิดข้อมูลเหล่านี้ไม่น่ากลัวและสามารถเข้าใจได้ด้วยความรู้คณิตศาสตร์พื้นฐาน แต่นักพัฒนาก็แบ่งออกเป็นสองฝ่ายว่าคำศัพท์นี้สร้างอุปสรรคที่ไม่จำเป็นสำหรับผู้เริ่มต้นหรือไม่
ปัญหาการตั้งชื่อทำให้นักพัฒนาแตกแยก
โปรแกรมเมอร์หลายคนเชื่อว่าคำว่า algebraic types ฟังดูน่าหวาดกลัวมากกว่าที่ควรจะเป็น แนวคิดนี้เองค่อนข้างตรงไปตรงมา คือการรวมชนิดข้อมูลโดยใช้การดำเนินการพื้นฐานสองแบบ ซึ่งคล้ายกับการบวกและการคูณในคณิตศาสตร์ระดับประถม อย่างไรก็ตาม สมาชิกชุมชนหลายคนโต้แย้งว่าโปรแกรมเมอร์ส่วนใหญ่จำได้เพียงพีชคณิตพื้นฐานจากสมัยประถม ไม่ใช่แนวคิดทางคณิตศาสตร์ขั้นสูงที่ชื่อนี้ให้ความรู้สึก
นักพัฒนาบางคนสนับสนุนให้ใช้คำที่คุ้นเคยมากกว่า เช่น unions แทน sum types โดยชี้ให้เห็นว่าภาษายอดนิยมอย่าง Python , TypeScript และ Rust รองรับฟีเจอร์เหล่านี้อยู่แล้วภายใต้ชื่อที่แตกต่างกัน พวกเขาโต้แย้งว่าสิ่งนี้จะทำให้แนวคิดเข้าถึงได้ง่ายขึ้นสำหรับโปรแกรมเมอร์ที่ทำงานจริง ซึ่งอาจหวาดกลัวคำศัพท์ที่ฟังดูเป็นวิชาการ
ภาษาโปรแกรมที่รองรับ Union/Sum Types:
- Python (Union types)
- TypeScript (Union types)
- Kotlin (Sealed classes)
- Swift (Enums with associated values)
- PHP (Union types)
- Rust (Enums)
- C (Unions - มีข้อจำกัด)
- C++ (std::variant)
- C (จะได้รับ unions ในเวอร์ชันถัดไป)
การแลกเปลี่ยนระหว่างพลังและความซับซ้อน
การถกเถียงที่สำคัญได้เกิดขึ้นเกี่ยวกับว่าควรสร้างความซับซ้อนเข้าไปในระบบชนิดข้อมูลมากแค่ไหน นักพัฒนาบางคนกังวลว่าระบบชนิดข้อมูลที่มีพลัง แม้จะมีประโยชน์ แต่อาจซับซ้อนจนทำร้ายประสิทธิภาพการทำงาน พวกเขาชี้ไปที่ตัวอย่างที่ระบบชนิดข้อมูลกลายเป็น Turing-complete ทำให้โปรแกรมเมอร์สามารถเขียนโค้ดที่ซับซ้อนอย่างไม่น่าเชื่อ ซึ่งเข้าใจยากและอาจทำให้คอมไพเลอร์ล่มได้
ระบบชนิดข้อมูลที่มีพลังเป็นแบบนั้น คุณสามารถเขียนโปรแกรมได้เกือบทุกอย่างด้วยสิ่งที่ เช่น Go ให้คุณก่อนการอัปเดต generics แต่บางคนอาจโต้แย้งว่าต้องการสิ่งเพิ่มเติม เช่น sum types เป็นต้น
คนอื่นๆ ปกป้อง algebraic types ว่าเป็นบล็อกการสร้างที่เรียบง่ายซึ่งไม่ได้สร้างความซับซ้อนโดยธรรมชาติ พวกเขาโต้แย้งว่าปัญหาไม่ได้อยู่ที่ชนิดข้อมูลเอง แต่อยู่ที่วิธีที่โปรแกรมเมอร์บางคนสร้างระบบที่ซับซ้อนขึ้นมาบนพื้นฐานเหล่านั้น
ประโยชน์ในโลกจริงขับเคลื่อนการนำมาใช้
แม้จะมีการโต้เถียงเรื่องการตั้งชื่อ แต่นักพัฒนาก็เห็นพ้องกันอย่างกว้างขวางเกี่ยวกับประโยชน์ในทางปฏิบัติ Algebraic types ช่วยตรวจจับข้อผิดพลาดในเวลาคอมไพล์ที่อาจทำให้เกิดการล่มในเวลารันไทม์ พวกมันทำให้โค้ดเชื่อถือได้มากขึ้นโดยการรับประกันว่าโปรแกรมเมอร์จัดการกับทุกกรณีที่เป็นไปได้ในตรรกะของพวกเขา
การอภิปรายเผยให้เห็นว่าภาษาหลักหลายภาษาได้เพิ่มการรองรับแนวคิดเหล่านี้แล้ว แม้ว่าจะเรียกด้วยชื่อที่แตกต่างกัน สิ่งนี้บ่งชี้ว่าอุตสาหกรรมการเขียนโปรแกรมรับรู้ถึงคุณค่าของมัน โดยไม่คำนึงถึงว่าจะเรียกว่าอะไร
การดำเนินการของ Algebraic Type:
- Product Types: รวมชนิดข้อมูลโดยใช้ตรรกะ "AND" (เหมือนกับ structs/records)
- ตัวอย่าง: คู่ข้อมูลที่ประกอบด้วยจำนวนเต็ม AND สตริง
- จำนวนค่าทั้งหมด = ค่าของ Type1 × ค่าของ Type2
- Sum Types: รวมชนิดข้อมูลโดยใช้ตรรกะ "OR" (เหมือนกับ unions)
- ตัวอย่าง: ค่าที่เป็นได้ทั้งจำนวนเต็ม OR สตริง
- จำนวนค่าทั้งหมด = ค่าของ Type1 + ค่าของ Type2
ฟีเจอร์ที่ขาดหายไปในภาษายอดนิยม
สมาชิกชุมชนเน้นย้ำว่าการขาด sum types ที่เหมาะสมในบางภาษาบังคับให้นักพัฒนาใช้วิธีการแก้ปัญหาชั่วคราว ตัวอย่างเช่น รูปแบบการจัดการข้อผิดพลาดของ Go กำหนดให้โปรแกรมเมอร์ปฏิบัติตามแบบแผนที่ไม่ได้บังคับโดยคอมไพเลอร์ ซึ่งนำไปสู่ข้อบกพร่องที่อาจเกิดขึ้น ภาษาที่มี algebraic types ในตัวสามารถป้องกันปัญหาเหล่านี้ได้โดยอัตโนมัติ
การสนทนาแสดงให้เห็นว่าแม้แนวคิดเหล่านี้จะได้รับการยอมรับอย่างกว้างขวางมากขึ้น แต่ยังมีงานที่ต้องทำในการทำให้เข้าถึงได้สำหรับนักพัฒนาทุกคน ไม่ว่าจะผ่านการตั้งชื่อที่ดีกว่า คำอธิบายที่ชัดเจนกว่า หรือการออกแบบภาษาที่ดีขึ้น เป้าหมายยังคงเหมือนเดิม คือการทำให้เครื่องมือการเขียนโปรแกรมที่มีพลังเข้าถึงได้สำหรับทุกคน