- Haskell-Cafe - Haskell.org

HDBC-ODBC crashes on ghc 6.8
by Thomas Hartman 20 Nov '07

20 Nov '07

This minimal program below fails in 6.8.1, works for 6.6.1, for up to date HDBC-ODBC-1.1.3. (I tried installing both from package and from darcs head) Installed and running from cygwin. When I run it as runghc fail.hs I get a windows popup error "ghc.exe has encountered a problem and needs to close, sorry for the inconvenience". ghci, same behavior. When I run it as ghc -e 'main' fail.hs, I don't get a popup window, and no error message is output, but it fails all the same. (I know this because more complicated, non-minimal programs, fail.) So this would seem to be a problem with ghc 6.8.1. $ cat fail.hs import Database.HDBC import Database.HDBC.ODBC main = connectODBC "some valid connect string, works when run from 6.6.1, not from 6.8.1" --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

1 0

ANN: The Monad.Reader Issue 9: SoC special
by Wouter Swierstra 19 Nov '07

19 Nov '07

I am pleased to announce that a new issue of The Monad.Reader is now available: http://www.haskell.org/haskellwiki/The_Monad.Reader Issue 9 is a "Summer of Code Special" - it consists of three articles from student participants of Google's Summer of Code, describing the projects they worked on: * Thomas Schilling Cabal Configurations * Jason Dagit Darcs Patch Theory * Mathieu Boespflug TaiChi: how to check your types with serenity The Monad.Reader is a quarterly magazine about functional programming. It is less formal than a journal, but somehow more enduring than a wiki page or blog post. If you'd like to write something for the next issue of The Monad.Reader, please get in touch. I haven't fixed the deadline for the next issue just yet. I hope to send out an official call for copy fairly soon. Enjoy! Wouter This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

3 2

Performance problems with parallelizing QuickCheck using channels (Control.Concurrent.Chan)
by Gwern Branwen 19 Nov '07

19 Nov '07

