January 2009 - Haskell-Cafe

Lazy vs correct IO [Was: A round of golf]
by oleg＠okmij.org 06 Apr '09

06 Apr '09

Lennart Augustsson wrote > main = do > name:_ <- getArgs > file <- readFile name > print $ length $ lines file Given the stance against top-level mutable variables, I have not expected to see this Lazy IO code. After all, what could be more against the spirit of Haskell than a `pure' function with observable side effects. With Lazy IO, one indeed has to choose between correctness and performance. The appearance of such code is especially strange after the evidence of deadlocks with Lazy IO, presented on this list less than a month ago. Let alone unpredictable resource usage and reliance on finalizers to close files (forgetting that GHC does not guarantee that finalizers will be run at all). Is there an alternative? -- Counting the lines in a file import IterateeM count_nl = liftI $ IE_cont (step 0) where step acc (Chunk str) = liftI $ IE_cont (step $! acc + count str) step acc stream = liftI $ IE_done acc stream count [] = 0 count ('\n':str) = succ $! count str count (_:str) = count str main = do name:_ <- getArgs IE_done counter _ <- unIM $ enum_file name >. enum_eof ==<< count_nl print counter The function count_nl could have been in the library, but I'm a minimalist. It is written in a declarative rather than imperative style, and one easily sees what it does. The above code as well as the IterateeM library is Haskell98. It does not use any unsafe Haskell functions whatsoever. time wc -l /usr/share/dict/words 235882 /usr/share/dict/words real 0m0.024s user 0m0.022s sys 0m0.000s time ~/Docs/papers/DEFUN08/Wc /usr/share/dict/words 235882 real 0m0.141s user 0m0.126s sys 0m0.008s To compare with lazy IO, the code using readFile gives time ~/Docs/papers/DEFUN08/Wc /usr/share/dict/words 235882 real 0m0.297s user 0m0.262s sys 0m0.023s So, choosing correctness does not mean losing in performance; in fact, one may even gain. Can enumerators compose? Well, we already seen the example above (enum_file name >. enum_eof) where the operation (>.) e1 >. e2 = (==<<) e2 . e1 is a flipped composition if monadic bind were considered a flipped application. Here is a more interesting example: count words in all the files whose names are given on the command line. There may be many files given, thousands of them. -- Count the stream. Again, could have been in the library stream_count :: Monad m => IterateeGM el m Int stream_count = liftI $ IE_cont (step 0) where step acc (Chunk []) = liftI $ IE_cont (step acc) step acc (Chunk [_]) = liftI $ IE_cont (step $! succ acc) step acc (Chunk ls) = liftI $ IE_cont (step $! acc + length ls) step acc stream = liftI $ IE_done acc stream main = do names <- getArgs let enumerators = foldr (\name -> (enum_file name >.)) enum_eof names IE_done (IE_done counter _) _ <- unIM $ enumerators ==<< enum_words stream_count print counter We notice that the composition of enumerators corresponds to the `concatenation' of their sources. Declaratively, the meaning of the above code is: -- all the given files are concatenated -- the resulting stream of characters is converted to a stream of words -- the stream of words is counted. Operationally, the code does not open more than one file at a time. More importantly, the code *never* reads more than 4096 characters at a time. A block of the file is read, split into words, counted, and only then another chunk is read. After one file is done, it is closed, and another file is processed. One can see that only one file is being opened at a time by enabling traces. The processing is fully incremental. /usr/local/share/doc/ghc6> find . -name \*.html -print | time xargs ~/Docs/papers/DEFUN08/Wc 3043421 16.99 real 15.83 user 0.71 sys BTW, the program has counted words in 1169 files. It is interesting to compare the above main function with the corresponding lazy IO: main'' = do names <- getArgs files <- mapM readFile names print $ length $ words (concat files) The number of lines is comparable. The execution is not. If we try to run the lazy IO code, we get: /usr/local/share/doc/ghc6> find . -name \*.html -print | time xargs ~/Docs/papers/DEFUN08/Wc Wc: ./libraries/Win32/Graphics-Win32-GDI-Path.html: openFile: resource exhausted (Too many open files)

9 12

what does "atomically#" mean?
by Daryoush Mehrtash 20 Mar '09

20 Mar '09

Any idea was the atomically# mean in the following code? atomically :: STM a -> IO a atomically (STM m) = IO (\s -> (*atomically# *m) s ) Code is from GHC.Conc module http://www.haskell.org/ghc/docs/6.6/html/libraries/base/GHC-Conc.html daryoush

4 5

Using cabal to build an exportable library?
by Justin Bailey 20 Mar '09

20 Mar '09

I've been following this instructions at http://www.haskell.org/haskellwiki/Calling_Haskell_from_C to build a Haskell library which I can call from a C program. I'd like to use cabal to do the build in the future. Are there any examples showing how to do it?

2 1

Proposal for associated type synonyms in Template Haskell
by Thomas van Noort 19 Mar '09

19 Mar '09

