- Beginners - Haskell.org

Show for Parameterized Type
by Hartmut 08 Aug '11

08 Aug '11

Hello, I made a parameterized data type EW, which builds on a type of class Read and Show. When showing EW's it shall prefix the output with "EW:". data (Read a,Show a) => EW a = EW a x01 = EW 20 x02 = EW "Test" instance Show (EW a) where show (EW x) = show "EW:" ++ show x But I got a syntax error with this above at "show (EW x) = ...": No instance of (Read a) asrising a use of 'EW' in the pattern .... How can I formulate this show method correctly? I'd appreciate Your help Hartmut

2 4

haddock instance documentation
by Christopher Howard 08 Aug '11

08 Aug '11

I'm learning to comment my code for haddock. However, haddock seems to be ignoring my documentation comments for instance implementations. Instead, it just uses the default explanation given in the original class definition. Does this require some kind of special syntax? -- frigidcode.com theologia.indicium.us

2 3

Re: [Haskell-beginners] Conciseness question
by Hein Hundal 08 Aug '11

08 Aug '11

Manfred Wrote: > Hmm, not quite sure I'm understanding why Data.Map would > help. > > What I want to have is something like the following without > the > verboseness of it: > > -- this is a minimal example. > -- Assume I would have some 15 such values. > a = "bla" > b = "bla2" > > valList = [ a, b ] > > Now in my program on the one hand I want to do something > with all > values, thus: map doSomething valList > > On the other hand I frequently want use single values in my > program, > like e.g.: > let x = "suffix " ++ a > > > What I don't want to do is to write a definition like > valList > because if I add a new value I have to remind myself not to > forget to > add it to valList too. Hi Manfred, I think that the Map type is about the best you are going to get. (I am a beginner, so take my advice with a few grains of salt.) Here is some code that does something like what you want. -- Start Code import Data.Map as M -- Makes a Map m1 = M.fromList [('a', "bla"), ('b', "bla2"), ('c', "bla3")] -- Function for looking up values in m1 look c = M.findWithDefault "fail" c m1 valList = M.keys m1 showSuffix = "suffix " ++ look 'a' -- Add three ! to the end of every string in m1 m2 = fmap ( ++"!!!") m1 -- Add a new key-value pair m3 = M.insert 'd' "blabla" m2 -- End Start Code Cheers, Hein

1 0

Further constraining types
by Christopher Howard 07 Aug '11

07 Aug '11

Let's say I have "f", which is a function of the following type: f :: Int -> Int However, let's say f is only capable of handling positive integers. Let's say that I'm committed to making f a complete function in the sense that (1) the pattern matching of the function is always complete and (2) there are no internal aborts, like an "error" call or an "undefined" expression. Obviously I could change the type to f :: Int -> Maybe Int ...to deal with the case where a negative parameter is passed in. But it seems like what I really want is something like this: f :: Positive Int -> Int I.e., the "positiveness" is hard-coded into the parameter type. But how do I do this? I was thinking it would involve some kind of "Positive Int" type, and some kind of "constructor" function like so: positiveNum :: Int -> Positive Int However, then this constructor function must deal with the problem of receiving a negative integer, and thus I have only shifted the problem. It is still an improvement, but yet it seems like I am missing some important concept here... -- frigidcode.com theologia.indicium.us

9 21

hslogger question
by Manfred Lotz 07 Aug '11

07 Aug '11

Hi there, Using hslogger I want to get - error messages and above to stdout and to logfile - debug messages and above to logfile only. Here is what I tried: import System.Log.Logger import System.Log.Handler.Simple import System.Log.Handler (setFormatter) import System.Log.Formatter -- By default, all messages of level WARNING and above are sent to stderr. -- Everything else is ignored. main :: IO () main = do -- all messages of level ERROR and above to stderr. updateGlobalLogger rootLoggerName (setLevel ERROR) h <- fileHandler "debug.log" DEBUG >>= \lh -> return $ setFormatter lh (simpleLogFormatter "[$time : $loggername : $prio] $msg") updateGlobalLogger rootLoggerName (addHandler h) errorM "MyApp.Init" "This is a bad error" -- This message will go to logfile only. debugM "MyApp.Main" "This buggy component is buggy" -- This message will go to logfile only. warningM "MyApp.Finish" "Still Buggy" errorM goes to stderr and logfile as expected. However, debugM and warningM are not to be seen at all. What am I doing wrong? -- Manfred

1 1

Looking for alternative practices suggestions
by Michael Litchard 06 Aug '11

