December 2008 - Beginners

RE: [Haskell-beginners] Profiling haskell code
by Sayali Kulkarni 08 Dec '08

08 Dec '08

Hey thanks Brent. This helped. I have one more question now. Consider I have two functions 1. gives me a range of numbers in an array. 2. has to get an array input for further process. Then how can I get the array generated by the first function tobe the input of the second function? Regards, Sayali -----Original Message----- From: Brent Yorgey [mailto:byorgey@seas.upenn.edu] Sent: Tuesday, November 18, 2008 5:47 PM To: Sayali Kulkarni Subject: Re: [Haskell-beginners] Profiling haskell code > I have just given it any random input array to be sorted. > The commands that I had sent earlier were tried on Cygwin... > ( > > > $ ghc --make Project.hs -prof -auto-all > > > > > > > > > $ Project +RTS -p > > > ) This ought to work fine. Just a note, to do any reasonable profiling you will need to give it a *much* larger list to sort. Otherwise it will execute so quickly that the timing data you get will be meaningless. > > Also can you tell me any other method for profiling the code that you > know? If you just want to see how long it takes to evaluate certain expressions, you can type ':set +s' in ghci; from then on after every expression you type it will tell you how long it took to evaluate and how much memory was used. -Brent

2 3

[haskell] About CPS form funtions
by 甜瓜 08 Dec '08

08 Dec '08

Hi, I am confused by section 4.6 in Yet Another Haskell Tutorial written by Hal Daume III. The auther provides a CPS form of "fold" funtion, but I don't know: 1. How to transform a normal function into CPS function. I need some hint in writting "cfold". 2. Why "cfold" is CPS form? In my mind, if a CPS funtion calls to other CPS function, it must only feed that function with either direct variables or continuations. But in the tutorial, cfold defines: cfold f z l = cfold' (\x t g -> f x (g t)) z l Note that the lambda function body is f x (g t); which means call g(t) first, and take the result, then call f(x, r). It is illegal in CPS because g(t) will never return. This is not same with function f. Here, f can be treated as atomic operation (belong the CPS system). Anyone can help me? Thank you in advance. --- melon

2 1

gtk2hs not rendering drawingArea
by Norbert Wojtowicz 06 Dec '08

06 Dec '08

