คำถามติดแท็ก functional-programming

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

4
หน่วยทดสอบรหัสฟังก์ชั่นแบบคงที่พิมพ์
ฉันต้องการถามคนอื่น ๆ ว่าในกรณีนี้การทดสอบหน่วยการพิมพ์แบบสแตติกทำงานได้ดีตามที่เขียนใน haskell, scala, ocaml, nemerle, f # หรือ haXe (สุดท้ายคือสิ่งที่ฉันสนใจจริงๆ แต่ฉันต้องการ แตะเข้าไปในความรู้ของชุมชนที่ใหญ่กว่า) ฉันถามสิ่งนี้เพราะจากความเข้าใจของฉัน: ด้านหนึ่งของการทดสอบหน่วยคือการมีรายละเอียดในรูปแบบที่รันได้ อย่างไรก็ตามเมื่อใช้รูปแบบการประกาศที่แมปข้อมูลจำเพาะอย่างเป็นทางการกับความหมายของภาษาเป็นไปได้หรือไม่ที่จริงแล้วมันเป็นไปได้หรือไม่ที่จะแสดงรายละเอียดในรูปแบบที่รันได้ในวิธีที่แยกจากกัน ลักษณะที่ชัดเจนของการทดสอบหน่วยคือการติดตามข้อผิดพลาดที่ไม่สามารถเปิดเผยได้ผ่านการวิเคราะห์แบบคงที่ เนื่องจากรหัสการทำงานที่ปลอดภัยประเภทนั้นเป็นเครื่องมือที่ดีในการเขียนโค้ดที่ใกล้เคียงกับที่ตัววิเคราะห์สถิตของคุณเข้าใจมากดูเหมือนว่าคุณสามารถเปลี่ยนความปลอดภัยไปสู่การวิเคราะห์แบบสถิต อย่างไรก็ตามข้อผิดพลาดง่าย ๆ เช่นการใช้xแทนy(ทั้งคู่เป็นพิกัด) ในรหัสของคุณไม่สามารถครอบคลุม ความผิดพลาดดังกล่าวอาจเกิดขึ้นในขณะที่เขียนรหัสทดสอบดังนั้นฉันไม่แน่ใจว่ามันคุ้มค่ากับความพยายามหรือไม่ การทดสอบหน่วยจะนำเสนอความซ้ำซ้อนซึ่งหมายความว่าเมื่อต้องการเปลี่ยนแปลงรหัสการใช้งานและการทดสอบที่ครอบคลุมรหัสนี้จะต้องเปลี่ยนทั้งคู่ แน่นอนว่าค่าโสหุ้ยนี้เป็นเรื่องเกี่ยวกับค่าคงที่ดังนั้นเราจึงสามารถโต้แย้งได้ว่ามันไม่สำคัญ ในความเป็นจริงในภาษาอย่าง Ruby นั้นไม่ได้เปรียบเทียบกับประโยชน์ที่ได้รับ แต่เนื่องจากการเขียนโปรแกรมเชิงฟังก์ชันที่ครอบคลุมการทดสอบหน่วยภาคพื้นดินจำนวนมากนั้นมีจุดประสงค์เพื่อให้ความรู้สึกว่าเป็นค่าใช้จ่ายที่คงที่เพียงอย่างเดียว จากนี้ฉันจะอนุมานว่าการทดสอบหน่วยค่อนข้างล้าสมัยในรูปแบบการเขียนโปรแกรมนี้ แน่นอนว่าการอ้างสิทธิ์ดังกล่าวสามารถนำไปสู่สงครามศาสนาเท่านั้นดังนั้นให้ฉันตั้งคำถามนี้ง่ายๆ เมื่อคุณใช้รูปแบบการเขียนโปรแกรมคุณใช้ขอบเขตการทดสอบแบบใดและเพราะเหตุใด (คุณหวังว่าจะได้คุณภาพสำหรับโค้ดของคุณ) หรือในทางกลับกัน: คุณมีเกณฑ์ที่คุณสามารถมีคุณสมบัติหน่วยของรหัสการทำงานแบบคงที่ตามที่ครอบคลุมโดยตัววิเคราะห์แบบคงที่และโดยไม่จำเป็นต้องครอบคลุมการทดสอบหน่วย?

