- Haskell-Cafe - Haskell.org

[Haskell-cafe] Re: blas bindings, why are they so much slower the C?
by Patrick Perry 24 Jul '08

24 Jul '08

Last month Anatoly Yakovenko published some disturbing numbers about the Haskell BLAS bindings I wrote being significantly slower than using plain C. I wanted to let everyone know that I've closed the performance gap, and now for doing ten million dot products, the overhead for using Haskell instead of C is about 0.6 seconds on my machine, regardless of the size of the vectors. The next version will incorporate the changes. If you can't wait for a formal release, the darcs repository is at http://www-stat.stanford.edu/~patperry/code/blas/ Anyone interested in more details can check out my blog: http://quantile95.com/2008/07/24/addressing-haskell-blas-performance-issues/ Thanks everyone for the input on this (especially Anatoly). If any else finds any performance discrepancies, please let me know and I will do whatever I can to fix them. Patrick

2 2

ansi2html - one program, several issues
by Krzysztof Skrzętnicki 24 Jul '08

24 Jul '08

Hi all Recently I wrote a little program that takes text file with ANSI color codes and outputs HTML file. Example input and output files (also attached): http://tener.videomed.com.pl/ansi2html/samo_pk_merusa.log http://tener.videomed.com.pl/ansi2html/samo_pk_merusa.log.html The good thing: it is linear in time. But this is not so much surprising given the problem stated. The bad thing: it is also linear in space and have a feeling that it can run a lot faster. I decided to optimize the code and now I have two things I don't understand and one bug: 1) Profiling shows that very simple functions are source of great memory and time consumption. However, if I turn them off and simply print their input arguments instead, the overall time and memory consumption doesn't change. But now another function is acting badly. My guess: somehow the cost of Parsec code is shifted into whatever function is using it's output. Let's see: doOneFile :: String -> IO () doOneFile fname = do t1 <- getCurrentTime doesFileExist (fname ++ ".html") >>= \b -> if b then hPutStrLn stderr $ printf "File already processed, skipping: %s" fname else do src <- readFile fname out <- openFile (fname ++ ".html") WriteMode let parsed = (parse mainParser fname src) hSetBuffering out (BlockBuffering (Just 64000)) hPutStrLn out "<html>" hPutStrLn out "<body bgcolor=\"black\">" hPutStrLn out "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">" hPutStrLn out "<span style=\"font-family: monospace; font-size: 13;\" ><span>" execStateT (hPrintHtml (St id)) (out,emptyStyle) -- wypisujemy pierwszy wiersz execStateT (mapM_ *hPrintHtml* (((either (\x -> (trace $ show x) [] ) (id) parsed)) :: [CharOrColor])) (out,emptyStyle) -- *[1]* -- mapM_ (hPutStr out . show) (((either (\x -> (trace $ show x) [] ) (id) ((parse mainParser fname src)))) :: [CharOrColor]) -- *[2]* hPutStrLn out "</span></span>" hPutStrLn out "</body>" hPutStrLn out "</html>" t2 <- getCurrentTime hPutStrLn stderr $ printf "File %s processed. It took %s. File size was %d characters." fname (show $ diffUTCTime t2 t1) (length src) hFlush out hClose out When profiled: beginSpan Main 32.7 39.7 hPrintHtml Main 21.1 18.4 dataParser Main 17.3 18.6 doOneFile Main 10.4 7.4 colorParser Main 8.7 8.8 justColor Main 3.2 2.0 mainParser Main 3.2 1.9 code0' Main 1.1 1.1 Ok, let's exchange [1] for [2]. Now: doOneFile Main 53.4 59.9 dataParser Main 21.6 21.7 colorParser Main 13.6 10.3 justColor Main 3.8 2.3 mainParser Main 3.6 2.2 code0' Main 1.3 1.2 2) I tried to use both of my processor cores. But simply typing spawning a thread for every file quickly lead to swapping. So instead of this I implemented "thread pool" with fixed number of threads. -- begin code -- type Pool = Chan () takeFromPool :: Pool -> IO () takeFromPool p = readChan p >> return () fillPool :: Pool -> IO () fillPool p = writeChan p () makeThreadPool :: Int -> IO Pool makeThreadPool num = do p <- newChan repeatNum num (fillPool p) return p repeatNum :: Int -> IO () -> IO () repeatNum n act | n > 0 = act >> (repeatNum (n-1) act) | otherwise = return () sparkComp :: Pool -> IO () -> IO (MVar ()) sparkComp pool comp = do takeFromPool pool >>= evaluate mvar <- newEmptyMVar >>= evaluate forkIO $ (comp >> fillPool pool >> putMVar mvar ()) >>= evaluate -- core dumps when changed do forkOS return mvar mapMPar :: (a -> IO ()) -> [a] -> Int -> IO () mapMPar comp lst numT = do tPool <- makeThreadPool numT mvars <- mapM (sparkComp tPool) (map comp lst) mapM_ takeMVar (mvars :: [MVar ()]) return () numThreads = 2 -- end code -- Now, when compiled with -threaded and run with -N2 the program is not faster, but this may be result of -threaded switch. The real puzzle for me: without -threaded switch code using mapMPar is 30% faster then using mapM_, even when numThreads = 1. I have no idea why. 3) When I changed my thread pool implementation to use forkOS instead of forkIO it core dumped when run with -N2 and multiple file input. With -N1 it was ok. Unfortunately I was unable to reproduce this bug after I changed something unrelated to above code. I'm working on GHC version 6.9.20080622, Windows XP. Perhaps someone will succeed reproducing it. Do you have any ideas about this program? Best regards Christopher Skrzętnicki

