- Beginners - Haskell.org

Type declaration
by Christian Sperandio 13 Apr '15

13 Apr '15

Hi, I’m currently playing with the mutable array to implement an heap sort sort (from The Art of Computer Programming) and I’m puzzled with an error. When I code: toHeap :: Ord a => [a] -> IO [a] toHeap [] = return [] toHeap [x] = return [x] toHeap xs = do arr <- newListArray (1, length xs) xs :: IO (IOArray Int a) getElems arr I’ve got this error: Could not deduce (a ~ a1) from the context (Ord a) bound by the type signature for toHeap :: Ord a => [a] -> IO [a] at /var/folders/fk/339860r16j759wmsfmjkyr4h0000gn/T/flycheck797T5s/Heapsort.hs:9:11-32 ‘a’ is a rigid type variable bound by the type signature for toHeap :: Ord a => [a] -> IO [a] at /var/folders/fk/339860r16j759wmsfmjkyr4h0000gn/T/flycheck797T5s/Heapsort.hs:9:11 ‘a1’ is a rigid type variable bound by an expression type signature: IO (IOArray Int a1) at /var/folders/fk/339860r16j759wmsfmjkyr4h0000gn/T/flycheck797T5s/Heapsort.hs:14:10 Expected type: [a1] Actual type: [a] Relevant bindings include xs :: [a] (bound at /var/folders/fk/339860r16j759wmsfmjkyr4h0000gn/T/flycheck797T5s/Heapsort.hs:12:8) toHeap :: [a] -> IO [a] (bound at /var/folders/fk/339860r16j759wmsfmjkyr4h0000gn/T/flycheck797T5s/Heapsort.hs:10:1) In the second argument of ‘newListArray’, namely ‘xs’ In a stmt of a 'do' block: arr <- newListArray (1, length xs) xs :: IO (IOArray Int a) But with the code below, all work: toHeap :: Ord a => [a] -> IO [a] toHeap [] = return [] toHeap [x] = return [x] toHeap xs = do arr <- buildArray xs getElems arr buildArray :: [a] -> IO (IOArray Int a) buildArray xs = newListArray (1, length xs) xs What do I miss ? Thanks. Chris

2 1

Linebreaks in lhs2tex eval
by martin 12 Apr '15

12 Apr '15

Hello all, it appears lhs2tex's \eval command does not show linebreaks. This is a pity, particularly when the output is formatted with a pretty printer. Is there a way to teach \eval to respect the linebreaks?

2 1

Need help to write join on my Temporals
by martin 12 Apr '15

12 Apr '15

Hello all, I have these Types type Time = Integer data Change a = Chg { ct :: Time, -- "change time" cv :: a -- "change value" } deriving (Eq,Show) data Temporal a = Temporal { td :: a, -- "temporal default" tc :: [Change a] -- "temporal changes" } deriving (Eq, Show) And I am trying to make Temporal a Monad by implementing join. My first Attempt was awfully verbose. It was also faulty, which was revealed by this QuickQueck (I am happy with my implementation of <*>) prop_tJoin tpr1 tpr2 = let f = (*) y1 = f <$> tpr1 <*> tpr2 y2 = (f <$> tpr1) `ap` tpr2 in y1 == y2 While I understand why my first implementatin was faulty, I fail to come up with anything remotely readable. I don't understand why I am having such difficulties, let alone solve them. I feel I am approaching this from the wrong angle. Any advice would be very much appreciated.

1 1

Debugging in Haskell
by Dimitri DeFigueiredo 12 Apr '15

12 Apr '15

I need to improve my Haskell debugging skills. I know of quickcheck, but that's for testing. It seems that: - Debug.Trace and - dynamic breakpoints in GHCi Are the two easy ways to check the state of your program at a specific point in execution. Is there another simple tool that I should know about? Any tips? Thank you, Dimitri

4 5

Managing boilerplate code in QuickCheck properties...
by Stuart Hungerford 11 Apr '15

11 Apr '15

Hi, I'm using the wonderful QuickCheck and Tasty libraries to test a bunch of properties (actually axioms for typeclasses): positivity_suite :: TestTree positivity_suite = testGroup "positivity axiom" [ testProperty "Float" (axiom_positivity :: Float -> Bool), testProperty "(Float, Float)" (axiom_positivity :: (Float, Float) -> Bool), -- etc ] symmetry_suite :: TestTree symmetry_suite = testGroup "symmetry axiom" [ testProperty "Float" (axiom_symmetry :: Float -> Float -> Bool), testProperty "(Float, Float)" (axiom_symmetry :: (Float, Float) -> (Float, Float) -> Bool), -- etc ] Over multiple typeclasses, axioms and instance types this leads to a huge amount of repeated, boilerplate code. I asked an earlier question on the Haskell Cafe mailing list about testing polymorphic typeclasses in QuickCheck but I'm realizing the issue is going to crop up beyond testing typeclass axioms and perhaps beyond testing. I can see several workarounds for managing the boilerplate code: 1. Define a set of CPP macros for the property type signatures 2. Do the same sort of thing with Template Haskell but with mapping over a list of desired test types 3. Define a very tedious but succinct set of type aliases allowing most properties to become more cryptic one-liners type Pr_F_F = Float -> Float -> Bool type Pr_F2_F2 = (Float, Float) -> (Float, Float) -> Bool -- etc, then testProperty "(Float, Float)" (axiom_symmetry :: Pr_F2_F2) How do experienced Haskellers deal with this situation? I feel I'm missing something in how I've gone about this. Thanks, Stu

