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

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

13 language-design  haskell  scala  naming-standards  monad 

แก้ไข:ฉันกำลังใช้คำถามใหม่อีกครั้ง เห็นได้ชัดว่าฉันทำให้เกิดความสับสนเพราะฉันไม่ได้ตระหนักว่าคำว่าdestructorถูกใช้ใน OOP สำหรับสิ่งที่แตกต่างกันมาก - เป็นฟังก์ชันที่เรียกใช้เมื่อวัตถุถูกทำลาย ในการเขียนโปรแกรมการทำงานเรา (พยายาม) หลีกเลี่ยงสถานะที่เปลี่ยนแปลงไม่ได้ดังนั้นจึงไม่เทียบเท่ากับมัน (ฉันเพิ่มแท็กที่เหมาะสมให้กับคำถาม) แต่ผมเคยเห็นว่าการบันทึกข้อมูลสำหรับ unwrapping ค่า (โดยเฉพาะอย่างยิ่งสำหรับชนิดข้อมูล valued เดียวเช่นnewtypes) บางครั้งเรียกว่าdestructorหรือบางทีอาจจะDeconstructor ตัวอย่างเช่นมี (ใน Haskell): newtype Wrap = Wrap { unwrap :: Int } นี่Wrapคือตัวสร้างและunwrapอะไร คำถามคือ: เราจะเรียกunwrapโปรแกรมการทำงานได้อย่างไร Deconstructor? Destructor? หรือคำอื่น ๆ ? และเพื่อชี้แจงว่าคำศัพท์นี้ / อื่น ๆ สามารถใช้งานได้กับภาษาอื่น ๆหรือใช้ใน Haskell หรือไม่? บางทีอาจมีคำศัพท์สำหรับเรื่องนี้โดยทั่วไปในภาษาที่ไม่สามารถใช้งานได้หรือไม่? ฉันเห็นทั้งสองคำแล้วเช่น: ... บ่อยครั้งที่หนึ่งมีตัวสร้างสมาร์ทและdestructors ที่ฉลาดเหล่านี้เพื่อความสะดวกในการทำงานกับพวกเขา …

13 terminology  functional-programming  haskell  data 

ฉันออกจากงาน (เพื่อย้ายไปยังประเทศอื่น) ซึ่งฉันตั้งโปรแกรมใน Javascript และ Haskell (บางไพ ธ อน) ส่วนใหญ่แล้ว ฉันชอบมันมากเพราะผู้คนมีจุดประสงค์ในเชิงบวกทางคณิตศาสตร์และยังได้ทำสิ่งต่างๆมากมาย นี่เป็นร้านค้ามืออาชีพอย่างแท้จริง ตอนนี้ฉันทำงานที่ร้าน Agile / XP ในขณะนี้เป็นสิ่งที่ดีและทั้งหมดที่ฉันรู้สึกว่าบางทีเราไม่เป็นมืออาชีพเมื่อมันมาถึงการเลือกเทคโนโลยีและห้องสมุด ฉันรู้สึกว่าวิธีการเขียนซอฟต์แวร์ของเรานั้นค่อนข้างอ่อนและไม่มีโครงสร้าง ฉันพยายามอ่านหนังสือที่ฉันได้รับการเสนอและดูเหมือนว่าพวกเขาจะสนับสนุนสไตล์นี้ ( ฮึ ) หลายครั้งที่เราเพิ่งเลือก libs จากฮับ git และใช้มันโดยไม่มีการตรวจสอบใด ๆ ฉันถูกบังคับให้ทำงานกับใครบางคนตลอดเวลาแม้ว่ามันจะเป็นงานเล็ก ๆ สำหรับคนคนหนึ่ง ดูเหมือนว่าจะมีกฎ "เร็ว ๆ " เล็กน้อยสำหรับทุกสิ่งแม้ว่ากฎนั้นอาจถูกทำลายโดยตัวอย่างเคาน์เตอร์เล็กน้อย (ครั้งหนึ่งฉันทำผิดพลาดจากการให้ตัวอย่างเคาน์เตอร์นั้นและฉันถูกโจมตีด้วยวาจา) นี่เป็นเรื่องปกติในอเมริกาหรือไม่ ฉันจะจัดการกับความหยิ่งยโสนี้ได้อย่างไร