(My previous email showed up as mangled in <http://www.haskell.org/pipermail/haskell-cafe/2007-November/034717.html>; I think the PGP signature was the problem; I removed it and sent it again, but it was put into moderation for size, and hasn't been released yet - so I'm sending this a third time but I'm removing attachments so it'll be under the annoying 20k size limit) So I've been trying to get my QuickCheck tests to run in parallel. I did take a look at Don's Parallel QuickCheck library <http://www.cse.unsw.edu.au/~dons/pqc.html>, but I didn't like how much code it had in it and I figured it'd be a good exercise to try to do myself. After quite a lot of help from the good folk of #haskell, I eventually came up with this: module Pcheck (parTest, parCheck) where import Control.Monad (replicateM_, liftM) import Control.Concurrent.Chan (newChan, writeChan, getChanContents) import Control.Concurrent (forkIO) import Test.QuickCheck (quickCheck', Testable()) -- | Takes a list of functions using parCheck, and returns True iff all return -- True. Evaluates them in parallel. parTest :: [IO Bool] -> IO Bool parTest = andTest . parList where andTest :: IO [Bool] -> IO Bool andTest = liftM and {- | Test in parallel. Forks off a QuickCheck 'n' times; QuickCheck tests using the proposition 't'. Returns True if all tests were passed, else False. Should be run with parallelizing options like with +RTS -N4 -RTS &etc. -} parCheck :: (Testable prop) => prop -> Int -> IO Bool parCheck t n = do chan <- newChan replicateM_ n $ forkIO $ (writeChan chan) =<< (quickCheck' t) liftM (and . take n) $ getChanContents chan -- | Takes a list of functions (presumably using parCheck) and evaluates all in parallel. parList :: [IO a] -> IO [a] parList fs = do chan <- newChan mapM_ (\m -> forkIO $ m >>= writeChan chan) fs liftM (take n) $ getChanContents chan where n = length fs I liked how simple the Channels library <http://haskell.org/ghc/docs/latest/html/libraries/base-3.0.0.0/Control-Conc…> seemed to be; I could just pass the channel as an argument and have every forkIO'd test simply chuck its Boolean result into it when done - which seem'd much simpler than using MVars and the other techniques for returning stuff from forkIO threads. And so it compiles, it runs tests correctly, and so on. But the problem is that it does so slowly. I have another module of equations about nuclear bombs called nuke.hs, which has a number of QuickCheck properties defined. Here's what happens when main is defined as 'parTest [the various tests..]': ./nuke +RTS -N7 -sstderr -RTS 40.57s user 46.55s system 116% cpu 1:14.61 total ./nuke +RTS -N6 -sstderr -RTS 40.72s user 47.66s system 117% cpu 1:15.50 total ./nuke +RTS -N5 -sstderr -RTS 42.33s user 49.08s system 116% cpu 1:18.67 total ./nuke +RTS -N4 -sstderr -RTS 43.71s user 48.41s system 117% cpu 1:18.48 total ./nuke +RTS -N3 -sstderr -RTS 41.51s user 48.25s system 114% cpu 1:18.10 total ./nuke +RTS -N2 -sstderr -RTS 42.28s user 47.18s system 115% cpu 1:17.39 total ./nuke +RTS -N1 -sstderr -RTS 27.87s user 18.40s system 99% cpu 46.498 total (From <http://hpaste.org/3886#a6>; compiled as "=ghc -v --make -threaded -O2 ./nuke.hs".) For some reason, running the parallel tests with a single thread is faster than running with 4 threads (I have a quad-core Intel processor)? I find this counter-intuitive to say the least. the par* functions are indeed operating in parallel, as evidenced by it using more than 100% CPU time, or, running on multiple cores, and all the tests are passed as True in both -N1 and -N[2-7] versions, so -N1 can't be bailing out early due to "and"'s laziness, and in general everything seems to be written correctly. I am perplexed by this. Is Chan simply a very inefficient way of parallelizing things? Is it not as parallel as I think? Or am I missing something else entirely? -- gwern .45 GIGN jya. wire ISI SADCC JPL embassy Recon World

2 1

Network.HTTP problem
by Radosław Grzanka 19 Nov '07

19 Nov '07

Hello, I have a problem with Network.HTTP module (http://www.haskell.org/http/) version 3001.0.0 . I have already mailed Bjorn Bringert about it but I didn't get answer yet so maybe someone here can help me. GHC v. 6.6.1 Ubuntu 7.10 x86_64 . I have turned on debug flag. Using get example (http://darcs.haskell.org/http/test/get.hs) I can download pages like this: $ ./get http://www.haskell.org/http/ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>Haskell HTTP package</title> <link href="style.css" rel="stylesheet" type="text/css" /> </head> <body> .... SNIP rest of the content SNIP .... Also the log contain content of this file. However, some links misbehaves like: $ ./get http://www.podshow.com/feeds/gbtv.xml ... no-output ... however I see content of this xml in debug file and wget downloads almost 250 kB of data. Also: $ ./get http://digg.com/rss/indexvideos_animation.xml ... hangs ... and debug file has size 0, but wget downloads the file I could suspect this is xml problem but: $ ./get http://planet.haskell.org/rss20.xml <?xml version="1.0"?> <rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/"> <channel> <title>Planet Haskell</title> <link>http://planet.haskell.org/</link> <language>en</language> <description>Planet Haskell - http://planet.haskell.org/</description> .... SNIP rest of the content SNIP .... so it works. Do you have any idea what is going on here? What goes wrong? What other (high level) modules could I use to download files through http? Cheers, Radek. -- Codeside: http://codeside.org/ Przedszkole Miejskie nr 86 w Lodzi: http://www.pm86.pl/

3 7

[Haskell-cafe] Letting the darcs test fail, if QuickCheck tests fail
by Henning Thielemann 18 Nov '07

18 Nov '07

When following the description on http://www.haskell.org/haskellwiki/How_to_write_a_Haskell_program#Add_some_… then darcs will run the QuickCheck tests on each 'darcs record', but the new patch is also accepted by darcs if one of the tests fail. What is the most simple way to let 'darcs record' fail, when a QuickCheck test fails?

3 3

Haskell performance question
by Dan Piponi 18 Nov '07

18 Nov '07

I see lots of shootout examples where Haskell programs seem to perform comparably with C programs, but I find it hard to reproduce anything like those figures when testing with my own code. So here's a simple case: I have this C program: #include <stdio.h> #define n 100000000 double a[n]; int main() { int i; for (i = 0; i<n; ++i) { a[i] = 1.0f; } for (i = 0; i<n-1; ++i) { a[i+1] = a[i]+a[i+1]; } printf("%f\n",a[n-1]); } And this Haskell program: import Data.Array.IO import Control.Monad n = 10000000 main = do a <- newArray (0,n-1) 1.0 :: IO (IOUArray Int Double) forM_ [0..n-2] $ \i -> do { x <- readArray a i; y <- readArray a (i+1); writeArray a (i+1) (x+y) } x <- readArray a (n-1) print x Even though 'n' is 10 times bigger in the C program it runs much faster than the Haskell program on my MacBook Pro with Haskell 6.6.1. I've tried lots of different combinations of flags that I've found in various postings to haskell-cafe but to no avail. What flags do I need to get at least within a factor of 2 or 3 of C? Am I using the wrong kind of array? Or is Haskell always going to be 15-20 times slower for this kind of numerical work? -- Dan

17 63

Re: [Haskell] AmeroHaskell
by Tim Chevalier 18 Nov '07

18 Nov '07

On 11/17/07, Derek Elkins <derek.a.elkins(a)gmail.com> wrote: > However, to put things in motion for something concrete at all, we're > hoping to put together a meeting taking place in the Portland area as > that seems most convenient to the most people who had registered > interest in AmeroHaskell and an easy place to find a venue. In that > vein, while no plans have been made, something aimed for the > January/February time-frame and probably hosted by Galois, if they are > willing, has been discussed. > In Portland, we've already had the first pdxfunc meeting: http://groups.google.com/group/pdxfunc While billed as a functional programming user group rather than a Haskell-specific group, we shouldn't duplicate effort. Cheers, Tim -- Tim Chevalier * catamorphism.org * Often in error, never in doubt "I don't know whether I believe in me, but I still believe in my friends" -- Nerissa Nields

2 3

Small optimisation question
by Andrew Coppin 18 Nov '07

18 Nov '07

Suppose I write something like this: foo :: [Int] foo = concat (replicate 4 [4,7,2,9]) The value of "foo" is completely determined at compile-time. So, will the compiler generate calls to concat and replicate, or will it just insert a large list constant here? Obviously, once somebody has completely examined the contents of "foo", after that point it won't matter either way. I'm just curiose. Concatinating some strings is cheap; I sometimes write constructs like the above using much more expensive operations. (Expensive in time; the space taken up by the result isn't that great.)

7 12

Showing Data.Ratio - different on GHC vs Hugs/Yhc
by Neil Mitchell 17 Nov '07

17 Nov '07

Hi Under Hugs and Yhc, showing a Ratio 1%2 gives "1 % 2". Under GHC showing 1%2 gives "1%2". Does the standard say anything about this? Is someone wrong? And how do Yhc/nhc/Hugs pass Bernouilli in the Nofib suite given that the output doesn't match? Thanks Neil

3 2

Re: let vs. where
by John Lato 17 Nov '07

17 Nov '07

This actually clears up something that's been bothering me for some time. I've never really like syntax of types for functions with multiple arguments. Using the same token, "->", to separate both arguments and the result seems very poor, because when reading a type you don't know if the value after that token is another argument or the final result without going further ahead. However, knowing that a function takes exactly one argument makes the syntax seem much more expressive for me. > From: Henning Thielemann <lemming(a)henning-thielemann.de> > > ... In > contrast to that, Haskell functions have exactly one argument and one > result, which I find is a nice thing.

2 1

List of all powers
by Kurt Hutchinson 17 Nov '07

17 Nov '07

As part of a solution I'm working on for Project Euler problem 119, I wanted to create an ordered list of all powers of all positive integers (starting with squares). This is what I came up with: powers = ( uniq . map fst . iterate next ) ( 1, ( 0, powertable ) ) powertable = map (\ n -> map (\ p -> n ^ p ) [ 2 .. ] ) [ 2 .. ] next ( _, ( lim, ps ) ) = ( p, ( lim', ps' ) ) where ( c, p ) = minimumBy ( compare `on` snd ) . zip [ 0 .. lim ] . head . transpose $ ps lim' = lim + ( if c == lim then 1 else 0 ) ( front, b : back ) = splitAt c ps ps' = front ++ ( tail b : back ) -- like the unix utility uniq [] = [] uniq [x] = [x] uniq (x:y:ys) | x == y = uniq (y:ys) | otherwise = x : uniq (y:ys) Basically, think of a grid of numbers, each row is the list of powers for one integer. To find the next power in the sequence, look at the the first number in each row (since that will be the smallest number in the row), up to limit number of rows. The limit is calculated as the number of rows that we've already taken one number from, plus one. This exploits the fact that the row heads are initially ordered. If we use a number from a row, shift that row down to remove the number used. It does pretty well, but I'd welcome any comments, or even suggestions of a completely different algorithm (for this little exercise, or problem 119). Thanks. Kurt Hutchinson

6 10

Erik Meijer's talk at Google?
by Galchin Vasili 17 Nov '07

17 Nov '07

Hello, Last week (?) Erik Meijer gave a talk at Google. Has a video been uploaded somewhere? Kind regards, Vasya

3 2

The percent operator
by PR Stanley 16 Nov '07

16 Nov '07

Hi I understand 2%4 will construct a fraction in Haskell. I've tried this in GHCI but got an error message. Is there such an operator in Prelude and if so how is it applied? Cheers, Paul

3 2

Chart plotting libraries
by Jon Harrop 16 Nov '07

16 Nov '07

I'd like some free software to help me plot charts like the one from the ray tracer language comparison: http://www.ffconsultancy.com/languages/ray_tracer/results.html I was using Mathematica but its stopped working and an upgrade is £2,000. Are there Haskell bindings to any free libraries or even Haskell implementations that would make something like this painless? There isn't anything for OCaml (that I'm not still writing ;-) so this might be a good opportunity to force me to do a little more Haskell. :-) -- Dr Jon D Harrop, Flying Frog Consultancy Ltd. http://www.ffconsultancy.com/products/?e

6 7

dropSpace not exported in ByteString
by Olivier Boudry 16 Nov '07

16 Nov '07

Hi all, I'm writing a Haskell program to do some address cleansing. The program uses the ByteString library. Data.ByteString.Char8 documentations shows functions for removing whitespace from start or end of a ByteString. Those functions are said to be more efficient than the dropWhile / reverse mixes. It looks exactly like what I'm searching for, but apparently those functions are not exported by the Data.ByteString.Char8 module. Are those functions only called by rules? Transformation of dropWhile isSpace into dropSpace? I've seen such a rule for dropSpace but did not found an equivalent rule for dropSpaceEnd. Is there a way to call the dropSpace and dropSpaceEnd or do I have to code with dropWhile and hope that some rule will magically transform my dropWhileS into dropSpaceS? Thanks, Olivier.

4 8

Re: Guidance on using asynchronous exceptions
by oleg＠pobox.com 16 Nov '07

16 Nov '07

Yang wrote: > Furthermore, is there any way to embed this information [about async > execptions] in the type system, so that Haskellers don't produce > async-exception-unaware code? (Effectively, introducing checked > interrupts?) Yes, it is possible to make the information about exceptions and interrupts a part of operation's type: http://www.haskell.org/pipermail/haskell/2004-June/014271.html Here is a simple illustration for your specific case > {-# OPTIONS -fglasgow-exts #-} > > module B where > import Control.Exception > > idarn _ msg = error msg > > myPutStrLn _ | False = idarn ?e_async "myPutStrLn is interruptible" > myPutStrLn x = putStrLn x *B> :t myPutStrLn myPutStrLn :: (?e_async::()) => String -> IO () Now it is obvious that myPutStrLn is subject to async interruptions > test1 x = do myPutStrLn "String" > myPutStrLn x *B> :t test1 test1 :: (?e_async::()) => String -> IO () and so can test1. The compiler figured that out. > myblock :: ((?e_async::()) => IO a) -> IO a > myblock x = let ?e_async = undefined -- meaning, we `handle' the exc > in block x If we try to *B> test1 "here" <interactive>:1:0: Unbound implicit parameter (?e_async::()) arising from use of `test1' at <interactive>:1:0-11 In the expression: test1 "here" In the definition of `it': it = test1 "here" meaning that we ought to `handle' that exceptional condition. The typechecker will not let us overlook the test. > -- ?e_async::t causes a problem: we really have to `handle' it > -- main = test1 "here" > test3 = myblock (test1 "here") *B> :t test3 test3 :: IO () The type of test3 shows that the condition is `handled'. And so test3 may now be run. > (Something like this is straightforward to build if I abandon > Concurrent Haskell and use cooperative threading, and if the > operations I wanted to perform could be done asynchronously.) All operations could be done asynchronously, at least on Linux and many Unixes: http://www.usenix.org/events/usenix04/tech/general/full_papers/elmeleegy/el… > (Something like this is straightforward to build if I abandon > Concurrent Haskell and use cooperative threading, and if the > operations I wanted to perform could be done asynchronously.) That seems as a very good idea. You might be aware that well-respected and well-experienced systems researchers call for *abandoning* threads. Threads are just a very bad model. The Problem with Threads Edward A. Lee http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-1.html Also, IEEE computer, May 2006, pp. 33-42. >From the abstract: ``Although threads seem to be a small step from sequential computation, in fact, they represent a huge step. They discard the most essential and appealing properties of sequential computation: understandability, predictability, and determinism. Threads, as a model of computation, are wildly nondeterministic, and the job of the programmer becomes one of pruning that nondeterminism. Although many research techniques improve the model by offering more effective pruning, I argue that this is approaching the problem backwards. Rather than pruning nondeterminism, we should build from essentially deterministic, composable components. Nondeterminism should be explicitly and judiciously introduced where needed, rather than removed where not needed. The consequences of this principle are profound. I argue for the development of concurrent coordination languages based on sound, composable formalisms. I believe that such languages will yield much more reliable, and more concurrent programs.'' I believe that delimited continuations is a good way to build coordination languages, because delimited continuations let us build a sound model of computation's interaction with its context.

3 2

Haskellforge?
by Maurício 16 Nov '07

16 Nov '07

Hi, Is there a "Haskellforge" somewhere, i.e., something like a sourceforge for open source Haskell programs, with darcs, automatic cabalization etc.? Has anyone tried that already? Maurício

4 4

let vs. where
by John Lato 16 Nov '07

16 Nov '07

Hello, I know there are several important differences between let-expressions and where-clauses regarding scoping and the restriction of "where" to a top-level definition. However, frequently I write code in which either one would be allowed, and I was wondering if there were any guidelines or preferences for one structure over the other. Currently my choice is guided by aesthetics more than anything else ( I prefer the look and ordering of a where clause). Is there anything else I should consider? What do veteran Haskell programmers prefer? Thank you, John Lato

20 29

the "interact" function and Hugs/ghci on Windows ...
by Galchin Vasili 16 Nov '07

16 Nov '07

Hello, I have a Haskell script that contains several functions that are implemented in terms on "interact". When I do a "function application", Hugs/ghci is waiting for input from stdin. How do one denote EOF from stdin, so that the function evaluation can continue and do the IO () action , ie.. write to stdout? Regards, Vasili

4 4

Guidance on using asynchronous exceptions
by Yang 16 Nov '07

16 Nov '07

To follow up on my previous post ("Asynchronous Exceptions and the RealWorld"), I've decided to put together something more concrete in the hopes of eliciting response. I'm trying to write a library of higher-level concurrency abstractions, in particular for asynchronous systems programming. The principal goal here is composability and safety. Ideally, one can apply combinators on any existing (IO a), not just procedures written for this library. But that seems like a pipe dream at this point. In the code below, the running theme is process orchestration. (I've put TODOs at places where I'm blocked - no pun intended.) I'm currently worried that what I'm trying to do is simply impossible in Concurrent Haskell. I'm bewildered by the design decisions in the asynchronous exceptions paper. I'm also wondering if there are any efforts under way to reform this situation. I found some relevant posts below hinting at this, but I'm not sure what the status is today. (Something like this is straightforward to build if I abandon Concurrent Haskell and use cooperative threading, and if the operations I wanted to perform could be done asynchronously.) Relevant papers --------------- http://citeseer.ist.psu.edu/415348.html http://research.microsoft.com/users/simonpj/papers/concurrent-haskell.ps.gz http://www.haskell.org/~simonmar/papers/web-server.ps.gz Relevant posts/threads ---------------------- http://osdir.com/ml/lang.haskell.prime/2006-04/msg00032.html http://osdir.com/ml/lang.haskell.general/2001-11/msg00131.html http://www.haskell.org/pipermail/haskell-prime/2006-April/001280.html http://www.haskell.org/pipermail/haskell-prime/2006-April/001290.html http://www.nabble.com/throwTo---block-statements-considered-harmful-tf27802… http://www.nabble.com/What-guarantees-(if-any)-do-interruptible-operations-… Misc ---- http://lambda-the-ultimate.org/node/1570 Advanced Exception Handling Mechanisms http://www.springerlink.com/content/3723wg2t81248027/ http://64.233.169.104/search?q=cache:c4pS0FDKMXcJ:www.cs.ioc.ee/tfp-icfp-gp… http://64.233.169.104/search?q=cache:hmC-jl-iNkoJ:www.jot.fm/issues/issue_2… http://www.mathematik.uni-marburg.de/~eden/paper/edenEuropar03.pdf Code ==== module Main where import Control.Concurrent import Control.Concurrent.MVar import Control.Exception import Control.Monad import Prelude hiding (log) import System.IO import System.Posix.Signals import System.Process log = putStrLn startProc cmd = runCommand cmd stopProc p = terminateProcess p waitProc p = waitForProcess p -- Run a process, blocking on it until it exits. If we're interrupted, -- terminate the process. (IIRC, terminateProcess issues SIGTERM, and -- the documentation is buggy; more detailed code should go here later -- to retry with SIGKILL.) runProc cmd = do log "launching proc" p <- startProc cmd waitProc p -- TODO allow interrupts only at this point `finally` ( log "stopping" >> stopProc p >> log "stopped" ) -- Sleep for n seconds. timeout n = do log "sleeping" threadDelay (n * 1000000) -- TODO allow interrupts only at this point log "waking" -- TODO is there any way to block *only* the Cancel exception? (Even -- if this could be done, though, it's still not a modular approach.) spawn :: IO a -> (a -> IO ()) -> IO ThreadId spawn f y = forkIO (block (f >>= y)) -- The any/sum/choice combinator. On return, guarantee that both tasks -- have stopped. (<|>) :: IO a -> IO b -> IO (Either a b) a <|> b = do result <- newEmptyMVar :: IO (MVar (Either a b)) tida <- newEmptyMVar :: IO (MVar ThreadId) tidb <- newEmptyMVar :: IO (MVar ThreadId) let yield lr x = do let name = case lr x of Left _ -> "a" Right _ -> "b" log $ "saving result of " ++ name putMVar result (lr x) log $ "saved result of " ++ name let other = case lr x of Left _ -> tidb Right _ -> tida log "taking other" t <- takeMVar other log "killing other" -- Later: replace the following with a throwTo -- so as to notify (rather than kill) the thread -- with a Cancel killThread t ta <- spawn a (yield Left) tb <- spawn b (yield Right) putMVar tida ta putMVar tidb tb log "waiting for result" res <- takeMVar result -- TODO wait for both tasks to have stopped log "returning result" return res -- simple test -- cmd1 = "for i in `seq 1`; do sleep 1; echo hello; done" cmd2 = "for i in `seq 3`; do sleep 1; echo world; done" main = do -- TODO for some reason, cmd2 doesn't get terminated. result <- runProc cmd1 <|> runProc cmd2 case result of Left _ -> putStrLn "finished process" Right _ -> putStrLn "got exception"

2 1

Performance problems with parallelizing QuickCheck using channels (Control.Concurrent.Chan)
by Gwern Branwen 16 Nov '07

16 Nov '07

So I've been trying to get my QuickCheck tests to run in parallel. I did take a look at Don's Parallel QuickCheck library <http://www.cse.unsw.edu.au/~dons/pqc.html>, but I didn't like how much code it had in it and I figured it'd be a good exercise to try to do myself. After quite a lot of help from the good folk of #haskell, I eventually came up with this: module Pcheck (parTest, parCheck) where import Control.Monad (replicateM_, liftM) import Control.Concurrent.Chan (newChan, writeChan, getChanContents) import Control.Concurrent (forkIO) import Test.QuickCheck (quickCheck', Testable()) -- | Takes a list of functions using parCheck, and returns True iff all return -- True. Evaluates them in parallel. parTest :: [IO Bool] -> IO Bool parTest = andTest . parList where andTest :: IO [Bool] -> IO Bool andTest = liftM and {- | Test in parallel. Forks off a QuickCheck 'n' times; QuickCheck tests using the proposition 't'. Returns True if all tests were passed, else False. Should be run with parallelizing options like with +RTS -N4 -RTS &etc. -} parCheck :: (Testable prop) => prop -> Int -> IO Bool parCheck t n = do chan <- newChan replicateM_ n $ forkIO $ (writeChan chan) =<< (quickCheck' t) liftM (and . take n) $ getChanContents chan -- | Takes a list of functions (presumably using parCheck) and evaluates all in parallel. parList :: [IO a] -> IO [a] parList fs = do chan <- newChan mapM_ (\m -> forkIO $ m >>= writeChan chan) fs liftM (take n) $ getChanContents chan where n = length fs I liked how simple the Channels library <http://haskell.org/ghc/docs/latest/html/libraries/base-3.0.0.0/Control-Conc…> seemed to be; I could just pass the channel as an argument and have every forkIO'd test simply chuck its Boolean result into it when done - which seem'd much simpler than using MVars and the other techniques for returning stuff from forkIO threads. And so it compiles, it runs tests correctly, and so on. But the problem is that it does so slowly. I have another module of equations about nuclear bombs called nuke.hs, which has a number of QuickCheck properties defined. Here's what happens when main is defined as 'parTest [the various tests..]': ./nuke +RTS -N7 -sstderr -RTS 40.57s user 46.55s system 116% cpu 1:14.61 total ./nuke +RTS -N6 -sstderr -RTS 40.72s user 47.66s system 117% cpu 1:15.50 total ./nuke +RTS -N5 -sstderr -RTS 42.33s user 49.08s system 116% cpu 1:18.67 total ./nuke +RTS -N4 -sstderr -RTS 43.71s user 48.41s system 117% cpu 1:18.48 total ./nuke +RTS -N3 -sstderr -RTS 41.51s user 48.25s system 114% cpu 1:18.10 total ./nuke +RTS -N2 -sstderr -RTS 42.28s user 47.18s system 115% cpu 1:17.39 total ./nuke +RTS -N1 -sstderr -RTS 27.87s user 18.40s system 99% cpu 46.498 total (From <http://hpaste.org/3886#a6>; compiled as "=ghc -v --make -threaded -O2 ./nuke.hs".) For some reason, running the parallel tests with a single thread is faster than running with 4 threads (I have a quad-core Intel processor)? I find this counter-intuitive to say the least. the par* functions are indeed operating in parallel, as evidenced by it using more than 100% CPU time, or, running on multiple cores, and all the tests are passed as True in both -N1 and -N[2-7] versions, so -N1 can't be bailing out early due to "and"'s laziness, and in general everything seems to be written correctly. I am perplexed by this. Is Chan simply a very inefficient way of parallelizing things? Is it not as parallel as I think? Or am I missing something else entirely? (Attached is the source of nuke.hs and pcheck.hs, as well as some data from -sstderr.) -- gwern .45 GIGN jya. wire ISI SADCC JPL embassy Recon World

1 0

(general question) Approaches for storing large amount of simple data structures
by bbrown 16 Nov '07

16 Nov '07

I have a project where I want to store a data structure on a file, binary or ascii. And I want to use haskell to read and write the file. I will have about half a million records so it would be nice if the format was able to load quickly. I guess I could, but I kind of want to avoid using XML. I have the following structure in pseudo code. A URL -> id -> keywords associated with that URL -> title associated with that URL -> links contained in that URL. (0 ... N) What is an approach for saving 500 thousand of those types of records and where I can load the data into a haskell data type. -- Berlin Brown [berlin dot brown at gmail dot com] http://botspiritcompany.com/botlist/?

2 1

Asynchronous exceptions and the RealWorld
by Yang 16 Nov '07

16 Nov '07

- I want to set timeouts on various IO operations in an existing library, ftphs. However, even if I wrap every call in `block`, it's unclear whether ftphs has been coded to deal with asynchronous exceptions, or whether state could be rendered inconsistent. Is there any solution for this aside from auditing/changing ftphs? - I can't find any documentation on which calls are (either directly or indirectly, or parametrically) "interruptible operations" (to use the term from the Async Exceptions paper). For instance, I experimentally determined that hPutStrLn on a socket is *not*. Does such documentation exist anywhere? Furthermore, is there any way to embed this information in the type system, so that Haskellers don't produce async-exception-unaware code? (Effectively, introducing checked interrupts?) - The above finding of hPutStrLn (as an example) is somewhat surprising, since the socket buffer may be full, causing the call to block indefinitely. We can unblock that call, but unless there's a way to atomically reinstate the block and save the result of the computation (the unit value), this effectively makes it impossible to determine whether the hPutStrLn returned. (Admittedly, this is a contrived example, since whether a call to hPutStrLn returns is usually not a useful result - but this is the first thing I tried, and I'm guessing there are more such IO operations that actually yield useful results.) - Are there any higher-level concurrency libraries that actually tackle these hand-in-hand issues (safe asynchronous interruptible IO, two-phase-commit to prevent dropping results, choice, etc.)? I tried searching for a while, coming up with PiMonad, HAppS.Util, MissingH.Threads.Timeout, but none of them really address these issues. Perhaps this is just impossible in Concurrent Haskell, and one would need to resort to the sure-fire home-rolled solution using delimited continuations and cooperative scheduling for any serious concurrency abstractions for systems programming. Thanks in advance for any answers!

1 0

Re: Flymake Haskell
by Daisuke IKEGAMI 16 Nov '07

16 Nov '07

Dear Stefan and Haskell-Cafe, Thanks to keeping your interest to the flymake-mode for Haskell. Stefan wrote: > Could you explain to me what flycheck_haskell.pl does, and give an > example of a problematic situation solved by the use of > flycheck_haskell.pl. Sure. The perl script flycheck_haskell.pl, which is presented at EmacsWiki, http://www.emacswiki.org/cgi-bin/emacs/FlymakeHaskell edits the warning and error messages as an one line from the output of ghc. Now I'll describe how to solve the perl script the problem for using the flymake-mode with ghc. Here is an example of an error message by ghc. Foo.hs:4:4: No instance for (Num Char) arising from the literal `0' at Foo.hs:4:4 Possible fix: add an instance declaration for (Num Char) In the expression: 0 In the definition of `i': i = 0 where the Foo.hs has an explicit error as follows: ---- module Foo where i :: Char -- a type error here i = 0 ---- The perl script removes newlines and white spaces from the error message from ghc and then print it as follows (long one line): Foo.hs:4:4: No instance for (Num Char) arising from the literal `0'... The reason why I needed the perl script is that the current flymake-mode assumes that the syntax checker must print warning/error messages as an 'one' line for each and the message must have the following information: - filename (required) - line number (required) - column number (optional) - warning/error message (required) The above requirement is the problem when we meet to use flymake-mode with ghc alone. If you want to know the detail about the original flymake-mode, please read the definition of two functions - 'flymake-parse-err-lines - 'flymake-parse-line instead of asking me more further. I'm a pragmatic programmer who knows a few about EmacsLisp and can't explain the flymake-mode clearly. However, I greatly appreciate any discussion about the flymake-mode for Haskell here. > > Note that it will not work in the future, since the flymake-mode > > has been developed so actively. > Huh? Where? I forgot to write the following sentence in the previous email: the flymake-mode has been developed so actively at not the official site http://flymake.sourceforge.net/ but http://cvs.savannah.gnu.org/viewvc/emacs/emacs/lisp/progmodes/flymake.el The latest changes had done on 2 weeks and 4 days ago. I would like to thank Don Stewart for his kindly comments on IRC and that he introduced Flymake Emacs at the latest Haskell news. Gwern Branwen helps me a lot and add a section about Flymake Haskell to the Haskell wiki. http://haskell.org/haskellwiki/Haskell_mode_for_Emacs I would like to thank also anonymous reviewers on EmacsWiki. Best wishes, ike

3 3

Vertigo / GHC / Memo
by Peter Verswyvelen 16 Nov '07

16 Nov '07

Hi Haskell Lovers, Im trying to compile Vertigo (http://conal.net/Vertigo) which seems to be a module from which I can really learn a lot of stuff. However, it seems to use a Memo module, which does not seem to be part of GHC (anymore?) As far as I understand, it uses a memo function to make sure that when performing symbolic differentiation, it does not get stuck in an endless loop. As I realize no generic memoization function can be made, I guess it got removed at some point? Can anyone give me a hint how to find a suitable Memo module for Vertigo? As a sidenote, I must say the memoization section on Haskell.org is not really helpful for a newbie like me... Thanks, Peter PS: I adapted the following code from SOE, but I'm not sure it does the job correctly (it will certainly be slow...) {-# OPTIONS_GHC -fglasgow-exts #-} module Memo(memo) where import Data.IORef import System.IO.Unsafe memo :: Eq a => (a->b) -> (a->b) memo f = unsafePerformIO $ do cache <- newIORef [] return $ \x -> unsafePerformIO $ do vals <- readIORef cache case x `inCache` vals of Nothing -> do let y = f x modifyIORef cache ((x,y):) return y Just y -> do return y inCache :: Eq a => a -> [(a,b)] -> Maybe b x `inCache` [] = Nothing x `inCache` ((x',y'):xys) = if x == x' then Just y' else x `inCache` xys

1 0

Using Data.Binary for compression
by Chad Scherrer 16 Nov '07

16 Nov '07

Hi, I'd like to be able to use Data.Binary (or similar) for compression. Say I have an abstract type Symbol, and for each value of Symbol I have a representation in terms of some number of bits. For compression to be efficient, commonly-used Symbols should have very short representations, while less common ones can be longer. Since an encoding like [Bool] would be really inefficient for this (at least I think it would, though some fancy fusion tricks might be able to help), I was thinking a reasonable approach might be to use Word8 (for example), and then specify a number of bits n, indicating that only the first n bits are to be written to the compressed representation. I was looking at the internals of Data.Binary, and saw it seems that PutM could be used for this purpose (was something like this its original purpose?). Today, I put this together: ------------------------------------ type BitRep = Word8 type NBits = Int type MyBits = (BitRep, NBits) (#) :: MyBits -> MyBits -> PutM MyBits (a, m) # (b, n) = case (a .|. (b `shiftR` m), m + n) of ans@(ab, s) -> if s < 8 then return ans else putWord8 ab >> return (b `shiftL` (8 - m), s - 8) ------------------------------------ Then, it would be easy enough to map [Symbol] -> [MyBits], and then use something like foldM (#) to get into the PutM monad. A couple of questions: (1) Am I reinventing the wheel? I haven't seen anything like this, but it would be nice to be a bit more certain. (2) This seems like it will work ok, but the feel is not as clean as the current Data.Binary interface. Is there something I'm missing that might make it easier to integrate this? (3) Right now this is just proof of concept, but eventually I'd like to do some performance tuning, and it would be nice to have a representation that's amenable to this. Any thoughts on speeding this up while keeping the interface reasonably clean would be much appreciated. Thanks! -Chad

6 7

cabal Main-Is restriction
by Nicolas Frisby 16 Nov '07

16 Nov '07

It seems the meaning of the -main-is switch for GHC and the Main-Is build option for Cabal executables differ. With GHC, I can point to any function "main" in any module, but in Cabal I must point to a filename with precisely the module name "Main". This is tying my hands with regard to organizing a default executable and exposing some of its functionality as a library. Is there a way to get around this restriction? Concretely, I want to point Cabal's Main-Is to Program/Main.hs which starts with module Program.Main where instead of just module Main where Is this currently possible? I recognize the "add a separate Program-Main.hs file" workaround, but I'll avoid it if I can. Thanks!

2 1

Haskell Job Opportunity
by Tom Hawkins 15 Nov '07

15 Nov '07

Hello, Eaton (eaton.com, Eden Prairie, MN US) is seeking software engineers for design and verification of electro-hydraulic control systems for industrial, automotive, and aerospace applications. Though I am still trying to get Haskell on the official job description, here are a few of the potential Haskell applications: - Domain specific languages. - Compiler design and embedded code generation. - Model checking and equivalence checking. - SAT decision procedures. - Constrained random simulation. - Software timing analysis. General knowledge of the following would be helpful: - Control theory. - Real-time, embedded programming. - Automotive and industrial systems. - Hydraulics and fluid power. If interested, send me a resume. Thanks! -Tom Hawkins

1 0

Weird ghci behaviour?
by Dan Piponi 15 Nov '07

15 Nov '07

On Unix-like OSes: If I run "ghc test.hs" and then run "ghci test.hs", ghci fails to load up my code. I have to touch test.hs and then run ghci. I can understand ghci refusing to recompile something it thinks it has already compiled. But it appears to refuse to load it into an interactive session - which is less useful. In fact, removing test.hi makes ghci work again. This is ghc 6.6. Anyone else seeing this? -- Dan

18 29

Brazilian Haskellers ?
by Ricardo Herrmann 15 Nov '07

15 Nov '07

Hi brazilian haskellers, How about trying to form a HUG-BR ? Maybe even something along the lines of FringeDC (http://www.lisperati.com/fringedc.html) I only know about 4 people that would join the cause, that's why I'm recruiting ;-) Feel free to contact me (I'm posting this from the Nabble interface, so I'm not sure my e-mail will show up ... just in case: rherrmann(a)gmail.com) -- Ricardo Guimarães Herrmann "In a concurrent world, imperative is the wrong default!" -- Tim Sweeney (Epic Games) -- View this message in context: http://www.nabble.com/Brazilian-Haskellers---tf4806561.html#a13751455 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

7 9

Haskell and html input elements
by PR Stanley 15 Nov '07

15 Nov '07

Hi back again! How easy/hard is it to control a haskell program through a web browser? Cheers Paul

3 3

Why are OCaml and Haskell being used at these companies?
by Galchin Vasili 15 Nov '07

15 Nov '07

Hello, Using http://www.indeed.com with the search phrase "Haskell functional", I found several Haskell positions inclusing Quantitative Functional Programmer (Analyst - Level)<http://www.indeed.com/rc/clk?jk=950afd03471e43cb&from=ja&cd=0B84_stXHsQIi--…> Credit Suisse - New York, NY Specific *Language* (embedded in *Haskell*) that will be... of competence in either *Haskell* or another statically-typed functional *language*. The ability to build... >From Credit Suisse - November 11, 3:32 PM I am looking for (objective.. i.e. not juts FPL cheerleading) opinions as to why Wall Street ( http://www.janestcapital.com/) and banking are now using OCaml and Haskell. I really want to understand what industrial markets are adopting FPLs and why in order to help push FPLs penetration into industry. Another company is http://www.galois.com Kind regards, Vasya

16 27

why PArr slower than list ?
by Albert Lee 15 Nov '07

15 Nov '07

I read the GHC/Data Parallel Haskell/GHC.PArr page http://haskell.org/haskellwiki/Data_Parallel_Haskell/GHC.PArr and make a simple test to compare the speed of PArr against List: {-# OPTIONS -fparr -fglasgow-exts #-} module Main where import GHC.PArr import System.CPUTime dotp :: Num a => [:a:] -> [:a:] -> a dotp xs ys = sumP [:x * y | x <- xs | y <- ys:] main = do t1 <- getCPUTime print $ sum [x*y|x<-[1..90000]|y<-[1..90000]] t2 <- getCPUTime print $ dotp [:1..90000:] [:1..90000:] t3 <- getCPUTime print $ t2 - t1 print $ t3 - t2 and I get the result: *Main> main 243004050015000 243004050015000 384540000000 1701841000000 My laptop is macbook macosx 10.4.8 and ghc-6.8 , anything wrong or I missed ?

3 2

some links broken in 6.8.1 documentation
by Daniil Elovkov 15 Nov '07

15 Nov '07

Hello folks A quick look at the 6.8.1 user's guide reveals some broken links: 1) Obtaining code coverage, pointing to http://haskell.org/ghc/docs/6.8.1/html/users_guide/hpc.html redirects to http://projects.unsafeperformio.com/hpc.html which tells that it's not found but guesses at another location, where it is found. 2) Concurrent and parallel haskell http://haskell.org/ghc/docs/6.8.1/html/users_guide/lang-parallel.html (and possibly other pages) have links to libraries according to the pre-base-split structure, like .../base/.. instead of .../parallel/..., which results in those links being broken. Thank you -- Daniil Elovkov

3 4

Re: [Haskell-cafe] Brazilian Haskellers ?
by PR Stanley 15 Nov '07

15 Nov '07

> > Hi brazilian haskellers, > >Wow! I knew the Haskell community has been growing... but there's a >brazillian of us? > >-- >Rich A mini UN, that's us.

1 0

cabal problem?
by Jens Blanck 15 Nov '07

15 Nov '07

I have problems building X11. I just installed ghc 6.8 but I got the same behaviour when asking it to use the old compiler. Jens > runghc Setup.hs configure Configuring X11-1.3.0.20071111... checking for gcc... gcc checking for C compiler default output file name... a.out checking whether the C compiler works... yes checking whether we are cross compiling... no checking for suffix of executables... checking for suffix of object files... o checking whether we are using the GNU C compiler... yes checking whether gcc accepts -g... yes checking for gcc option to accept ANSI C... none needed checking how to run the C preprocessor... gcc -E checking for X... libraries /usr/X11R6/lib64, headers /usr/X11R6/include checking for gethostbyname... yes checking for connect... yes checking for remove... yes checking for shmat... yes checking for IceConnectionNumber in -lICE... yes checking whether to build Xinerama... yes checking for egrep... grep -E checking for ANSI C header files... yes checking for sys/types.h... yes checking for sys/stat.h... yes checking for stdlib.h... yes checking for string.h... yes checking for memory.h... yes checking for strings.h... yes checking for inttypes.h... yes checking for stdint.h... yes checking for unistd.h... yes checking X11/extensions/Xinerama.h usability... yes checking X11/extensions/Xinerama.h presence... yes checking for X11/extensions/Xinerama.h... yes configure: creating ./config.status config.status: creating config.mk config.status: creating X11.buildinfo config.status: creating include/HsX11Config.h config.status: include/HsX11Config.h is unchanged config.status: creating include/X11_extras_config.h config.status: include/X11_extras_config.h is unchanged > runghc Setup.hs build Preprocessing library X11-1.3.0.20071111... Building X11-1.3.0.20071111... [ 1 of 17] Compiling Graphics.X11.Xlib.Types ( dist/build/Graphics/X11/Xlib/Types.hs, dist/build/Graphics/X11/Xlib/Types.o ) [ 2 of 17] Compiling Graphics.X11.Types ( dist/build/Graphics/X11/Types.hs, dist/build/Graphics/X11/Types.o ) [ 3 of 17] Compiling Graphics.X11.Xlib.Atom ( dist/build/Graphics/X11/Xlib/Atom.hs, dist/build/Graphics/X11/Xlib/Atom.o ) [ 4 of 17] Compiling Graphics.X11.Xlib.Color ( Graphics/X11/Xlib/Color.hs, dist/build/Graphics/X11/Xlib/Color.o ) [ 5 of 17] Compiling Graphics.X11.Xlib.Context ( Graphics/X11/Xlib/Context.hs, dist/build/Graphics/X11/Xlib/Context.o ) [ 6 of 17] Compiling Graphics.X11.Xlib.Display ( Graphics/X11/Xlib/Display.hs, dist/build/Graphics/X11/Xlib/Display.o ) [ 7 of 17] Compiling Graphics.X11.Xlib.Event ( dist/build/Graphics/X11/Xlib/Event.hs, dist/build/Graphics/X11/Xlib/Event.o ) [ 8 of 17] Compiling Graphics.X11.Xlib.Font ( dist/build/Graphics/X11/Xlib/Font.hs, dist/build/Graphics/X11/Xlib/Font.o ) [ 9 of 17] Compiling Graphics.X11.Xlib.Misc ( dist/build/Graphics/X11/Xlib/Misc.hs, dist/build/Graphics/X11/Xlib/Misc.o ) [10 of 17] Compiling Graphics.X11.Xlib.Region ( Graphics/X11/Xlib/Region.hs, dist/build/Graphics/X11/Xlib/Region.o ) [11 of 17] Compiling Graphics.X11.Xlib.Screen ( Graphics/X11/Xlib/Screen.hs, dist/build/Graphics/X11/Xlib/Screen.o ) [12 of 17] Compiling Graphics.X11.Xlib.Window ( Graphics/X11/Xlib/Window.hs, dist/build/Graphics/X11/Xlib/Window.o ) [13 of 17] Compiling Graphics.X11.Xlib.Image ( Graphics/X11/Xlib/Image.hs, dist/build/Graphics/X11/Xlib/Image.o ) [14 of 17] Compiling Graphics.X11.Xlib ( Graphics/X11/Xlib.hs, dist/build/Graphics/X11/Xlib.o ) [15 of 17] Compiling Graphics.X11.Xlib.Extras ( dist/build/Graphics/X11/Xlib/Extras.hs, dist/build/Graphics/X11/Xlib/Extras.o ) Warning: orphan instances: instance base:GHC.Read.Read [ X11-1.3.0.20071111:Graphics.X11.Xlib.Types.Rectangle] = $f1 [16 of 17] Compiling Graphics.X11.Xinerama ( dist/build/Graphics/X11/Xinerama.hs, dist/build/Graphics/X11/Xinerama.o ) [17 of 17] Compiling Graphics.X11 ( Graphics/X11.hs, dist/build/Graphics/X11.o ) /usr/bin/ar: creating dist/build/libHSX11-1.3.0.20071111.a > sudo runghc Setup.hs install root's password: Setup.hs: Warning: Unknown field 'build-type' Setup.hs: error reading ./.setup-config; run "setup configure" command?

3 2

Renaming constructors for readability
by Dougal Stanton 14 Nov '07

14 Nov '07

I wonder, is there an equivalent of the 'type' keyword for constructors? An example: -- create a pseudo-C pointer type -- which can point to a value or a -- null. type Pointer a = Maybe a -- int a = 3; -- int *pa = &a; ampersand :: t -> Pointer t ampersand a = Just a -- int b = *pa. star :: Pointer a -> a star (Just a) = a -- note this function behaves -- in an 'authentic' fashion ;-) To really complete the illusion it would be nice to replace the names Just and Nothing with PointerTo and Null. Then the constructors would really mean something. Is there a solution? -- Dougal Stanton dougal(a)dougalstanton.net // http://www.dougalstanton.net

5 7

Screen scraping with an interactive process: Buffering problems?
by Denis Bueno 14 Nov '07

14 Nov '07

Hi all, I'm writing some code to interact with an ACL2 [0] process. I'd like to be able to write a function test :: String -> IO Bool that will attempt to prove something by forking an ACL2 process and screen scraping its output, to see whether the conjecture was proved. The code below [1] is close: it launches the process, sends the conjecture to ACL2, and reads ACL2's output line-by-line until it finds "Proof succeeded" or "attempt has failed". This works well enough for the simple case, but there is a problem. In readACL2Answer, the code shouldn't have to check for success *and* failure, since the conditions are complementary. But if I change that code to check only for success, then it is possible (and indeed it happens every time) that if I send ACL2 a conjecture it can't prove, readACL2Answer blocks indefinitely -- and the print statements show that hWaitForInput has said there is more data on the Handle but hGetLine blocks trying to read it. The reason for this, as far as I can tell, is that there *is* more data -- a character, for example -- but no newline, so hGetLine blocks waiting for a newline. However, if I'm reading the BufferMode documentation [3] correctly, the fact that I've set my streams to LineBuffering should mitigate that scenario. Concretely, I know that ACL2 runs in a REPL and the last thing it prints is in fact an incomplete line -- "ACL2 !>". I'd rather not have to read every line character by character just to detect the uncommon case. Should I just do it character by character? Am I reading the BufferMode docs wrong, and if so, what is the correct interpretation? Is there better approach for the original problem I'm trying to solve? Thanks for reading this far. =] -- Denis [0] http://www.cs.utexas.edu/users/moore/acl2/ [1] import System.Process import System.IO type Proc = (Handle, Handle, Handle, ProcessHandle) testThm = test "(equal x x)" -- something acl2 can prove testBad = test "(equal x (not x))" -- something it can't -- | Pass a conjecture form to ACL2, attempt to prove it, and return a boolean -- indicating whether ACL2 was able to prove it. test :: String -> IO Bool test thm = do i@(stdin, _, _, pid) <- setUpACL2 success <- testProc i thm hPutStrLn stdin "(good-bye)" putStrLn "saying goodbye" exitCode <- waitForProcess pid case exitCode of ExitSuccess -> return success ExitFailure i -> error ("ACL2 bad exit code: " ++ show i) -- | Pass a conjecture vio the given process' input stream, and return whether -- it is proved. testProc :: Proc -> String -> IO Bool testProc i@(stdin, stdout, _, pid) thm = do hSetBuffering stdout LineBuffering hSetBuffering stdin LineBuffering success <- testInACL2 ("(thm " ++ thm ++ ")") i putStrLn "found success value" return success succeedRx = mkRegex "Proof succeeded[.]" failedRx = mkRegex "attempt has failed[.]" -- create acl2 process and return handles setUpACL2 :: IO Proc setUpACL2 = runInteractiveCommand "acl2" testInACL2 :: String -> Proc -> IO Bool testInACL2 str (pin, pout, perr, pid) = do putStrLn "printing to acl2..." hPutStrLn pin str putStrLn "getting acl2 result..." readACL2Answer pout -- | How long we should wait for ACL2 to start saying something. Five -- seconds, currently. readTimeout = 100 readACL2Answer :: Handle -> IO Bool -- I *should* be required *only* to check for *success* in the matchRegex -- statement below, instead of checking for success and failure. But if I do -- that, and the theorem to be proved fails, this function blocks indefinitely -- (at least I observe a much greater than 5 second wait period), even though -- it should only block for `readTimeout' milliseconds. I'm not sure why this -- is, but at least there is an acceptable workaround. readACL2Answer pout = hWaitForInput pout readTimeout >>= (\isReady -> if isReady then do putStrLn "getting line" line <- hGetLine pout putStrLn $ "read line: " ++ line -- Check for success or failure. case (matchRegex succeedRx line, matchRegex failedRx line) of (Nothing, Nothing) -> readACL2Answer pout (Nothing, Just _) -> return False (Just _, _) -> return True else do putStrLn "not ready" return False) [3] http://haskell.org/ghc/docs/latest/html/libraries/base-3.0.0.0/System-IO.ht…

2 4

More good performance results for ghc 6.8
by Don Stewart 14 Nov '07

14 Nov '07

Trying out some of the great language shootout programs with ghc 6.8 is producing nice results. For example, our "classic" cache-hammering, bitwise sieve benchmark is out of the box 10% faster with the new compiler. The (already rather good) benchmark is here (the same speed as the OCaml version under ghc 6.6): http://shootout.alioth.debian.org/gp4/benchmark.php?test=nsievebits&lang=all And timing with old and new ghc: ghc 6.6.1 Primes up to 81920000 4774995 Primes up to 40960000 2488465 Primes up to 20480000 1299069 ./A66 13 4.50s user 0.02s system 100% cpu 4.515 total ghc 6.8.1 Primes up to 81920000 4774995 Primes up to 40960000 2488465 Primes up to 20480000 1299069 ./A68 13 4.13s user 0.01s system 99% cpu 4.142 total Lovely work GHC HQ, when low level, highly tuned code like this gets magically faster! Once 6.8 is in Gentoo (or earlier...) we should see similar improvements across a range of shootout programs. -- Don

2 1

how does ghci and hugs handle redirecting of stdin/stdout?
by Galchin Vasili 14 Nov '07

14 Nov '07

Thanks, Vasya

1 0

Performance help
by Justin Bailey 14 Nov '07

14 Nov '07

I've been working on a program over the last few days to evolve cellular automata rules using a genetic algorithm. Luckily, this email has nothing to do with CAs but everything to do with Haskell performance. For those who don't know, a CA is represented as a row of cells, where each can be either black (on/1) or white (off/0). A CA is "run" by generating a new row from the previous row according to some rule. Each cell is examined in turn and based on the state of it's neighbors and itself, a new cell in the next row is generated that is either black or white. The function below is my "step" function that generates this new row. It's at the heart of my program and where all the execution time is spent. In this scenario it's executed around 800 million times. On my relatively modest desktop using GHC 6.8.1, the program takes about 30 seconds to run. Here's the function, with some of the type declarations: data Rule = Rule { ruleWidth :: Int, rules :: UArray Int Bool } data Ring = Ring { currIdx :: !Int, vals :: (UArray Int Bool), lower, upper, size:: !Int } type CA = Ring currR :: Int -> Ring -> Bool currR amt r@(Ring curr arr l u s) = unsafeAt arr ((curr + amt) `mod` s) stepWithUArray :: Int -> Rule -> CA -> CA stepWithUArray rowLen rule@(Rule width rules) row = let upper = rowLen - 1 getRule currIdx = pattern' start 0 where start = currIdx - width end = currIdx + width pattern' cnt !result | cnt > end = result | otherwise = if (currR cnt row) then pattern' (cnt + 1) (result * 2 + 1) else pattern' (cnt + 1) (result * 2) makeNewRow :: ST s (ST.STUArray s Int Bool) makeNewRow = do arr <- ST.newArray_ (0, upper) let fill idx | idx > upper = return () | otherwise = do unsafeWrite arr idx (unsafeAt rules (getRule idx)) fill (idx + 1) fill 0 return $! arr in fromUArray (ST.runSTUArray makeNewRow) fromUArray produces a new Ring (i.e. CA) from an array. 'makeNewRow' iterates over every cell in the current row using getRule to get the new value for each cell and returns the new row as an array. getRule essentially treats the neighbors of the current cell as bits, with the most significant to the left. An index into the rules array is constructed based on the values around the cell being examined (which wrap on the ends, thus the Ring construct). That index is used to get the value of the new cell from the rules array. Profiling shows that the following lines take up the most execution and allocation: makeNewRow = ... -- 20.5% execution, 26.7% allocation if (currR cnt row) ... -- 14.7% execution, 26.6% allocation, in pattern' currR ... -- 14.7% execution, 0% allocation Any suggestions for improving this code? Thanks in advance! Justin p.s. The entire program is attached. Compile with ghc -O2 -funbox-strict-fields -fbang-patterns --make GA-CA.hs. It runs 25 rules on each of 25 initial CAs for 2 generations. p.p.s. On the bright side, this program has excellent memory performance. It uses a constant 2 - 7 MB depending on the initial parameters for the entire run. Beautiful!

4 8

Somewhat random history question
by Andrew Coppin 14 Nov '07

14 Nov '07

Somebody just asked me "...if GHC is written in Haskell, how the heck did they compile GHC in the first place?"

19 37

Haskell library documentation question
by Galchin Vasili 14 Nov '07

14 Nov '07

Hello, Is there anyway to get a .pdf version of http://www.haskell.org/ghc/docs/latest/html/libraries/? Kind regards, Vasili

2 1

Annoying (windows only?) related GHCi "problem"?
by Peter Verswyvelen 14 Nov '07

14 Nov '07

When I start a windowed program (e.g. GLUT or GTK2Hs) from within GHCi, my application's window does not become the foreground window. Is this on purpose? Thanks, Peter

2 1

Trouble using HDBC-postgres on Windows - can't find libpq.dll
by Justin Bailey 14 Nov '07

14 Nov '07

I've compiled HDBC 1.0.1 and HDBC-postgresql-1.0.1 under Windows with a little tweaking. However, when I try to run the tests I get this error: >runghc -package HDBC-postgresql runtests.hs ghc.exe: can't load .so/.DLL for: pq (addDLL: unknown error) libpq.dll is in my path, and I added the correct paths to the .cabal file when I built it. Does anyone have an idea what might be the problem? Justin p.s. I have postgres 8.2 installed if that matters.

2 3

Building Haskell stuff on Windows
by Arthur van Leeuwen 13 Nov '07

13 Nov '07

Hello all, maybe I'm just not used enough to Windows, but let me explain my woes of today. It seems to me to be *much* too hard to get a full install of GHC + GTK2Hs going on Windows, going from the idea that I want the currently released stable versions of everything. So, this is the way I progressed (from a clean Windows install): - Installed MinGW 5.1.3 - Installed MSYS 1.0.10 - Installed GHC 6.8.1 - edit /etc/fstab in MSYS to correctly bind MinGW - Installed gtk-dev-2.10.11-win32-1 - Downloaded gtk2hs-0.9.12.tar.gz - cd /d/haskell/gtk2hs-0.9.12 - ran configure - discovered I needed happy (this was not documented!) - Downloaded happy-1.17.tar.gz - unpacked, configured, built, installed - ran configure for gtk2hs - discovered I needed alex (this was not documented!) - Downloaded alex-2.10.tar.gz - Setup.lhs of alex-2.10 did not compile due importing Distribution.Simple(compilerPath) - Installed darcs - darcs got alex development tree - Setup.lhs of alex-2.10 compiled - building alex-2.10 failed due to wishing an existing alex - broke down and downloaded alex-2.10 binaries - installed alex-2.10 next to happy in C:\Program Files\Haskell\bin - ran configure for gtk2hs - ran make - discovered alex should not be in C:\Program Files as make breaks on paths with embedded spaces... - copied C:\Program Files\Haskell to C:\Haskell and modified $PATH - reran configure for gtk2hs - ran make - discovered gtk2hs 0.9.12 hides 'containers' - broke down and darcs got gtk2hs development tree - installed automake - ran autoreconf - discovered automake for MSYS 1.0.10 is too old - installed automake-1.9 - ran aclocal-1.9 - ran autoconf - ran configure - discovered I need to explicitly add GTK libs to aclocal - ran aclocal-1.9 -I with GTK library path - ran autoconf - ran configure for gtk2hs - ran make - complained on IRC - ran make install - sighed deeply Ofcourse, on complaining I learned that hackage contains alex 2.2, rather than 2.10, but that is not apparent from the alex webpages. It seems to me that much of this is way too hard to figure out... figuring out the dependency graph should not be necessary, as the developers should know what parts go into their code! Furthermore, as much as I applaud hackage, it is not ready for use, as it does not afford things you might want, such as searching for latest (stable) releases of packages. Plus, it is still not the default go-to place for many things. Maybe developers that decide to put their most recent versions on hackage could document that on the main webpages of their code? (I've ran into this with FileManip as well, not just with Alex). With kind regards, Arthur. -- /\ / | arthurvl(a)cs.uu.nl | Work like you don't need the money /__\ / | A friend is someone with whom | Love like you have never been hurt / \/__ | you can dare to be yourself | Dance like there's nobody watching

11 18

Ray tracer benchmark: GHC 6.6 vs 6.8
by Jon Harrop 13 Nov '07

13 Nov '07

Following Lennart Augustsson's improvements of the Haskell implementations of my ray tracer language comparison: http://augustss.blogspot.com/2007/11/benchmarking-ray-tracing-haskell-vs.ht… I thought I'd share the performance improvements offered by Lennart's new code with the latest release of GHC. Time in seconds to run the five versions on my Athlon64 X2 2.2GHz running 64-bit Debian Lenny: ghc-6.6.1 22.0715339184 16.5431628227 13.3524830341 11.1260569096 6.33169198036 ghc-6.8.1 16.654654026 12.3998670578 7.8039829731 7.31486296654 6.03285193443 So 6.8 is up to a third faster! The fastest implementations in other language run at around 4s, so Haskell has gone from being 3x slower in the previous implementations with GHC 6.6 to only 50% slower with the new implementations and new GHC. -- Dr Jon D Harrop, Flying Frog Consultancy Ltd. http://www.ffconsultancy.com/products/?e

1 0

Using type-level programming to tag functions with time and space complexity
by Daniel McAllansmith 13 Nov '07

13 Nov '07

I was wondering if anyone had done work on tagging functions at the type level with their time or space complexity and, if it's even feasible, calculating the complexity of compound functions. Any pointers? Cheers Daniel

3 2

Interesting effect of upgrading GHC
by Andrew Coppin 13 Nov '07

13 Nov '07

Hi guys. I just removed GHC 6.6.1 and installed 6.8.1, and I noticed something rather unexpected. I recompiled an existing program (with -O2), and instead of taking 30 seconds to compile, it took roughly 2 seconds. That's a really serious speedup! o_O Anybody have any idea what might have caused this? (Not, you understand, that I'm complaining! But the release notes say 10-15% faster, not 15,000% faster...) I am also curiose to see whether the compiled code execution speed is better/worse - but the program in question is mainly GUI, so I can't test it with that... Perhaps my Chaos program? ;-)

5 4

can someone explain monad transformers to me, or how do you combine maybe and IO?
by Anatoly Yakovenko 13 Nov '07

13 Nov '07

I wanted something that would work like liftM but with IO as well, so something like this: > liftM ((+) 1) $ Just 1 Just 2 but with the function lifted being of type (a -> IO b). so I came up with maybeIO::(a -> IO b) -> (Maybe a -> IO (Maybe b)) maybeIO ff = (\ aa -> case aa of Nothing -> return $ Nothing Just vv -> do rv <- ff vv return $ Just rv) incIO:: Int -> IO Int incIO ii = return $ ii + 1 > maybeIO incIO $ Just 1 Just 2 works just like I want it to. But isn't this something that a monad transformer should be able to do?

3 2