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

Haskell เป็นภาษาโปรแกรมที่ใช้งานได้มีการพิมพ์แบบสแตติกการประเมินแบบสันหลังยาวการขนานอย่างกว้างขวางและการสนับสนุนการทำงานพร้อมกัน

3
ทำไมการเข้าถึง System.Info ไม่ถือว่าเป็นการดำเนินการ IO ใน Haskell
ในโมดูลSystem.Infoฉันเห็นฟังก์ชั่นเหล่านี้: os :: String arch :: String compilerName :: String compilerVersion :: Version ทำไมจึงไม่มีIOมี? พวกเขากำลังเข้าถึงระบบ ... ฉันผิดหรือเปล่า? ความคาดหวังของฉันเป็นสิ่งที่ชอบ: os :: IO String arch :: IO String compilerName :: IO String compilerVersion :: IO Version ใช้กรณี: print os -- "darwin" print arch -- "x86_64" print compilerName -- "ghc"
25 haskell 

2
รุ่น GHC ที่ทันสมัยมีการลบหลักฐานชนิดใดบ้าง
สมมติว่าฉันมีพารามิเตอร์ที่มีอยู่เพื่อประโยชน์ของระบบประเภทตัวอย่างเช่นในโปรแกรมขนาดเล็กนี้: {-# LANGUAGE GADTs #-} module Main where import Data.Proxy import Data.List data MyPoly where MyConstr :: Proxy a -> a -> (Proxy a -> a -> Int -> Int) -> MyPoly listOfPolys :: [MyPoly] listOfPolys = [MyConstr Proxy 5 (const (+)) , MyConstr Proxy 10 (const (+)) , MyConstr …

2
ความจำเป็นสำหรับการบริสุทธิ์ในการประยุกต์ใช้
ฉันกำลังเรียนผู้สมัครของ Haskell ดูเหมือนว่าฉัน (ฉันอาจผิด) ว่าpureฟังก์ชั่นไม่จำเป็นจริงๆตัวอย่างเช่น: pure (+) <*> [1,2,3] <*> [3,4,5] สามารถเขียนเป็น (+) <$> [1,2,3] <*> [3,4,5] บางคนสามารถอธิบายถึงประโยชน์ที่pureฟังก์ชั่นมอบให้เหนือการทำแผนที่อย่างชัดเจนด้วยfmapหรือไม่?

2
สมมติฐานใน“ Learn You a Haskell” เมื่ออนุมานประเภทใด
คำถามนี้ไม่ใช่เรื่องส่วนตัว ใช้คำกริยาที่เจาะจงมากในหนังสืออ้างอิงและฉันต้องการที่จะเข้าใจความหมายของถ้อยคำนั้นเพราะฉันกลัวว่าฉันเข้าใจผิดบางอย่าง จากLearn You a Haskellย่อหน้าต่อไปนี้เป็นย่อหน้าที่สามและสุดท้ายที่มีคำว่า "เราถือว่า*" data Barry t k p = Barry { yabba :: p, dabba :: t k } Functorและตอนนี้เราต้องการที่จะทำให้มันเป็นตัวอย่างของ Functorต้องการประเภทของประเภท* -> *แต่Barryดูเหมือนว่าจะมีชนิดนั้น ชนิดของBarryอะไร something -> something -> something -> *ดีที่เราเห็นมันต้องใช้เวลาสามพารามิเตอร์ชนิดดังนั้นจึงเป็นไปได้ มันปลอดภัยที่จะบอกว่าเป็นชนิดที่เป็นรูปธรรมและทำให้มีชนิดของp สำหรับเราคิดและอื่น ๆ โดยขยายมีชนิดของ ตอนนี้ขอเพียงแค่เปลี่ยนชนิดผู้ที่มีของที่เรานำมาใช้เป็นตัวยึดและเราพบว่ามีชนิดของ*k*t* -> *something(* -> *) -> * -> * -> * …
18 haskell 

5
มีวิธีที่จะตระหนักถึงฟังก์ชั่นของประเภท ((a -> b) -> b) -> ab ทั้งสอง?
ข้อเสนอ(P -> Q) -> QและP \/ Qเทียบเท่า มีวิธีที่จะเห็นความเท่าเทียมกันนี้ใน Haskell หรือไม่: from :: Either a b -> ((a -> b) -> b) from x = case x of Left a -> \f -> f a Right b -> \f -> b to :: ((a -> b) -> b) -> Either a …
18 haskell  logic 

2
Haskell: Typeclass กับการส่งผ่านฟังก์ชัน
สำหรับฉันดูเหมือนว่าคุณสามารถส่งผ่านอาร์กิวเมนต์ของฟังก์ชันได้มากกว่าการใช้ typeclass ตัวอย่างเช่นแทนที่จะกำหนดประเภทความเสมอภาค: class Eq a where (==) :: a -> a -> Bool และใช้มันในฟังก์ชั่นอื่น ๆ เพื่อระบุอาร์กิวเมนต์ชนิดต้องเป็นตัวอย่างของEq: elem :: (Eq a) => a -> [a] -> Bool เราไม่สามารถกำหนดelemฟังก์ชั่นของเราโดยไม่ต้องใช้ตัวพิมพ์ดีดและส่งผ่านอาร์กิวเมนต์ฟังก์ชันที่ทำงานได้หรือไม่

2
มีความแตกต่างระหว่างลายเซ็นประเภท a -> b -> a และ c -> a -> c หรือไม่
คำถามนี้เป็นคำถามเชิงทฤษฎีเกี่ยวกับฟังก์ชั่นของ Haskell ซึ่งสามารถโต้แย้งได้ทุกประเภท มีความแตกต่างระหว่างวิธีการทำงานกับลายเซ็นประเภทของหรือไม่ a -> b -> a และ c -> a -> c มีการยกตัวอย่าง? ความช่วยเหลือใด ๆ ที่ชื่นชม

1
นอกจาก as-pattern @ ยังมีความหมายอะไรใน Haskell
ฉันกำลังศึกษา Haskell อยู่ในขณะนี้และพยายามทำความเข้าใจโครงการที่ใช้ Haskell เพื่อใช้อัลกอริทึมการเข้ารหัสลับ หลังจากอ่านLearn You a Haskell for Great Goodออนไลน์ฉันเริ่มเข้าใจโค้ดในโครงงานนั้น จากนั้นฉันก็พบว่าฉันติดอยู่ที่รหัสต่อไปนี้ด้วยสัญลักษณ์ "@": -- | Generate an @n@-dimensional secret key over @rq@. genKey :: forall rq rnd n . (MonadRandom rnd, Random rq, Reflects n Int) => rnd (PRFKey n rq) genKey = fmap Key $ randomMtx 1 $ …

1
ตัวแยกวิเคราะห์ Haskell ควรอนุญาตให้เลข Unicode เป็นตัวอักษรตัวเลขหรือไม่
ในการออกกำลังกายฉันกำลังเขียนโปรแกรมแยกวิเคราะห์สำหรับ Haskell ตั้งแต่เริ่มต้น ในการสร้าง lexer ฉันสังเกตเห็นกฎต่อไปนี้ในรายงาน Haskell 2010 : หลัก → ascDigit | uniDigit ascDigit → 0| 1| … | 9 uniDigit →ใด ๆ Unicode ทศนิยมหลัก octit → 0| 1| … | 7 hexit → หลัก | A| … | F| a| … |f ทศนิยม → หลัก { หลัก } …

1
มีตัวแทนของ Van Laarhoven ของ `ตัวเลือก '
เลนส์หลายประเภทมีการแสดงของ van Laarhoven ตัวอย่างเช่นLensประเภทLens s t a b สามารถแสดงเป็น: Functor f => (a -> f b) -> s -> f t ในทำนองเดียวกันTraversalสามารถแสดงในลักษณะที่คล้ายกันสลับFunctorข้อ จำกัด สำหรับApplicative: Applicative f => (a -> f b) -> s -> f t กรอบเลนส์หลายประการเช่นMonocleและลูกศรOptionalกำหนดประเภทที่เรียกว่า ในการสืบทอดของ Monocle Optics นั้น Optionalเหมาะสมระหว่างLensและTraversal ตามที่ฉันเข้าใจแล้ว: หาก a Traversalเป็นเช่นLensนั้นอาจมีเป้าหมายเป็นศูนย์ถึงหลายเป้าหมายดังนั้นสิ่งนั้นOptionalก็เหมือนเช่นLensนั้นที่มีเป้าหมายเป็นศูนย์ถึงหนึ่งเป้าหมาย ใน Monocle Optionalหมายถึงคู่ของฟังก์ชั่น: getOrModify …

2
สแต็คไม่ได้รับการทดสอบด้วยรุ่น GHC & Cabal
ในโครงการ Haskell ของฉันเมื่อฉันstack runมันแสดงต่อไปนี้ แต่ยังคงทำงานอยู่ คำเตือนนี้คืออะไร? ฉันจะกำจัดมันได้อย่างไร Stack has not been tested with GHC versions above 8.6, and using 8.8.2, this may fail Stack has not been tested with Cabal versions above 2.4, but version 3.0.1.0 was found, this may fail

3
การใช้คำนี้ฟังก์ชั่นเป็นไปได้โดยไม่ต้องขั้นตอน postprocessing หลังจากพับหรือไม่?
Real World Haskell, ตอนที่ 4, หน้า 98 ของการพิมพ์ถามว่าwordsสามารถนำไปใช้โดยใช้ folds หรือไม่และนี่คือคำถามของฉันเช่นกัน: เป็นไปได้ไหม? ถ้าไม่ทำไม ถ้ามันเป็นอย่างไร ฉันคิดว่าสิ่งต่อไปนี้จะขึ้นอยู่กับความคิดที่ว่าแต่ละช่องว่างควรจะเติมคำสุดท้ายในรายการเอาท์พุท (นี้เกิดขึ้นในotherwiseยาม) และช่องว่างที่ควรจะเพิ่มคำ emtpy รายการเอาท์พุทหากยังไม่ได้มีอยู่ (มีการจัดการในif- then- else) myWords :: String -> [String] myWords = foldr step [[]] where step x yss@(y:ys) | x == ' ' = if y == "" then yss else "":yss | …

3
พิมพ์เพื่อเป็นตัวแทนรายการที่มีค่า 0 ถึง 5
ฉันมีแบบฝึกหัดที่ฉันต้องกำหนดประเภทเพื่อแสดงรายการที่มีค่า 0 ถึง 5 ก่อนอื่นฉันคิดว่าฉันสามารถแก้ปัญหาแบบนี้ซ้ำได้: data List a = Nil | Content a (List a) แต่ฉันไม่คิดว่านี่เป็นวิธีที่ถูกต้อง คุณช่วยให้อาหารฉันด้วยความคิดได้ไหม
14 haskell 


1
unsafeDupablePerformIO และ accursedUnutterablePerformIO แตกต่างกันอย่างไร
ฉันหลงทางในส่วนที่ จำกัด ของ Haskell Library และพบคาถาสองอันนี้: {- System.IO.Unsafe -} unsafeDupablePerformIO :: IO a -> a unsafeDupablePerformIO (IO m) = case runRW# m of (# _, a #) -> a {- Data.ByteString.Internal -} accursedUnutterablePerformIO :: IO a -> a accursedUnutterablePerformIO (IO m) = case m realWorld# of (# _, r #) …

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