6
แนะนำการตั้งโปรแกรมการทำงานในสภาพแวดล้อมการพัฒนาของคุณ [ปิด]
ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา นี่เป็นเรื่องยาว แต่ฉันจะพยายามสรุปให้ดีที่สุดเท่าที่จะทำได้ เราเป็นร้าน NET ที่เขียนซอฟต์แวร์สำหรับกองทุนประเภทต่างๆ ตัวอย่างเช่นเราเขียนซอฟต์แวร์การจัดการการเรียกร้องสุขภาพซอฟต์แวร์การจัดการบำนาญซอฟต์แวร์ 401 (k) และสิ่งอื่น ๆ ทางการเงิน ตอนนี้เรากำลังเข้าสู่อาณาจักรใหม่: อนุพันธ์และประเภทการวิเคราะห์เชิงปริมาณซึ่งดูเหมือนน่าตื่นเต้นมาก นี่คือสิ่งที่จะลงมาในอีก 8-12 เดือนข้างหน้า ตอนนี้ฉันได้เรียนรู้การเขียนโปรแกรมฟังก์ชั่นด้วยตัวเองแล้วส่วนใหญ่เป็นเพียงผิวเผินที่ใช้ภาษาต่าง ๆ ผ่านหนังสือเล่มนี้แต่ไม่เคยขุดลึกเข้าไปในนั้น ตอนนี้เนื่องจากเราเป็น. NET shop ฉันคิดว่า F # อาจเป็นทางเลือกที่ดีเพราะเราอาจใช้ประโยชน์จากไลบรารี NET. บางส่วนและความรู้ที่มีอยู่อาจเป็นไปได้ คำถามของฉันคือจะเริ่มที่ไหน ฉันมีช่วงเวลาที่ยากลำบากอย่างมากที่จะคิดออกว่าฉันควรจะไปกับ Haskell, Erlang, Scala, F # ฯลฯ พวกเขาทั้งหมดดูน่าสนใจและมีความสามารถและค่อนข้างตรงไปตรงมานี่อาจเป็นโอกาสดีที่จะแยกตัวออกจาก Microsoft มีใครมีสถานการณ์ที่คล้ายกัน? ถ้าเป็นเช่นนั้นประสบการณ์ของคุณคืออะไรที่ทำให้การทำงานเป็นไปอย่างรวดเร็วและคุณเลือกอะไรและทำไม? ฉันรู้ว่านี่เป็นคำถามที่ยิ่งใหญ่ แต่ฉันไม่รู้จักนักพัฒนาที่ใช้วิธีการทำงานในตอนนี้ดังนั้นฉันไม่มีที่อื่นที่จะหันไปนอกเหนือจาก Googling …

2
รหัส Erlang ที่สวยงาม [ปิด]
ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว ฉันพยายามเรียนรู้เพิ่มเติมเกี่ยวกับ Erlang มากกว่าโครงการของเล่นที่ฉันเล่นด้วย ด้วยเหตุนี้ผมอ่านผ่านโปรแกรม Erlangและบางส่วนของข้อมูลที่เก็บจากอาร์มสตรองในซอฟท์แว ฉันยังต้องการอ่านตัวอย่างโค้ด (ควรใช้งานจริง) ที่แสดงประเภทของสิ่งต่าง ๆ ที่คุณสามารถสร้างได้ด้วย Erlang ซึ่งอาจจะยากในภาษาอื่น ๆ นอกเหนือจาก (ฉันคิดว่า) Yawsมีตัวอย่างที่เปิดเผยต่อสาธารณชนของรหัส Erlang ที่สวยงามที่ฉันสามารถอ่านเพื่อทำความเข้าใจภาษาได้ดีขึ้นและ / หรือดูการใช้สำนวนสำหรับการสร้างภาษาต่างๆหรือไม่? ฉันไม่ได้มองหารหัสที่ "ทำให้งานสำเร็จ" แต่ใช้วิธีปฏิบัติที่น่าสงสัยหรือตัวอย่างตามบรรทัด "นี่คือวิธีที่คุณเขียนfactorialใน Erlang" ในหลอดเลือดดำเดียวกันทุกคนสามารถแนะนำวรรณคดีที่ดีสำหรับการเรียนรู้ภาษานี้ (นอกเหนือจาก "การเขียนโปรแกรม Erlang" ที่กล่าวถึง)? สำหรับการตั้งค่าสิ่งที่คุณเองเคยเรียนรู้ แต่ถ้ามีหนังสือมาตรฐานชุมชนบางเล่มให้โยนมันเข้าไปด้วย

