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

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

18 functional-programming 

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

18 design  functional-programming  uml  modeling 

ดูเหมือนว่ารหัส F # มักจะจับคู่รูปแบบกับประเภท อย่างแน่นอน match opt with | Some val -> Something(val) | None -> Different() ดูเหมือนทั่วไป แต่จากมุมมองของ OOP ที่ดูน่ากลัวอย่างมากเช่นโฟลว์ควบคุมตามการตรวจสอบประเภทรันไทม์ซึ่งโดยทั่วไปแล้วจะขมวดคิ้ว หากต้องการสะกดคำใน OOP คุณอาจต้องการใช้การโหลดมากเกินไป: type T = abstract member Route : unit -> unit type Foo() = interface T with member this.Route() = printfn "Go left" type Bar() = interface …

18 object-oriented  functional-programming  f#  pattern-matching 

คำถามคือ: เครื่องปั่นไฟทำลายกระบวนทัศน์การเขียนโปรแกรมการทำงานหรือไม่? ทำไมหรือทำไมไม่? ถ้าใช่สามารถใช้เครื่องกำเนิดไฟฟ้าในการเขียนโปรแกรมเชิงหน้าที่ได้อย่างไร พิจารณาสิ่งต่อไปนี้: function * downCounter(maxValue) { yield maxValue; yield * downCounter(maxValue > 0 ? maxValue - 1 : 0); } let counter = downCounter(26); counter.next().value; // 26 counter.next().value; // 25 // ...etc downCounterวิธีการปรากฏไร้สัญชาติ เช่นกันการโทรdownCounterด้วยอินพุตเดียวกันก็จะส่งผลให้ออกเหมือนกัน อย่างไรก็ตามในเวลาเดียวกันการโทรnext()ไม่ได้ผลลัพธ์ที่สอดคล้องกัน ฉันไม่แน่ใจหรือไม่ว่าเครื่องปั่นไฟทำลายกระบวนทัศน์การเขียนโปรแกรมการทำงานเพราะในตัวอย่างนี้counterเป็นวัตถุกำเนิดไฟฟ้าและอื่น ๆ โทรจะก่อให้เกิดผลเช่นเดียวกับวัตถุกำเนิดอื่นที่สร้างขึ้นด้วยเดียวกันแน่นอนnext()maxValue เช่นกันการเรียกsomeCollection[3]ใช้อาร์เรย์จะส่งคืนองค์ประกอบที่สี่เสมอ ในทำนองเดียวกันการเรียกnext()สี่ครั้งบนวัตถุตัวสร้างจะส่งคืนองค์ประกอบที่สี่เสมอ สำหรับบริบทเพิ่มเติมคำถามเหล่านี้เพิ่มขึ้นในขณะที่ทำงานในการเขียนโปรแกรมกะตะ บุคคลที่ตอบคำถามตั้งคำถามว่าเครื่องปั่นไฟสามารถใช้ในการเขียนโปรแกรมการทำงานหรือไม่และพวกเขายังคงอยู่ในสถานะ

17 javascript  functional-programming  iterator  ecmascript 

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

17 functional-programming  pure-function 

ขออภัยสำหรับคำถามข้างเคียงอีกคำถามของ FP + แต่ฉันไม่พบคำถามที่มีอยู่ซึ่งตอบคำถามนี้ให้ฉันได้ ความเข้าใจของฉัน (จำกัด ) ของการเขียนโปรแกรมเชิงฟังก์ชันคือผลกระทบของรัฐ / ผลข้างเคียงควรถูกย่อให้เล็กสุดและแยกจากตรรกะไร้สัญชาติ ฉันยังรวบรวมวิธีการของ Haskell เพื่อทำสิ่งนี้ IO monad ประสบความสำเร็จในการทำสิ่งนี้ด้วยการห่อตัวการกระทำแบบ stateful ไว้ในคอนเทนเนอร์เพื่อการดำเนินการในภายหลังโดยพิจารณานอกขอบเขตของโปรแกรม ฉันพยายามที่จะเข้าใจรูปแบบนี้ แต่จริงๆแล้วเพื่อตรวจสอบว่าจะใช้ในโครงการ Python หรือไม่ดังนั้นต้องการหลีกเลี่ยง Haskell ถ้ามี ตัวอย่างที่เข้ามาหยาบ หากโปรแกรมของฉันแปลงไฟล์ XML เป็นไฟล์ JSON: def main(): xml_data = read_file('input.xml') # impure json_data = convert(xml_data) # pure write_file('output.json', json_data) # impure ไม่ใช่วิธีการของ IO monad ในการทำสิ่งนี้อย่างมีประสิทธิภาพ: steps …

