ควรใช้ภาษาการเขียนโปรแกรมเชิงฟังก์ชันเมื่อใด

ในสถานการณ์ใดที่ฉันควรเลือกใช้ภาษาโปรแกรมที่ใช้งานได้กับภาษาเชิงวัตถุแบบละเอียดเช่น C ++, C # หรือ Java

ฉันเข้าใจว่าการเขียนโปรแกรมเชิงฟังก์ชันคืออะไรสิ่งที่ฉันไม่เข้าใจจริงๆคือปัญหาประเภทใดจึงเป็นทางออกที่สมบูรณ์แบบ?

ในความคิดของฉันภาษาที่ใช้งานได้ดีสำหรับสองสิ่งหลัก ๆ คือ AI เกมและการคำนวณทางคณิตศาสตร์ เป็นสิ่งที่ดีในเกม AIs เนื่องจากมีการปรับแต่งรายการที่ดี (อย่างน้อยใน Lisp และ Scheme) และสำหรับการคำนวณทางคณิตศาสตร์เนื่องจากไวยากรณ์ของมัน Scheme, Lisp และ Haskell มีไวยากรณ์ที่ทำให้การคำนวณทางคณิตศาสตร์ง่ายต่อการอ่าน สิ่งสุดท้ายที่ฉันต้องเพิ่มคือภาษาที่ใช้งานได้เป็นภาษาที่สนุกมาก หลักสูตรโครงการของฉันเป็นหนึ่งในหลักสูตรที่ฉันสนุกที่สุด

ฉันได้ทำการค้นคว้าเกี่ยวกับเรื่องนี้ด้วยตัวเองและคิดว่าฉันอาจเพิ่ม CONCURRENCY ลงในรายการเหตุผลในการใช้ภาษาที่ใช้งานได้ ดูว่าในบางจุดความเร็วโปรเซสเซอร์ในอนาคตอันใกล้จะไม่สามารถเพิ่มขึ้นได้โดยใช้เทคโนโลยี cpu เดียวกัน ฟิสิกส์ของสถาปัตยกรรมไม่ยอมให้ทำ

นั่นคือที่มาของการประมวลผลพร้อมกัน

น่าเสียดายที่ภาษา OOP ส่วนใหญ่ไม่สามารถใช้ประโยชน์จากโปรเซสเซอร์หลายตัวพร้อมกันได้เนื่องจากการพึ่งพาซึ่งกันและกันระหว่างข้อมูล

ในภาษาโปรแกรมที่ใช้งานได้จริงคอมพิวเตอร์สามารถเรียกใช้ฟังก์ชันสองฟังก์ชัน (หรือมากกว่านั้น) พร้อมกันได้เนื่องจากฟังก์ชันเหล่านี้ไม่ได้เปลี่ยนแปลงข้อมูลสถานะภายนอก

นี่คือบทความที่ยอดเยี่ยมเกี่ยวกับการเขียนโปรแกรมเชิงฟังก์ชันที่คุณอาจชอบ

เพื่อนคนหนึ่งของฉันอ้างถึงอาจารย์ในวิทยาลัยของเขาคนหนึ่งว่า:

วาดเส้นตารางที่มีชนิดข้อมูลอยู่ด้านบนและดำเนินการกับประเภทข้อมูลเหล่านั้นทางด้านซ้าย ถ้าคุณตัดตารางในแนวตั้งแสดงว่าคุณกำลังทำ OO ถ้าคุณตัดกริดในแนวนอนแสดงว่าคุณกำลังทำ FP

คำตอบของฉันคือ FP เป็นวิธีการเขียนโปรแกรมที่ใช้งานได้อย่างสมบูรณ์โดยมีแอปพลิเคชันที่หลากหลายพอ ๆ ฉันคิดว่าคำถามที่สำคัญกว่าคือ:

1. คุณมีเวลาลงทุนในการเรียนรู้สัญกรณ์ใหม่และวิธีคิดใหม่ ๆ หรือไม่?
2. ภาษาใดที่คุณกำลังพิจารณาว่ามีไลบรารีที่สมบูรณ์เพียงพอที่คุณจะไม่ติดขัดในการคิดค้นนวัตกรรมใหม่ ๆ

สำหรับคำถามแรกหากคุณทำสิ่งนี้เพื่อประโยชน์ในการเรียนรู้เป็นหลักฉันขอแนะนำให้ดูที่Haskellเนื่องจากมีสื่อสนับสนุนมากมาย (หนังสือบทความชุมชนที่ใช้งานอยู่ ฯลฯ )

สำหรับคำถามที่สอง Haskell มีไลบรารีที่หลากหลาย (แม้ว่าบางแห่งจะโตกว่าคนอื่น ๆ ) แต่Scala (ภาษาที่ใช้งาน OO แบบไฮบริดที่ทำงานบน JVM) มีข้อดีที่คุณสามารถค่อยๆเปลี่ยนไปใช้รูปแบบการทำงานได้มากขึ้น และคุณมีไลบรารี Java ที่เข้าถึงได้ทั้งหมดสำหรับคุณ

ในทางปฏิบัติทุกอย่างที่คุณสามารถทำได้ใน PP สามารถทำได้ใน FP และสิ่งเดียวกันในทางกลับกัน เป็นอีกวิธีหนึ่งในการเขียนโค้ดบางอย่างซึ่งเป็นอีกมุมมองหนึ่งของปัญหาและวิธีอื่นในการแก้ไข