13 ruby  haskell  agile 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันรู้ว่าการเรียกซ้ำคืออะไร (เมื่อ patten reoccurs อยู่ภายในตัวเองโดยทั่วไปแล้วฟังก์ชั่นที่เรียกตัวเองว่าเป็นหนึ่งในสายของมันหลังจากการแบ่งแบบมีเงื่อนไข ... ใช่ไหม?) และฉันสามารถเข้าใจฟังก์ชั่นแบบเรียกซ้ำได้ ปัญหาของฉันคือเมื่อฉันเห็นตัวอย่างใหม่ฉันมักสับสนอยู่เสมอ ถ้าฉันเห็นการวนซ้ำหรือการแมปการซิปการทำรังการเรียก polymorphic และอื่น ๆ ฉันรู้ว่าจะเกิดอะไรขึ้นโดยดูที่มัน เมื่อฉันเห็นรหัสซ้ำกระบวนการคิดของฉันมักจะเป็น 'wtf นี่คืออะไร' ตามด้วย 'oh it recursive' ตามด้วย 'ฉันเดาว่ามันต้องใช้งานถ้าพวกเขาบอกว่าทำ' คุณมีเคล็ดลับ / แผน / ทรัพยากรเพื่อสร้างทักษะในด้านนี้หรือไม่? การเรียกซ้ำเป็นแนวคิดแปลก ๆ ดังนั้นฉันจึงคิดวิธีจัดการกับมันอาจจะแปลกและไม่เท่าเทียมกันเท่ากัน

13 learning  functional-programming  lisp  haskell  recursion 

เป็นไปได้ที่จะใช้ประเภทคงที่หรือขึ้นอยู่กับการพิสูจน์ฟังก์ชั่น idempotent? ฉันค้นหา Google และสถานที่ต่าง ๆ บน StackOverflow / StackExchange เพื่อหาคำตอบอย่างไม่มีโชค สิ่งที่ฉันพบมากที่สุดคือการสนทนาเกี่ยวกับ Idris: https://groups.google.com/forum/#!topic/idris-lang/yp7vrspChRg น่าเสียดายที่การอภิปรายนั้นอยู่เหนือหัวฉันเล็กน้อย

12 haskell 

นี่เป็นปัญหาที่การเขียนโปรแกรมอย่างง่ายจาก Spoj: http://www.spoj.com/problems/PROBTRES/ โดยพื้นฐานแล้วคุณจะถูกขอให้แสดงรอบวัฏจักร Collatz ที่ใหญ่ที่สุดสำหรับตัวเลขระหว่าง i และ j (รอบ Collatz ของจำนวน $ n $ คือจำนวนขั้นตอนที่จะได้รับจาก $ n $ ถึง 1 ในที่สุด) ฉันได้มองหาวิธี Haskell เพื่อแก้ปัญหาด้วยประสิทธิภาพเปรียบเทียบมากกว่าของ Java หรือ C ++ (เพื่อให้พอดีกับขีด จำกัด เวลาทำงานที่อนุญาต) แม้ว่าโซลูชัน Java อย่างง่ายที่จดจำความยาวของรอบของรอบใด ๆ ที่คำนวณแล้วจะใช้งานได้ แต่ฉันไม่ประสบความสำเร็จในการนำแนวคิดนี้ไปใช้เพื่อรับโซลูชัน Haskell ฉันได้พยายาม Data.Function.Memoize เช่นเดียวกับเทคนิค memoization ที่่กลั่นในบ้านเวลาเข้าสู่ระบบโดยใช้ความคิดจากการโพสต์นี้: /programming/3208258/memoization-in-haskell น่าเสียดายที่การบันทึกช่วยจำทำให้การคำนวณรอบ (n) ช้าลง ฉันเชื่อว่าช้าลงมาจากค่าใช้จ่ายของทาง Haskell …

12 programming-practices  functional-programming  haskell 

