February 2011 - Haskell-Cafe

How large is the Haskell community ?
by Aaron Gray 17 Mar '11

17 Mar '11

I was wondering if anyone had an idea or estimate as to how large the Haskell community is ? Aaron

18 22

Data.ByteString.Lazy.ByteString vs Data.ByteString.Lazy.Internal.ByteString
by C K Kashyap 17 Mar '11

17 Mar '11

Hi, I noticed that even though I declare the type of a function in my code as Data.ByteString.Lazy.ByteString ... when I check it out in ghci using :t, it shows this - Data.ByteString.Lazy.Internal.ByteString Is this expected? Regards, Kashyap

7 11

Re: [Haskell-cafe] ANN: unordered-containers - a new, faster hashing-based containers library
by Louis Wasserman 14 Mar '11

14 Mar '11

A couple thoughts: size takes O(n). That's just depressing. Really. Do you think union, intersection, etc. could be supported? Louis Wasserman wasserman.louis(a)gmail.com http://profiles.google.com/wasserman.louis

21 48

Cmdargs and common flags
by Magnus Therning 12 Mar '11

12 Mar '11

I'm looking for a good way of dealing with common flags in cmdargs. Currently what I do requires a bit of repetition that I'd really like to get rid of: 1. Data types data Modes = Cmd1 { foo :: String, ... } | Cmd2 { foo :: String, ... } 2. Mode specifications cmd1 = Cmd1 { foo = def &= help "..", ...} cmd2 = Cmd2 { foo = def &= help "..", ...} I have no idea how to deal with the repetition in the data types, so all suggestions are welcome. For the repetition in the mode specifications I attempted to factor the common bits into a "variable": flagFoo = "" &= help ".." but that resulted in only the first command getting the proper specification. I suppose this comes down to the impurity, but how do I work around that? (Especially, are there any good examples of using the pure part of the API?) /M -- Magnus Therning OpenPGP: 0xAB4DFBA4 email: magnus(a)therning.org jabber: magnus(a)therning.org twitter: magthe http://therning.org/magnus

3 5

Why don't my OS threads terminate?
by Bas van Dijk 10 Mar '11

10 Mar '11

Dear all, At work, I'm developing a webapplication with happstack. When I let it run for some time (< 5min.) it crashes with the following message: "failed to create OS thread: Resource temporarily unavailable" This happens because the server continuously creates OS threads but never terminates them. This keeps going on until I hit the OS thread limit. I would like to know why the OS threads are created and more importantly why they aren't terminated. Unfortunately I can't publish the source code because it's proprietary software. Hopefully the following description may give an idea what's going on: The webapplication is basically a simple measurement application: The client side (HTML, Javascript, JQuery) contains a plot which shows the measurements that the server generates. The client contains a loop which first longpolls[2] the server to wait for a new measurement, the server will then block (using takeMVar) until (using putMVar) a measurement is available. The client then retrieves the measurement from the server including all other relevant data. These requests all happen asynchronously using ajax calls[1]. The server starts by forking a thread which runs the measure loop. At each iteration the measure loop reads data from a file then fits that data to a model. For fitting I use my levmar fitting library[3]. The coefficients of the fitted model are then used to calculate a measurement. I believe the OS threads are created by my levmar library. This library uses bindings-levmar[4] which is a binding to a C library. bindings-levmar uses safe FFI calls because the levmar C procedures are reentrant (they need to call back into Haskell to execute the model function). I believe the RTS creates an OS thread for each safe FFI call. When I replace my levmar fit function with a function which just returns a random number the problem disappears. The problem also doesn't appear in a standalone application I have which just uses my levmar fit function to fit all the datafiles, without the webserver. It seems that the combination of happstack and levmar causes the OS threads to not terminate. I tried space profiling the application but that did not reveal anything interesting. I even used threadscope to look at the application eventlog (see: [5]) but that also looked normal. Hopefully someone can point me where to look next. Thanks, Bas [1] http://api.jquery.com/jQuery.ajax/ [2] http://en.wikipedia.org/wiki/Push_technology#Long_polling [3] http://hackage.haskell.org/package/levmar [4] http://hackage.haskell.org/package/bindings-levmar [5] http://bifunctor.homelinux.net/~bas/crash.eventlog

3 6

ANN: theoremquest-0.0.0
by Tom Hawkins 08 Mar '11

08 Mar '11

I have been wanting to gain a better understanding of interactive theorem proving for some time. And I've often wondered: Can theorem proving be made into a user-friendly game that could attract mass appeal? And if so, could a population of gamers collectively solve interesting and relevant mathematical problems? To try to answer these questions -- and to gain some experience myself with theorem proving -- I started a project called TheoremQuest [1]. TheoremQuest intends to be a multi-player game system, where the game server receives requests by clients, such as theorem queries and inference rule applications. The TheoremQuest server validates deductions, compares them with existing theorems in the database, then returns results. TheoremQuest's deductive system borrows that of John Harrison's HOL Light [2]. There are 2 Hackage packages: theoremquest [3] is a library that declares types for terms, inference rules, and client-server transactions, used by both server and clients; and theoremquest-client [4] is an example client (tq). All the code, including the server-side, is hosted at github [5]. Currently the client-server interface is working, but little else. The library has defined most of the core inference rules, but has none of the basic types or axioms. And the "tq" client is nothing at all like a game; at this point it is just a command line tool to test the server. Currently "tq" can ping the server, create a new user, apply inference rules, and print out theorems. Here's how "tq" can prove "x |- x": $ tq newuser tomahawkins tomahawkins(a)gmail.com Ack $ export THEOREMQUEST_USER=tomahawkins $ tq infer 'ASSUME (Var (Variable "x" Bool))' Id 1 $ tq theorem 1 assumptions: Var (Variable "x" Bool) conclusion: Var (Variable "x" Bool) I'd love to have help with this project, if anyone's interested. I'm still grappling with the logical core, but I think the real challenge will be creating game clients that are both capable and yet intuitive enough to appeal to the general population. If the masses can play Sudoku, shouldn't they be capable of interactive theorem proving? -Tom [1] http://theoremquest.org [2] http://www.cl.cam.ac.uk/~jrh13/hol-light/ [3] http://hackage.haskell.org/package/theoremquest [4] http://hackage.haskell.org/package/theoremquest-client [5] http://github.com/tomahawkins/theoremquest