Hello, I'm having problems getting a drawingArea to render, I've narrowed the program down to the following skeleton. Any suggestions on what I'm doing wrong? The label gets updated correctly, but the drawingArea just remains gray as if it was never rendered. I'm including an entire compilable skeleton in case someone wants to help me debug it. (I have a feeling I'm just missing something very obvious...) Thanks in advance, Norbert skeletonTest.hs: module Main where import Graphics.UI.Gtk -- hiding (fill) import Graphics.UI.Gtk.Glade import Graphics.Rendering.Cairo.SVG import Graphics.Rendering.Cairo import Control.Monad main = do initGUI let gFile = "brainSpin.glade" windowXmlM <- xmlNew gFile let windowXml = case windowXmlM of (Just windowXml) -> windowXml Nothing -> error "Can't find the glade file \"brainSpin.glade\" in the current directory" window <- xmlGetWidget windowXml castToWindow "brainSpinMain" onDestroy window mainQuit label <- xmlGetWidget windowXml castToLabel "label1" drawArea <- xmlGetWidget windowXml castToDrawingArea "drawArea" widgetShowAll window labelSetText label "foo" -- THIS is the offending code. Originally I was working with SVGs, but I simplified -- it to this, just to track down the problem. It seems any Render () does not -- get updated in the drawArea let r = do setSourceRGB 0 0 0 paint drawin <- widgetGetDrawWindow drawArea renderWithDrawable drawin r mainGUI brainSpin.glade: <?xml version="1.0" encoding="UTF-8" standalone="no"?> <!DOCTYPE glade-interface SYSTEM "glade-2.0.dtd">  <glade-interface> <widget class="GtkWindow" id="brainSpinMain"> <child> <widget class="GtkVBox" id="vbox1"> <property name="visible">True</property> <child> <widget class="GtkLabel" id="label1"> <property name="visible">True</property> <property name="label" translatable="yes">label</property> </widget> </child> <child> <widget class="GtkDrawingArea" id="drawArea"> <property name="visible">True</property> </widget> <packing> <property name="position">1</property> </packing> </child> </widget> </child> </widget> </glade-interface>

2 2

Useful set of -W switches for .ghci?
by Александър Л. Димитров 05 Dec '08

05 Dec '08

Hey list, I'm currently using :set -Wall in my .ghci to enforce some good coding practices on my side. Something like missing type signatures and the like. It has saved me quite a lot of hassle over the last couple of days as I experimented more with Haskell. But it seems, -Wall may be just a little too… overzealous: Prelude> 2^2 Warning: Defaulting the following constraint(s) to type `Integer' `Num t' arising from a use of `^' at <interactive>:1:0-2 Warning: Defaulting the following constraint(s) to type `Integer' `Integral t' arising from a use of `^' at <interactive>:1:0-2 Warning: Defaulting the following constraint(s) to type `Integer' `Num t' arising from a use of `^' at <interactive>:1:0-2 Warning: Defaulting the following constraint(s) to type `Integer' `Integral t' arising from a use of `^' at <interactive>:1:0-2 4 (I've shortened ghci's response a bit) So, do you have a good (recommended) set of -W switches for a newbie playing around in GHCi, so I can learn a good style? Forgive me if it's somewhere on page one of some book or tutorials - I've read so many of both, I'm beginning to forget things. Thanks, Aleks

2 2

getRecursiveContents - example from `Real World Haskell'
by Johann Giwer 05 Dec '08

05 Dec '08

`Real World Haskell' is a great book. I really love it. When I tried an example from the 9th Chapter, I was a bit disappointed: *Main> f <- getRecursiveContents "/home/johann/" Heap exhausted; Current maximum heap size is 128000000 bytes (122 Mb); use `+RTS -M<size>' to increase it. The function lookes like this: getRecursiveContents :: FilePath -> IO [FilePath] getRecursiveContents topdir = do names <- getDirectoryContents topdir let properNames = filter (`notElem` [".", ".."]) names paths <- forM properNames $ \name -> do -- 1 let path = topdir </> name isDirectory <- doesDirectoryExist path if isDirectory then getRecursiveContents path else return [path] return (concat paths) -- 2 OK, I'm using a small machine and my home directory contains ~30,000 files. But that couldn't be the real problem. And even if this function is a small example it should work reliable. The programming language I know best (and this is meant relative -- I'm only a `would be programmer') is python. Python has good support for functional programming, but no builtin tail recursion. So my first idea about the bug in `getRecursiveContents' went in this direction. Two hours later I had worked out this solution: getRecursiveContents :: FilePath -> IO [FilePath] getRecursiveContents = getRecursiveContents' [] where getRecursiveContents' l p = E.handle (\_ -> return (p:l)) $ do -- 3 c <- getDirectoryContents p let c' = filter (`notElem` [".", ".."]) c x <- foldM (\l' p' -> getRecursiveContents' l' (p </> p')) l c' -- 4 return (x) Folding (4) and appending (3) would give less memory usage than mapping (1) and concatenation (2), I thought. This function worked well for small directory (for which the original one did, too). But tested with my home directory it went into an infinite loop. That led me to the actually problem: `doesDirectoryExist' also accepts symlinks to directories. Another hour later this was fixed: getRecursiveContents :: FilePath -> IO [FilePath] getRecursiveContents = getRecursiveContents' [] where getRecursiveContents' l p = do s <- getSymbolicLinkStatus p if isDirectory s then E.handle (\_ -> return (p:l)) $ do c <- getDirectoryContents p let c' = filter (`notElem` [".", ".."]) c x <- foldM (\l' p' -> getRecursiveContents' l' (p </> p')) l c' return (x) else return (p:l) Finally I fixed the original function (this only took about 30 min :-). The handle (5) catches errors caused by unreadable directories getRecursiveContents :: FilePath -> IO [FilePath] getRecursiveContents topdir = E.handle (\_ ->return [topdir]) $ do -- 5 names <- getDirectoryContents topdir let properNames = filter (`notElem` [".", ".."]) names paths <- forM properNames $ \name -> do let path = topdir </> name s <- getSymbolicLinkStatus path if isDirectory s then getRecursiveContents path else return [path] return (concat paths) The imports for all functions mentioned above are: import Control.Monad ( forM, filterM, foldM ) import qualified Control.Exception as E import System.Directory (doesDirectoryExist, getDirectoryContents) import System.FilePath ((</>)) import System.Posix (getSymbolicLinkStatus, isDirectory) Any suggestions about this solution are welcome. Johann

1 0

Special session on Haskell language
by John Edward 03 Dec '08

03 Dec '08

Special session on Haskell language at MULTICONF-09 call for papers Special session on Haskell language will be held at the 2009 Multi Conference in Computer Science, Information Technology and Control systems and Computational Science and Computer Engineering (MULTICONF-09) (website: http://www.PromoteResearch.org) and it will be held during July 13-16 2009 in Orlando, FL, USA. We invite draft paper submissions. The event consists of the following conferences: · International Conference on Artificial Intelligence and Pattern Recognition (AIPR-09) · International Conference on Automation, Robotics and Control Systems (ARCS-09) · International Conference on Bioinformatics, Computational Biology, Genomics and Chemoinformatics (BCBGC-09) · International Conference on Enterprise Information Systems and Web Technologies (EISWT-09) · International Conference on High Performance Computing, Networking and Communication Systems (HPCNCS-09) · International Conference on Information Security and Privacy (ISP-09) · International Conference on Recent Advances in Information Technology and Applications (RAITA-09) · International Conference on Software Engineering Theory and Practice (SETP-09) · International Conference on Theory and Applications of Computational Science (TACS-09) · International Conference on Theoretical and Mathematical Foundations of Computer Science (TMFCS-09) The website http://www.PromoteResearch.org contains more details. Sincerely John Edward Publicity committee

1 0

What causes <<loop>>?
by Martin Hofmann 03 Dec '08

03 Dec '08

I've already posted this mail on haskell-cafe, but apparently the subject suggested a too simple question, so I try it here again. I am picking up a discussion with the same topic from haskell-users on 8th November. Thunks with reference on themselves was mentioned as main reason for <<loop>>. > A safe recursive definition would be > let x = Foo (x+1) > However, if you leave out the constructor, > let x = x + 1 > you get a <<loop>> (or a deadlock). > Are there any other reasons? I am trying to debug monadic code which stores state information in a record maintaining several Data.Maps, but in vain so far. A state is modified/changed in several steps by a compound function i.e. changeA $ changeB $ changeC state Could this also lead to a deadlock? If so, can I prevent this using CPS? If the state transformation is the main purpose/computation of the monad at all, is it better to use CPS? Is code using mtl, records or Data.Map more prone to <<loop>> or does this not matter at all. How can I identify self-referencing thunks more easily? Is there any rule of thumb to prevent <<loop>>? Are there any less obvious newbie mistakes causing <<loop> then the one above? Sorry, a lot of questions at once, but I am kind of helpless because I can't find any reason of my <<loop>>, so any comments, experience, and tips are highly appreciated. Thanks, Martin

1 0

ANNOUNCE: Haskell Communities and Activities Report (15th ed., November 2008)
by Janis Voigtlaender 03 Dec '08

03 Dec '08

On behalf of the many, many contributors, I am pleased to announce that the Haskell Communities and Activities Report (15th edition, November 2008) http://www.haskell.org/communities/ is now available from the Haskell Communities home page in PDF and HTML formats. Many thanks go to all the people that contributed to this report, both directly, by sending in descriptions, and indirectly, by doing all the interesting things that are reported. I hope you will find it as interesting a read as I did. If you have not encountered the Haskell Communities and Activities Reports before, you may like to know that the first of these reports was published in November 2001. Their goal is to improve the communication between the increasingly diverse groups, projects, and individuals working on, with, or inspired by Haskell. The idea behind these reports is simple: Every six months, a call goes out to all of you enjoying Haskell to contribute brief summaries of your own area of work. Many of you respond (eagerly, unprompted, and sometimes in time for the actual deadline ;-) to the call. The editor collects all the contributions into a single report and feeds that back to the community. When I try for the next update, six months from now, you might want to report on your own work, project, research area or group as well. So, please put the following into your diaries now: ---------------------------------------- End of April 2009: target deadline for contributions to the May 2009 edition of the HC&A Report ---------------------------------------- Unfortunately, many Haskellers working on interesting projects are so busy with their work that they seem to have lost the time to follow the Haskell related mailing lists and newsgroups, and have trouble even finding time to report on their work. If you are a member, user or friend of a project so burdened, please find someone willing to make time to report and ask them to "register" with the editor for a simple e-mail reminder in April (you could point me to them as well, and I can then politely ask if they want to contribute, but it might work better if you do the initial asking). Of course, they will still have to find the ten to fifteen minutes to draw up their report, but maybe we can increase our coverage of all that is going on in the community. Feel free to circulate this announcement further in order to reach people who might otherwise not see it. Enjoy! Janis Voigtlaender <hcar at haskell.org> -- Dr. Janis Voigtlaender http://wwwtcs.inf.tu-dresden.de/~voigt/ mailto:voigt@tcs.inf.tu-dresden.de

3 2

Memoization
by abdullah abdul Khadir 01 Dec '08

01 Dec '08

Hi, I am a student and we had an assignment in Haskell. The question, was given a string of the form "1-2+3*5-7+4-6+3" i.e., any sequence of integers as well as some operators between them we had to find a maximum possible value for the expression as well as the expression itself . So for maxval "1-2+3*5-7+4-6+3" it is (76,"(1-((2+3)*((5-(7+4))-(6+3))))"). The function we had to write was maxval :: String -> (Int,String). For further details on the question, have a look at our sir's web page here<http://www.cmi.ac.in/%7Emadhavan/courses/programming08/assignment6.txt>. I solved the question, we had to use memoization, and submitted the solution. It is given below. Now the problem is I am just wondering if it can be solved in a better manner. Translation : Is there some way in Haskell to do it in a more simpler way and as well as to reduce the number of lines of the program. > {- > > --------------------------------------------------------------------------------------------------------------------------- > *********************** module Memo.hs > ****************************************************** > > --------------------------------------------------------------------------------------------------------------------------- > -} > module > Memo(Table,emptytable,memofind,memolookup,memoupdate,memoupdateArray) where > > data (Eq a) => Table a b c = T [(a,a,(b,c),(b,c))] > deriving (Eq,Show) > > emptytable :: (Eq a) => (Table a b c) > emptytable = T [] > > memofind :: (Eq a) => (Table a b c) ->(a,a)-> Bool > memofind (T []) _ = False > memofind (T ((y,z,(v1,s1),(v2,s2)):l)) x > | x == (y,z) = True > | otherwise = memofind (T l) x > > memolookup :: (Eq a) => (Table a b c) -> (a,a) -> ((b,c),(b,c)) > memolookup (T ((y,z,(v1,s1),(v2,s2)):l)) x > | x == (y,z) = ((v1,s1),(v2,s2)) > | otherwise = memolookup (T l) x > > memoupdate :: (Eq a) => (Table a b c) -> (a,a,(b,c),(b,c)) -> (Table a b c) > memoupdate (T l) x = T (x:l) > > memoupdateArray :: (Eq a) => (Table a b c) -> [(a,a,(b,c),(b,c))] -> (Table > a b c) > memoupdateArray t [] = t > memoupdateArray t (x:xs) = memoupdate (memoupdateArray t xs) x > > {- > > --------------------------------------------------------------------------------------------------------------------------- > ***********************End of module > Memo.hs*********************************************** > > --------------------------------------------------------------------------------------------------------------------------- > -} > > > {- > > --------------------------------------------------------------------------------------------------------------------------- > ******************The actual program , > assign-6.hs****************************************** > > --------------------------------------------------------------------------------------------------------------------------- > -} > > minArray :: [(Int,String)] -> (Int,String) > minArray ((x,expr):[]) = (x,expr) > minArray ((x,expr):l) |((min x (fst (minArray l))) ==x) = (x,expr) > |otherwise = (minArray l) > > maxArray :: [(Int,String)] -> (Int,String) > maxArray ((x,expr):[]) = (x,expr) > maxArray ((x,expr):l) |((max x (fst (minArray l))) ==x) = (x,expr) > |otherwise = (minArray l) > > import Memo > import Char > > type Tuple = (Int,Int,(Int,String),(Int,String)) > > maxval :: String ->(Int, String) > maxval expr = snd (memolookup (buildmemo expr 1 emptytable) (1,length > expr)) > > initmemo :: (String) -> (Table Int Int String) > initmemo expr = (memoupdateArray (emptytable) > [(i,i,(toInt(expr!!(i-1)),[expr!!(i-1)]), > (toInt(expr!!(i-1)),[expr!!(i-1)]))|i<-[1..length > expr],j<-[0,1],i `mod` 2 ==1]) > > buildmemo :: (String)->Int -> (Table Int Int String)-> (Table Int Int > String) > buildmemo expr col memo | (col > length expr) = memo > | (col == 1) = buildmemo expr 3 (memoupdateArray > (emptytable) > [(i,i,(toInt(expr!!(i-1)),[expr!!(i-1)]), > > (toInt(expr!!(i-1)),[expr!!(i-1)]))|i<-[1..length expr],i `mod` 2 ==1]) > | otherwise = buildmemo expr (col+2) (memoupdateArray > (memo) (createList expr memo (1,col))) > > createList :: String-> (Table Int Int String) -> (Int,Int) -> [Tuple] > createList expr memo (i,j) | j > (length expr) = [] > | otherwise = (i,j,min_expr,max_expr):(createList expr > memo (i+2,j+2)) > where > min_expr = minArray [x | (x,y) <- list] > max_expr = maxArray [y | (x,y) <- list] > list = [(compute memo (i,k) (k+2,j) > (expr!!k))|k<-[i..j-2],k `mod` 2 ==1] > > compute :: (Table Int Int > String)->(Int,Int)->(Int,Int)->Char->((Int,String),(Int,String)) > compute memo (x1,x2) (y1,y2) op |op == '+' = > ((min1+min2,"("++min1_expr++"+"++min2_expr++")"), > > (max1+max2,"("++max1_expr++"+"++max2_expr++")")) > |op == '-' = > ((min1-max2,"("++min1_expr++"-"++max2_expr++")"), > > (max1-min2,"("++max1_expr++"-"++min2_expr++")")) > |op == '*' = (minArray xs,maxArray xs) > where > xs = [(min1*min2,"("++min1_expr++"*"++min2_expr++")"), > (min1*max2,"("++min1_expr++"*"++max2_expr++")"), > (max1*min2,"("++max1_expr++"*"++min2_expr++")"), > > (max1*max2,"("++max1_expr++"*"++max2_expr++")")] > ((min1,min1_expr),(max1,max1_expr)) = (memolookup memo > (x1,x2)) > ((min2,min2_expr),(max2,max2_expr)) = (memolookup memo > (y1,y2)) > > minArray :: [(Int,String)] -> (Int,String) > minArray ((x,expr):[]) = (x,expr) > minArray ((x,expr):l) |((min x (fst (minArray l))) ==x) = (x,expr) > |otherwise = (minArray l) > > maxArray :: [(Int,String)] -> (Int,String) > maxArray ((x,expr):[]) = (x,expr) > maxArray ((x,expr):l) |((max x (fst (maxArray l))) ==x) = (x,expr) > |otherwise = (maxArray l) > > toInt :: Char -> Int > toInt x = ord x - ord '0' > > {- > > --------------------------------------------------------------------------------------------------------------------------- > ***********************End of program > assign-6.hs******************************************* > > --------------------------------------------------------------------------------------------------------------------------- > -}

2 1