17 python  functional-programming  state  side-effect  monad 

ในหลาย ๆ บทความที่อธิบายถึงประโยชน์ของการเขียนโปรแกรมเชิงปฏิบัติฉันได้เห็นภาษาโปรแกรมที่ใช้งานได้เช่น Haskell, ML, Scala หรือ Clojure เรียกว่า "ภาษาที่ประกาศ" ซึ่งแตกต่างจากภาษาที่จำเป็นเช่น C / C ++ / C # / Java คำถามของฉันคือสิ่งที่ทำให้ภาษาโปรแกรมการทำงานประกาศเมื่อเทียบกับความจำเป็น คำอธิบายที่พบบ่อยซึ่งอธิบายถึงความแตกต่างระหว่างการเขียนโปรแกรมเชิงประกาศและเชิงบังคับคือในการเขียนโปรแกรมเชิงบังคับคุณต้องบอกคอมพิวเตอร์ว่า "ทำอย่างไร" ซึ่งต่างจาก "สิ่งที่ต้องทำ" ในภาษาที่ประกาศ ปัญหาที่ฉันมีกับคำอธิบายนี้คือคุณกำลังทำทั้งสองอย่างในภาษาการเขียนโปรแกรมทั้งหมด แม้ว่าคุณจะลงไปที่แอสเซมบลีระดับต่ำสุดที่คุณยังบอกคอมพิวเตอร์ว่า "สิ่งที่ต้องทำ" คุณบอกซีพียูเพื่อเพิ่มตัวเลขสองตัวคุณไม่ได้บอกวิธีการเพิ่ม ถ้าเราไปที่ปลายอีกด้านหนึ่งของภาษาที่มีฟังก์ชั่นบริสุทธิ์ระดับสูงอย่าง Haskell คุณกำลังบอกคอมพิวเตอร์ว่าจะทำภารกิจเฉพาะอย่างได้อย่างไร นั่นคือสิ่งที่โปรแกรมของคุณเป็นลำดับของคำแนะนำเพื่อให้ได้งานเฉพาะซึ่งคอมพิวเตอร์ไม่ทราบว่าจะบรรลุผลได้อย่างไร ฉันเข้าใจว่าภาษาเช่น Haskell, Clojure ฯลฯ มีระดับที่สูงกว่า C / C ++ / C # / Java อย่างเห็นได้ชัดและมีคุณสมบัติเช่นการประเมินแบบขี้เกียจโครงสร้างข้อมูลที่ไม่เปลี่ยนรูปแบบฟังก์ชันที่ไม่ระบุชื่อการปิดบังโครงสร้างข้อมูลถาวร ฟังก์ชั่นการเขียนโปรแกรมเป็นไปได้และมีประสิทธิภาพ …

17 functional-programming  prolog  imperative-programming  declarative-programming 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ตลอดปีที่ผ่านมาฉันเขียนโค้ดScala (มาจากพื้นหลัง Java) ฉันชอบวิธีที่คุณสามารถสร้างรหัสที่ง่ายและสะอาดยิ่งขึ้นด้วย vals คลาส case, ฟังก์ชัน map / filter / lambda, implicits และการอนุมานประเภท ฉันใช้มันเป็นส่วนใหญ่สำหรับแอปพลิเคชันAkka ปีนี้ฉันอยู่ในโปรเจค Scala กับทีมใหม่ที่ชอบการเขียนโปรแกรมที่ใช้งานได้จริง พวกเขาใช้Scalazอย่างหนักและรหัสจะถูกเติมเต็มทุกที่ด้วยผู้สมัครขอบเขตบริบทผู้อ่าน / นักเขียน / รัฐ monad แม้วิธีการหลักคือ "พัน" ใน I / O monad เหตุผลของพวกเขาคือสิ่งนี้ทำให้คอมไพเลอร์ "ทำงานเพื่อเรา" ในการยืนยันว่ารหัสถูกต้องและแต่ละฟังก์ชั่นเป็นอิสระจากผลข้างเคียง ถึงกระนั้นจากมุมมองของฉันทุกไวยากรณ์นี้จริงๆได้รับในทางของตรรกะทางธุรกิจ ตัวอย่างเช่นประเภทของ "MyBusinessObject" นั้นใช้ได้เช่นเดียวกับประเภทเช่น "รายการ [MyBusinessObject]", "ตัวเลือก [MyBusinessObject]" …

17 functional-programming  scala 

