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

ฉันมาจากพื้นหลังเชิงวัตถุที่ฉันได้เรียนรู้ว่าชั้นเรียนหรืออย่างน้อยสามารถใช้เพื่อสร้างเลเยอร์ของสิ่งที่เป็นนามธรรมซึ่งช่วยให้สามารถรีไซเคิลรหัสได้อย่างง่ายดายซึ่งสามารถนำไปใช้เพื่อสร้างวัตถุหรือใช้ในการสืบทอด ตัวอย่างเช่นฉันสามารถมีคลาสสัตว์และจากนั้นแมวและสุนัขที่สืบทอดและเช่นนั้นทั้งหมดสืบทอดลักษณะเดียวกันจำนวนมากและจากชั้นย่อยเหล่านั้นฉันสามารถสร้างวัตถุที่สามารถระบุสายพันธุ์ของสัตว์หรือแม้แต่ชื่อ ของมัน หรือฉันสามารถใช้คลาสเพื่อระบุหลายอินสแตนซ์ของรหัสเดียวกันที่จัดการหรือมีสิ่งต่าง ๆ เล็กน้อย เช่นโหนดใน search-tree หรือการเชื่อมต่อฐานข้อมูลที่แตกต่างกันหลายอย่างและสิ่งใดที่ไม่ ฉันเพิ่งจะเข้าสู่การเขียนโปรแกรมเพื่อการทำงานดังนั้นฉันจึงเริ่มสงสัยว่า: ภาษาที่ใช้งานได้จริงจะจัดการกับสิ่งเหล่านี้ได้อย่างไร นั่นคือภาษาที่ไม่มีแนวคิดของคลาสและวัตถุ

23 object-oriented  functional-programming  class 

คำศัพท์เหล่านี้ถูกกล่าวถึงในหลักสูตรมหาวิทยาลัยของฉัน googling อย่างรวดเร็วชี้ให้ฉันเห็นเอกสารจากมหาวิทยาลัยบางส่วน แต่ฉันกำลังมองหาคำอธิบายง่ายๆ

22 functional-programming  haskell 

โครงสร้างข้อมูลใดที่คุณสามารถใช้เพื่อให้คุณสามารถลบและแทนที่ O (1) หรือคุณจะหลีกเลี่ยงสถานการณ์เมื่อคุณต้องการโครงสร้างดังกล่าวได้อย่างไร

22 functional-programming  data-structures 

ฉันสังเกตเห็นว่าภาษาที่ใช้งานได้ส่วนใหญ่ใช้ลิสต์ที่เชื่อมโยงเดี่ยว ๆ (รายการ "ข้อเสีย") เป็นประเภทลิสต์พื้นฐานที่สุด ตัวอย่าง ได้แก่ Common LISP, Haskell และ F # สิ่งนี้แตกต่างจากภาษากระแสหลักโดยที่ประเภทรายการเนทีฟเป็นอาร์เรย์ ทำไมถึงเป็นอย่างนั้น? สำหรับ Common LISP (ถูกพิมพ์แบบไดนามิก) ฉันเข้าใจว่าข้อเสียนั้นเป็นเรื่องทั่วไปมากพอที่จะเป็นฐานของรายการต้นไม้และอื่น ๆ นี่อาจเป็นเหตุผลเล็กน้อย สำหรับภาษาที่พิมพ์แบบสแตติกฉันไม่สามารถหาเหตุผลที่ดีได้ฉันยังสามารถหาข้อโต้แย้งได้ ฟังก์ชั่นการใช้งานช่วยส่งเสริมการเปลี่ยนแปลงไม่ได้ดังนั้นความง่ายในการแทรกของรายการที่เชื่อมโยงจึงเป็นข้อได้เปรียบน้อยกว่า รูปแบบการใช้งานช่วยกระตุ้นการใช้งานไม่ได้ดังนั้นยังใช้ข้อมูลร่วมกัน อาเรย์จะแบ่งปัน "บางส่วน" ได้ง่ายกว่ารายการที่ลิงก์ คุณสามารถทำการจับคู่รูปแบบในอาร์เรย์ปกติได้เช่นกันและดียิ่งขึ้น (เช่นคุณสามารถพับจากขวาไปซ้ายได้อย่างง่ายดาย) ยิ่งไปกว่านั้นคุณจะได้รับการเข้าถึงแบบสุ่มฟรี และ (ข้อได้เปรียบในทางปฏิบัติ) หากพิมพ์ภาษาแบบคงที่คุณสามารถใช้เค้าโครงหน่วยความจำปกติและเพิ่มความเร็วจากแคช เหตุใดจึงชอบรายการที่เชื่อมโยง