06 Aug '11

I'm finding that in more than one instance I pass a data structure to a function, simply so that I can pass it to it's helper function. It bugs me that I'm passing a value that isn't being used directly. This seems wrong. Example: I have a "data URLSequence" that contains a way to calculate the ip address of a URL. This gets passed to a helper function that generates a particular URL, which then populates the URLSequence. Is there a standard practice to avoid what I am talking about? Or is this normal and I should accept it?

6 7

repetition
by Luca Ciciriello 04 Aug '11

04 Aug '11

Hi All. Is there any function in Prelude that removes the repeated elements in a list? In example I've a list like this one: xs = ["3","3","3","3","3","4","4","4","4","4","5","5","5","5","5","6","6","6","6","6","6","6"] I need a function f such that f xs = ["3","4","5","6"] thanks in advance for any answer. Luca

6 10

parallel quicksort
by Ovidiu Deac 03 Aug '11

03 Aug '11

I'm trying to write a parallel quicksort algorithm for lists. This is my original implementation: quickSort [] = [] quickSort (x:xs) = (quickSort small) ⊕ [x] ⊕ (quickSort big) where small = [p | p ← xs, p ≤ x] big = [p | p ← xs, p > x] and the output is: $ ghc -threaded -rtsopts -o quicksort quicksort.hs && ./quicksort +RTS -N2 -RTS [1 of 1] Compiling Main ( quicksort.hs, quicksort.o ) Linking quicksort ... Sorting 1000000 elements... CPU Time: 13290000000000 Time elapsed: 8.929503s ovidiu@asus:~/work/haskell$ ghc -threaded -rtsopts -o quicksort quicksort.hs && ./quicksort +RTS -N2 -RTS Sorting 1000000 elements... CPU Time: 11240000000000 Time elapsed: 7.785293s ovidiu@asus:~/work/haskell$ ghc -threaded -rtsopts -o quicksort quicksort.hs && ./quicksort +RTS -N1 -RTS Sorting 1000000 elements... CPU Time: 6790000000000 Time elapsed: 6.817648s ovidiu@asus:~/work/haskell$ ghc -threaded -rtsopts -o quicksort quicksort.hs && ./quicksort +RTS -N1 -RTS Sorting 1000000 elements... CPU Time: 6980000000000 Time elapsed: 7.006658s ovidiu@asus:~/work/haskell$ ghc -threaded -rtsopts -o quicksort quicksort.hs && ./quicksort +RTS -N1 -RTS Sorting 1000000 elements... CPU Time: 5900000000000 Time elapsed: 5.932236s ...so the conclusion is that using option N1 is faster the N2. This makes sense. Then I tried to parallelize it: First try: ----------------- quickSort [] = [] quickSort (x:xs) = small `pseq` ((quickSort small) ⊕ [x] ⊕ (quickSort big)) where small = [p | p ← xs, p ≤ x] big = [p | p ← xs, p > x] $ ghc -threaded -rtsopts -o quicksort quicksort.hs && ./quicksort +RTS -N2 -RTS [1 of 1] Compiling Main ( quicksort.hs, quicksort.o ) Linking quicksort ... Sorting 1000000 elements... CPU Time: 12020000000000 Time elapsed: 8.29653s This is slower then the non-parallel version Second try: --------------- quickSort [] = [] quickSort (x:xs) = small `par` ((quickSort small) ⊕ [x] ⊕ (quickSort big)) where small = [p | p ← xs, p ≤ x] big = [p | p ← xs, p > x] $ ghc -threaded -rtsopts -o quicksort quicksort.hs && ./quicksort +RTS -N2 -RTS Sorting 1000000 elements... CPU Time: 14750000000000 Time elapsed: 10.772271s Even slower Third try: ------------- quickSort [] = [] quickSort (x:xs) = small `par` (big `par` ((quickSort small) ⊕ [x] ⊕ (quickSort big))) where small = [p | p ← xs, p ≤ x] big = [p | p ← xs, p > x] $ ghc -threaded -rtsopts -o quicksort quicksort.hs && ./quicksort +RTS -N2 -RTS [1 of 1] Compiling Main ( quicksort.hs, quicksort.o ) Linking quicksort ... Sorting 1000000 elements... CPU Time: 134490000000000 Time elapsed: 122.917093s Fourth try: ------------------------ quickSort [] = [] quickSort (x:xs) = small `par` (big `pseq` ((quickSort small) ⊕ [x] ⊕ (quickSort big))) where small = [p | p ← xs, p ≤ x] big = [p | p ← xs, p > x] $ ghc -threaded -rtsopts -o quicksort quicksort.hs && ./quicksort +RTS -N2 -RTS [1 of 1] Compiling Main ( quicksort.hs, quicksort.o ) Linking quicksort ... Sorting 1000000 elements... CPU Time: 12770000000000 Time elapsed: 8.844304s ----------------------------- It seems that I'm unable to make it parallel. What am I doing wrong? Thanks, ovidiu See the full code below: -------------------------------------------------- module Main where import Prelude import Data.List import Data.Time.Clock import System.CPUTime import System.Random import Control.Parallel import Control.Exception (evaluate) import Control.DeepSeq (rnf) import Text.Printf quickSort [] = [] quickSort (x:xs) = small `par` (big `par` ((quickSort small) ⊕ [x] ⊕ (quickSort big))) where small = [p | p ← xs, p ≤ x] big = [p | p ← xs, p > x] randomlist :: Int → StdGen → [Int] randomlist n = take n∘unfoldr (Just∘random) len = 10 ↑ 6 time = do t ← getCurrentTime c ← getCPUTime return (t,c) measure f p = do (t1, c1) ← time evaluate $ rnf $ f p (t2, c2) ← time return (diffUTCTime t2 t1, c2 - c1) main = do seed ← newStdGen let rs = randomlist len seed printf "Sorting %d elements...\n" len (t, cpu) ← measure quickSort rs printf "CPU Time: %dλnTime elapsed: %sλn" cpu (show t)

