- Haskell-Cafe - Haskell.org

Moving nobench towards HaBench
by Andy Georges 23 Jan '09

23 Jan '09

Hello, A while back, we had a discussion on #haskell about assembling a Haskell benchmark suite, that is suitable for doing performance tests. A preliminary page was erected athttp://www.haskell.org/haskellwiki/HaBench . In the meantime, Donald Steward extended the original nofib suite with some shootout benchmarks afaik, resulting in nobench. The code base for the latter currently resides at http://code.haskell.org/nobench/ . I have been trying to get it running on GHC 6.10.1. For now, I added a number of type definitions to the code, causing the build/runtime system to compile. The same probably ought to be done for the benchmarks themselves, unless there is a cheat around this using some language extension. Anyhow, I'll post a patch against the current repository as soon as I have a number of benchmarks running. The main issue that still remains is the availability of real life benchmarks. I agree with the fact that micro-benchmarks can be useful for testing purposes or measures the efficacy and effectiveness of certain optimisations, yet I firmly believe any community has need of a set of benchmarks that actually reflects the real life usage of the language. I am think along the lines of something alike to the DaCapo projects, which assembled a number of very good benchmarks for the Java language and its VM. So the question basically boils down to this. Is there anybody interested in making the move toward HaBench, and if so, do you know of real life benchmarks that can serve for this exact purpose? The benchmarks should preferably execute for > 10s on modern machines, using a decent amount of RAM (say somewhere between 50 and 500MB), thus exercising all parts of a modern computing system. The code should not be trivial and the set of benchmarks should eventually cover the most uses of Haskell in the industry. Of course, the benchmarks themselves should be open source. If possible, they should come with multiple inputs, allowing a short (test) run as well as longer measurement runs. If you are able and willing to help out, drop by at the HaBench page and drop a line, -- Andy

1 0

Processor availability
by Louis Wasserman 22 Jan '09

22 Jan '09

How might I go about finding out how many processors are available in a concurrent GHC program? I have some code I'd like to parallelize, but I don't want to spawn a separate (even lightweight) thread for each of thousands of minor tasks. Louis Wasserman wasserman.louis(a)gmail.com

4 3

Big endian vs little endian in Haskell land?
by Galchin, Vasili 22 Jan '09

22 Jan '09

Hello, Are there applications that have to deal with both(!!!) big endian and little endian on persistent store?? I.e. when marshalling out and unmarshalling in "endian-ness" has to be considered?? Regards, Vasili

2 2

Question about allocaArray and friends
by Patrick Perry 22 Jan '09

22 Jan '09

In C, if you try to "alloca" too much memory, then the stack gets overwritten and bad things happen. Does GHC exhibit the same behavior with allocaArray and the like? Is there a way to find out how much is safe to allocate? Thanks in advance for the help, Patrick

2 1

Factoring into type classes
by Patai Gergely 22 Jan '09

22 Jan '09

Hi everyone, I have a general program design question, but I can't really think of good examples so it will be a bit vague. There was a discussion on Show not long ago which brought up the problem that there are several ways to "show" a data structure, and it depends on the context (or should I call it a use case?) which of these we actually want, e.g. human readable form, debug information, serialisation for later reading and so on, and one of the solutions was to propose a family of show functions that carry the intended use in their name. However, there are other type classes that are too general to assign such concrete uses to. For instance, if a data structure can have more than one meaningful (and useful) Functor or Monoid instance, what should one do? Should one refrain from instantiating these classes altogether and just use the names of operations directly? If one still decides to pick a certain set of operations as an instance, what are the factors that should guide this decision? What about designing libraries, how much should one prefer standard classes for their interfaces? It seems to me that there is practically no literature on design issues like these, and it would be nice to hear some opinions from experienced Haskellers. Gergely -- http://www.fastmail.fm - The way an email service should be

15 21

ANN: STM-IO-Hooks-0.0.1
by Peter Robinson 22 Jan '09

22 Jan '09

This library provides an STM monad with commit and retry IO hooks. A retry-action is run (once) in a separate thread if the transaction retries, while commit-actions are executed iff the transaction commits. The code is based on the AdvSTM Monad [1] by Chris Kuklewicz, but in addition also ensures some atomicity guarantees for commit-actions, see documentation for details. Cheers, Peter [1] http://www.haskell.org/haskellwiki/New_monads/MonadAdvSTM