22 programming-languages  functional-programming  list  linked-list 

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

22 programming-languages  python  functional-programming 

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

22 functional-programming  paradigms 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัพเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน5 ปีที่ผ่านมา มาจากพื้นหลังการเขียนโปรแกรมตามขั้นตอน / OO ฉันมักจะเขียนโปรแกรม Scheme ตามขั้นตอน ฉันจะถูกขัดจังหวะในการเรียนรู้โครงการหรือเสียงกระเพื่อมในการทำงานจากพื้นดินขึ้นมาเพื่อรีเซ็ตความคิดของโปรแกรมเมอร์ของฉัน มีแบบฝึกหัดหรือหนังสือที่มีมาตรฐาน de-facto สำหรับการอธิบายวิธีปฏิบัติที่ดีที่สุดวิธีการออกแบบและข้อมูลที่เป็นประโยชน์อื่น ๆ เกี่ยวกับแนวคิดการเขียนโปรแกรมการทำงาน? หนังสือเล่มไหนที่ทำให้มันพิเศษ?

22 books  functional-programming  lisp  scheme 

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

21 design-patterns  unit-testing  functional-programming  dependency-injection 

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

21 functional-programming  concurrency  state 

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

21 math  scala  functional-programming 

ฉันมักจะพบว่าตัวเองกำลังเขียนฟังก์ชั่นที่มีลักษณะเช่นนี้เพราะพวกเขาทำให้ฉันสามารถเข้าถึงข้อมูลได้อย่างง่ายดายและยังมีลายเซ็นที่ยอมรับพารามิเตอร์เพื่อกำหนดข้อมูลที่จะเข้าถึง public static string GetFormattedRate( Func<string, RateType>> getRate, string rateKey) { var rate = getRate(rateKey); var formattedRate = rate.DollarsPerMonth.ToString("C0"); return formattedRate; } หรือ public static string GetFormattedRate( Func<RateType, string> formatRate, Func<string, RateType>> getRate, string rateKey) { var rate = getRate(rateKey); var formattedRate = formatRate(rate); return formattedRate; } จากนั้นฉันก็ใช้สิ่งนี้: using FormatterModule; …

20 c#  architecture  functional-programming 