9 12

I think I've found a regression in Haskell Platform, but what do I do next?
by Nick Frolov 08 Mar '11

08 Mar '11

Hi, Recently I had to switch from ghc 6.12.3 to ghc 7.0.1 because of the bug #4235. This switch has introduced a problem with one of third-party libraries I use ('satchmo', an interface for SAT solvers). The problem is that writing to stdin of a process started by System.Process.runInteractiveCommand silently fails provided it's stderr is not read. If stderr of the spawned process is redirected to /dev/null or fully read by the parent process, then problem does not come up. The troubled code is available at http://bit.ly/dNwrIV (lines 43-45). Changes between versions of the 'process' library (1.0.1.3 -> 1.0.1.4) bundled with ghc 6.12.3 and 7.0.1 only include one bug fix, which is not the source of the problem described, as far as I can understand. The problem is not present with ghc 6.12.* at all. Something has definitely changed between these two ghc versions. Since I've spent considerable amount of time on finding a workaround for the problem, I'd like to file a real bug report, but I'm not completely sure where to do it because there are several pieces of software involved (ghc itself, 'process', 'satchmo' and 'minisat2' SAT solver). Could somebody guide me please?

2 2

A practical Haskell puzzle
by Yitzchak Gale 04 Mar '11

04 Mar '11

You have written a large software system in Haskell. Wishing to play to Haskell's strength, you have structured your system as a series of composable layers. So you have data types Layer1, Layer2, ... and functions layer2 :: Layer1 -> Layer2 layer3 :: Layer2 -> Layer3 ... etc. Of course you'll want to be able to run any range of the layers separately, at least for testing and debugging purposes if not for the functionality itself. So your UI module (command line or whatever) that launches your application provides a data type data Layers = Layers Int Int that indicates which layers to run, and functions deserialize1 :: L.ByteString -> Layer1 deserialize2 :: L.ByteString -> Layer2 ... serialize1 :: Layer1 -> L.ByteString serialize2 :: Layer2 -> L.ByteString ... etc. Now you need a function runLayers :: Layers -> L.ByteString -> L.ByteString so that the effect is for example runLayers (Layers 4 6) = serialize6 . layer6 . layer5 . deserialize4 Typically there could be 20 or 30 layers, so writing out each case could result in hundred of boilerplate definitions for runLayers. Scripting the generation of all that boilerplate, e.g. using TH, doesn't seem very attractive either. On the other hand, it seems silly to have to use super-advanced type olegery for such a trivially simple yet centrally important component of the system. What is the best way to write runLayers? Feel free to change the details of the above design, as long as it meets the functionality requirements expressed. Regards, Yitz

7 16

Terminal library : which ?
by Permjacov Evgeniy 03 Mar '11

03 Mar '11

What terminal library you will recomedn? Requirements: crossplatform (win/lin), with direct (i.e. with line/column number pair) cursor positioning and possybly direct symbol output. MUST provide function to get terminal dimensions. (could not find one).

2 1

SMP parallelism gains inferior than expected
by José Pedro Magalhães 01 Mar '11

01 Mar '11

(Forwarding to haskell-cafe) Hi, I have a program that computes a matrix of Floats of m rows by n columns. Computing each Float is relatively expensive. Each line is completely independent of the others, so I thought I'd try some simple SMP parallelism on this code: myFun :: FilePath -> IO () myFun fp = do fs <- readDataDir fp let process f = readFile' f >>= parse printLine = putStrLn . foldr (\a b -> show a ++ "\t" ++ b) "" runDiff l = [ [ diff x y | y <- l ] | (x,i) <- zip l (map getId fs), myFilter i ] ps <- mapM process fs sequence_ [ printLine x | x <- runDiff ps *`using` parList rdeepseq* ] So, I'm using parList to evaluate the rows in parallel, and fully evaluating each row. Here are the timings on a Dual Quad Core AMD 2378 @2.4 GHz, ghc-6.12.3, parallel-2.2.0.1: -N time (ms) none 1m50 2 1m33 3 1m35 4 1m22 5 1m11 6 1m06 7 1m45 The increase at 7 is justified by the fact that there were two other processes running. I don't know how to justify the small increase at N3, though, but that doesn't matter too much. The problem is that I am not getting the gains I expected (halving at N2, a third at N3, etc.). Is this the best one can achieve with this implicit parallelism, or am I doing something wrong? In particular, is the way I'm printing the results at the end destroying potential parallel gains? Any insights on this are appreciated. Thanks, Pedro

2 1