ภาษาที่ใช้งานได้จริงหรือใกล้เคียงกับการทำงานล้วนได้รับประโยชน์จากโครงสร้างข้อมูลถาวรเนื่องจากมีความไม่เปลี่ยนรูปแบบและเหมาะสมกับรูปแบบการเขียนโปรแกรมเชิงหน้าที่ แต่ในบางครั้งเราจะเห็นไลบรารีของโครงสร้างข้อมูลถาวรสำหรับภาษา (ตามรัฐ, OOP) เช่น Java การอ้างสิทธิ์ที่มักได้ยินในความโปรดปรานของโครงสร้างข้อมูลแบบถาวรคือเนื่องจากพวกมันไม่เปลี่ยนรูปพวกมันจึงปลอดภัยต่อเธรด อย่างไรก็ตามเหตุผลที่โครงสร้างข้อมูลถาวรนั้นมีความปลอดภัยต่อเธรดคือหากเธรดหนึ่งต้องการ "เพิ่ม" องค์ประกอบให้กับคอลเลกชันถาวรการดำเนินการจะส่งกลับคอลเลกชันใหม่เช่นเดิม แต่มีองค์ประกอบที่เพิ่มเข้ามา เธรดอื่นจึงเห็นคอลเลกชันดั้งเดิม แน่นอนว่าคอลเล็กชั่นทั้งสองนี้มีสถานะภายในเป็นจำนวนมาก - นั่นคือสาเหตุที่โครงสร้างถาวรเหล่านี้มีประสิทธิภาพ แต่เนื่องจากเธรดที่แตกต่างกันเห็นสถานะของข้อมูลที่แตกต่างกันจึงดูเหมือนว่าโครงสร้างข้อมูลถาวรนั้นไม่เพียงพอที่จะจัดการกับสถานการณ์ที่เธรดหนึ่งทำการเปลี่ยนแปลงที่สามารถมองเห็นเธรดอื่นได้ สำหรับเรื่องนี้ดูเหมือนว่าเราจะต้องใช้อุปกรณ์เช่นอะตอมการอ้างอิงหน่วยความจำทรานแซคชันของซอฟต์แวร์หรือแม้กระทั่งการล็อคแบบคลาสสิกและกลไกการซิงโครไนซ์ ทำไมจึงเป็นไปไม่ได้ที่ PDSs จะกลายเป็นสิ่งที่มีประโยชน์ต่อ "ความปลอดภัยของเธรด" หรือไม่? มีตัวอย่างจริงที่ PDS ช่วยในการซิงโครไนซ์หรือแก้ไขปัญหาการทำงานพร้อมกันหรือไม่? หรือ PDS เป็นเพียงวิธีหนึ่งในการจัดหาอินเตอร์เฟสแบบไร้รัฐให้กับวัตถุเพื่อสนับสนุนสไตล์การเขียนโปรแกรมที่ใช้งานได้หรือไม่

17 functional-programming  data-structures  multithreading  concurrency 

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

17 books  functional-programming 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันเจอโครงการ Ur / Webระหว่างการค้นหากรอบงานเว็บสำหรับภาษาที่คล้ายกับ Haskell ดูเหมือนว่าโครงการที่น่าสนใจจะทำโดยคนคนหนึ่ง โดยทั่วไปมันเป็นภาษาที่ใช้งานได้เฉพาะโดเมนสำหรับการเขียนโปรแกรมเว็บโดยใช้ ML และ Haskell ได้ดีที่สุด ไวยากรณ์คือ ML แต่มีคลาสประเภทและ monad จาก Haskell และมีการประเมินอย่างเข้มงวด ฝั่งเซิร์ฟเวอร์ถูกคอมไพล์เป็นรหัสเนทีฟไคลเอนต์ถึง Javascript ดูหน้าสไลด์และคำถามที่พบบ่อยเพื่อดูข้อได้เปรียบอื่น ๆ ที่โฆษณา เมื่อดูการสาธิตและซอร์สโค้ดของพวกเขาฉันคิดว่าโปรเจ็กต์นี้มีแนวโน้มดีมาก รุ่นล่าสุดคือบางสิ่งบางอย่าง 20110123 ดังนั้นดูเหมือนว่าจะอยู่ระหว่างการพัฒนาอย่างแข็งขันในขณะนี้ มีใครที่นี่มีประสบการณ์เพิ่มเติมอีกหรือไม่ มีปัญหา / สิ่งรบกวนเมื่อเปรียบเทียบกับ Haskell นอกเหนือจากไวยากรณ์ที่ละเอียดกว่าเล็กน้อยของ ML หรือไม่

17 web-development  functional-programming  haskell  web-framework 