ฉันตัดสินใจที่จะทำหน้าที่ของการเรียนรู้การเขียนโปรแกรมการทำงาน จนถึงตอนนี้มันช่างระเบิดและฉันก็ 'เห็นแสงสว่าง' เหมือนเดิม น่าเสียดายที่ฉันไม่รู้จักโปรแกรมเมอร์ที่ใช้งานจริงใด ๆ ที่ฉันสามารถตอบคำถามได้ ขอแนะนำ Stack Exchange ฉันกำลังเรียนหลักสูตรการพัฒนาเว็บ / ซอฟต์แวร์ แต่ผู้สอนของฉันไม่คุ้นเคยกับการเขียนโปรแกรมที่ใช้งานได้ เขาสบายดีกับฉันที่ใช้มันและเขาแค่ขอให้ฉันช่วยให้เขาเข้าใจว่ามันทำงานอย่างไรเพื่อให้เขาสามารถอ่านรหัสของฉันได้ดีขึ้น ฉันตัดสินใจว่าวิธีที่ดีที่สุดในการทำเช่นนี้คือการแสดงฟังก์ชั่นทางคณิตศาสตร์อย่างง่ายเช่นการเพิ่มคุณค่าให้กับพลัง ในทางทฤษฎีฉันสามารถทำได้อย่างง่ายดายด้วยฟังก์ชันที่สร้างไว้ล่วงหน้า แต่นั่นจะเอาชนะวัตถุประสงค์ของตัวอย่างได้ อย่างไรก็ตามฉันมีปัญหาในการหาวิธีการเก็บค่า ตั้งแต่นี่คือการเขียนโปรแกรมการทำงานฉันไม่สามารถเปลี่ยนตัวแปร หากฉันต้องเขียนโค้ดแบบนี้มันจะมีลักษณะดังนี้: (ต่อไปนี้เป็นรหัสเทียมทั้งหมด) f(x,y) { int z = x; for(int i = 0, i < y; i++){ x = x * z; } return x; } ในการเขียนโปรแกรมการใช้งานฉันไม่แน่ใจ นี่คือสิ่งที่ฉันมาด้วย: f(x,y,z){ if z …

20 functional-programming  pseudocode 

เป็นสถาปัตยกรรมระบบตัวแทน Entityเชิงวัตถุโดยความหมาย? ดูเหมือนว่าฉันหรือขั้นตอนการทำงานมากขึ้น ความคิดเห็นของฉันคือมันไม่ได้ป้องกันคุณจากการใช้งานในภาษา OO แต่มันจะไม่เป็นเรื่องแปลกที่จะทำเช่นนั้นในทาง OO อย่างแข็งขัน ดูเหมือนว่า ECS จะแยกข้อมูล (E & C) ออกจากพฤติกรรม (S) เป็นหลักฐาน : แนวคิดคือไม่มีวิธีการฝังเกมในเอนทิตี และ : ส่วนประกอบประกอบด้วยชุดข้อมูลขั้นต่ำที่จำเป็นสำหรับวัตถุประสงค์เฉพาะ ระบบคือฟังก์ชั่นวัตถุประสงค์เดียวที่ใช้ชุดของเอนทิตีที่มีองค์ประกอบเฉพาะ ฉันคิดว่านี่ไม่ใช่เชิงวัตถุเพราะส่วนใหญ่ของการมุ่งเน้นวัตถุคือการรวมข้อมูลและพฤติกรรมของคุณเข้าด้วยกัน เป็นหลักฐาน : ในทางตรงกันข้ามวิธีการเชิงวัตถุสนับสนุนให้โปรแกรมเมอร์วางข้อมูลที่ไม่สามารถเข้าถึงได้โดยตรงโดยส่วนที่เหลือของโปรแกรม แต่จะเข้าถึงข้อมูลได้โดยการเรียกฟังก์ชั่นที่เขียนขึ้นเป็นพิเศษโดยทั่วไปเรียกว่าเมธอดซึ่งรวมอยู่ในข้อมูล ในทางกลับกัน ECS ดูเหมือนจะเป็นเรื่องเกี่ยวกับการแยกข้อมูลของคุณออกจากพฤติกรรมของคุณ

20 design-patterns  object-oriented  functional-programming  architectural-patterns  entity-component-system 

ตัวอย่างเช่นฉันได้รับรหัสต่อไปนี้: auto z = [](int x) -> int { if (x > 0) { switch (x) { case 2: return 5; case 3: return 6; default: return 1; } } return 0; }; และต่อมาฉันเรียกสิ่งนี้หลายครั้ง ในรหัส asm ฉันเห็นสายภายนอกด้วยแลมบ์ดา .... บางสิ่งบางอย่าง ... มันกลายเป็นเรื่องง่ายที่จะอ่านและฉันคิดว่ามันอาจทำให้ประสิทธิภาพ ดังนั้นฉันอาจชนะในการเขียนโปรแกรม meta แต่ฉันเสียในการดีบัก asm และประสิทธิภาพหรือไม่ ฉันควรหลีกเลี่ยงฟีเจอร์ภาษาที่ทันสมัยมาโครและด้านการเขียนโปรแกรมเมตาอื่น ๆ เพื่อให้แน่ใจในประสิทธิภาพและการแก้ไขข้อบกพร่องอย่างง่ายหรือไม่?

20 c++  programming-practices  functional-programming  meta-programming 

ฉันเริ่มเขียนโปรแกรมด้วย Python และฉันสับสนกับแนวคิดอย่างเช่น coroutines และ closures ตอนนี้ฉันคิดว่าฉันรู้จักพวกเขาในระดับตื้น ๆ แต่ฉันไม่เคยรู้สึกว่าช่วงเวลา "สว่าง" ดังนั้นฉันเลือกเรียน Clojure ฉันซื้อหนังสือของ Stuart Halloway และมันก็ดี แต่เมื่อฉันดูที่ดัชนีไม่มีคำพูดใด ๆ เช่น coroutine หรือความต่อเนื่อง ฉัน googled พวกเขา แต่ก็ไม่มีอะไรที่นั่น ดังนั้นคำถามของฉันคือ: Clojure มีการต่อเนื่องหรือ coroutines ในการทำงานเช่น pong-ponging โดยไม่ล้นกอง? ตัวอย่าง Python (แม้ว่า Python มาตรฐานไม่รองรับเวอร์ชันเต็มรูปแบบของ coroutine สมมาตรนี้): def ping(): while 1: print "ping" function to switching to pong …

20 functional-programming  clojure