1 0

Why does QuickCheck insist on this class constraint?
by martin 11 Apr '15

11 Apr '15

Hello all, Ghc complainend about Could not deduce (Arbitrary a1) arising from a use of ‘arbitrary’ Could not deduce (Eq a1) arising from a use of ‘arbitrary’ in the following code .. data CList a = CList [Change a] deriving Show instance (Arbitrary c, Eq c) => Arbitrary (CList c) where arbitrary = do ts <- orderedList :: Gen[Time] vs <- listOf arbitrary :: Arbitrary c => Gen [c] return $ CList $ zipWith (\t v -> Chg t v) (nub ts) vs instance (Arbitrary a, Eq a) => Arbitrary (Temporal a) where arbitrary = do d <- arbitrary (CList cs) <- arbitrary :: (Arbitrary a, Eq a) => Gen (CList a) -- <=== return (Temporal d cs) ..if I leave out the class constraints in the line maked with "<===". Why is that so, i.e. why isn't the constraint four lines up (in the instance declaration) sufficient?

3 3

(.) vs ($)
by Vale Cofer-Shabica 06 Apr '15

06 Apr '15

Could someone please explain why the commented line fails spectacularly while the final line succeeds? >import System.IO (getContents) >import System.Environment (getArgs) >fileInput :: IO String >fileInput = getArgs>>=readFirst where > readFirst :: [FilePath] -> IO String > readFirst [] = System.IO.getContents >--readFirst xs = readFile.head xs > readFirst xs = readFile $ head xs I'm particularly confused given the following typings (from ghci): readFile.head :: [FilePath] -> IO String readFile.head [] :: a -> IO String And this is still stranger: :type readFile.head ["foo", "bar"] <interactive>:28:16: Couldn't match expected type `a0 -> FilePath' with actual type `[Char]' In the expression: "foo" In the first argument of `head', namely `["foo", "bar"]' In the second argument of `(.)', namely `head ["foo", "bar"]' <interactive>:28:23: Couldn't match expected type `a0 -> FilePath' with actual type `[Char]' In the expression: "bar" In the first argument of `head', namely `["foo", "bar"]' In the second argument of `(.)', namely `head ["foo", "bar"]' Many thanks in advance, vale

5 6

Haskell Platform SHA
by sojourner 04 Apr '15

04 Apr '15

Downloaded Haskell Platform 2014.2.0.0.0 for Mac OSX from https://www.haskell.org/platform/mac.html. Twice. The SHA-256 on the web page is 62f39246ad95dd2aed6ece5138f6297f945d2b450f215d074820294310e0c48a. But running shasum or openssl on the downloaded file results in 7c00f945fa7afb0f264bf253759f3dd02944a0ffef7b5f13317fa835ce841952.

3 2

Lens: zooming
by Konstantin Saveljev 02 Apr '15

02 Apr '15

Hello, I have this newtype: newtype Awesome a = Awesome (StateT AwesomeState (ExceptT B.ByteString IO) a) deriving (Functor, Applicative, Monad, MonadIO, MonadError B.ByteString, MonadState AwesomeState) AwesomeState is quite deeply nested record. I'm using lens package in my project and can use some basic primitives from that package. But today I read about 'zoom' from lens package and think it might help me write my code a bit faster and cleaner. Right now if I try to update something deeply nested in my state I do it by hand (pseudocode follows): smth <- use $ myState.thisField.otherField myState.thisField.otherField .= smth { _someProperty = "aaa", _otherThing = (smth^.otherThing) { _hereIsSomethingElse = 2 } } and so on. I hope you get the picture. Now I though with zooming I would be able to do it more easily: zoom (myState.thisField.OtherField) $ do someProperty .= "aaa" otherThing.hereIsSomethingElse .= 2 But the problem is that if I try to use zoom I get an error message which I do not understand how to handle. Tried to search for information but couldn't get anything that I could understand (just found a single stackoverflow question which didn't clear it enough for me). The error message: Couldn't match type ‘Control.Lens.Internal.Zoom.Zoomed Awesome’ with ‘Control.Lens.Internal.Zoom.Zoomed m0’ Anyone could suggest what it is that I need to do to be able to use 'zoom'? Best regards, Konstantin Saveljev

2 1

Random Generator
by Shishir Srivastava 02 Apr '15

02 Apr '15

Hi, I am trying to use the output value from the random function to generate the random generator for the next value in list. Below is the code - ---- import System.Random myrandoms :: (RandomGen g, Random a) => g -> [a] myrandoms gen = let (value, newGen) = random gen in value:myrandoms (mkStdGen (value::Int)) ---- however the compilation fails when the module is loaded - [1 of 1] Compiling Main ( myrandoms.hs, interpreted ) myrandoms.hs:3:80: Could not deduce (a ~ Int) from the context (RandomGen g, Random a) bound by the type signature for myrandoms :: (RandomGen g, Random a) => g -> [a] at myrandoms.hs:2:14-48 `a' is a rigid type variable bound by the type signature for myrandoms :: (RandomGen g, Random a) => g -> [a] at myrandoms.hs:2:14 Relevant bindings include value :: a (bound at myrandoms.hs:3:22) myrandoms :: g -> [a] (bound at myrandoms.hs:3:1) In the first argument of `mkStdGen', namely `(value :: Int)' In the first argument of `myrandoms', namely `(mkStdGen (value :: Int))' ---------- Even though I am converting my 'value' parameter to Int in my new generator, I am unable to see the error behind this. Please can someone explain or even better provide a fix. Thanks, Shishir

4 3