แนวคิดนี้ได้รับแรงบันดาลใจจากตัวดำเนินการข้อเท็จจริงเช่น +, -,%, เป็นต้นซึ่งสามารถมองเห็นได้ว่าเป็นฟังก์ชั่นที่ผ่านการโต้แย้งหนึ่งหรือสองครั้งและไม่มีผลข้างเคียง สมมติว่าฉันหรือคนอื่นเขียนภาษาที่หยุดไม่ให้มีการโต้แย้งมากกว่าสองข้อและยังใช้งานได้ผ่านการส่งคืนเท่านั้น: ก) ภาษานั้นจะทำให้เข้าใจรหัสได้ง่ายขึ้นหรือไม่ b) การไหลของรหัสจะชัดเจนขึ้นหรือไม่ (บังคับให้ทำตามขั้นตอนมากขึ้นโดยที่การโต้ตอบ 'ซ่อน' อาจมีน้อยลง c) ข้อ จำกัด จะทำให้ภาษามีขนาดใหญ่เกินไปสำหรับโปรแกรมที่ซับซ้อนมากขึ้น d) (โบนัส) ความคิดเห็นอื่น ๆ เกี่ยวกับข้อดี / ข้อเสีย บันทึก: การตัดสินใจสองครั้งจะยังคงต้องทำก่อนคืออนุญาตให้ผู้ใช้ป้อนข้อมูลนอกหลัก () หรือเทียบเท่าและสิ่งที่กฎจะเกี่ยวกับสิ่งที่เกิดขึ้นเมื่อผ่านอาร์เรย์ / โครงสร้าง ตัวอย่างเช่นหากมีคนต้องการฟังก์ชั่นเดียวที่จะเพิ่มค่าหลายค่าเขาสามารถหลีกเลี่ยงข้อ จำกัด โดยรวมมันเข้าไปในอาร์เรย์ สิ่งนี้สามารถหยุดได้โดยไม่อนุญาตให้อาร์เรย์หรือโครงสร้างจากการโต้ตอบกับตัวเองซึ่งจะช่วยให้คุณตัวอย่างเช่นหารจำนวนแต่ละจำนวนด้วยจำนวนที่แตกต่างกันขึ้นอยู่กับตำแหน่งของมัน

16 design  programming-languages  functional-programming  functions 