2
ฟังก์ชั่นการเขียนโปรแกรมสำหรับซอฟต์แวร์ฝังตัว [ปิด]
ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน5 ปีที่ผ่านมา ฉันได้พูดคุยเกี่ยวกับ F # และการเขียนโปรแกรมเชิงฟังก์ชั่นกับเพื่อนเมื่อคืนที่แล้วและเขาก็ถามคำถามที่น่าสนใจกับฉัน คุณจะทำอย่างไรซอฟต์แวร์ฝังตัวในการทำงาน? ฉันหมายความว่านี่ดูเหมือนจะเป็นเรื่องที่ค่อนข้างเป็นธรรมชาติในแง่ของรหัสไร้สัญชาติ แต่ฝังตัวยังทำให้เกิดความจำเจด้วยความทรงจำและฉันก็ไม่แน่ใจในเรื่องราวของการทำงานในเรื่องนั้น มีข้อเสนอแนะเกี่ยวกับภาษาหรือแพ็คเกจสำหรับฝังตัวด้วยฟังก์ชั่น?

1
ส่วนขยายฟรีของ monad และปฏิกิริยามีความสัมพันธ์อย่างไร
ฉันมาจากพื้นหลัง C # ที่ LINQ พัฒนาเป็น Rx.NET แต่มีความสนใจใน FP เสมอ หลังจากที่ได้รู้จักกับ monads และบางโครงการใน F # ฉันก็พร้อมที่จะลองและก้าวไปอีกระดับ ตอนนี้หลังจากพูดคุยเกี่ยวกับ monad ฟรีจากผู้คนจาก Scala และการเขียนหลายครั้งใน Haskell หรือ F # ฉันได้พบไวยากรณ์พร้อมล่ามเพื่อความเข้าใจที่คล้ายกับIObservableโซ่ ใน FRP คุณเขียนคำจำกัดความการดำเนินการจากชิ้นส่วนเฉพาะของโดเมนที่เล็กลงรวมถึงผลข้างเคียงและความล้มเหลวที่อยู่ในห่วงโซ่ ใน monad ฟรีถ้าฉันเข้าใจอย่างถูกต้องคุณทำเช่นเดียวกันโดยทำให้การทำงานของคุณเป็น functors และยกพวกเขาโดยใช้ coyoneda อะไรคือความแตกต่างระหว่างทั้งสองที่เอียงเข็มไปทางใดก็ได้ อะไรคือความแตกต่างพื้นฐานเมื่อกำหนดบริการหรือโปรแกรมของคุณ

4
Monads แก้ปัญหาการเขียนโปรแกรมอะไรบ้าง? [ปิด]
ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน3 ปีที่ผ่านมา ฉันได้อ่านบทความจำนวนมากที่อธิบายว่าพระสงฆ์คืออะไรอย่างไรunitและbindทำงานอย่างไรบ้างบางคนก็ถกเถียงกันในทฤษฎีหมวดหมู่อย่างเป็นนามธรรมดังนั้น (อย่างน้อยสำหรับฉัน) ที่ทำให้ตาตกบางคนไม่สนใจสิ่งเหล่านั้น burritos กล่องและสิ่งที่ไม่ หลังจากสองสามสัปดาห์ของการศึกษาและเซลล์ประสาททอดจำนวนมาก (ฉันคิดว่า) ฉันเข้าใจว่า Monads ทำงานอย่างไร แต่ยังมีอีกสิ่งหนึ่งที่หนีความเข้าใจของฉันไปสิ่งที่โพสต์ไม่กี่สัมผัสจริง ๆ (ยกเว้น IO และรัฐ): ทำไม? ทำไม Monads ถึงมีความสำคัญ? ทำไมพวกเขาถึงสำคัญ? ปัญหาที่พวกเขากำลังแก้ไขคืออะไร ปัญหาเหล่านั้นสามารถแก้ไขได้เฉพาะกับ Monads หรือมีวิธีอื่นบ้างไหม?