2 4

force strict expression evaluation
by Ovidiu Deac 03 Aug '11

03 Aug '11

I'm trying to do some performance evaluation and I'm stuck with the fact that Haskell's lazy evaluation - which make my sort extremely fast :) I read this page: http://www.haskell.org/haskellwiki/Performance/Strictness but I didn't get it so I'm asking here: How do I make the function 'measure' to actually force the evaluation of (f p)? Thanks, ovidiu See the code below: ------------------------------------ module Main where import Prelude import Data.List import Data.Time.Clock import System.Random quickSort [] = [] quickSort (x:xs) = (quickSort small) ++ [x] ++ (quickSort big) where small = [p | p <- xs, p <= x] big = [p | p <- xs, p > x] randomlist :: Int -> StdGen -> [Int] randomlist n = take n . unfoldr (Just . random) len = 10 ^ 10 measure f p = do t1 <- getCurrentTime let sorted = f p t2 <- getCurrentTime let diff = diffUTCTime t2 t1 return diff main = do seed <- newStdGen let rs = randomlist len seed putStrLn $ "Sorting " ++ (show len) ++ " elements..." t <- measure quickSort rs putStrLn $ "Time elapsed: " ++ (show t)

3 3

Network client - reading and writing to a socket
by Manfred Lotz 02 Aug '11

02 Aug '11

Hi there, I'm trying to write a network client which connects to an IMAP server thus reading from and writing to socket 143. I have an initial solution which works except that laziness bites me. Perhaps the whole solution using connectTo and handle is the wrong approach. Here is the code: module Main where import System.IO import qualified Data.ByteString.Char8 as B import Network server :: String server = "127.0.0.1" port :: PortID port = PortNumber 143 sendMsg :: Handle -> String -> IO () sendMsg h m = do putStrLn ("Sending command: " ++ m) B.hPutStrLn h (B.pack m) >> hFlush h recvMsg :: Handle -> IO B.ByteString recvMsg h = do c <- B.hGet h 1 c' <- B.hGetNonBlocking h 40000 return $ B.concat [c,c'] main :: IO () main = withSocketsDo $ do h <- connectTo server port hSetBuffering h LineBuffering imapDialog h imapDialog :: Handle -> IO () imapDialog h = do greet <- recvMsg h B.putStrLn greet sendMsg h "1 LOGIN manfred \"password\"" resp <- recvMsg h B.putStrLn resp sendMsg h "2 SELECT HAM-learn" resp1 <- recvMsg h B.putStrLn resp1 sendMsg h "3 FETCH 1:* (uid flags internaldate body[header.fields (Message-Id)])" resp2 <- recvMsg h B.putStrLn resp2 sendMsg h "4 FETCH 1 (rfc822)" resp3 <- recvMsg h B.putStrLn resp3 The problem is that the message itself is some 30K big and I only get some 16K of the message. How could I force to get the whole message? -- Manfred

5 14