อย่างไรก็ตามเนื่องจากมีคนไม่มากที่ใช้ FP ปัญหาจึงเป็นเรื่องของการขาดไลบรารีที่ดีความสามารถในการพกพา / การบำรุงรักษา (เนื่องจากผู้ดูแลมีโอกาสที่จะเข้าใจสิ่งที่เขียนใน C ++ มากกว่า Scheme) และการขาดเอกสารและชุมชน ฉันรู้ว่ามีเอกสารบางอย่างอย่างไรก็ตามเปรียบเทียบกับ C ++, C # หรือ Java แล้วคุณจะเข้าใจว่าฉันหมายถึงอะไร

อย่างไรก็ตามหากคุณต้องการทำ FP จริงๆคุณสามารถใช้ลักษณะนี้ได้แม้ใน C ++ และ C # แน่นอนว่ามันจะไม่ใช่ FP 100% หากคุณใช้ไลบรารีมาตรฐาน น่าเสียดายที่ฉันไม่คิดว่า C # ได้รับการปรับให้เหมาะกับการใช้งานการเขียนโปรแกรมและอาจสร้างปัญหาด้านประสิทธิภาพมากมาย

นี่เป็นโพสต์ส่วนตัวมากกว่าสิ่งที่ฉันคิดเกี่ยวกับ FP ไม่ใช่การประกาศอย่างเข้มงวด

ภาษาที่ใช้งานได้ดีในหลาย ๆ สถานการณ์ ขึ้นอยู่กับไลบรารีของภาษาที่ใช้งานได้เฉพาะ

คุณจะตอบคำถาม "เมื่อใดควรใช้ภาษาโปรแกรมเชิงวัตถุ"?

แม้ว่านี่จะเป็นค่อนข้างคำถามอัตนัยฉันต้องการเพียงเพื่อเพิ่มว่าภาษาที่จะใช้ในการทำงานจำนวนมากที่จะแยกวิเคราะห์ภาษาเฉพาะโดเมน ; ลักษณะการทำงานช่วยให้สามารถแยกวิเคราะห์ไวยากรณ์ได้ดี

จากสิ่งที่ฉันเห็นมันเป็นเรื่องของรสนิยมมากกว่าฟังก์ชั่นการใช้งาน (ไม่ได้ตั้งใจเล่น) ไม่มีอะไรเกี่ยวกับรูปแบบของภาษาที่ทำให้งานเฉพาะเจาะจงดีขึ้นหรือแย่ลง

โดยทั่วไปให้ใช้ภาษาที่ง่ายที่สุดในการแสดงวิธีแก้ปัญหา สำหรับการเขียนโปรแกรมเชิงฟังก์ชันนี่คือเมื่อการแก้ปัญหานั้นแสดงออกมาในรูปของฟังก์ชันได้อย่างง่ายดายดังนั้นชื่อ โดยทั่วไปจะดีสำหรับการดำเนินการทางคณิตศาสตร์ AI การจับคู่รูปแบบ โดยทั่วไปสิ่งที่สามารถแบ่งออกเป็นชุดของกฎที่ต้องใช้เพื่อให้ได้คำตอบ คุณสามารถกำหนดภาษาที่ "ดีที่สุด" ที่จะใช้หลังจากที่คุณวิเคราะห์ปัญหาของคุณได้เพียงพอแล้ว นี่คือจุดที่รหัสหลอกมีประโยชน์ หากคุณพบว่าตัวเองกำลังเขียนโค้ดหลอกที่ดูเหมือน FP ให้ใช้ FP

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

โปรดทราบว่าเป็นไปได้ที่จะเลียนแบบ FP ภายในภาษา OO ผ่าน API ที่ออกแบบมาอย่างชาญฉลาด ตัวอย่างเช่นฉันเคยเห็นไลบรารี Java จำนวนมาก (JMock เป็นตัวอย่างหนึ่ง) ที่ใช้วิธีการผูกมัดเพื่อจำลอง FP DSL จากนั้นคุณจะเห็นโครงสร้างเช่น:

logger.expects(once()).method("error") .with( and(stringContains(action),stringContains(cause)) );

โดยพื้นฐานแล้วจะสร้างฟังก์ชันที่ได้รับการประเมินเพื่อพิจารณาว่าลำดับการเรียกบนวัตถุจำลองนั้นถูกต้องหรือไม่ (ตัวอย่างที่ขโมยมาจากhttp://www.jmock.org/yoga.html )

ไวยากรณ์คล้าย FP ในภาษา OO อื่นคือการใช้การปิดเช่นใน Ruby

ฉันคิดว่าโพสต์ก่อนหน้านี้ถูกต้องนี่เป็นรายการสั้น ๆ การเขียนโปรแกรมเชิงฟังก์ชันเป็นโซลูชันที่สมบูรณ์แบบสำหรับสิ่งต่อไปนี้:

• การประมวลผลแบบไร้สัญชาติ
• สมการทางคณิตศาสตร์รวมถึง ML (Machine Learning)
• กระบวนการที่ไม่เปลี่ยนรูป
• เมื่อคุณต้องการการทำงานพร้อมกันที่ปรับขนาดได้