6 14

Profiling nested case
by Mitar 24 Jul '08

24 Jul '08

Hi! I am making a simple raycasting engine and have a function which take a point in space and return a color of an object (if there is any) at this point in space. And because the whole thing is really slow (or was really slow) on simple examples I decided to profile it. It takes around 60 seconds for a 640x480 px image with 400 depth of field. This is at worst 122,880,000 calculations (if the scene is rather empty) of a coordinate of a point in space and then checking for a color. And 60 seconds look really a lot to me for that. So I went profiling and found out that the strange part of code is the main color checking function which has a list of objects (at this time the list is hardcoded). It looks like this: world :: SpacePoint -> VoxelColor world point = case msum . sequence elements $ point of Just v -> v Nothing -> noColor where elements = [redSphere (0,50,0) 50, greenSphere (25,-50,0) 50, blueSphere (-150,0,150) 50] So three spheres in a world and I check if the point is in any of them. Like that: sphere :: SpacePoint -> BasicReal -> VoxelColor -> WorldElement -- center of sphere, it's radius, it's color sphere (x0,y0,z0) r color (x,y,z) | x' * x' + y' * y' + z' * z' <= r * r = Just color | otherwise = Nothing where x' = x - x0 y' = y - y0 z' = z - z0 redSphere :: SpacePoint -> BasicReal -> WorldElement redSphere c r = sphere c r redColor So profiling told me that world function takes 38.4 % of all running time. So I decided to play with it. Maybe a more direct approach would be better: world :: SpacePoint -> VoxelColor world point = findColor [redSphere (0,50,0) 50, greenSphere (25,-50,0) 50, blueSphere (-150,0,150) 50] where findColor [] = noColor findColor (f:fs) = case f point of Just v -> v Nothing -> findColor fs Great, it improved. To 40 s. But still it was too much. I tried this: world :: SpacePoint -> VoxelColor world point = case redSphere (0,50,0) 50 point of Just v -> v Nothing -> case greenSphere (25,-50,0) 50 point of Just v -> v Nothing -> case blueSphere (-150,0,150) 50 point of Just v -> v Nothing -> noColor And it took 15 s. And also the profiling was like I would anticipate. Calculating points coordinates and checking spheres takes almost all time. So any suggestions how could I build a list of objects to check at runtime and still have this third performance? Why this big difference? (I am using GHC 6.8.3 with -O2 compile switch.) (The <* operator is casting a ray, that is multiplying a ray direction vector with a scalar factor.) Mitar

10 17

ghc socket weirdness
by Tim Newsham 24 Jul '08

24 Jul '08

FreeBSD/7.0 amd64: GHCi, version 6.8.2: http://www.haskell.org/ghc/ :? for help Loading package base ... linking ... done. Prelude> :module +Network Prelude Network> listenOn $ PortNumber 8765 Loading package parsec-2.1.0.0 ... linking ... done. Loading package network-2.1.0.0 ... linking ... done. *** Exception: getAddrInfo: does not exist (servname not supported for ai_socktype) (same error when compiled). Anyone seen this before? I have multiple NICs, could that be confusing listenOn (does it not just bind on 0.0.0.0?) Tim Newsham http://www.thenewsh.com/~newsham/