3
วิธีเขียนโค้ดที่จัดการได้ด้วยฟังก์ชั่นการเขียนโปรแกรม?
ฉันเพิ่งเริ่มต้นด้วยฟังก์ชั่นการเขียนโปรแกรม (กับ JavaScript และ Node.js) และจากลักษณะของสิ่งที่ดูเหมือนว่ารหัสที่ฉันเขียนจะกลายเป็นนรกหนึ่งของรหัสฐานในการจัดการเมื่อเทียบกับภาษาโปรแกรมที่มี ประเภทของกระบวนทัศน์เชิงวัตถุ ด้วย OOP ฉันคุ้นเคยกับแนวทางปฏิบัติที่จะช่วยให้มั่นใจว่าโค้ดของคุณได้รับการจัดการและขยายได้อย่างง่ายดาย แต่ฉันไม่แน่ใจว่าของการประชุมที่คล้ายกันกับการเขียนโปรแกรมการทำงาน

5
ใครบางคนควรใช้ FP คิดว่าอ่านรหัสจำเป็น?
ฉันจบการศึกษาจากมหาวิทยาลัยเมื่อประมาณห้าเดือนที่แล้วและทำงานในท้องถิ่นเมื่อสี่เดือนที่ผ่านมา ขณะอยู่ที่มหาวิทยาลัยฉันเรียน Haskell, F # และอื่น ๆ ด้วยตัวเอง เราถูกสอน Java ที่มหาวิทยาลัย แต่ฉันได้สัมผัสกับการเขียนโปรแกรมการทำงานเร็ว ๆ นี้และใช้เวลากับมันมากกว่าที่ฉันทำกับการเขียนโปรแกรมที่จำเป็น เป็นผลให้สมองของฉันมีสายสำหรับการคิดการทำงาน บริษัท ที่ฉันเข้าร่วมใช้ Python และรหัสมีความจำเป็นอย่างยิ่ง ฉันมีเวลายากมากที่จะอ่านโค้ดที่จำเป็น ฉันไม่สามารถติดตามการกลายพันธุ์ เมื่อการทำ for-if-else-for-... การซ้อนกันมีความลึกมากกว่าสี่ระดับฉันจะสูญเสียการติดตามสิ่งที่เกิดขึ้นในโค้ดอย่างสมบูรณ์ เพื่อเพิ่มเข้าไป Python เป็นภาษาแบบไดนามิกดังนั้นจึงไม่มีประเภทในรหัส มัน' หลายสัปดาห์มาแล้วที่ฉันพยายามทำความเข้าใจส่วนหนึ่งของ codebase ของเรา (ซึ่งค่อนข้างซับซ้อนพอสมควร) แต่ฉันไม่ได้ทำความคืบหน้าใด ๆ เพื่อทำความเข้าใจ กรุณาเสนอเทคนิคการปฏิบัติเกี่ยวกับวิธีที่ฉันควรจะไปเกี่ยวกับการทำความเข้าใจรหัสที่ ขอบคุณล่วงหน้า! แก้ไข: บางทีฉันควรพูดถึงว่ามีความคิดเห็นไม่มากในรหัสและชื่อยังไม่ง่ายนัก

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

