- Beginners - Haskell.org

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

07 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 02 Aug '11

02 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

linker error, protips welcome
by Michael Litchard 02 Aug '11

02 Aug '11

ghci is trying to load both network-2.3.0.2 and network-2.3.0.4 I don't have 2.3.02 installed I checked package.conf, and it's not there. What can I check to see what's going on? hcifoo> :main Loading package bytestring-0.9.1.10 ... linking ... done. Loading package transformers-0.2.2.0 ... linking ... done. Loading package mtl-2.0.1.0 ... linking ... done. Loading package parsec-3.1.1 ... linking ... done. Loading package unix-2.4.2.0 ... linking ... done. Loading package network-2.3.0.2 ... linking ... done. Loading package array-0.3.0.2 ... linking ... done. Loading package old-locale-1.0.0.2 ... linking ... done. Loading package old-time-1.0.0.6 ... linking ... done. Loading package HTTP-4000.1.1 ... linking ... done. Loading package containers-0.4.0.0 ... linking ... done. Loading package deepseq-1.1.0.2 ... linking ... done. Loading package text-0.11.0.6 ... linking ... done. Loading package curl-1.3.7 ... linking ... done. Loading package HUnit-1.2.2.3 ... linking ... done. Loading package filepath-1.2.0.0 ... linking ... done. Loading package directory-1.1.0.0 ... linking ... done. Loading package process-1.0.1.5 ... linking ... done. Loading package time-1.2.0.3 ... linking ... done. Loading package random-1.0.0.3 ... linking ... done. Loading package haskell98-1.1.0.1 ... linking ... done. Loading package network-2.3.0.4 ... GHCi runtime linker: fatal error: I found a duplicate definition for symbol my_inet_ntoa whilst processing object file /home/mlitchard/.cabal/lib/network-2.3.0.4/ghc-7.0.3/HSnetwork-2.3.0.4.o This could be caused by: * Loading two different object files which export the same symbol * Specifying the same object file twice on the GHCi command line * An incorrect `package.conf' entry, causing some object to be loaded twice. GHCi cannot safely continue in this situation. Exiting now. Sorry.

1 0

Suggestions for creating a "bind" function that can be applied to different things?
by Costello, Roger L. 02 Aug '11

02 Aug '11

Hi Folks, When I say: "Let x be of datatype Int." I think the proper terminology is "bind". That is, I bind the name "x" to the Int datatype. Is that the correct terminology? Assuming it is, I would like to bind a name to many different things. I seek your suggestions on how to do this. First let dt1, dt2, dt3, dt4 be "DataTypes": dt1, dt2, dt3, dt4 :: DataType And let "Name" be synonymous with String: type Name = String And let title, author, date, cost be "Elements": title, author, date, cost, book :: Element I would like a "bind" function that binds a Name to a DataType to create an Element: bind :: Name -> DataType -> Element Here are a few examples of using bind to create Elements: title = bind "Title" dt4 author = bind "Author" dt4 date = bind "Date" dt4 I would also like to bind a Name to a DataType to create an "Attribute": bind :: Name -> DataType -> Attribute Here's an example of using bind to create an Attribute: currency = bind "Currency" dt3 And I'd like to bind an Attribute to an Element: bind :: Attribute -> Element -> Element Here's an example of binding the currency Attribute to a cost Element: cost = bind currency (bind "Cost" dt1) Finally, I'd like to create an Element by binding a Name to a list of Elements: bind :: Name -> [Element] -> Element Here's an example of this: book = bind "Book" [title, author, date, cost] As you see, I'd like to "bind" to lots of different things. But I can't create multiple functions with the same name, "bind". And I'd rather not create a function for each thing that I want to bind to, e.g., elementBind, attributeBind, attributeToElementBind, multipleElementsBind. There must be an elegant solution. What is your suggestion? /Roger

2 1