2 1

More fun with micro-benchmarks and optimizations. (GHC vs Perl)
by Corey O'Connor 23 Jul '08

23 Jul '08

I have the need to regularly write tiny programs that analyze output logs. The output logs don't have a consistent formatting so I typically choose Perl for these tasks. The latest instance of having to write such a program was simple enough I figured I'd try my hand at using Haskell instead. The short story is that I could quickly write a Haskell program that achieved the goal. Yay! However, the performance was ~8x slower than a comparable Perl implementation. With a lot of effort I got the Haskell version to only 2x slower. A lot of the optimization was done with guesses that the performance difference was due to how each line was being read from the file. I couldn't determine much using GHC's profiler. I still have two questions after all this: - Can I get a Haskell implementation as fast as the Perl? - What do I need to do to get GHC's profiler to provide me usable information? Telling me that 98% of the time was in "main" is not very enlightening ;-) All the code and data for this little experiment I've placed here: http://tothepowerofdisco.com/repo/sum_optimization/ My first, and shortest, version is SumTiny.hs. The optimized version is SumFast.hs. The long version for the curious: The (cleaned up) data was a 78k line file consisting of lines like the following: framerate (prev == no pts): 15 framerate (delta): 25 framerate (invalid timebase): 12.5 ... and so on. The need was for a program that calculated 1.0 / framerate for each line and produced the sum. Easy no? My straightforward Haskell solution was: ------------------------------------------------------------------- import Text.Regex.Posix main = do f_lines <- readFile "test.out" >>= return . lines let duration = foldl add_line 0.0 f_lines add_line sum line = let [[_,m]] = line =~ "([0-9.]+)" framerate = read m delta = 1.0 / framerate in sum + delta putStrLn $ "Duration (sec): " ++ show duration ------------------------------------------------------------------- Just for fun I decided to compare it to a Perl implementation: ------------------------------------------------------------------- #!/usr/bin/perl my @f_lines = split(/\n/,`cat test.out`); my $sum = 0.0; foreach(@f_lines) { /([0-9.]+)/; my $delta = 1.0 / $1; $sum += $delta; } print("Duration (sec): ", $sum, "\n"); ------------------------------------------------------------------- (I'm sure there are other ways to write this same program in both languages.) I was pretty happy with how the Haskell implementation's code compared to the Perl implementation's just in terms of looks. Though I think the Perl implementation is easier to understand at the part where the regex match is extracted. For fun I compared the performance of the two: (64bit linux running on a 2.4ghz Core2Duo) $ time perl ./Sum.pl Duration (sec): 3155.62666666438 real 0m0.121s user 0m0.103s sys 0m0.016s $ time ./SumTiny Duration (sec): 3155.626666664377 real 0m1.099s user 0m1.073s sys 0m0.009s Youch! ~1s is fast enough that I don't care, but I'm still curious why there is a 8x performance difference. Profiling with manual cost center annotations (See SumTinyProf.hs) indicated the "do" expression main is equal to was responsible 90% of the tiny. Which isn't revealing at all! Some experimenting led me to find a 2x slower implementation (SumFast.hs). Quick notes ont he changes I made: - Used ByteStrings instead of String. - Used hGetLine instead of reading the entire file lazily and splitting on "\n" - Fusing the foldl' with the loop of reading each line from the file. - Using bang patterns to make the fused loop strict on the accumulator argument. I think the largest performance gain was from changing how each line was read from the file. The lazy read and split seemed very slow compared to a loop that used hGetLine. -- -Corey O'Connor

5 8

BLAS Solve Example
by Darrin Thompson 23 Jul '08

23 Jul '08

I'm stuck on something that I thought would be easy. I have a matrix and a vector. > module Main where > import Data.Vector.Dense > import Data.Matrix.Dense > import BLAS.Matrix.Solve > > m = listMatrix (2, 3) ([1, 2, 3, 4, 5, 6]::[Double]) > v = listVector 2 ([1, 2]::[Double]) > > main = do ??? Can I use one of the haskell libraries to solve that system? My goal is to automate some tedium on small exercises from the Linear Algebra text by Jim Heffron. -- Darrin

4 4

Aren't type system extensions fun?
by Andrew Coppin 23 Jul '08

23 Jul '08