4
กระบวนทัศน์การทำงานไม่แตกต่างกันมากเกินไปกับฮาร์ดแวร์พื้นฐานที่จะมีประสิทธิภาพโดยทั่วไป?
แรงบันดาลใจจากคำถามจาก SO: /programming/6623391/how-to-gain-control-of-a-5gb-heap-in-haskell มันอาจเป็นการถกเถียงกันมานานเกี่ยวกับข้อดีและข้อเสียของ FP มากมาย แต่สำหรับตอนนี้ฉันต้องการ จำกัด ขอบเขตของ FP ที่มีประสิทธิภาพหลักสำหรับฮาร์ดแวร์ที่ทันสมัย วิทยานิพนธ์: กระบวนทัศน์การใช้งานหมายถึงความไม่สามารถเปลี่ยนแปลงได้และไร้สัญชาติ (?) แต่ฮาร์ดแวร์ที่เราเรียกใช้โปรแกรมการทำงานนั้นเป็นสถานะออโตมาต้าอัน จำกัด การแปลโปรแกรม 'ฟังก์ชั่นที่ใช้งานได้จริง' เป็น 'การแสดงสถานะฮาร์ดแวร์' ทำให้การควบคุมเพียงเล็กน้อยสำหรับโปรแกรมเมอร์ทำให้โอเวอร์เฮด (?) และ จำกัด การใช้ความสามารถของฮาร์ดแวร์ ฉันถูกหรือผิดในข้อความที่ถาม? มันสามารถพิสูจน์ได้ว่า FP ทำ / ไม่ได้บอกถึงการลงโทษด้านประสิทธิภาพที่สำคัญของสถาปัตยกรรมคอมพิวเตอร์ที่มีวัตถุประสงค์ทั่วไปที่ทันสมัยหรือไม่? แก้ไข: ตามที่ฉันได้กล่าวแล้วในการตอบสนองต่อความคิดเห็นบางคำถามไม่ได้เกี่ยวกับประสิทธิภาพการใช้งานและรายละเอียด มันเกี่ยวกับการมีอยู่หรือไม่มีค่าโสหุ้ยหลักที่ใช้ FP กับออโตมาตะแบบ stateful อาจนำมาซึ่ง