ใน Haskell, functor typeclass functor ถูกกำหนดดังนี้ (ดูตัวอย่างHaskell wiki ): class Functor (f :: * -> *) where fmap :: (a -> b) -> f a -> f b เท่าที่ผมเข้าใจ (โปรดถูกต้องฉันหากฉันผิด) เช่น functor สามารถมีเป้าหมายเป็นหมวดหมู่หมวดหมู่นี้สร้างขึ้นโดยใช้ตัวสร้างประเภทเช่นเพียง[], Maybeฯลฯ บนมืออื่น ๆ หนึ่งอาจคิดว่า functors มีหมวดหมู่ใด ๆ เป็นเป้าหมายของ functor เช่นหมวดหมู่ของ Haskell ทุกประเภท ยกตัวอย่างเช่นIntอาจจะเป็นวัตถุที่อยู่ในหมวดหมู่ที่กำหนดเป้าหมายของ functor หนึ่งไม่เพียงหรือMaybe Int[Int] แรงจูงใจสำหรับข้อ …

12 haskell 

(หมายเหตุฉันใส่คำถามที่นี่เพราะมันเกี่ยวกับกลไกเชิงแนวคิดของมันไม่ใช่ปัญหาการเข้ารหัส) ผมทำงานในโปรแกรมขนาดเล็กที่ใช้ลำดับของตัวเลข fibonacci ใน equasion ของมัน แต่ผมสังเกตเห็นว่าถ้าผมได้มากกว่าจำนวนหนึ่งมันก็เจ็บปวดช้า googling รอบ bit ฉัน stumbled เมื่อเทคนิคใน Haskell ที่รู้จักกันเป็นMemoization, พวกเขาแสดงรหัสทำงานเช่นนี้: -- Traditional implementation of fibonacci, hangs after about 30 slow_fib :: Int -> Integer slow_fib 0 = 0 slow_fib 1 = 1 slow_fib n = slow_fib (n-2) + slow_fib (n-1) -- Memorized variant is …

12 haskell  recursion 

ฉันเรียนรู้การเขียนโปรแกรมการทำงานที่มีHaskell ในขณะเดียวกันฉันกำลังศึกษาทฤษฎีออโตมาตาและในขณะที่ทั้งสองดูเหมือนจะเข้ากันได้ดีฉันจึงเขียนห้องสมุดเล็ก ๆ เพื่อเล่นกับออโตมาตะ นี่คือปัญหาที่ทำให้ฉันถามคำถาม ในขณะที่ศึกษาวิธีประเมินความสามารถในการเข้าถึงของรัฐฉันได้รับแนวคิดว่าอัลกอริทึมแบบเรียกซ้ำง่าย ๆ จะไม่มีประสิทธิภาพมากนักเนื่องจากบางเส้นทางอาจแบ่งปันบางสถานะและฉันอาจจบการประเมินมากกว่าหนึ่งครั้ง ตัวอย่างเช่นที่นี่การประเมินความสามารถในการเข้าถึงของgจากaฉันต้องแยกfทั้งสองขณะตรวจสอบเส้นทางผ่านdและc : ดังนั้นความคิดของฉันก็คืออัลกอริทึมทำงานแบบขนานบนหลาย ๆ พา ธ และอัปเดตบันทึกที่แชร์ของรัฐที่ถูกแยกอาจจะดี แต่นั่นก็มากเกินไปสำหรับฉัน ฉันเคยเห็นว่าในกรณีการเรียกซ้ำง่าย ๆ บางครั้งเราสามารถผ่านสถานะเป็นอาร์กิวเมนต์และนั่นคือสิ่งที่ฉันต้องทำที่นี่เพราะฉันส่งต่อรายชื่อของรัฐที่ฉันได้ผ่านเพื่อหลีกเลี่ยงการวนซ้ำ แต่มีวิธีที่จะส่งผ่านรายการนั้นย้อนกลับเช่นกลับใน tuple พร้อมกับผลบูลีนของcanReachฟังก์ชั่นของฉันได้อย่างไร (แม้ว่าจะรู้สึกว่าถูกบังคับเล็กน้อย) นอกจากความถูกต้องของตัวอย่างคดีของฉันแล้วยังมีเทคนิคอื่นใดอีกบ้างที่สามารถใช้แก้ปัญหาแบบนี้ได้อีก? ฉันรู้สึกเหมือนเหล่านี้จะต้องมากพอที่พบว่ามีจะต้องมีการแก้ปัญหาเช่นสิ่งที่เกิดขึ้นด้วยหรือfold*map จนถึงตอนนี้การอ่านlearnyouahaskell.comฉันยังไม่พบอะไรเลย แต่ลองคิดดูว่าฉันยังไม่ได้แตะพระเลย ( ถ้าสนใจฉันโพสต์รหัสของฉันในcodereview )

