คำถามติดแท็ก monad

2
รูปแบบ“ Free Monad + Interpreter” คืออะไร
ฉันเคยเห็นคนที่พูดถึงFree Monad กับ Interpreterโดยเฉพาะอย่างยิ่งในบริบทของการเข้าถึงข้อมูล รูปแบบนี้คืออะไร? ฉันควรใช้เมื่อใด มันทำงานอย่างไรและฉันจะใช้มันอย่างไร ฉันเข้าใจ (จากโพสต์เช่นนี้ ) ว่ามันเกี่ยวกับการแยกแบบจำลองจากการเข้าถึงข้อมูล มันแตกต่างจากรูปแบบพื้นที่เก็บข้อมูลที่รู้จักกันดีอย่างไร ดูเหมือนว่าพวกเขาจะมีแรงจูงใจที่เหมือนกัน

5
คำวิจารณ์ของ IO monad ที่ถูกมองว่าเป็น monad state ที่ปฏิบัติงานบนโลกนี้
IOmonad ใน Haskell มักจะมีการอธิบายเป็น monad รัฐที่รัฐเป็นโลก ดังนั้นค่าของชนิดIO amonad worldState -> (a, worldState)ถูกมองว่าเป็นสิ่งที่ชอบ ก่อนหน้านี้ฉันอ่านบทความ (หรือโพสต์รายการบล็อก / จดหมายข่าว) ที่วิจารณ์มุมมองนี้และให้เหตุผลหลายประการว่าทำไมมันไม่ถูกต้อง แต่ฉันจำไม่ได้ว่าทั้งบทความและเหตุผล มีใครรู้บ้าง แก้ไข:บทความดูเหมือนจะหายไปดังนั้นเริ่มรวบรวมข้อโต้แย้งต่าง ๆ ที่นี่ ฉันเริ่มที่จะทำให้สิ่งต่าง ๆ น่าสนใจยิ่งขึ้น แก้ไข:บทความที่ฉันกำลังมองหาคือการจัดการกับทีมที่น่าอึดอัดใจ: อินพุต / เอาท์พุต monadic, การทำงานพร้อมกัน, ข้อยกเว้นและการโทรภาษาต่างประเทศใน Haskellโดย Simon Peyton Jones (ขอบคุณคำตอบของ TacTics)

7
อาจจะเป็นข้อยกเว้น Monad
ฉันสงสัยว่าอะไรคือข้อดีของMaybe monad ที่มีข้อยกเว้น? ดูเหมือนว่าMaybeเป็นวิธีการทางtry..catchไวยากรณ์ที่ชัดเจน (และค่อนข้างใช้พื้นที่มาก) อัปเดตโปรดทราบว่าฉันตั้งใจจะไม่พูดถึง Haskell

3
วิธีต่าง ๆ ในการดู monad
ในขณะที่เรียนรู้ Haskell ฉันได้พบกับบทเรียนมากมายที่พยายามอธิบายสิ่งที่ monads และทำไม monads มีความสำคัญใน Haskell แต่ละคนใช้การเปรียบเทียบดังนั้นการจับความหมายได้ง่ายขึ้น ในตอนท้ายของวันฉันได้จบลงด้วยมุมมองที่แตกต่างกัน 3 แบบว่า monad คืออะไร: ดู 1: Monad เป็นป้ายกำกับ บางครั้งฉันคิดว่า monad เป็นป้ายชื่อประเภทเฉพาะ ตัวอย่างเช่นฟังก์ชั่นของประเภท: myfunction :: IO Int myfunction เป็นฟังก์ชันที่เมื่อใดก็ตามที่มีการดำเนินการมันจะให้ค่า Int ชนิดของผลลัพธ์ไม่ใช่ Int แต่เป็น IO Int ดังนั้น IO จึงเป็นเลเบลของค่า Int เตือนผู้ใช้ให้รู้ว่าค่า Int เป็นผลลัพธ์ของกระบวนการที่ได้ทำการกระทำของ IO ดังนั้นค่า Int นี้จึงถูกทำเครื่องหมายเป็นค่าที่มาจากกระบวนการที่มี IO ดังนั้นค่านี้จึงเป็น "สกปรก" กระบวนการของคุณไม่บริสุทธิ์อีกต่อไป ดู …