Hello, Recently, we released a library on Hackage for generic rewriting (package "rewriting" if you are curious). The user of the library is expected to define type class instances to enable rewriting on his or her own datatypes. As these instances follow the datatype declarations closely, we tried to generate the instances using Template Haskell. Unfortunately, associated type synonyms are not yet supported by TH. After a presentation at the WGP'08, Simon encouraged us to write a proposal about adding associated type synonyms to TH, so that it can be added to GHC. So, here is our proposal. The TH AST must allow 1) kind declarations of associated type synonyms in class declarations and 2) their definitions in instance declarations. For example, class Foo a where type Bar a :: * instance Foo Int where type Bar Int = String The TH library defines a datatype Dec which contains a constructor for class declarations and instance declarations: data Dec = ... | ClassD Cxt Name [Name] [FunDep] [Dec] | InstanceD Cxt Type [Dec] ... 1) Associated type synonym kind declarations We suggest to add a constructor to the Dec type: ... | AssocTySynKindD Name [Name] (Maybe Kind) ... assocTySynKindD :: Name -> [Name] -> Maybe KindQ -> DecQ The first field is the name of the associated type synonym, the second field is a list of type variables, and the third field is an optional kind. Since kinds are not yet defined in TH, we have to add some kind of kind definition (pun intended): data Kind = StarK | ArrowK Kind Kind type KindQ = Q Kind starK :: KindQ arrowK :: KindQ -> KindQ -> KindQ We explicitly choose not to reuse the Type type to define kinds (i.e., type Kind = Type as in GHC) since we think a separation between the two worlds is much clearer to the users of TH. 2) Associated type synonym definitions We suggest to add another constructor to the Dec type: ... | AssocTySynD Name [Type] Type ... assocTySynD :: Name -> [TypeQ] -> TypeQ -> DecQ The first field is the name of the type synonym, the second field is a list of type arguments, and the third field is the body of the type synonym. We would like to hear your comments to this proposal. Regards, Thomas

5 5

What *not* to use Haskell for
by Dave Tapley 19 Mar '09

19 Mar '09

Hi everyone So I should clarify I'm not a troll and do "see the Haskell light". But one thing I can never answer when preaching to others is "what does Haskell not do well?" Usually I'll avoid then question and explain that it is a 'complete' language and we do have more than enough libraries to make it useful and productive. But I'd be keen to know if people have any anecdotes, ideally ones which can subsequently be twisted into an argument for Haskell ;) Cheers, Dave

39 82

C-like Haskell
by drblanco 18 Feb '09

18 Feb '09

I'm trying to do a calculation for Gauss' circle problem, which counts the integer lattice points with distance to the origin <= r. It's sequence A000328 on the AT&T integer sequence database. I can't figure out a way to do it quickly in Haskell for r around 10^9. Here's my attempt, which takes about 75s for r=10^8. circ2 r = (1+4*r) + 4 * (circ2' (rs+1) r 1 0) where rs = r^2 -- circ2' :: Int64 -> Int64 -> Int64 -> Int64 -> Int64 circ2' rad x y sum | x<y = sum | rad<=rs = circ2' (rad+1+2*y) x (y+1) (sum+1+2*(x-y)) | otherwise = circ2' (rad+1-2*x) (x-1) y sum The commented out line was to try to force it to use machine-size ints, but instead it made it eat memory like mad. It overflows if everything is forced to be ints, and isn't much faster. Making rad and sum Integers fixes the overflow but still takes ~45 secs. I do already have the number I wanted, but was wondering how this could be made faster, or even why it's so slow. This is all on GHC 6.8.3 under OS X Intel, using ghc -O2. For comparison, the C code below runs in <1 second. typedef unsigned long long bigint; bigint gausscount(bigint r) { bigint sum=0; bigint x, y; bigint rs=r*r; bigint rad=rs+1; x=r; y=1; while (y<x) { while (rad>rs) { rad-=2*x; rad++; x--; } sum+=1+2*(x-y); rad+=2*y+1; y++; } sum*=4; sum++; return sum; } -- View this message in context: http://www.nabble.com/C-like-Haskell-tp21717584p21717584.html Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

8 11

Complex C99 type in Foreign
by Maurício 16 Feb '09

16 Feb '09

Hi, Are there plans to include C99 'complex' type in Foreign, maybe as CFloatComplex, CDoubleComplex and CLongDoubleComplex? This seems an easy addition to the standard and would allow binding of a few interesting libraries, like GSL. Best, Maurício

3 8

Iteratee-based IO and lightweight monadic regions in the wild
by Artyom Shalkhakov 14 Feb '09

14 Feb '09

Hello, Is anybody planning to use these shiny new ways for doing IO? I'm also interested in a fair comparison of ByteString/Binary with iteratee-based IO. Has anybody done this? Regards, Artyom Shalkhakov.

2 1

space leak with 'concat' ?
by Henning Thielemann 14 Feb '09

14 Feb '09

$ ghc +RTS -M16m -c30 -RTS -e 'concat $ repeat "bla"' This breaks down after a while, also if I increase the memory restriction: ... ablablablablablablablablablablablablablablablablablablablablablaHeap exhausted; Current maximum heap size is 15998976 bytes (15 Mb); use `+RTS -M<size>' to increase it. Whereas this one works: $ ghc +RTS -M16m -c30 -RTS -e 'cycle "bla"' 'concat' seems to be the culprit. What's so bad about it?

8 14

The Haskell re-branding exercise
by Paul Johnson 12 Feb '09

12 Feb '09

16 32