12 algorithms  functional-programming  haskell 

ดังนั้นฉันจึงทำไคลเอนต์ javascript / html ที่เกี่ยวข้องอย่างเป็นธรรมด้วยการโทร ajax จำนวนมากและการโทรกลับ -mem ฉันสนุกสนานกับความคิดที่จะใช้ Fay เพื่อจุดประสงค์นี้ ฉันรู้เรื่อง Elm แล้ว พยายามและชอบองค์ประกอบ FRP ตอนนี้ฉันต้องการทราบว่าโครงสร้างที่คล้ายกันเป็นไปได้ใน Fay หรือไม่ มีตัวอย่างที่เป็นรูปธรรมของ FRP ในเรื่องนี้บ้างไหม ณ จุดนี้? เทคโนโลยีบางอย่างที่เกี่ยวข้อง: Arrowlets , arrowised FRP ใน javascript FlapJaxอีกทางเลือกหนึ่งของจาวาสคริปต์ Bacon.js , FRP ใน javascript ทางออกหนึ่งที่เป็นไปได้โดยใช้เบคอน ด้วยการสาธิต

12 javascript  functional-programming  haskell  paradigms 

ฉันกำลังจะเริ่มโครงการจำลองสถานการณ์ / การสร้างแบบจำลอง ฉันรู้อยู่แล้วว่า OOP ใช้สำหรับโครงการประเภทนี้ อย่างไรก็ตามการเรียน Haskell ทำให้ฉันพิจารณาใช้กระบวนทัศน์ของ FP สำหรับการสร้างแบบจำลองระบบของส่วนประกอบ ให้ฉันทำอย่างละเอียด: สมมติว่าฉันมีองค์ประกอบประเภท A ซึ่งมีลักษณะเป็นชุดข้อมูล (พารามิเตอร์เช่นอุณหภูมิหรือความดัน PDE และเงื่อนไขขอบเขต ฯลฯ ) และส่วนประกอบประเภท B ซึ่งมีชุดข้อมูลแตกต่างกัน (แตกต่างกัน หรือพารามิเตอร์เดียวกัน PDE และเงื่อนไขขอบเขตที่แตกต่างกัน) สมมติว่าฟังก์ชั่น / วิธีการที่จะนำไปใช้กับแต่ละองค์ประกอบเหมือนกัน (ตัวอย่างวิธี Galerkin) สถานะที่ไม่แน่นอนของวัตถุจะถูกใช้สำหรับพารามิเตอร์ที่ไม่คงที่ ถ้าฉันจะใช้วิธีการของ OOP ฉันจะสร้างวัตถุสองชนิดที่จะห่อหุ้มข้อมูลของแต่ละประเภทวิธีการในการแก้ไข PDE (การสืบทอดจะใช้ที่นี่เพื่อนำโค้ดกลับมาใช้ใหม่) และวิธีแก้ปัญหากับ PDE ในทางตรงกันข้ามถ้าฉันจะใช้วิธีการ FP แต่ละองค์ประกอบจะถูกแบ่งออกเป็นส่วนข้อมูลและฟังก์ชั่นที่จะดำเนินการกับข้อมูลเพื่อให้ได้โซลูชั่นสำหรับ PDE พารามิเตอร์ที่ไม่คงที่จะถูกส่งผ่านเป็นฟังก์ชั่นของอย่างอื่น (เวลาเช่น) หรือแสดงโดยความไม่แน่นอนบางอย่าง (การเลียนแบบความไม่แน่นอน ฯลฯ ) …

12 c++  object-oriented  functional-programming  haskell  modeling 

ในท้ายที่สุดแล้วโปรแกรมทั้งหมดของเรามีโครงสร้าง นั่นคือมันไม่สำคัญว่าเราจะสร้างมันให้บริสุทธิ์หรือใช้ประโยชน์ได้อย่างไร - พวกมันถูกแปลเป็นชุดประกอบเสมอดังนั้นสิ่งที่จริง ๆ แล้วสิ่งที่วิ่งอยู่หลังหมวกคือคำแนะนำรัฐและลูป พวกเราเลียนแบบ FP ในฐานะที่เป็นฮาร์ดแวร์ noob คำถามของฉันคือ: ทำไมเราไม่ใช้สถาปัตยกรรมคอมพิวเตอร์ที่คำนวณสิ่งต่าง ๆ ในรูปแบบที่ใช้งานได้จริง? ตัวอย่างเช่นคอมพิวเตอร์อาจประกอบด้วย "functional chips" ดั้งเดิมเช่น "concat", "map" และ "ลด" และโปรแกรมจะบอกคอมพิวเตอร์ว่าจะไหลของข้อมูลระหว่างชิปเหล่านั้นอย่างไรเพื่อคำนวณผลลัพธ์ที่ต้องการ เช่นในภาษาที่ต่อกัน สิ่งนี้ไม่สมเหตุสมผล แต่อาจแสดงสิ่งที่ฉันคิด