1 0

Comments from OCaml Hacker Brian Hurt
by John Goerzen 22 Jan '09

22 Jan '09

Hi folks, Don Stewart noticed this blog post on Haskell by Brian Hurt, an OCaml hacker: http://enfranchisedmind.com/blog/2009/01/15/random-thoughts-on-haskell/ It's a great post, and I encourage people to read it. I'd like to highlight one particular paragraph: One thing that does annoy me about Haskell- naming. Say you've noticed a common pattern, a lot of data structures are similar to the difference list I described above, in that they have an empty state and the ability to append things onto the end. Now, for various reasons, you want to give this pattern a name using on Haskell's tools for expressing common idioms as general patterns (type classes, in this case). What name do you give it? I'd be inclined to call it something like "Appendable". But no, Haskell calls this pattern a "Monoid". Yep, that's all a monoid is- something with an empty state and the ability to append things to the end. Well, it's a little more general than that, but not much. Simon Peyton Jones once commented that the biggest mistake Haskell made was to call them "monads" instead of "warm, fluffy things". Well, Haskell is exacerbating that mistake. Haskell developers, stop letting the category theorists name things. Please. I beg of you. I'd like to echo that sentiment! He went on to add: If you?re not a category theorists, and you're learning (or thinking of learning) Haskell, don't get scared off by names like "monoid" or "functor". And ignore anyone who starts their explanation with references to category theory- you don't need to know category theory, and I don't think it helps. I'd echo that one too. -- John

74 231

Elegant external sorting
by Bulat Ziganshin 22 Jan '09

22 Jan '09

Hello haskell-cafe, SPJ asked us a few years ago about examples of simple and elegant haskell programs. i want to propose this external sorting program: it reads stdin in chunks of 5000 lines, writes sorted chunks into files and then merges files together: import Data.List import Control.Monad import Control.Arrow main = do -- (Lazily) create sorted sublists sublists <- fmap chop_and_sort getContents -- Write the sublists into files named 1..n n <- fmap length $ zipWithM writeFile (map show [1..]) sublists -- Read (again lazily) contents of these files sublists <- mapM (fmap lines.readFile.show) [1..n] -- Merge them and write result to stdout putStr (unlines (merge_lists compare sublists)) -- Split input list into 5000-line chunks and sort them chop_and_sort = lines >>> recursive (splitAt 5000) >>> map (sort>>>unlines) -- unfoldr variant that stops on empty list recursive splitFunc = unfoldr (\xs -> guard (xs>[]) >> Just (splitFunc xs)) -- Merging sorted lists (kidnapped from Data.List) merge_lists :: (a -> a -> Ordering) -> [[a]] -> [a] merge_lists cmp [] = [] merge_lists cmp [xs] = xs merge_lists cmp xss = merge_lists cmp (merge_pairs cmp xss) merge_pairs :: (a -> a -> Ordering) -> [[a]] -> [[a]] merge_pairs cmp [] = [] merge_pairs cmp [xs] = [xs] merge_pairs cmp (xs:ys:xss) = merge cmp xs ys : merge_pairs cmp xss merge :: (a -> a -> Ordering) -> [a] -> [a] -> [a] merge cmp xs [] = xs merge cmp [] ys = ys merge cmp (x:xs) (y:ys) = case x `cmp` y of GT -> y : merge cmp (x:xs) ys _ -> x : merge cmp xs (y:ys) -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

1 0

Pure Haskell implementation of Float type?
by Tim Chevalier 22 Jan '09

22 Jan '09

Hello, Is there a pure Haskell implementation of Floats, i.e., one that (unlike GHC.Float) doesn't use foreign calls for things like isFloatNegativeZero? I don't care about performance; I'm just looking for something that doesn't use foreign calls. Thanks, Tim -- Tim Chevalier * http://cs.pdx.edu/~tjc * Often in error, never in doubt "It is easy to keep secrets by being honest in an ironic tone of voice." -- Andrew Solomon

5 7

How to make code least strict?
by Robin Green 22 Jan '09

22 Jan '09

What guidelines should one follow to make Haskell code least-strict? -- Robin

7 9