เมื่อเร็ว ๆ นี้ฉันได้ปัดความรู้ของฉันเกี่ยวกับวิธีการทำงานของ Monads ฉันยังได้รับการแนะนำให้รู้จักกับแนวคิดของการเป็น'Comonad'ซึ่งจะอธิบายเป็นผกผันสองของ monad อย่างไรก็ตามฉันไม่สามารถคาดศีรษะได้ เพื่อทำความเข้าใจ Monads ฉันได้ทำการเปรียบเทียบของตัวเอง: Monads สามารถมองเห็นเป็น 'พิมพ์เขียวเพื่อสร้างสายพานลำเลียงของการแสดงออก' ในการกำหนด Monad ใหม่ (ระบบสายพานแบบใหม่) คุณต้องกำหนด: วิธีวางสิ่งของบนสายพานลำเลียงเช่น 'เริ่ม' สายพาน (รู้จักในชื่อunitหรือreturn) วิธีเชื่อมต่อเครื่อง (นิพจน์) ที่จะเป็นส่วนหนึ่งของสายพานลำเลียงเข้ากับสายพาน (ที่รู้จักกันjoinหรือbindหรือ>>=) (มีการดำเนินการที่สามที่ใช้สายพานลำเลียงในปัจจุบันโยนเนื้อหาออกไปและเริ่มสายพานลำเลียงใหม่ที่รู้จักกันในนาม>>แต่ใช้งานบ่อยครั้งมาก) เพื่อให้เครื่องจักรและสายพานทำงานร่วมกันอย่างเหมาะสมคุณจะต้องตรวจสอบให้แน่ใจว่า: หากคุณใส่อะไรลงบนสายพานลำเลียงและส่งผ่านเครื่องผลลัพธ์ที่ได้ควรจะเหมือนกับเมื่อคุณส่งผ่านเครื่องด้วยตนเอง (ข้อมูลประจำตัวด้านซ้าย) หากคุณต้องการใส่สายพานลำเลียงระหว่างสายพานที่มีอยู่แล้วคุณไม่ควรท้ายด้วยสายพานลำเลียงที่มีสายพานลำเลียงอยู่ด้านบน แต่ควรเป็นสายพานที่ยาวกว่า (เอกลักษณ์ที่ถูกต้อง) มันไม่สำคัญสำหรับผลลัพธ์ถ้าคุณใช้เครื่อง A ด้วยตนเองแล้วส่งผลลัพธ์ผ่าน BC ที่เชื่อมต่อกับเครื่องลำเลียงหรือถ้าคุณใช้ AB ที่เชื่อมต่อกับเครื่องลำเลียงแล้วจากนั้นส่งผลลัพธ์ด้วยตนเองผ่าน C ในคำอื่น ๆ : (( >> = b) >> = …

16 functional-programming  monad 

บางคนบอกว่าถ้าคุณนำหลักการของ SOLID มาใช้กับสุดขั้วคุณก็จะจบลงด้วยการเขียนโปรแกรมที่ใช้งานได้ ฉันเห็นด้วยกับบทความนี้ แต่ฉันคิดว่าซีแมนทิกส์บางอย่างหายไปจากการเปลี่ยนจากส่วนต่อประสาน / วัตถุไปเป็นฟังก์ชัน / ปิดและฉันต้องการทราบว่า Function Programming สามารถลดความสูญเสียได้อย่างไร จากบทความ: นอกจากนี้หากคุณใช้หลักการแยกส่วนต่อประสาน (ISP) อย่างจริงจังคุณจะเข้าใจว่าคุณควรใช้การเชื่อมต่อแบบสวมบทบาทแทนการเชื่อมต่อส่วนหัว หากคุณผลักดันการออกแบบของคุณไปสู่อินเทอร์เฟซที่เล็กลงเรื่อย ๆ ในที่สุดคุณจะมาถึงสุดยอด Role Interface: อินเทอร์เฟซด้วยวิธีการเดียว เรื่องนี้เกิดขึ้นกับฉันมาก นี่คือตัวอย่าง: public interface IMessageQuery { string Read(int id); } ถ้าฉันใช้การพึ่งพาIMessageQueryส่วนหนึ่งของสัญญาโดยนัยคือการโทรRead(id)จะค้นหาและส่งคืนข้อความด้วย ID ที่กำหนด เปรียบเทียบสิ่งนี้กับการพึ่งพาของลายเซ็นการทำงานที่เทียบเท่า, int -> string. โดยไม่ต้องชี้นำใด ๆ ToString()เพิ่มเติมฟังก์ชั่นนี้อาจจะง่าย หากคุณดำเนินการIMessageQuery.Read(int id)ด้วยToString()ฉันอาจกล่าวหาว่าคุณถูกโค่นล้มโดยเจตนา! ดังนั้นโปรแกรมเมอร์ฟังก์ชันสามารถทำอะไรได้เพื่อรักษาซีแมนทิกส์ของอินเตอร์เฟสที่มีชื่อดี ยกตัวอย่างเช่นมันเป็นเรื่องธรรมดาที่จะสร้างประเภทเรคคอร์ดโดยมีสมาชิกคนเดียวหรือไม่? type MessageQuery = { …

16 object-oriented  functional-programming  solid 

ฉันค่อนข้างมั่นใจว่าทุกคนคุ้นเคยกับวิธีการทั่วไปของแบบฟอร์ม: T DoSomething<T>(T item) ฟังก์ชั่นนี้เรียกว่า parametrically polymorphic (PP) โดยเฉพาะอันดับ 1 PP สมมติว่าวิธีนี้สามารถแสดงโดยใช้ฟังก์ชั่นวัตถุของรูปแบบ: <T> : T -> T นั่นคือ<T>หมายความว่าใช้พารามิเตอร์ประเภทเดียวและT -> Tหมายความว่าใช้พารามิเตอร์ประเภทเดียวTและส่งกลับค่าประเภทเดียวกัน ต่อไปนี้จะเป็นฟังก์ชัน PP อันดับ 2: (<T> : T -> T) -> int ฟังก์ชั่นไม่มีพารามิเตอร์ประเภทตัวเอง แต่ใช้ฟังก์ชั่นซึ่งใช้พารามิเตอร์ประเภท คุณสามารถทำสิ่งนี้ซ้ำ ๆ ได้โดยทำรังให้ลึกและลึกขึ้นรับ PP ในระดับที่สูงกว่าและสูงกว่า คุณลักษณะนี้หายากมากในบรรดาภาษาการเขียนโปรแกรม แม้แต่ Haskell ก็ไม่อนุญาตตามค่าเริ่มต้น มันมีประโยชน์หรือไม่ มันสามารถอธิบายพฤติกรรมที่ยากที่จะอธิบายเป็นอย่างอื่นได้หรือไม่? นอกจากนี้มันหมายความว่าอะไรที่จะต้องมีความคิดมาก ? (ในบริบทนี้)

16 programming-languages  functional-programming  type-systems  generics