12 functional-programming  computer-science  haskell  lisp  clojure 

สัญชาตญาณของประเภทที่เป็นตัวเลือกเช่นเดียวกับMaybe Intที่ไม่มี Int (เช่นนั้นNothingมี) หรือว่ามีInt บางตัว มีบางสิ่งที่นั่น มันทำให้ฉันรู้สึกว่าเราเรียก constructor ชนิดสำหรับ "เชิงลบ" กรณีNothingเพราะมันหมายความว่าที่ - ว่าไม่มีIntมี แต่ใช้คำว่าทำไมเพียงแค่ในกรณีที่เน้นอยู่ในสิ่งที่เป็นจริงมี ? สำหรับฉันคำว่า "เพิ่ง" มีความหมายแฝงอยู่ว่าสิ่งที่อธิบายนั้นน้อยกว่าทางเลือก ตรงกันข้ามกับสิ่งที่อยู่ที่นั่นจริง ๆ ; ตัวอย่างเช่น, ตอบ: คุณกำลังทำอะไรคืนนี้ B: ไม่; ฉันแค่จะอยู่ในและดูทีวี ตอบ: คุณตรวจสอบเสียงผีที่น่าขนลุกรอบ ๆ บ้านของคุณหรือไม่? B: ใช่ปรากฎว่ามันเป็นแค่นกฮูก เห็นได้ชัดว่าฉันขาดสัญชาตญาณสิ่งที่ตัวเลือกการตั้งชื่อนี้มีพื้นฐานมาจาก มันคืออะไร? เพราะให้ฉันคำเพียงหมายถึงตรงข้ามของวิธีการที่จะนำมาใช้ในที่Maybeประเภท

11 functional-programming  haskell  data-types  null 

ฉันต้องการกำหนดคลาสประเภทสำหรับวัตถุทางเรขาคณิตที่สามารถตัดกันด้วยกัน: class Intersect a b c | a b -> c where intersect :: a -> b -> c -- Language extensions: -XMultiParamTypeClasses, -XFunctionalDependencies แนวคิดก็คือมีฟังก์ชั่นการตัดกันที่ใช้งานทั่วไปที่สามารถจัดการกับวัตถุประเภทต่างๆ หนึ่งสามารถจินตนาการกรณีเช่น instance Intersect Line Plane (Maybe Point) where ... instance Intersect Plane Plane (Maybe Line) where ... แต่ฉันก็อยากจะประกาศด้วยว่าการตัดกันนั้นเป็นการสลับ: instance (Intersect a b c) => Intersect …

11 haskell  type-systems  typeclass 

เรากำลังใช้ไลบรารีการบีบอัดเมทริกซ์โดยยึดตามไวยากรณ์ไวยากรณ์สองมิติที่ได้รับการแก้ไข ตอนนี้เรามีสองวิธีสำหรับประเภทข้อมูลของเรา - วิธีใดจะดีกว่าในกรณีที่ใช้หน่วยความจำ (เราต้องการบีบอัดบางอย่าง;)) ไวยากรณ์ประกอบด้วย NonTerminals ที่มี 4 โปรดักชั่นหรือเทอร์มินัลทางด้านขวามือ เราจะต้องใช้ชื่อของโปรดักชั่นเพื่อการตรวจสอบความเท่าเทียมกันและการย่อเล็กสุดไวยากรณ์ ครั้งแรก: -- | Type synonym for non-terminal symbols type NonTerminal = String -- | Data type for the right hand side of a production data RightHandSide = DownStep NonTerminal NonTerminal NonTerminal NonTerminal | Terminal Int -- | Data type …

11 functional-programming  haskell  memory  grammar