2
monads เป็นทางเลือกที่ทำงานได้ (อาจจะดีกว่า) กับลำดับชั้นการสืบทอดหรือไม่
ฉันจะใช้คำอธิบายภาษาที่ไม่เชื่อเรื่องพระเจ้าของ monads เช่นนี้ก่อนอธิบาย monoids: หนังสือคือ ( ๆ ) ชุดของฟังก์ชั่นที่ใช้บางชนิดเป็นพารามิเตอร์และส่งกลับชนิดเดียวกัน monadเป็น ( ๆ ) ชุดของฟังก์ชั่นที่ใช้เป็นกระดาษห่อประเภทเป็นพารามิเตอร์และส่งกลับชนิดกระดาษห่อเดียว หมายเหตุเหล่านั้นคือคำอธิบายไม่ใช่คำจำกัดความ รู้สึกอิสระที่จะโจมตีคำอธิบายนั้น! ดังนั้นในภาษา OO monad อนุญาตให้มีองค์ประกอบการดำเนินการเช่น: Flier<Duck> m = new Flier<Duck>(duck).takeOff().flyAround().land() โปรดทราบว่า monad กำหนดและควบคุมซีแมนทิกส์ของการดำเนินการเหล่านั้นมากกว่าคลาสที่มีอยู่ ตามเนื้อผ้าในภาษา OO เราจะใช้ลำดับชั้นและการสืบทอดเพื่อให้ความหมายเหล่านั้น ดังนั้นเราจึงต้องการมีBirdระดับด้วยวิธีการtakeOff(), flyAround()และland()และเป็ดจะได้รับมรดกเหล่านั้น แต่แล้วเราก็มีปัญหากับนกที่บินไม่ได้เพราะpenguin.takeOff()ล้มเหลว เราต้องหันไปใช้ข้อยกเว้นในการขว้างและจัดการ นอกจากนี้เมื่อเราบอกว่าเพนกวินเป็นเราทำงานเป็นปัญหากับมรดกหลายตัวอย่างเช่นถ้าเรายังมีลำดับชั้นของBirdSwimmer โดยพื้นฐานแล้วเรากำลังพยายามที่จะใส่คลาสเป็นหมวดหมู่ (ด้วยการขอโทษกับหมวดหมู่ทฤษฎีพวก) และกำหนดความหมายตามหมวดหมู่มากกว่าในแต่ละชั้นเรียน แต่พระสงฆ์ดูเหมือนจะเป็นกลไกที่ชัดเจนกว่าสำหรับการทำเช่นนั้นมากกว่าลำดับชั้น ดังนั้นในกรณีนี้เราจะมีFlier<T>monad เหมือนตัวอย่างด้านบน: Flier<Duck> m = new Flier<Duck>(duck).takeOff().flyAround().land() ... Flier<Penguin>และเราจะไม่ยกตัวอย่าง เราสามารถใช้การพิมพ์แบบคงที่เพื่อป้องกันสิ่งนั้นไม่ให้เกิดขึ้นด้วยอินเทอร์เฟซของตัวทำเครื่องหมาย …

4
ประโยชน์ของรูปแบบ IO monad สำหรับการจัดการผลข้างเคียงทางวิชาการล้วนๆหรือไม่?
ขออภัยสำหรับคำถามข้างเคียงอีกคำถามของ 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 …

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

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 หรือมีวิธีอื่นบ้างไหม?