Haskell 98 provides a simple and clean type system, which I feel I understand very well. GHC provides a vast zoo of strange and perplexing type system extensions, which I don't understand at all. (Well, some of it is simple enough - e.g., multiparameter type classes. But GADTs? FDs? ATs? Hmm...) Anyway, it seems there is a large set of such type system extensions that involve writing "forall" all over the place. I have by now more or less managed to comprehend the fact that data Thing = forall x. Thing x allows a type variable to appear on the RHS that is *not* present on the LHS, thus "hiding" the type of something inside the structure. And for some reason, they call this "existential quantification" [which I can't spell never mind pronounce]. Today I was reading a potentially interesting paper, and I stumbled across something referred to as a "rank-2 type". Specifically, class Typable x => Term x where gmapT :: (forall y. Term y => y -> y) -> x -> x At this point, I am at a complete loss as to how this is any different from gmapT :: Term y => (y -> y) -> x -> x Can anybody enlighten me? This is probably the first real use I've ever seen of so-called rank-2 types, and I'm curios to know why people think they need to exist. [Obviously when somebody vastly more intelligent than me says something is necessary, they probably know something I don't...] At this point, I don't think I even wanna *know* what the hell a rank-N type is... o_O

23 42

Haskell Weekly News: Issue 78 - July 23, 2008
by Brent Yorgey 23 Jul '08

23 Jul '08

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20080723 Issue 78 - July 23, 2008 --------------------------------------------------------------------------- Welcome to issue 78 of HWN, a newsletter covering developments in the [1]Haskell community. Issue 78: In Which Michi and Neil Become Doctors, Sun Donates Some Sweet Loot, and Jules Is Revealed To Be A Helpful Anthropomorphic Robot Community News Congratulations are in order this week to two members of the community who have completed PhDs. Neil Mitchell (ndm) passed his PhD viva last week, subject to minor corrections. Mikael Johansson (Syzygy-) [2]has also completed his PhD and will soon be starting a postdoc at Stanford with the topology in computer science working group. Congratulations, Drs. Mitchell and Johansson! Announcements rosezipper. Eric Kow (kowey) [3]announced the release of [4]rosezipper, Krasimir Angelov and Iavor S. Diatchki's Data.Tree implementation of zippers. list-extras 0.1.0. wren ng thornton (koninkje) [5]announced the initial release of [6]list-extras, a home for common not-so-common list functions. Sun Microsystems and Haskell.org joint project on OpenSPARC. Duncan Coutts (dcoutts) [7]announced a [8]joint project between Sun Microsystems and the Haskell.org community to exploit the high performance capabilities of Sun's latest multi-core [9]OpenSPARC systems via Haskell! Sun has donated a powerful 8 core SPARC Enterprise T5120 Server to the Haskell community, and $10,000 to fund a student to further develop support for high performance Haskell on the SPARC. The student will work with a mentor from Haskell.org and an adviser from Sun's SPARC compiler team. If you're a student and this sounds interesting to you, send in those applications!! Hayoo! beta 0.2. Timo B. [10]announced the second beta release of [11]Hayoo!, a Haskell API search engine providing advanced features like suggestions, find-as-you-type, fuzzy queries and much more. The major change in this release is the inclusion of all packages available on Hackage in the index. Haskell-beginners mailing list. Benjamin L. Russell [12]announced the creation of the [13]Haskell-Beginners Mailing List, beginners at haskell.org, devoted to discussion of primarily beginner-level topics related to Haskell. It's already off to a great start, so if you're a Haskell beginner, or someone interested in answering beginner questions, please subscribe! Haskeline 0.2. Judah Jacobson [14]announced the initial (alpha-ish) release of [15]Haskeline, a library for line input in command-line programs. It is similar in purpose to editline or readline, but is written in Haskell and thus (hopefully) more easily used in other Haskell programs. Google Summer of Code Progress updates from participants in the 2008 [16]Google Summer of Code. Generic tries. Jamie Brandon is working on a library for efficient maps using generalized tries. [17]This week, he ran QuickCheck on his test suite for the first time, and found a large number of failing tests! He's got his work cut out for him straightening those out over the next few days. DPH physics engine. Roman Cheplyaka (Feuerbach) is working on a [18]physics engine using [19]Data Parallel Haskell. [20]This week, he implemented full handling of rigid body collisions, including angular velocity. Next he plans to explore various ways to make the engine faster, including broad-phase collision detection. GHC plugins. Max Bolingbroke is working on dynamically loaded plugins for GHC. [21]This week, he revealed his "mystery project": an HTML pretty-printer for GHC core! [22]Here is a sample. Now his focus turns to tidying things up and solidifying documentation in preparation for getting his patches merged into GHC HEAD. Hoogle 4. Neil Mitchell (ndm) is working on [23]Hoogle 4. [24]This week, he fleshed out the final part of type search, including support for instances and alpha renaming of variables. Unfortunately, it uses too much memory to be feasibly run on the base libraries! Neil has some ideas on how to fix this, however, which he plans to tackle next week. Language.C. Benedikt Huber (visq) is [25]working on Language.C, a standalone parser/pretty printer library for C99. He has finally completed a working implementation for analysing declarations and definitions, and [26]presents a working example of the library's use. Cabal dependency framework. Andrea Vezzosi (Saizan) is working on a [27]make-like dependency analysis framework for Cabal. GHC API. Thomas Schilling (nominolo) is working on [28]improvements to the GHC API. Libraries Proposals and extensions to the [29]standard libraries. generalize mapAccumL/R. Ross Paterson [30]proposed adding generalized versions of mapAccumL and mapAccumR to Data.Traversable. signal-handling API. Simon Marlow [31]proposed a [32]new signal-handling API. Discussion Point-free style in guards. L29Ah [33]asked a question about using a points-free style in guard expressions, leading to a number of clever suggestions involving custom combinators. Optimizing sequence. Gracjan Polak started a [34]discussion on the strictness properties of the sequence function, and its implications for optimization. It sounds as though adding an alternate strict version of sequence to the libraries could be a good idea. Blog noise [35]Haskell news from the [36]blogosphere. * Eric Kow (kowey): [37]rose zipper on hackage. Eric has uploaded an implementation of a zipper for Data.Tree to hackage. * Jamie Brandon: [38]QuickCheck strikes again. An update on Jamie's Google Summer of Code project. Lots of failing QuickCheck tests mean Jamie has his work cut out for him. * >>> Ayumilove: [39]Haskell Programming Tutorial Part 1. A video introduction to Haskell? * Roman Cheplyaka (Feuerbach): [40]Status report: week 7-8. An update on Roman's Google Summer of Code project. * Conal Elliott (conal): [41]Designing for the future. * Benedikt Huber (visq): [42]Language.C: Analysing Definitions. An update on Benedikt's Google Summer of Code project. * Max Bolingbroke: [43]Compiler Plugins For GHC: Week Six. An update on Max's Google Summer of Code project. * Arnar Birgisson (Arnar): [44]Playing with Haskell's lazy lists. Arnar implements Eric Rowland's [45]simple prime-generating recurrence using lazy lists in Haskell. * Neil Mitchell (ndm): [46]GSoC Hoogle: Week 8. An update on Neil's Google Summer of Code project. * Matthew Sackman: [47]What is the point?. Matthew had his submission rejected from the Haskell Symposium, and isn't happy about it. * Tupil: [48]Stemming with Haskell reloaded. An updated, more functional/Haskellish interface to the stemmer library. * Luke Palmer (luqui): [49]Semantic Design. Luke's reflections on a design approach learned from Conal Elliott. * Muad`Dib (vixey): [50]Rascal - Mini-haskell like language. * Jeremy Shaw: [51]HTML Templating in HAppS using HSP. Jeremy writes a very cool introduction/tutorial to using HSP (Haskell Server Pages) with HAppS. * >>> Duane Johnson: [52]Lazy Evaluation at Work. Duane likes the idea of lazy file I/O. * >>> Duane Johnson: [53]A Glimmer of Monadic Hope. Duane figures out do-notation. * >>> Duane Johnson: [54]Using 'foldr' in Haskell. Duane figures out how to define (++) and concat in terms of foldr. * Mikael Johansson (Syzygy-): [55]Dr rer nat, Magna cum laude. * >>> Holden Karau: [56]Integrating your HUnit (or other) tests into your cabal package. * Real-World Haskell: [57]Beta availability hiccups. * >>> Antoine Hersen: [58]ICFP 2008 Postmortem. * Edward Kmett (edwardk): [59]A Sort of Difference. Edward uses an analysis of quicksort in Haskell as a jumping-off point for an introduction to difference lists. * Ralf Lammel: [60]The Expression Lemma -- Explained. Ralf explains the relationship between OOP and FP. * >>> Greg McClure: [61]Learning languages through problem-solving. Greg extols the virtues of [62]Project Euler for learning new languages, and exhibits a solution to the first problem in Haskell, Erlang, and Python. Quotes of the Week * kryptiskt: my point is that our brain isn't some logic machine, it's a jury-rigged contraption to help us get food, friends and sex. It's the Perl of intelligences. * Fallacy: peyton `simon` jones * Quadrescence: [on #haskell] Well, the nice population here attracts people. Unlike other pla_C_es. How'd those underscores get there? * mauke: hmm, regexes get even more cryptic after z-encoding: ZLz3fUZCZLz3fUzlznzrwZRZLz3fUzezrwZRzbZLz3fUzlzezrwZRZLz3fUznzrwZRZR * BMeph: Haskell: Where even the newest newcomer acts monadically: join :: ask (ask something) -> ask something * Quadrescence: quicksilver: You must be an anthropomorphic robot or something. About the Haskell Weekly News New editions are posted to [63]the Haskell mailing list as well as to [64]the Haskell Sequence and [65]Planet Haskell. [66]RSS is also available, and headlines appear on [67]haskell.org. Headlines are available as [68]PDF. To help create new editions of this newsletter, please see the information on [69]how to contribute. Send stories to byorgey at seas dot upenn dot edu. The darcs repository is available at darcs get [70]http://code.haskell.org/~byorgey/code/hwn/ . References 1. http://haskell.org/ 2. http://blog.mikael.johanssons.org/archive/2008/07/dr-rer-nat-magna-cum-laud… 3. http://koweycode.blogspot.com/2008/07/rose-zipper-on-hackage.html 4. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/rosezipper 5. http://article.gmane.org/gmane.comp.lang.haskell.cafe/42485 6. http://code.haskell.org/~wren/ 7. http://article.gmane.org/gmane.comp.lang.haskell.general/16351 8. http://haskell.org/opensparc/ 9. http://opensparc.net/ 10. http://article.gmane.org/gmane.comp.lang.haskell.general/16349 11. http://holumbus.fh-wedel.de/hayoo 12. http://article.gmane.org/gmane.comp.lang.haskell.general/16345 13. http://www.haskell.org/mailman/listinfo/beginners 14. http://article.gmane.org/gmane.comp.lang.haskell.general/16343 15. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/haskeline 16. http://hackage.haskell.org/trac/summer-of-code/wiki/SoC2008 17. http://jamiiecb.blogspot.com/2008/07/quickcheck-strikes-again.html 18. http://haskell.org/haskellwiki/Hpysics 19. http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell 20. http://physics-dph.blogspot.com/2008/07/status-report-week-7-8.html 21. http://blog.omega-prime.co.uk/2008/07/21/compiler-plugins-for-ghc-week-six/ 22. http://www.omega-prime.co.uk/files/GHC-Core-HTML.html 23. http://code.haskell.org/hoogle/ 24. http://neilmitchell.blogspot.com/2008/07/gsoc-hoogle-week-8.html 25. http://www.sivity.net/projects/language.c/wiki/ 26. http://hsbene.blogspot.com/2008/07/languagec-analysing-definitions.html 27. http://code.haskell.org/~Saizan/cabal 28. http://hackage.haskell.org/trac/ghc/wiki/GhcApiStatus 29. http://haskell.org/haskellwiki/Library_submissions 30. http://article.gmane.org/gmane.comp.lang.haskell.libraries/9649 31. http://article.gmane.org/gmane.comp.lang.haskell.libraries/9599 32. http://hackage.haskell.org/trac/ghc/ticket/2451 33. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/42475 34. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/42453 35. http://planet.haskell.org/ 36. http://haskell.org/haskellwiki/Blog_articles 37. http://koweycode.blogspot.com/2008/07/rose-zipper-on-hackage.html 38. http://jamiiecb.blogspot.com/2008/07/quickcheck-strikes-again.html 39. http://www.5min.com/Video/Ayumilove-Haskell-Programming-Tutorial-Part-1-311… 40. http://physics-dph.blogspot.com/2008/07/status-report-week-7-8.html 41. http://feeds.feedburner.com/~r/conal/~3/342784118/ 42. http://hsbene.blogspot.com/2008/07/languagec-analysing-definitions.html 43. http://blog.omega-prime.co.uk/2008/07/21/compiler-plugins-for-ghc-week-six/ 44. http://www.hvergi.net/2008/07/playing-with-haskells-lazy-lists/ 45. http://recursed.blogspot.com/2008/07/rutgers-graduate-student-finds-new.html 46. http://neilmitchell.blogspot.com/2008/07/gsoc-hoogle-week-8.html 47. http://www.wellquite.org/what_is_the_point.html 48. http://blog.tupil.com/stemming-with-haskell-reloaded/ 49. http://luqui.org/blog/archives/2008/07/18/semantic-design/ 50. http://muaddibspace.blogspot.com/2008/07/rascal-mini-haskell-like-language.… 51. http://nhlab.blogspot.com/2008/07/html-templating-in-happs-using-hsp.html 52. http://blog.inquirylabs.com/2008/07/18/lazy-evaluation-at-work/ 53. http://blog.inquirylabs.com/2008/07/17/a-glimmer-of-monadic-hope/ 54. http://blog.inquirylabs.com/2008/07/17/using-foldr-in-haskell/ 55. http://blog.mikael.johanssons.org/archive/2008/07/dr-rer-nat-magna-cum-laud… 56. http://feeds.feedburner.com/~r/holdenkarau/iYtm/~3/337908379/integrating-yo… 57. http://www.realworldhaskell.org/blog/2008/07/16/beta-availability-hiccups/ 58. http://endymion2021.livejournal.com/17117.html 59. http://comonad.com/reader/2008/a-sort-of-difference/ 60. http://blogs.msdn.com/ralflammel/archive/2008/07/16/the-expression-lemma-ex… 61. http://www.codechops.com/?p=15 62. http://www.projecteuler.net/ 63. http://www.haskell.org/mailman/listinfo/haskell 64. http://sequence.complete.org/ 65. http://planet.haskell.org/ 66. http://sequence.complete.org/node/feed 67. http://haskell.org/ 68. http://code.haskell.org/~byorgey/code/hwn/archives/20080723.pdf 69. http://haskell.org/haskellwiki/HWN 70. http://code.haskell.org/~byorgey/code/hwn/

1 0

Optimizing 'sequence'
by Gracjan Polak 23 Jul '08

23 Jul '08

Hi all, On the other day I noticed that we could optimize 'sequence' more. I needed it for my monadic parser. Below is my small experiment. Sequence from standard library needs 2.3s to finish (and additional stack space), my version uses only 0.65s and default stack. Is my version better or am I missing something obvious? -- standard sequence1 :: Monad m => [m a] -> m [a] sequence1 ms = foldr k (return []) ms where k m m' = do { x <- m; xs <- m'; return (x:xs) } -- accumulator version sequence2 :: Monad m => [m a] -> m [a] sequence2 ms = sequence' [] ms where sequence' vs [] = return (reverse vs) sequence' vs (m:ms) = m >>= (\v -> sequence' (v:vs) ms) main = do let l = map return [1..1000000] w <- sequence1 l print (sum w) return () gracjan@home:~/some_faster> time ./Some1 +RTS -K100M 500000500000 real 0m2.318s user 0m2.284s sys 0m0.032s gracjan@home:~/some_faster> time ./Some2 500000500000 real 0m0.652s user 0m0.592s sys 0m0.052s -- Gracjan

7 11

InterleavableIO
by Marco Túlio Gontijo e Silva 23 Jul '08

23 Jul '08

Hello, I've done a package based on the Jules Bean's e-mail [1] to Haskell-Café, with a more generalized implementation. In the original version, you could use InterleavableIO with StateT Int IO (), but not with StateT Int (ReaderT Char IO) (). In this version, this is possible. The package, interleavableIO, is available at [2]. I've also done an application that generates a version of a module with generalized parameters, called interleavableGen, available at [3]. This is very alpha, and interleavableGen has been tested only with Control.Exception yet. Comments are very welcome. Greetings. [1]: http://www.haskell.org/pipermail/haskell-cafe/2007-July/028501.html [2]: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/interleavableIO-… [3]: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/interleavableGen… -- Marco Túlio Gontijo e Silva Página: http://marcotmarcot.googlepages.com/ Blog: http://marcotmarcot.blogspot.com/ Correio: marcot(a)riseup.net XMPP: marcot(a)jabber.org IRC: marcot(a)irc.freenode.net Telefone: 25151920 Celular: 98116720 Endereço: Rua Turfa, 639/701 Prado 30410-370 Belo Horizonte/MG Brasil

1 0