3
การเขียนโปรแกรมใช้งานและการผจญภัยข้อความ
นี่เป็นคำถามเชิงทฤษฎีส่วนใหญ่เกี่ยวกับ FP แต่ฉันจะผจญภัยข้อความ (เช่น Zork โรงเรียนเก่า) เพื่อแสดงจุดของฉัน ฉันต้องการทราบความคิดเห็นของคุณเกี่ยวกับวิธีจำลองสถานการณ์จำลองด้วย FP การผจญภัยข้อความดูเหมือนจะเรียก OOP ตัวอย่างเช่น "ห้อง" ทั้งหมดเป็นอินสแตนซ์ของRoomคลาสคุณสามารถมีItemคลาสพื้นฐานและอินเทอร์เฟซที่เหมือนกับItem<Pickable>สิ่งที่คุณสามารถพกพาไปเรื่อย ๆ การสร้างแบบจำลองโลกใน FP ทำงานแตกต่างกันโดยเฉพาะอย่างยิ่งถ้าคุณต้องการบังคับให้เปลี่ยนแปลงในโลกที่ต้องกลายพันธุ์ในขณะที่เกมดำเนินไป (วัตถุถูกย้ายศัตรูพ่ายแพ้การให้คะแนนเพิ่มขึ้น ฉันนึกภาพวัตถุชิ้นใหญ่ชิ้นเดียวWorldที่มีทุกอย่าง: มีห้องอะไรบ้างที่คุณสามารถสำรวจได้ว่ามันเชื่อมโยงกันอย่างไรสิ่งที่ผู้เล่นกำลังแบกคันโยกที่ถูกกระตุ้น ฉันคิดว่าวิธีการที่บริสุทธิ์จะส่งวัตถุขนาดใหญ่นี้ไปยังฟังก์ชันใด ๆ และให้พวกเขาส่งคืน (อาจแก้ไข) ตัวอย่างเช่นฉันมีmoveToRoomฟังก์ชั่นที่รับWorldและส่งคืนพร้อมWorld.player.locationเปลี่ยนเป็นห้องใหม่World.rooms[new_room].visited = Trueและอื่น ๆ แม้ว่านี่จะเป็นวิธีที่ "ถูกต้อง" มากกว่า แต่ก็ดูเหมือนว่าจะมีการบังคับใช้ความบริสุทธิ์เพื่อประโยชน์ของมัน ขึ้นอยู่กับภาษาการเขียนโปรแกรมการส่งผ่านWorldวัตถุที่มีขนาดใหญ่มากไปมาอาจมีราคาแพง นอกจากนี้ทุกฟังก์ชั่นอาจต้องมีการเข้าถึงWorldวัตถุใด ๆ ตัวอย่างเช่นห้องอาจเข้าถึงได้หรือไม่ขึ้นอยู่กับคันโยกที่ถูกเรียกในห้องอื่นเพราะอาจถูกน้ำท่วม แต่หากผู้เล่นมีเสื้อชูชีพก็สามารถเข้าได้ สัตว์ประหลาดอาจก้าวร้าวหรือไม่ขึ้นอยู่กับว่าผู้เล่นสังหารญาติของเขาในห้องอื่น ซึ่งหมายความว่าroomCanBeEnteredฟังก์ชั่นความต้องการที่จะเข้าถึงWorld.player.invetoryและWorld.rooms, describeMonsterความต้องการในการเข้าถึงWorld.monstersและอื่น ๆ (โดยทั่วไปคุณต้องผ่านภาระทั้งหมดไปรอบ ๆ ) นี่ดูเหมือนว่าฉันจะเรียกตัวแปรทั่วโลกถึงแม้ว่านี่จะเป็นรูปแบบการเขียนโปรแกรมที่ดีโดยเฉพาะใน FP คุณจะแก้ปัญหานี้อย่างไร

8
ทำไมไวยากรณ์ภาษาที่ใช้งานไม่ได้ใกล้เคียงกับภาษามนุษย์มากกว่า?
ฉันสนใจการเขียนโปรแกรมการทำงานและตัดสินใจที่จะเข้าร่วมกับ Haskell หัวของฉันเจ็บ ... แต่ในที่สุดฉันก็จะได้รับ ... ฉันมีความอยากรู้อยากเห็นหนึ่งทำไมทำไมไวยากรณ์ถึงคลุมเครือ (ขาดคำอื่น) มีเหตุผลทำไมมันไม่แสดงออกเพิ่มเติมใกล้กับภาษามนุษย์? ฉันเข้าใจว่า FP นั้นเก่งในการสร้างแบบจำลองแนวคิดทางคณิตศาสตร์และมันยืมบางส่วนของวิธีการแสดงออกที่กระชับ แต่ก็ยังไม่ใช่คณิตศาสตร์ ... เป็นภาษา

2
โค้ดตัวอย่างเพื่ออธิบายปัญหา Banana Monkey Jungle โดย Joe Armstrong [ปิด]
ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน2 ปีที่ผ่านมา ในหนังสือโคเดอร์ในที่ทำงาน Joe Armstrong ระบุว่า: ฉันคิดว่าการขาดความสามารถในการนำกลับมาใช้ใหม่เป็นภาษาเชิงวัตถุไม่ใช่ภาษาที่ใช้งานได้ เนื่องจากปัญหาเกี่ยวกับภาษาเชิงวัตถุคือพวกเขามีสภาพแวดล้อมโดยนัยทั้งหมดที่พวกเขามีอยู่ คุณต้องการกล้วย แต่สิ่งที่คุณได้รับคือกอริลลาที่ถือกล้วยและป่าทั้งหมด ฉันไม่ได้รับมันมากที่นี่ หากปัญหาคือการได้รับกล้วยเราสามารถสรุปเหตุผลทั้งหมดที่อยู่เบื้องหลังฟังก์ชั่น 'getBanana' ลิงและป่ามีส่วนเกี่ยวข้องอย่างไรในบริบทนี้ ใครบางคนสามารถเขียนโค้ดขนาดสั้นที่อธิบายถึงปัญหาในวิธีที่เข้าใจง่ายขึ้นพูดแสดงให้เห็นถึงความจริงที่ว่าBananaวัตถุนั้นต้องการMonkeyและJungleวัตถุที่จะเริ่มต้นได้โปรด

3
เป็นไปได้ไหมที่จะมีฟังก์ชั่นการแกงและการแปรผันในเวลาเดียวกัน?
ฉันกำลังคิดเกี่ยวกับการทำให้ฟังก์ชั่นการแกงและการเปลี่ยนแปลงทั้งสองมีอยู่ในภาษาการเขียนโปรแกรมฟังก์ชั่นแบบไดนามิก แต่ฉันสงสัยว่ามันเป็นไปได้หรือไม่ นี่คือรหัสเทียมบางส่วน: sum = if @args.empty then 0 else @args.head + sum @args.tail ซึ่งคาดว่าจะรวมข้อโต้แย้งของมันทั้งหมด แล้วถ้าตัวเองจะได้รับการรักษาเป็นจำนวนมากแล้วผลที่ได้คือsum 0ตัวอย่างเช่น, sum + 1 เท่ากับ 1 โดยสมมติว่า+สามารถใช้กับตัวเลขได้ อย่างไรก็ตามแม้sum == 0จะเป็นจริงsumจะยังคงรักษาคุณค่าและคุณสมบัติการทำงานของมันไม่ว่าจะมีอาร์กิวเมนต์เท่าใด (เช่น "นำไปใช้บางส่วน" และ "variadic" ในเวลาเดียวกัน) ตัวอย่างเช่นถ้าฉันประกาศ g = sum 1 2 3 จากนั้นgเท่ากับ6แต่เรายังคงสามารถใช้ต่อไปgได้ ตัวอย่างเช่นg 4 5 == 15เป็นจริง ในกรณีนี้เราไม่สามารถแทนที่วัตถุgด้วยตัวอักษร6เพราะแม้ว่าพวกเขาให้ค่าเดียวกันเมื่อถือว่าเป็นจำนวนเต็มพวกเขามีรหัสที่แตกต่างกันภายใน หากการออกแบบนี้ถูกใช้ในภาษาการเขียนโปรแกรมจริงมันจะทำให้เกิดความสับสนหรือความกำกวมหรือไม่?

6
ฟีเจอร์ของฟังก์ชั่นอะไรที่คุ้มค่ากับความสับสน OOP เล็กน้อยเพื่อประโยชน์ที่พวกเขานำมา?
หลังจากเรียนรู้การเขียนโปรแกรมที่ใช้งานได้ใน Haskell และ F # กระบวนทัศน์ OOP ดูเหมือนว่าจะย้อนกลับไปพร้อมกับคลาสอินเทอร์เฟซวัตถุ FP ด้านใดที่ฉันสามารถนำไปใช้ในการทำงานที่เพื่อนร่วมงานของฉันสามารถเข้าใจได้ สไตล์ FP ใด ๆ ที่ควรค่าแก่การพูดคุยกับเจ้านายของฉันเกี่ยวกับการฝึกสอนทีมของฉันใหม่ ลักษณะที่เป็นไปได้ของ FP: การเปลี่ยนไม่ได้ การประยุกต์ใช้บางส่วนและการแกง ฟังก์ชั่นชั้นหนึ่ง (ตัวชี้ฟังก์ชั่น / วัตถุการทำงาน / รูปแบบกลยุทธ์) การประเมินผลขี้เกียจ (และ Monads) ฟังก์ชั่นบริสุทธิ์ (ไม่มีผลข้างเคียง) นิพจน์ (เทียบกับข้อความ - แต่ละบรรทัดของโค้ดจะสร้างค่าแทนหรือนอกเหนือจากการทำให้เกิดผลข้างเคียง) recursion การจับคู่รูปแบบ มันเป็นฟรีสำหรับทุกสิ่งที่เราสามารถทำอะไรก็ได้ที่ภาษาโปรแกรมรองรับจนถึงขีด จำกัด ที่ภาษานั้นรองรับหรือไม่ หรือมีแนวทางที่ดีกว่า

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.