2
ทำไมประเภทตัวเลือก Scala ไม่ถูกเรียกว่าอาจจะเหมือนกับใน Haskell [ปิด]
ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ทำไมประเภทตัวเลือก Scala ไม่ถูกเรียกว่าอาจจะเหมือนกับใน Haskell อาจทำให้รู้สึก "ความหมาย" มากขึ้นสำหรับฉัน แต่บางทีตัวเลือกอาจมีพฤติกรรมที่แตกต่างกันซึ่งฉันไม่ทราบ มีเหตุผลใดเป็นพิเศษหรือไม่ที่ตัวเลือกใน Scala ไม่ได้ถูกเรียกว่าอาจจะ?

4
เมื่อการเขียนโปรแกรมในลักษณะการทำงานคุณมีสถานะแอปพลิเคชันเดียวที่คุณสานผ่านตรรกะของแอปพลิเคชันหรือไม่
ฉันจะสร้างระบบที่มีสิ่งต่อไปนี้ทั้งหมดได้อย่างไร : การใช้ฟังก์ชั่นบริสุทธิ์กับวัตถุที่ไม่เปลี่ยนรูป ส่งผ่านไปยังข้อมูลฟังก์ชันที่ฟังก์ชันต้องการเท่านั้นไม่เกิน (เช่นไม่มีวัตถุสถานะแอปพลิเคชันขนาดใหญ่) หลีกเลี่ยงการขัดแย้งกับฟังก์ชันมากเกินไป หลีกเลี่ยงการสร้างวัตถุใหม่เพียงเพื่อจุดประสงค์ในการบรรจุและเอาพารามิเตอร์ออกจากฟังก์ชั่นเพื่อหลีกเลี่ยงการส่งพารามิเตอร์ไปยังฟังก์ชันมากเกินไป ถ้าฉันจะแพ็คหลายรายการไปยังฟังก์ชันเป็นวัตถุเดียวฉันต้องการให้วัตถุนั้นเป็นเจ้าของข้อมูลนั้นไม่ใช่สิ่งที่สร้างขึ้นชั่วคราว สำหรับฉันแล้วดูเหมือนว่ารัฐ monad ทำผิดกฎข้อที่ 2 ถึงแม้ว่ามันจะไม่ชัดเจนเพราะมันถูกสานต่อผ่าน monad ฉันรู้สึกว่าฉันจำเป็นต้องใช้เลนส์อย่างใด แต่มีน้อยมากที่เขียนเกี่ยวกับมันสำหรับภาษาที่ไม่สามารถใช้งานได้ พื้นหลัง ในการออกกำลังกายฉันกำลังแปลงแอปพลิเคชันที่มีอยู่ของฉันจากสไตล์เชิงวัตถุเป็นสไตล์การทำงาน สิ่งแรกที่ฉันพยายามทำคือการสร้างแกนในของแอปพลิเคชันให้ได้มากที่สุด สิ่งหนึ่งที่ฉันได้ยินคือวิธีการจัดการ "รัฐ" ในภาษาที่ใช้งานได้อย่างหมดจดและนี่คือสิ่งที่ฉันเชื่อว่าทำโดย Monads ของรัฐนั่นคือเหตุผลที่คุณเรียกฟังก์ชันบริสุทธิ์ว่า "ผ่านสถานะของ โลกตามที่มันเป็น "จากนั้นเมื่อฟังก์ชั่นกลับมาก็จะกลับสู่สถานะของโลกตามที่มีการเปลี่ยนแปลง เพื่อแสดงให้เห็นว่าวิธีการที่คุณสามารถทำ "สวัสดีโลก" ในลักษณะการทำงานล้วนเป็นเหมือนคุณผ่านโปรแกรมของคุณที่สถานะของหน้าจอและรับกลับสถานะของหน้าจอด้วยการพิมพ์ "สวัสดีโลก" ดังนั้นในทางเทคนิคคุณกำลังโทรไปยังฟังก์ชั่นที่บริสุทธิ์และไม่มีผลข้างเคียง จากนั้นฉันก็ผ่านแอปพลิเคชันของฉันและ: 1. ขั้นแรกให้สถานะแอปพลิเคชันทั้งหมดของฉันเป็นวัตถุระดับโลกเดียว (GameState) 2. ประการที่สองฉันทำให้ GameState ไม่เปลี่ยนรูป คุณไม่สามารถเปลี่ยนได้ หากคุณต้องการการเปลี่ยนแปลงคุณต้องสร้างสิ่งใหม่ ฉันทำสิ่งนี้โดยการเพิ่มตัวคัดลอกตัวเลือกที่จะเลือกหนึ่งหรือมากกว่าหนึ่งช่องที่มีการเปลี่ยนแปลง 3. สำหรับแต่ละแอปพลิเคชันฉันส่งผ่าน GameState เป็นพารามิเตอร์ ภายในฟังก์ชั่นหลังจากที่ทำสิ่งที่มันจะทำมันจะสร้าง GameState ใหม่และส่งคืน …

1
Futures / Monads vs Events
ในกรอบแอปพลิเคชันเมื่อผลกระทบต่อประสิทธิภาพการทำงานสามารถถูกเพิกเฉยได้ (10-20 เหตุการณ์ต่อวินาทีสูงสุด) อะไรคือการบำรุงรักษาและความยืดหยุ่นในการใช้เป็นสื่อที่ต้องการสำหรับการสื่อสารระหว่างโมดูล - เหตุการณ์หรืออนาคต / สัญญา / Monads ? บ่อยครั้งที่มีการกล่าวกันว่ากิจกรรม (pub / sub, ผู้ไกล่เกลี่ย) อนุญาตให้มีเพศสัมพันธ์แบบหลวม ๆ - แอปที่บำรุงรักษาได้ดีกว่า ... ประสบการณ์ของฉันปฏิเสธสิ่งนี้: เมื่อคุณมีเหตุการณ์มากกว่า 20 เหตุการณ์ - การแก้ไขข้อบกพร่องกลายเป็นเรื่องยาก เพราะมันยากมากที่จะเห็น: ใครเมื่อไหร่และทำไมใช้อะไร สัญญา (ฉันกำลังเข้ารหัสใน Javascript) มีความน่าเกลียดและโง่กว่าเหตุการณ์มาก แต่: คุณสามารถเห็นการเชื่อมต่อระหว่างการเรียกใช้ฟังก์ชั่นได้อย่างชัดเจนดังนั้นตรรกะของแอปพลิเคชันจะกลายเป็นสิ่งที่ตรงไปตรงมามากขึ้น สิ่งที่ฉันกลัว แม้ว่าจะเป็นสัญญาที่จะนำการแต่งงานที่ยากขึ้นกับพวกเขา ... ป.ล. : คำตอบไม่จำเป็นต้องอิงจาก JS ประสบการณ์จากภาษาอื่น ๆ ที่ใช้งานได้ดี

1
ดีกว่าที่จะใช้ข้อผิดพลาด monad กับการตรวจสอบในฟังก์ชั่น monadic ของคุณหรือใช้ monad ของคุณเองด้วยการตรวจสอบโดยตรงในการผูกของคุณ?
ฉันสงสัยว่าการออกแบบที่ดีกว่าคืออะไรสำหรับการใช้งาน / การบำรุงรักษาและสิ่งที่ดีกว่าเท่าที่เหมาะสมกับชุมชน รับรูปแบบข้อมูล: type Name = String data Amount = Out | Some | Enough | Plenty deriving (Show, Eq) data Container = Container Name deriving (Show, Eq) data Category = Category Name deriving (Show, Eq) data Store = Store Name [Category] deriving (Show, Eq) data Item = Item …

6
ทำไมฉันถึงต้องใส่ใจ Haskell? Monad คืออะไรและทำไมฉันต้องใช้ [ปิด]
ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันไม่ได้รับสิ่งที่พวกเขาแก้ปัญหา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.