- Haskell-Cafe - Haskell.org

Profiling with QtHaskell
by Øystein Kolsrud 20 Apr '12

20 Apr '12

Hi! Does anyone know if it is possible to use QtHaskell with profiling turned on? -- Mvh Øystein Kolsrud

3 3

Parallel Haskell Digest 9
by Eric Kow 20 Apr '12

20 Apr '12

Parallel Haskell Digest 9 ========================= Hello Haskellers! The Google Summer of Code is upon us and students have already submitted their proposals. There are a couple potential projects on concurrent data structures, which we'll have a look at below. We will also be continuing our tour of Haskell concurrency abstractions with our word month, *transaction*. This digest is brought to you by the Parallel GHC project, an MSR-sponsored effort to push parallel Haskell technologies out into the real world. Check our project news below to see how we're doing in that front. Finally, you may heard Functional Propaganda from a Simon or two. But how would the same message affect you if it came from a hardcore C++ hacker? If you haven't seen it making the rounds, have a quick look at Bartosz Milewski's [The Downfall of Imperative Programming][b0], and maybe tell your imperative friends? The FP monster is hatching from its academic egg; best be prepared! [HTML version](http://www.well-typed.com/blog/65) News ---------------------------------------------------------------------- Let's have a quick look at some of those GSoC proposals, particularly those with a parallel Haskell theme. It's all about performance this year. Two of the proposals involve using or improving parallellism in Haskell, and four are related to high-performance concurrency. * [Parallel CSG engine][g2] Constructive Solid Geometry (CSG) is the common approach to define complex bodies in engineering applications, ray tracing engines and physical simulators. Dmitry Dzhus' proposal is to deliver a fast parallel CSG engine using the Accelerate/Repa libraries for vectorised computations on GPU. * [NUMA supporting features for GHC][g7] Sajith Sasidharan wants to reach into the GHC RTS, with the aim of “extracting that last ounce of performance from NUMA systems, by firing all CPUs if/when necessary and by ensuring a suitably NUMA-aware memory allocation behavior.” Work in this area would benefit folks doing scientific computing, who may need great amounts of task and data parallelism. * [Windows support for the new GHC I/O manager][g6] The new I/O manager (GHC 7) brings great scalability improvements to Haskell — 10k simultaneous connections to your web server? no sweat. Unfortunately for Haskellers on Windows, these improvements are currently only available on Unix. Mikhail Glushenkov (who worked on GSoC last year to make improvements to Cabal) proposes to remedy this, making the new manager available on Windows. The challenge is that Windows I/O completion ports have slightly different semantics than their epoll/kqueue analogues on Unix. * [Lock-free hash table and priority queue][g3] More along the theme of high performance concurrency, Florian Hartwig's project aims to use GHC's new-ish atomic compare-and-swap (CAS) primitive to implement a high-performance lock-free hash table and a lock-free priority queue in Haskell. The CAS instruction is a bit of hardware support for concurrency: it compares a value in memory to an expected value, and iff they match, replaces it with a new value. * [Implement Concurrent Hash-table / Hashmap][g5] Loren Davis also proposes a thread-safe mutable hash table implementation in Haskell. Loren is still weighing some of the alternative approaches suggested in the Haskell community. He is currently leaning towards a lock-stripping approach as it would fulfill an immediate need in the community. * [Concurrent Datastructures with good Performance][g4] Mathias Bartl aims to implement two concurrent data types in Haskell, along with the usual battery of automated unit tests and benchmarks. The two that Mathias has in mind are a lock-free concurrent bag, and a concurrent priority queue. Parallel GHC project update ---------------------------------------------------------------------- We have been continuing our work to make ThreadScope more helpful and informative in tracking down your parallel and concurrent Haskell performance problems. We now have the ability to collect heap statistics from the GHC runtime system and present them in ThreadScope. These features will be available for users of a recent development GHC (7.5.x) or the eventual 7.6 release. In addition to heap statistics, we have been working on collecting information from hardware performance counters, more specifically adding [support for Linux Perf Events][hs-perf]. This could be useful for studying IO-heavy programs, the idea being to visualise system calls as being distinct from actual execution of Haskell code. Speaking of performance, we are also continuing work on the new Cloud Haskell implementation (see Duncan Coutts' [Fun in the Afternoon Talk][t4]), and have lately been focused on reducing message latency. This consists of work in three areas: improving binary serialisation, investigating the implications of using `Chan` and `MVar` to pass messages between threads, and perhaps improving the Haskell network library implementation to compete better with a direct C implementation. Word of the month ---------------------------------------------------------------------- Lately, we've been investigating the various ways Haskell helps us to get to grips with concurrency. We talked about how the `MVar`, the Haskell variant on locks, allows us to share mutable variables between threads, with some safeguards to help ensure consistency. `MVar`'s may provide a nice high-level packaging around locks, but as we mentioned in the last digest, they can still go horrifically wrong, just like locks and synchronized methods in other languages. We could go through the usual litany of reasons why locks are bad news, but maybe a healthier approach would be for us to focus on the positive. What do we want as programmers? One possibility is what Simon PJ ([Beautiful Concurrency][stm-bc]) calls “modular programming”, the ability to “[build] large programs by gluing together smaller programs”. Locks fall short of helping us to meet this desire. First, because the mere act of combining two locky programs may be inherently incorrect; `withdraw acct1 amt >> deposit acct2 amt` is bad because of the gap between the two actions where the money is in neither account. Second, because they seal off programs that we may otherwise like to moosh together; if process p1 waits for input on a pipe, process p2 waits for input on another pipe, how do wait for either of p1 or p2? So how do we wrestle back this modularity from our locky masters? And how do we make programming fun again? Our word of the month today is “transaction”. Software transactional memory (STM) takes this idea of a transaction (a sequence of operations that can be treated as a single atomic block) from database design. The Haskell implementation of STM was introduced in the 2005 paper [Composable Memory Transactions][stm-05] by Harris *et. al.* If programming fun is what you're after, this is a paper that comes with its own war-cry: “compositionality: a programmer can control atomicity and blocking behaviour in a modular way that respects abstraction barriers.” Here are some quick highlights of the stm library. You may notice a couple of things, first that this library introduces its own notion of variable, the `TVar` and second that STM involves a new monad of its own. Unlike the `MVar` that we saw in the last digest, `TVar`'s do not have the same notion of being full or empty; they just hold values plain and simple. As for the STM monad, we will see why it matters when we first try to do some IO. -- Control.Concurrent.STM data STM a instance Monad STM atomically :: STM a -> IO a data TVar a newTVar :: a -> STM (TVar a) readTVar :: TVar a -> STM a writeTVar :: TVar a -> a -> STM () retry :: STM a orElse :: STM a -> STM a -> STM a To get a rough idea how some of this is used, let's look at the transactional hello world, safely wiring money from one bank account to another. For the purposes of our example, a bank account is just a balance. To get some money from an account, we read the balance, subtract the amount, and write the new balance. Making a deposit is just withdrawing negative-money. type Account = TVar Int withdraw :: Account -> Int -> STM () withdraw acc amount = do bal <- readTVar acc writeTVar acc (bal - amount) deposit :: Account -> Int -> STM () deposit acc amount = withdraw acc (- amount) These primitive operations (withdraw and deposit) bring us to the question of modularity. How do we know that it's safe to combine these mini-programs into a bigger one? In other words, if we write something like `withdraw from 42 >> deposit to 42`, how do we avoid the possibility of running into some twilight zone state where the money is neither here nor there? If people do strange things like simultaneously transfering money in the other direction, will our program still work? The answer lies in the distinction between `STM` (transactions) and `IO` (actions). So long as we remain in STM, we are simply assembling transactions, piecing smaller ones (“withdraw from a”) into larger ones (“withdraw from a and deposit it to b”), but not actually performing them! Having composed our transactions, we can use the function `atomically` to turn them into IO actions. -- still just a transaction transfer :: Account -> Account -> Int -> STM () transfer from to amount = do deposit to amount withdraw from amount -- now we have an action! doTransfer :: Account -> Account -> Int -> IO () doTransfer from to amount = atomically $ transfer from to amount And `atomically` does what it says on the tin: it runs the transaction in a way that renders it indivisible, no twlight zones. Lest there is any confusion, even though the transaction is indivisible, we can *still* have concurrency during the course of the transaction, even simultaneously read the affected `TVar`s if we want to. The indivisibility simply means that we never catch our transactions with their pants down. We neither read nonsense mid-transactional values (simultaneous reads would either get the before or after value), nor injecting values into a transaction mid-stream. To get a feel for how these guarantees are possible, it could be useful to take a peek under the hood. For each transaction that is run, GHC maintains a thread-local log with an entry for each `TVar` accessed in that transaction. Each entry contains both the old value and the new value that would be committed if the transaction is succesful. This may be easier to see with a silly example: main = do v1 <- atomically $ newTVar "Joe" v2 <- atomically $ newTVar "Bob" done <- atomically $ newTVar 0 -- thread A (you can just pretend forkDelayIO == forkIO) forkDelayIO . atomically $ do -- transaction log if A runs first x <- readTVar v1 -- v1: Joe -> Joe y <- readTVar v2 -- v1: Joe -> Joe, v2: Sue -> Sue writeTVar v1 "Sue" -- v1: Joe -> Sue writeTVar v2 x -- v1: Joe -> Sue, v2: Bob -> Joe writeTVar v1 y -- v1: Joe -> Bob, v2: Bob -> Joe modifyTVar done (+1) -- (stm 2.3 but easy to define) -- thread B forkDelayIO . atomically $ do -- (if A runs first) writeTVar v1 "Jean" -- v1: Bob -> Jean writeTVar v2 "Paul" -- v1: Bob -> Jean, v2: Joe -> Paul modifyTVar done (+1) waitThreads 2 done people <- atomically $ do -- (if A runs first) p1 <- readTVar v1 -- v1: Jean -> Jean p2 <- readTVar v2 -- v1: Jean -> Jean, v2: Paul -> Paul return (p1, p2) print people -- if A runs first, (Jean, Paul) -- if B runs first, (Paul, Jean). -- boring details just for this example forkDelayIO job = forkIO $ randomRIO (1, 1000000) >>= threadDelay >> job waitThreads n v = atomically $ do { d <- readTVar v; when (d < n) retry } In the above, we fork off two threads, A which swaps a pair of names and, B which overwrites them with other names. Atomicity here means that other threads never see any intermediary states and state changes from other threads don't affect the current thread. For example, thread B should never see `v1` being set to "Sue". Likewise, if thread A should still read "Joe" from v1 even if B simultaneously writes "Jean". This is made possible by validation of the transaction logs. Validation normally occurs at the end of a transaction (we won't cover the two other cases here: exceptions, and thread wake-ups). It consists of checking that all the expected “before” values for `TVar`s still match reality. If the logs are good, we commit the new values; if not, we simply discard them and try the transaction again, taking the new reality into account. This validate-and-commit model allows us to run transactions simultaneously, safely, but with the occasional rollback and retry to ensure atomicity. The notion of a transaction log brings us to the notion of cost. Good things don't always come cheap, and using a good thing like STM may require a little familiarity with the cost model behind it. Basically, it's important to keep in mind that the values we write to `TVar`'s may come from some arbitrary expression, and that arbitrary expressions may be arbitrarily expensive. So being forced to retry transactions may involve redoing something expensive. If the transactions affect many variables, the chances of hitting a retry go up. Likewise, if the transaction takes a long time to run, the chance goes up of some other thread making a change that triggers a retry. In the pathological worst case, you can have some transactional behemoth that never manages to commit; because some smaller faster transaction keeps stealing its thunder. So keep an eye out for starvation and the more general problem for retries being expensive. Cost may be a bit of a bummer, but there's also a Haskell-related silver lining behind all this. Because we have a purely functional language and the enforced separation between pure functions and side-effecting actions, STM is actually quite practical in Haskell. The number of things we need to track in a transaction log is limited to handful of explicit `TVar`s rather that just about everything. If you are coming from other languages, you may have a memory of STM as being nice, but wildly impractical. Not so in Haskell. Eminently viable. Aside from making STM practical, this sort of separation is also good for general peace of mind. Suppose for example that we coded up a feature in our banking software to send our users a text message alert whenever their balances fall below a threshold. If we were in the middle of a complicated transaction, we might be tempted to just slap that logic right in the middle of the transaction; however, the Haskell implementation makes this deliberately impossible. This can be a bit frustrating at first (and new Haskellers are sometimes faced with the “how do I get this out of the monad” puzzle), but saves us the greater danger of bombarding our users with spurious retry-induced text messages. The guarantees that STM offer make it a great place to get started with Haskell concurrency. After all, why make software any buggier than it needs to be? If you do want to get started, have a look at Simon Peyton Jones' [Beautiful Concurrency][stm-bc]. It's a particularly good idea to do so, because there's some really interesting ground that we've not covered here (briefly, blocking, the `retry` function aborts the current transaction, and causes it to be retried when appropriate; and choice: <code>a `orElse` b</code> tries `a`, and if that should retry, then `b`, and if that should also retry, the whole expression again). Other great STM resources are Simon Marlow's [tutorial on parallelism and concurrency][stm-sm] and the [Real World Haskell chapter on STM][stm-rwh]. With the four resources combined, you'll see a nice range of examples from the usual bank-account one to concurrently shuffling windows between desktops. Blogs ---------------------------------------------------------------------- * [The Downfall of Imperative Programming][b0] (9 Apr) Take a hardcore C++ veteran with imperative programming in his bloodstream and loads of experience under his belt. Now give him a passion for concurrency and what do you get? First, you get a keen awareness that the future is massively multicore. Second, you get a hard-won appreciation for how difficult concurrent programming can be; for all jokes we make in the Haskell community about firing the missiles, the consequences of data races can sometimes be [deadly][therac-25]. Third, you get the conviction that functional programming is the inevitable way forward. Bartosz Milewski sums up the situation thus: Sooner or later you’ll have to face the multicore reality. You will be forced to learn functional methods to the extent to which your imperative language supports them. Despite that, data races will infest your code and leak into released products. So you might as well take a shortcut and embrace a full blown functional language now. See what you make of his blog post if you have not done so already. There's quite a bit of buzz about this post, so you may also be interested in the [programming reddit discussion][r2] around it as well. * [Building A Concurrent Web Scraper With Haskell][b1] (10 Mar) Let's make a concurrent web scraper! This blog post by Aditya Bhargava presents a hands-on introduction to both arrows (via hxt) and concurrency (via parallel-io). Aditya builds from the bottom-up, showing us little pieces of program that we might cobble together, culminating in a 52 line Haskell program that crawls web sites and fetches images within their pages. The parallel-io library used in this tutorial provides a thread pool which minimises contention by guaranteeing a limit to the number of unblocked threads running at the same time. It uses lock based concurrency with `MVar`'s under the hood. * [0MQ and Haskell][b2] (6 Mar) Magnus Therning could not find any excuses to look into 0MQ. But “to hell with reason”, Magnus ended up deciding to just poke around without any specific goal in mind. He found a [nice tutorial][pyzero] based on Python and translated its mini examples into Haskell. Magnus wonders why the API for `subscribe` is `String` rather than `ByteString` based. Also, he's finding that his client mysteriously dies after receiving a few messages. Any comments? * [SIMD Support for the vector library][b3] (27 Mar) Single instruction, multiple data (SIMD) is the sort of thing you might be interested in if you're into data parallelism: hardware that can perform the same instruction on multiple data simultaneously. Geoffrey Mainland posted about his efforts to bring SIMD support to GHC, the bigger picture being that you ought to be able to write nice high-level Haskell and have it work as fast the low-level Haskell or C that you might otherwise crank out. To try things out, Geoff benchmarks taking the dot product of two vectors in various Haskell and C versions. No happy ending yet, unfortunately: while the low-level Haskell version is competitive with C, the high-level is not. Check the post out for dissection of the results down the Core and assembly level. Hopefully better news in a follow-up posting. * [Adding SIMD Support to Data Parallel Haskell][b3b] (18 Apr) Hopefully better news? Not as such, but perhaps something more interesting. In the previous post, we could make use of SIMD support by issuing some explicit instructions from the vector library. OK, but what about people who writing parallel code, say, by using a parallel arrays framework? And what if you could get this SIMD support virtually for free — no syntax attached? Geoff makes this possible by extending the [Data Parallel Haskell][dph] framework so you would only have to tweak a single import statement, and exploitation of SIMD instructions would be automatic. See the posting for some nice benchmarks and also a brief introduction to Data Parallel Haskell. * [Work Efficient Higher-Order Vectorisation][b4] (24 Mar) Found on Manuel Chakravarty's tumblr: Our new draft paper on Work Efficient Higher-Order Vectorisation introduces a novel representation for nested, irregular parallel arrays that enables the work-efficient SIMD-ification of nested data parallelism — i.e., nested parallelism is transformed into flat parallelism, while maintaining the work complexity of a naive pointer-based representation of nested arrays. This solves a long standing problem that dates back to the original implementation of the language NESL. Talks, tutorials, and packages ---------------------------------------------------------------------- * [stm-chans 1.3.1][t1] (1 Mar) The stm-chans package offers a collection of channel types, similar to `Control.Concurrent.STM.TChan` but with additional features. This latest update by wren ng thornton takes advantage of optimisations in the newly released stm-2.3. It's highly recommended that all users bump their minimum stm-chans requirement to version 1.3.1 * [accelerate 0.10.1][t2] (12 Apr) Manuel Chakravarty has just released version 0.10.0.0 of Accelerate, an embedded language for GPU-accelerated array computations in Haskell that targets NVIDIA's CUDA framework and also has an experimental (and partial) OpenCL backend. A considerable amount of example code is in the companion package accelerate-examples. The main user-visible changes in this release are frontend bug fixes. * [Parallel Functional Programming course][t3] Students at Chalmers and Gothenburg University are currently 6 lectures into a course on parallel functional programming. The course has so far covered parallelism with `par`/`pseq`, Strategies and monad-par, using ThreadScope, and skeletons as a means to structure parallel computations. The course page has lecture notes and exercises which could be of interest even if you aren't currently following the course. * [Cloud Haskell][t4] (Fun in the Afternoon) Well-Typed's Duncan Coutts was at the recent [Fun in the Afternoon][fun-aft], a termly seminar on Functional Programming in the UK). Duncan presented some of the motivation behind Cloud Haskell (”Erlang for Haskell”) and distributed programming, along with the Cloud Haskell design, and our work on a new implementation to follow on the initial protoype by Jeff Epstein. Our new implementation adds a swappable network transport layer. If you're happy with TCP/IP, don't wait for the new implementation; just `cabal install remote` and give Jeff's prototype a try. Mailing lists ---------------------------------------------------------------------- ### Concurrency * [Transactional memory going mainstream with Intel Haswell][m1] (9 Feb) Ben was wondering if any STM experts would comment on this recent [Ars Technica article][arswell] on the Intel Haswell chip. Austin Seipp pointed us to a comment by Duncan Coutts in the Reddit discussion (unfortunately not; the new extension would sledgehammer all instructions between the XBEGIN/XEND instructions). Ryan Ingram suggests that maybe the extension could be used to optimise the existing implementation, perhaps by wrapping transaction commits with XBEGIN/XEND) * [Behavior of -threaded in GHC 7.4.1?][m2] (14 Feb) Mike Craig just debugging a recent issue with GHC 7.4.1 and the zeromq3-haskell library, which provides a provides an FFI binding to libzmq. Unfortunately, code which used to run when compiled on GHC 7.0.4 dies with “operation on non-socket” when built with GHC 7.4.1. With the latter GHC, Mike can only run the code if he omits `-threaded`, or if he uses the `-V0` flag to turn off the RTS clock and associated signals. After more debugging, he tracked the problem down to a `addFinalizer` on a `Socket` tuple. The finalizer was being run prematurely, perhaps because the Socket type was being optimised away. Putting the finalizer on the `Ptr ()` in the tuple seems to solve the problem. * [Question about concurrency, threads and GC][m6] (2 Mar) Paul Graphov is trying to implement a networked application that supports bidirectional conversations, ie. not just request/response, but also sending notifications to clients. Paul is particularly interested in STM, but he's stuck on a bit of a design problem. His thinking so far is that he'll need to start 3 threads for each client, one to read data from the socket, one that sends queued messages to that socket, and one for the main behaviour loop. Joey Adams noticed that this was the same sort of problem we reported in the [previous digest][ph-8]. Joey was grappling with making making asynchronous I/O composable and safe. He wound up not using the stm-channelize package that he wrote, and recommends instead a 3-thread solution, using a thread each for receiving, sending, and coordination. Check out the small Haskell [chat server][chat-1] that Joey wrote to illustrate the idea. Alexander V Vershilov suggests a data-driven behaviour based on conduits and stm channels. He's also provided an [example chat server][chat-2], which you can compare against Joey's version. The two examples take a similar approach, and `could perhaps be combined to good effect. * ["killThread" hangs! (ironic)][p1] (25 Feb) Ryan Newton is gathering information in preparation for a possible bug report. He's testing the new network transport layer in distributed-process (Cloud Haskell) and gets hangs in `killThread`. Strangely, the pattern for hanging goes: GHC 6.12.3 [OK], 7.0.2 [HANGS], 7.2.1 [HANGS], 7.4.1 [OK]. Any ideas? Simon Marlow suggests it may be a bug in the RTS asychronous exception handling code, fixed with commit `fa71e6c`. * [Synchronizations in memory allocation?][p2] (21 Mar) Following up on the recent scaling bottleneck thread, Ryan Newton wondered: “What is the reason for GHC managing all this pinned memory for foreign pointers itself rather than using an external C malloc/free implementation and thus keeping disjoint Haskell and C heaps?” Simon Marlow says it's basically because GHC's `mallocForeignPtrBytes` is much faster than `malloc()`/`free()` Ryan was asking because he is looking to how to do better on [NUMA][numa] platforms. “We've got a NUMA-aware work-stealing scheduler now for monad-par, but it isn't really helping much yet. So we need to answer the question of how well our memory is being localized to socket-preferred physical addresses.” NUMA isn't something the GHC team have looked into for the RTS yet. He has some ideas for improvements to the block allocator; more details in the thread. * [Haskell for BigData][p3] (16 Mar) Andrei Varanovich observes that while Haskell has a lot to offer in the world of parallel/concurrent programming (from DPH to Cloud Haskell), it still lacks two important components for working with Big Data: * Integration with a distributed file system, such as Hadoop distributed file system * A data aggregration framework (eg. MapReduce, but of course something much richer; this being Haskell and all) Andrei was interested in submitting a Google Summer of Code proposal to build a big data framework for Haskell on top of Cloud Haskell. I didn't see a proposal this year, but maybe next time? See the thread for technical suggestions, supportive comment, and pointers for a succesful Haskell GSoC project. ### Parallelism * *Help wanted!* [Parallelism causes space leaks][m9] (23 Mar) Yavuz Yetim posted a small chunk of code using Strategies for parallelism. When he enables his `parList rdeepseq` strategy, though, he gets a stack overflow on smallish input (1 MB file), even if he allows GHC to use a 1GB stack. Switching to `parMap`, `parListChunk` and other strategies don't seem to help either. * [Data.Array.Accelerate initialization timings][m5] …[more][m5b] (20 Feb) Paul Sujkov is finding that array initialisation in Data.Array.Accelerate takes 10x the amount of time than either Data.Array and bare C++ CUDA array initialisation. Is there anything Paul might be doing wrong in particular? The accelerate package currently provides two backends, an interpreter (reference implementation) and a CUDA backend generating code for CUDA-capable NVDIA GPUs. Martin Dybdal comments that Paul should use `Data.Array.Accelerate.use` to generate hints to transfer arrays to GPU, and `Data.Array.Accelerate.CUDA.run` to actually perform the transfer. Manuel Chakravarty adds that the the `fromList` function is really just meant for testing, or for initialising small arrays. For anything bigger, going from vanilla lists is a bad idea, so have a look at `Data.Array.Accelerate.IO`. * [Reasons for Super-Linear Speedup][m7] (5 Mar) Burak Ekici has parallelized RSA decryption and encryption schemes by using second generation strategies. He's getting 10 times performance improvements… on a quad-core CPU (with an 8MB cache). Is this just mismeasurement, or are there some differences in how GHC handles serial/parallel of computation, say with respect to cache usage? Bardur Arantsson replies that the usual explanation for this sort of thing is that the working data suddenly fits within the per-CPU L2 cache when split up. StackOverflow and Reddit ---------------------------------------------------------------------- * [Is there a way in Haskell to query thread state using ThreadID after a forkIO?][s1] * [Are haskell channels `Control.Concurrent.Chan` safe for multiple readers/producers?][s2] * [How to take F# measurements to get speedups][s3] * [Using Haskell to program the GPU : haskell][r1] * [The Downfall of Imperative Programming][r2] * [Examples of easy parallelism in Haskell?][r3] Help and Feedback ---------------------------------------------------------------------- If you'd like to make an announcement in the next Haskell Parallel Digest, then get in touch with me, Eric Kow, at <parallel(a)well-typed.com>. Please feel free to leave any comments and feedback! [arswell]: http://arstechnica.com/business/news/2012/02/transactional-memory-going-mai… [chat-1]: https://github.com/joeyadams/haskell-chat-server-example [chat-2]: https://github.com/qnikst/chat-server/blob/master/src/Main.hs [dph]: http://ghc-simd.blogspot.co.uk/2012/04/adding-simd-support-to-data-parallel… [fun-aft]: http://sneezy.cs.nott.ac.uk/fun/2012-02 [numa]: https://en.wikipedia.org/wiki/Non-Uniform_Memory_Access [hs-perf]: http://www.berniepope.id.au/linuxPerfEvents.html [pyzero]: http://nichol.as/zeromq-an-introduction [stm-bc]: http://research.microsoft.com/en-us/um/people/simonpj/papers/stm/beautiful.… [stm-05]: http://research.microsoft.com/en-us/um/people/simonpj/papers/stm/stm.pdf [stm-sm]: http://community.haskell.org/~simonmar/par-tutorial.pdf [stm-rwh]: http://book.realworldhaskell.org/read/software-transactional-memory.html [ph-8]: http://www.well-typed.com/blog/64 [simd-ghc]: http://hackage.haskell.org/trac/ghc/wiki/SIMD [therac-25]: http://en.wikipedia.org/wiki/Therac-25 [g1]: http://parfunk.blogspot.co.uk/2012/02/potential-gsoc-haskell-lock-free-data… [g2]: http://www.google-melange.com/gsoc/proposal/review/google/gsoc2012/dmitrydz… [g3]: http://www.google-melange.com/gsoc/proposal/review/google/gsoc2012/florianh… [g4]: http://www.google-melange.com/gsoc/proposal/review/google/gsoc2012/mathiasb… [g5]: http://www.google-melange.com/gsoc/proposal/review/google/gsoc2012/lorehead… [g6]: http://www.google-melange.com/gsoc/proposal/review/google/gsoc2012/refold/3… [g7]: http://www.google-melange.com/gsoc/proposal/review/google/gsoc2012/sajith/1 [b0]: http://fpcomplete.com/the-downfall-of-imperative-programming/ [b1]: http://adit.io/posts/2012-03-10-building_a_concurrent_web_scraper_with_hask… [b2]: http://therning.org/magnus/archives/1009 [b3]: http://ghc-simd.blogspot.co.uk/2012/03/simd-support-for-vector-library.html [b3b]: http://ghc-simd.blogspot.co.uk/2012/04/adding-simd-support-to-data-parallel… [b4]: http://tumblr.justtesting.org/post/19825349916/work-efficient-higher-order-… [t1]: http://www.haskell.org/pipermail/haskell-cafe/2012-March/099805.html [t2]: http://justtesting.org/gpu-computing-in-haskell-version-010-of-dataa [t3]: http://www.cse.chalmers.se/edu/course/pfp/ [t4]: http://sneezy.cs.nott.ac.uk/fun/2012-02/coutts-2012-02-28.pdf [m1]: http://www.haskell.org/pipermail/haskell-cafe/2012-February/099300.html [m2]: http://www.haskell.org/pipermail/haskell-cafe/2012-February/099456.html [m3]: http://www.haskell.org/pipermail/haskell-cafe/2012-February/099456.html [m5]: http://www.haskell.org/pipermail/haskell-cafe/2012-February/099578.html [m5b]: http://www.haskell.org/pipermail/haskell-cafe/2012-February/099584.html [m6]: http://www.haskell.org/pipermail/haskell-cafe/2012-March/099830.html [m7]: http://www.haskell.org/pipermail/haskell-cafe/2012-March/099890.html [m9]: http://www.haskell.org/pipermail/haskell-cafe/2012-March/100349.html [p1]: https://groups.google.com/d/msg/parallel-haskell/NI5qxYw-5RA/fTljjfXYWYUJ [p2]: https://groups.google.com/d/msg/parallel-haskell/fsHrxz3ei70/FKe0kgV5mqcJ [p3]: https://groups.google.com/d/msg/parallel-haskell/nxDoibiuGWE/N68MR19uu1kJ [s1]: http://stackoverflow.com/questions/9475392/is-there-a-way-in-haskell-to-que… [s2]: http://stackoverflow.com/questions/9616515/are-haskell-channels-control-con… [s3]: http://stackoverflow.com/questions/9678284/how-to-take-f-measurements-to-ge… [r1]: http://www.reddit.com/r/haskell/comments/qnq4y/using_haskell_to_program_the… [r2]: http://www.reddit.com/r/programming/comments/s112h/the_downfall_of_imperati… [r3]: http://www.reddit.com/r/haskell/comments/sdx5v/examples_of_easy_parallelism… -- Eric Kow <http://erickow.com>

1 0

Using Data Types a la Carte
by Alex Rozenshteyn 20 Apr '12

20 Apr '12

I'm trying to implement a set of languages with a large overlap between them. >From what I understand, there are 3 main ways to do this: Finally Tagless, Data Types a la Carte, or manually. I'm currently leaning toward DTalaC, but not strongly. There seem to be two packages which implement the DTalaC style: syntactic and compdata. Alternatively, I can write the common code myself. Does anyone have recommendations for which one to use, and any materials for learning to use them? -- Alex R

2 1

ANNOUNCE: graphviz-2999.13.0.0
by Ivan Lazar Miljenovic 20 Apr '12

20 Apr '12

I'm hoping the second part of the version number isn't ominous, but I've just uploaded the latest release in my bindings for the Graphviz suite of graph visualisation tools. The changes in this release are: * Added support for the `osage` and `patchwork` visualisation tools, available as of Graphviz-2.28.0. * Updated attributes as of Graphviz-2.28.0: - `SVG` colors are now supported, and the support for different colors has been revamped. - `overlap=false` is now equivalent to `overlap=prism` and the `RemoveOverlaps` option has been removed. - `LabelScheme` and `Rotation` are new attributes for use with `sfdp`. - `Scale` is a new attribute for use with `twopi`. - Add new italics, bold, underline, superscript and subscript options for HTML-like labels. - `LHeight` and `LWidth` for getting the height and width of the root graph and clusters. * Updated attributes from the current development branch of Graphviz (i.e. 2.29.*). Please note that these will probably not work yet, but are implemented now for future-proofing. - A new style for edges: `Tapered`. - `XLabel` allows you to specify labels external to a node or edge. `ForceLabels` allow you to specify that these should be drawn even when they will cause overlaps. - `ImagePath` allows you to specify where to search for images. - HTML-like labels now support `ID` values as well as horizontal and vertical rules. - `BgColor` and `FillColor` now take a list of colors: this allows gradient fills for graphs, clusters and nodes. The `Radial` style and `GradientAngle` are also used for this purpose. - `FillColor` is now used by edges to set the color of any arrows. - [WebP](http://en.wikipedia.org/wiki/WebP) output support added. * Other attribute changes: - Use a specified data type for the `Ordering` attribute rather than an arbitrary `Text` value, and provide a documented wrapper in `Data.GraphViz.Attributes`. - `Bb` has been renamed `BoundingBox`. - `ID` now only takes `EscString` (a type alias for `Text`) values rather than arbitrary `Label`s. - The `Data.GraphViz.Attributes.HTML` module has had all values re-named and is now meant to be imported qualified. It is also no longer re-exported from `Data.GraphViz.Attributes.Complete`. * The `ToGraphID` class provides a common wrapper to help create cluster identifiers, etc. * Cabal's `Test-Suite` functionality is now used. As part of this, the `Data.GraphViz.Testing` module and sub-modules are no longer exported by the library. * The new `Benchmark` support in Cabal-1.14 is now used for the benchmark script. * Dropped support for base-3. * The `Data.GraphViz.State` module is no longer exposed, as there's no need for users to use it. * Bugfixes: - Some corner cases in canonicalisation prevented it from being idempotent. - The `TestParsing` script will no longer crash and refuse to continue if an IO-based error (e.g. unable to successfully call `dot`) occurs. - A typo was spotted by **Gabor Greif**. -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com http://IvanMiljenovic.wordpress.com

3 4

Parallel Strategy
by mukesh tiwari 19 Apr '12

19 Apr '12

Hello All I am trying to understand the Strategies ( http://hackage.haskell.org/packages/archive/parallel/3.2.0.2/doc/html/Contr…) and wrote this quick code. import Data.Listimport Control.Parallel.Strategies fun :: [ Int ] -> [ Int ]fun [] = []fun ( x : xs ) = ( x + 1 ) : fun xs main = do let xs = ( fun [ 1..1000000 ] ) `using` parListChunk 500000 rdeepseq return () When I am running this code due to laziness , the xs is not evaluating. [mukesh.tiwari@user ParallelStrat]$ time ./Main +RTS -N1 -s 48,320 bytes allocated in the heap 5,928 bytes copied during GC 38,592 bytes maximum residency (1 sample(s)) 14,656 bytes maximum slop 1 MB total memory in use (0 MB lost due to fragmentation) Tot time (elapsed) Avg pause Max pause Gen 0 0 colls, 0 par 0.00s 0.00s 0.0000s 0.0000s Gen 1 1 colls, 0 par 0.00s 0.00s 0.0002s 0.0002s Parallel GC work balance: -nan (0 / 0, ideal 1) MUT time (elapsed) GC time (elapsed) Task 0 (worker) : 0.00s ( 0.00s) 0.00s ( 0.00s) Task 1 (worker) : 0.00s ( 0.00s) 0.00s ( 0.00s) Task 2 (bound) : 0.00s ( 0.00s) 0.00s ( 0.00s) SPARKS: 0 (0 converted, 0 overflowed, 0 dud, 0 GC'd, 0 fizzled) INIT time 0.00s ( 0.00s elapsed) MUT time 0.00s ( 0.00s elapsed) GC time 0.00s ( 0.00s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 0.00s ( 0.00s elapsed) Alloc rate 48,368,368 bytes per MUT second Productivity 0.0% of total user, 0.0% of total elapsed gc_alloc_block_sync: 0whitehole_spin: 0gen[0].sync: 0gen[1].sync: 0 real 0m0.003suser 0m0.002ssys 0m0.001s [mukesh.tiwari@user ParallelStrat]$ time ./Main +RTS -N2 -s 48,248 bytes allocated in the heap 40 bytes copied during GC 38,440 bytes maximum residency (1 sample(s)) 18,904 bytes maximum slop 2 MB total memory in use (0 MB lost due to fragmentation) Tot time (elapsed) Avg pause Max pause Gen 0 0 colls, 0 par 0.00s 0.00s 0.0000s 0.0000s Gen 1 1 colls, 0 par 0.00s 0.00s 0.0001s 0.0001s Parallel GC work balance: -nan (0 / 0, ideal 2) MUT time (elapsed) GC time (elapsed) Task 0 (worker) : 0.00s ( 0.00s) 0.00s ( 0.00s) Task 1 (bound) : 0.00s ( 0.00s) 0.00s ( 0.00s) Task 2 (worker) : 0.00s ( 0.00s) 0.00s ( 0.00s) SPARKS: 0 (0 converted, 0 overflowed, 0 dud, 0 GC'd, 0 fizzled) INIT time 0.00s ( 0.00s elapsed) MUT time 0.00s ( 0.00s elapsed) GC time 0.00s ( 0.00s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 0.00s ( 0.00s elapsed) Alloc rate 48,248,000,000,000 bytes per MUT second Productivity 100.0% of total user, 0.0% of total elapsed gc_alloc_block_sync: 0whitehole_spin: 0gen[0].sync: 0gen[1].sync: 0 real 0m0.004suser 0m0.000ssys 0m0.004s The library doc suggest that parListChunk divides a list into chunks, and applies the strategy evalList strat to each chunk in parallel. Looking at the source code ( http://hackage.haskell.org/packages/archive/parallel/3.2.0.2/doc/html/src/C…) , list is split into chunks and then strategy is applied parallel to every chunk. Could some one please tell me what is wrong with this concept and why the code above is showing laziness. Regards Mukesh Tiwari

2 2

Template Haskell vs Rewrite Rules?
by Ismael Figueroa Palet 19 Apr '12

19 Apr '12

I'm working on getting annotated versions of all instances of a function of a typeclass, and was wondering what are the relation/differences between Template Haskell and the Rewrite Rules section. Of course this is specific to GHC. Another question, in Racket, primitive function application is denoted #%app. And using macros I can re-export #%app to be a different function f, so a program: (g a) is rewritten into (f g a) is there a way to do the same thing using TH or Rewrite Rules? Thanks -- Ismael

3 3

Administrative questions about Haskell GSOC (Google Summer of Code)
by Ryan Newton 19 Apr '12

19 Apr '12

Hello, As someone new to the GSOC system there are some things I'm confused about. There's a bunch of info out there, and I certainly haven't read all of it. Who are the "program administrator" and "organization administrator" for the Haskell organization? Those roles are mentioned in the manual here: http://en.flossmanuals.net/GSoCMentoring/what-is-gsoc/ Presumably those are the people that actually click "accept" on the melange site: https://google-melange.appspot.com/gsoc/homepage/google/gsoc2012 How many slots did we get? Is the system just to accept the top rated student proposals? If I can find the answers to these questions maybe I can update the Wiki for next year so it has a bit more info for mentors and about the process as well as students: http://hackage.haskell.org/trac/summer-of-code/wiki/Soc2012 Thank you, -Ryan

1 0

Rewrite rules for enumFromTo
by Michael Snoyman 19 Apr '12

19 Apr '12

Hi all, Following a little thread on Reddit[1], I'm trying to add rewrite rules to conduit to make some simple usages of `yield` more efficient. I've pushed these changes to a branch on Github[2]. However, I'm not able to fully optimize the following program: import Data.Conduit import qualified Data.Conduit.List as CL main :: IO () main = do x <- mapM_ yield [1..1000] $$ CL.fold (+) 0 print (x :: Int) Ideally, I would like to rewrite the entirety of `mapM_ yield [1..1000]` to `Data.Conduit.List.enumFromTo 1 1000` and thereby avoid the intermediate list. However, whenever I add such a rule, it doesn't fire. Instead, -ddump-rule-firings tells me: Rule fired: Class op enumFromTo Rule fired: mapM_ yield Rule fired: Class op + Rule fired: Class op >>= Rule fired: Class op show Rule fired: eftIntList I'm quite a novice at rewrite rules; can anyone recommend an approach to get my rule to fire first? Thanks, Michael PS: In case you're wondering, the `mapM_ yield` rule turns `mapM_ yield` into `yieldMany`. So ideally, I'd like to have another rule that turns `yieldMany [x..y]` into `Data.Conduit.List.enumFromTo x y`. [1] http://www.reddit.com/r/haskell/comments/sdzmx/many_ways_to_skin_a_conduit/… [2] https://github.com/snoyberg/conduit/tree/rewrite

2 2

Haskell Weekly News: Issue 223
by Daniel Santa Cruz 19 Apr '12

19 Apr '12

Welcome to issue 223 of the HWN, an issue covering crowd-sourced bits of information about Haskell from around the web. This issue covers the week of April 8 to 14, 2012. Quotes of the Week * merijn: I'm tempted to just do unsafePerformIO newEmptyMVar at the top level quicksilver: I can't really be expected to deal with your sinfulness. That's between you and your god. * acowley: Good haskell code is 20 LANGUAGE pragmas, 40 imports, then one line of perl. * deggis: oh. running GHC HEAD. must try that next week if coffee just someday isn't enough * dmwit: hGetContents does not close its handle. dmwit: hGetContents semicloses its handle. * monochrom: isTrue = (unsafeCoerce :: Either a b -> Bool) . (unsafeCoerce :: Maybe c -> Either a b) . (unsafeCoerce :: Bool -> Maybe c) * dmwit: For basically all good properties P, IEEE 754 is not P. * Cale: Little known fact: For any positive integer n, the infinite sequence of Project Euler problems has only finitely many elements whose solution is not divisible by n. Top Reddit Stories * Announcing Yesod 1.0 Domain: yesodweb.com, Score: 101, Comments: 42 On Reddit: [1] http://goo.gl/izD19 Original: [2] http://goo.gl/oTSto * Why reasoning about space usage in Haskell is hard Domain: ro-che.info, Score: 63, Comments: 14 On Reddit: [3] http://goo.gl/yIkI4 Original: [4] http://goo.gl/IAQtu * GHC HEAD now has type level natural number/ literals Domain: github.com, Score: 63, Comments: 18 On Reddit: [5] http://goo.gl/GfGbB Original: [6] http://goo.gl/Lkp6v * Working Together Domain: yesodweb.com, Score: 62, Comments: 31 On Reddit: [7] http://goo.gl/o3G85 Original: [8] http://goo.gl/jBdJA * How less is more : polymorphic types can improve safety even in monomorphic functions Domain: blog.malde.org, Score: 61, Comments: 13 On Reddit: [9] http://goo.gl/fzUlO Original: [10] http://goo.gl/WHE3A * A Hopefully Fair and Useful Comparison of Haskell Web Frameworks Domain: softwaresimply.blogspot.com, Score: 60, Comments: 30 On Reddit: [11] http://goo.gl/WuDuL Original: [12] http://goo.gl/DXBA8 * First impressions of Haskell: A review of my Haskell adventure Domain: binarysculpting.com, Score: 46, Comments: 36 On Reddit: [13] http://goo.gl/gG0fl Original: [14] http://goo.gl/ZqUT3 * A "radix tree" import syntax? Domain: self.haskell, Score: 41, Comments: 26 On Reddit: [15] http://goo.gl/kBOLZ Original: [16] http://goo.gl/kBOLZ * Using ContT to please the eye Domain: self.haskell, Score: 28, Comments: 15 On Reddit: [17] http://goo.gl/hbFrs Original: [18] http://goo.gl/hbFrs * Designing a DCPU-16 emulator in Haskell: on determinism and I/O Domain: jaspervdj.be, Score: 28, Comments: 6 On Reddit: [19] http://goo.gl/KHIgP Original: [20] http://goo.gl/NT89i Top StackOverflow Questions * What are type quantifiers? votes: 15, answers: 3 Read on SO: [21] http://goo.gl/d3hnH * Haskell: How does 'atomicModifyIORef' work? votes: 12, answers: 2 Read on SO: [22] http://goo.gl/3b5dK * Is there a runtime penalty associated with typeclasses? votes: 12, answers: 1 Read on SO: [23] http://goo.gl/Isw7k * Timing out pure functions votes: 11, answers: 1 Read on SO: [24] http://goo.gl/aTzVG * Haskell - simple constructor comparison (?) function votes: 11, answers: 3 Read on SO: [25] http://goo.gl/ZC6CC * Partial Application with Infix Functions votes: 10, answers: 3 Read on SO: [26] http://goo.gl/QvabF * Haskell: Why is there no type mismatch (and why does this compile)? votes: 9, answers: 2 Read on SO: [27] http://goo.gl/1gxFE * “Dependent optional” data in Haskell votes: 9, answers: 4 Read on SO: [28] http://goo.gl/9K5Wx * How can I help SpecConstr in GHC? votes: 8, answers: 2 Read on SO: [29] http://goo.gl/PGa4C * How to get good performance when writing a list of integers from 1 to 10 million to a file? votes: 7, answers: 2 Read on SO: [30] http://goo.gl/Kym6r * Efficiently turn a ByteString into a hex representation votes: 7, answers: 1 Read on SO: [31] http://goo.gl/aq2ct Until next time, Daniel Santa Cruz References 1. http://www.yesodweb.com/blog/2012/04/announcing-yesod-1-0 2. http://www.reddit.com/r/haskell/comments/s0tr2/announcing_yesod_10/ 3. http://ro-che.info/articles/2012-04-08-space-usage-reasoning.html 4. http://www.reddit.com/r/haskell/comments/rzu8a/why_reasoning_about_space_us… 5. https://github.com/ghc/packages-base/blob/b5b5ec18819fb85ebf1bdb6345ac03178… 6. http://www.reddit.com/r/haskell/comments/s0vln/ghc_head_now_has_type_level_… 7. http://www.yesodweb.com/blog/2012/04/working-together 8. http://www.reddit.com/r/haskell/comments/s2ei5/working_together/ 9. http://blog.malde.org/posts/polymorphic-types-are-safer.html 10. http://www.reddit.com/r/haskell/comments/s7q3b/how_less_is_more_polymorphic… 11. http://softwaresimply.blogspot.com/2012/04/hopefully-fair-and-useful-compar… 12. http://www.reddit.com/r/haskell/comments/s3pbm/a_hopefully_fair_and_useful_… 13. http://binarysculpting.com/2012/04/12/a-review-of-my-haskell-adventure/ 14. http://www.reddit.com/r/haskell/comments/s6okb/first_impressions_of_haskell… 15. http://www.reddit.com/r/haskell/comments/s2o8p/a_radix_tree_import_syntax/ 16. http://www.reddit.com/r/haskell/comments/s2o8p/a_radix_tree_import_syntax/ 17. http://www.reddit.com/r/haskell/comments/s49kk/using_contt_to_please_the_ey… 18. http://www.reddit.com/r/haskell/comments/s49kk/using_contt_to_please_the_ey… 19. http://jaspervdj.be/posts/2012-04-12-st-io-dcpu-16.html 20. http://www.reddit.com/r/haskell/comments/s5xqb/designing_a_dcpu16_emulator_… 21. http://stackoverflow.com/questions/10062253/what-are-type-quantifiers 22. http://stackoverflow.com/questions/10102881/haskell-how-does-atomicmodifyio… 23. http://stackoverflow.com/questions/10148897/is-there-a-runtime-penalty-asso… 24. http://stackoverflow.com/questions/10071560/timing-out-pure-functions 25. http://stackoverflow.com/questions/10112733/haskell-simple-constructor-comp… 26. http://stackoverflow.com/questions/10131300/partial-application-with-infix-… 27. http://stackoverflow.com/questions/10091874/haskell-why-is-there-no-type-mi… 28. http://stackoverflow.com/questions/10136222/dependent-optional-data-in-hask… 29. http://stackoverflow.com/questions/10145954/how-can-i-help-specconstr-in-ghc 30. http://stackoverflow.com/questions/10080273/how-to-get-good-performance-whe… 31. http://stackoverflow.com/questions/10099921/efficiently-turn-a-bytestring-i…

1 0

Visi 0.1 is available for OS X
by David Pollak 19 Apr '12

19 Apr '12

Folks, Visi 0.1 is available as an executable for OS X 10.7 ( http://tunaforcats.com/visi_0_1.tar.bz ) The blog post announcement is available at http://blog.goodstuff.im/visi-01-for-os-x/ Visi is written mostly in Haskell (which is totally awesome, btw). I'll be hacking on Visi this weekend at BayHac '12 ( http://www.haskell.org/haskellwiki/BayHac2012) Thanks, David -- Visi.Pro, Cloud Computing for the Rest of Us http://visi.pro Lift, the simply functional web framework http://liftweb.net Follow me: http://twitter.com/dpp Blog: http://goodstuff.im

1 0

Re: [Haskell-cafe] [Haskell] ANN: cabal-install-0.14.0
by Felipe Almeida Lessa 18 Apr '12

18 Apr '12

On Tue, Apr 17, 2012 at 1:59 PM, Andres Löh <andres.loeh(a)googlemail.com> wrote: > * Completely new modular dependency solver (default in most cases) Great! =D -- Felipe.

1 0

ghc/profiling and very big "entries"
by Emmanuel CHANTREAU 18 Apr '12

18 Apr '12

Hello I got this line in the profile output: COST CENTRE MODULE no. entries %time %alloc %time %alloc ticks bytes addDeduction L42s.Maths.Prover.Base 22730 2362045 1.1 4.6 52.3 52.6 81 614808848 And it seems that "addDeduction" has been called 2 362 045 times ? But from other (personal) log files this function should be called less than 10 000 times. I wonder if the laziness of haskell can grow the "entries" field which is defined by: "The number of times this particular point in the call tree was entered.", but what "enter" means for ghc is a question for me. Thank you for answering -- Emmanuel Chantréau http://www.maretmanu.org/emmanuel/

1 0

ANNOUNCE: haskell-src-exts-1.13.2
by Niklas Broberg 18 Apr '12

18 Apr '12

Fellow Haskelleers, I'm pleased to announce the release of haskell-src-exts-1.13.2! * On hackage: http://hackage.haskell.org/package/haskell-src-exts * Via cabal: cabal install haskell-src-exts * Darcs repo: http://code.haskell.org/haskell-src-exts This release contains only a few small tweaks and bug-fixes. Changelog: 1.13.1 --> 1.13.2 =============== * Fix the bug with the precedence of unary prefix minus. Previously it was resolved as binding more tightly than any infix operator, now it is correctly treated as having the same fixity as binary infix minus. 1.13.0 --> 1.13.1 =============== * Allow an optional semi before the closing tag of an element. This achieves a similar effect for XmlSyntax in do blocks as DoAndIfThenElse does for the if construct. No more need to indent the closing tag one step further than the opening tag. * Add a dummy 'noLoc :: SrcLoc' to L.H.E.SrcLoc, to use when generating code. It could definitely be done more elegantly, but not without inducing another major version bump, so later. * Fix a regression from 1.11.x where the parser would crash upon encountering non-simple class/data declaration heads, e.g. 'data A [a]'. Now fails with a parse error as intended. Cheers, /Niklas

1 0

ANNOUNCE: pipes-core 0.1.0
by Paolo Capriotti 18 Apr '12

18 Apr '12

I'm pleased to announce the release of version 0.1.0 of pipes-core, a library for efficient, safe and compositional IO, similar in scope to iteratee and conduits. http://hackage.haskell.org/package/pipes-core This release fixes a mistake in the previous version which violated the category laws in certain cases. I have now written a fairly explicit proof of the category laws for the current implementation, which I'll try to keep updated as the library evolves: https://github.com/pcapriotti/pipes-core/wiki/Category-laws-for-pipes --- # CHANGELOG for pipes-core: ## Version 0.1.0 - Significant simplification of the internals. - Removed `ensure` primitive. # CHANGELOG for pipes-extra: ## Version 0.1.0 - Improved naming in Control.Pipe.Coroutine. - Replaced ChunkPipe with PutbackPipe. --- BR, Paolo Capriotti

4 7

Osx, brew install of 64 bit ghc
by G 17 Apr '12

17 Apr '12

Got a new ghc via brew 7.0.4 and then recompiled / installed haskell-platform via brew Not getting issue trying to compile using ideah in intellij such as Bad interface file: /usr/local/Cellar/ghc/64-apple-darwin/lib/ghc-7.0.4/base-4.3.1.0/Prelude.hi magic number mismatch: old/corrupt interface file? (wanted 129742, got 33214052) Anyone point me in the right direction as to the issue ? Have tried trashing the project etc with no luck. Thanks

1 0

CFT -- Haskell Implementors' Workshop 2012
by Johan Tibell 17 Apr '12

17 Apr '12

Call for Talks ACM SIGPLAN Haskell Implementors' Workshop http://haskell.org/haskellwiki/HaskellImplementorsWorkshop/2012 Copenhagen, Denmark, September 14th, 2012 The workshop will be held in conjunction with ICFP 2012 http://www.icfpconference.org/icfp2012/ Important dates Proposal Deadline: 10th July 2012 Notification: 27th July 2012 Workshop: 14th September 2012 The Haskell Implementors' Workshop is to be held alongside ICFP 2012 this year in Copenhagen, Denmark. There will be no proceedings; it is an informal gathering of people involved in the design and development of Haskell implementations, tools, libraries, and supporting infrastructure. This relatively new workshop reflects the growth of the user community: there is a clear need for a well-supported tool chain for the development, distribution, deployment, and configuration of Haskell software. The aim is for this workshop to give the people involved with building the infrastructure behind this ecosystem an opportunity to bat around ideas, share experiences, and ask for feedback from fellow experts. We intend the workshop to have an informal and interactive feel, with a flexible timetable and plenty of room for ad-hoc discussion, demos, and impromptu short talks. Scope and target audience ------------------------- It is important to distinguish the Haskell Implementors' Workshop from the Haskell Symposium which is also co-located with ICFP 2012. The Haskell Symposium is for the publication of Haskell-related research. In contrast, the Haskell Implementors' Workshop will have no proceedings -- although we will aim to make talk videos, slides and presented data available with the consent of the speakers. In the Haskell Implementors' Workshop, we hope to study the underlying technology. We want to bring together anyone interested in the nitty-gritty details behind turning plain-text source code into a deployed product. Having said that, members of the wider Haskell community are more than welcome to attend the workshop -- we need your feedback to keep the Haskell ecosystem thriving. The scope covers any of the following topics. There may be some topics that people feel we've missed, so by all means submit a proposal even if it doesn't fit exactly into one of these buckets: * Compilation techniques * Language features and extensions * Type system implementation * Concurrency and parallelism: language design and implementation * Performance, optimisation and benchmarking * Virtual machines and run-time systems * Libraries and tools for development or deployment Talks ----- At this stage we would like to invite proposals from potential speakers for a relatively short talk. We are aiming for 20 minute talks with 10 minutes for questions and changeovers. We want to hear from people writing compilers, tools, or libraries, people with cool ideas for directions in which we should take the platform, proposals for new features to be implemented, and half-baked crazy ideas. Please submit a talk title and abstract of no more than 200 words to: johan.tibell(a)gmail.com We will also have a lightning talks session which will be organised on the day. These talks will be 2-10 minutes, depending on available time. Suggested topics for lightning talks are to present a single idea, a work-in-progress project, a problem to intrigue and perplex Haskell implementors, or simply to ask for feedback and collaborators. Organisers ---------- * Lennart Augustsson (Standard Chartered Bank) * Manuel M T Chakravarty (University of New South Wales) * Gregory Collins - co-chair (Google) * Simon Marlow (Microsoft Research) * David Terei (Stanford University) * Johan Tibell - co-chair (Google)

1 0

process-conduit appears to hang on windows
by grant 17 Apr '12

17 Apr '12

Hi, I am trying to use process-conduit on windows, but it appears to hang when using the conduitCmd. Is there a reason why this doesn't work? Thanks for any help, Grant {-# LANGUAGE QuasiQuotes #-} import System.Process.QQ import Data.Conduit import qualified Data.Conduit.Binary as CB import qualified Data.Conduit.List as CL import Data.Conduit.Process import qualified Data.ByteString as B import System.IO main :: IO () main = runResourceT $ [scmd|dir *.txt|] $$ [ccmd|find /i "help"|] =$ CB.sinkHandle stderr main1::IO() main1 = runResourceT $ sourceCmd "dir" $= conduitCmd "find /i \"help\"" $$ CB.sinkHandle stdout

2 3

Connection to database
by yrazes 17 Apr '12

17 Apr '12

Hi guys, I was trying to get a connection MySql Haskell and I followed this steps: 1. install cabal-install install libghc-haskelldb-hdbc-dev (headers del haskell y hdbc) install libmysqlclient-dev (headers del mysqlclient) 2. git clone git://github.com/bos/hdbc-mysql.git 3. julita@yulys:~/hdbc-mysql$ ls ChangeLog Database README.markdown Test.hs COPYING HDBC-mysql.cabal Setup.lhs testsrc julita@yulys:~/hdbc-mysql$ runhaskell Test.hs but I got this error message: Database/HDBC/MySQL.hs:65:8: Could not find module `Database.HDBC.MySQL.RTS': Use -v to see a list of the files searched for. * I tried to do something about the Setup.lhs, but I could not do anything at all. If somebody can help me, I will appreciate it. Best regards, Julita

2 2

CFP SCAM 2012 - submissions due May 4 (abstracts: April 29)
by Sonia Haiduc 17 Apr '12

17 Apr '12

********************************************************************** * 12th IEEE International Working Conference on Source * * Code Analysis and Manipulation * * SCAM 2012 * * http://scam2012.cs.usask.ca/ * * * * September 23 - 24, 2012 * * Riva Del Garda, Trento, Italy * ********************************************************************** * *** CALL FOR PAPERS *** * ********************************************************************** OVERVIEW/SCOPE ************** The aim of SCAM is to bring together researchers and practitioners working on theory, techniques and applications, which concern analysis and/or manipulation of the source code of computer systems. While much attention in the wider software engineering community is properly directed towards other aspects of systems development and evolution, such as specification, design and requirements engineering, it is the source code that contains the only precise description of the behavior of the system. The analysis and manipulation of source code thus remains a pressing concern. COVERED TOPICS AND PAPER FORMATS ******************************** We welcome submission of *full papers* that describe original and significant work in the field of source code analysis and manipulation. SCAM explicitly solicits results from any theoretical or technological domain that can be applied to the following or similar topics: - program transformation - abstract interpretation - program slicing - source level software metrics - decompilation - source level testing and verification - source level optimization - program comprehension SCAM also welcomes *short tool papers* that introduce tools for source code analysis and manipulation. Tool papers should describe a concrete source code analysis or manipulation tool that is available for download and general use and can be run and demonstrated at the conference. Submitted papers should not be longer than 10 pages (6 pages for tool papers). All papers submitted should follow IEEE Computer Society Press Proceedings Author Guidelines. The papers should be submitted electronically in PDF form via the conference web site.Submitted papers must not have been previously published or concurrently submitted for consideration elsewhere. In addition to the main and tool tracks, SCAM 2012 solicits 2-page *Frontiers position papers* describing a significantly new idea in the theory, technology, application or engineering of source code analysis and manipulation systems. Frontiers authors will join in an open panel discussion of the frontiers of the area at the conference. IMPORTANT DATES *************** Abstract submission (full and frontiers papers): April 29, 2012 Papers submission (full and frontiers papers): May 04, 2012 Tool papers submission: May 31, 2012 Notification full and frontier papers: June 16, 2012 Notification tool papers: June 21, 2012 Camera ready submission: July 06, 2012 Working Conference: September 23 - 24, 2012 PROCEEDINGS *********** All accepted papers will appear in the proceedings which will be published by the IEEE Computer Society Press. Best papers from SCAM 2012 will be considered for revision, extension, and publication in a special issue of the Journal of Software: Evolution and Process. ORGANIZING COMMITTEE ******************** *General Chair* James R. Cordy, Queen's University, Canada *Program Co-Chairs* Mariano Ceccato, Fondazione Bruno Kessler, Italy Zheng Li, Beijing University of Chemical Technology, China *Tool Chair* Chanchal K. Roy, University of Saskatchewan, Canada *Local Arangements Chair* Alessandro Marchetto, Fondazione Bruno Kessler, Italy *Finance Chair* Dave Binkley, Loyola University Maryland, USA *Publications Chair* Dawn Lawrie, Loyola University Maryland, USA *Publicity Chair* Sonia Haiduc, Wayne State University, Detroit, USA *Web chair* Minhaz Fahim Zibran, University of Saskatchewan, Canada

1 0

Announce: keera-three-balance-checker-0.0.1
by Ivan Perez 16 Apr '12

16 Apr '12

Hi everyone, I wrote a small app to keep my Three Mobile PayG balance always under control. I've been using it for a while and it seems to work fine. It's just an icon docked in the system bar that shows the current balance when you move the mouse over it. If you don't know what Three Mobile is, then you don't need this. If you use a different operator and would find this kind of app handy, let me know and we can probably find a way to make it work for you. Code, instructions and screenshots: https://github.com/ivanperez-keera/keera-three-balance-checker My cabal repo: remote-repo: ivanperez-keera:http://ivanperez-keera.github.com/packages/archive If any of you find it useful, I'd be glad to know. If you find any bugs, drop me a line and we'll find out how to fix them together. Cheers, Ivan. PS. Why Announce instead of ANNOUNCE? Because this is not a big deal, it's just a toy.

2 1

Building cabal-install for new ghc build
by Lyndon Maydwell 16 Apr '12

16 Apr '12

Hi Café. I'm building GHC from package ghc-7.4.1-src.tar.bz2 as the binary download was throwing segfaults for me (and apparently a few others). This has worked well and my issues with GHC and GHCi are now resolved. However I have needed to build cabal-install. This can't be done using cabal-install because it isn't installed :) I've found that I had to make several modifications to the bootstrap.sh and cabal-install.cabal files in order to get this to work. I am wondering how the maintainers of the Haskell-platform, etc are dealing with these issues. There seems to be a cabal-install-7.4.1 package on Hackage to address these issues, but I couldn't get it to work for me. Is this actually being used by the community? I realize that I am making trouble for myself by not just using the Haskell-Platform, but there are some packages I want to use that depend on recent versions of base. Thanks!

2 2

ANNOUNCE : Juicy.Pixels 1.2.1
by Vincent Berthoux 16 Apr '12

16 Apr '12

Hello everyone, I'm pleased to announce you the new version of Juicy.Pixels, the 1.2.1, no new major features, here's the changelog : - Removed dependency on the array package. - Updated dependency list to handle latest mtl version. - Helper functions to save files without thinking about it. - Some code snippets in the API documentations GitHub : https://github.com/Twinside/Juicy.Pixels Hackage : http://hackage.haskell.org/package/JuicyPixels Regards Vincent Berthoux

1 0

Conduit Best Practices for leftover data
by Myles C. Maxfield 16 Apr '12

16 Apr '12

Hello, I am interested in the argument to Done, namely, leftover data. More specifically, when implementing a conduit/sink, what should the conduit specify for the (Maybe i) argument to Done in the following scenarios (Please note that these scenarios only make sense if the type of 'i' is something in Monoid): 1) The conduit outputted the last thing that it felt like outputting, and exited willfully. There seem to be two options here - a) the conduit/sink should greedily gather up all the remaining input in the stream and mconcat them, or b) Return the part of the last thing that never got represented in any part of anything outputted. Option b seems to make the most sense here. 2) Something upstream produced Done, so the second argument to NeedInput gets run. This is guaranteed to be run at the boundary of an item, so should it always return Nothing? Instead, should it remember all the input it has consumed for the current (yet-to-be-outputted) element, so it can let Data.Conduit know that, even though the conduit appeared to consume the past few items, it actually didn't (because it needs more input items to make an output)? Remembering this sequence could potentially have disastrous memory usage. On the other hand, It could also greedily gather everything remaining in the stream. 3) The conduit/sink encountered an error mid-item. In general, is there a commonly-accepted way to deal with this? If a conduit fails in the middle of an item, it might not be clear where it should pick up processing, so the conduit probably shouldn't even attempt to continue. It would probably be good to return some notion of where it was in the input when it failed. It could return (Done (???) (Left errcode)) but this requires that everything downstream in the pipeline be aware of Errcode, which is not ideal.I could use MonadError along with PipeM, but this approach completely abandons the part of the stream that has been processed successfully. I'd like to avoid using Exceptions if at all possible. It doesn't seem that a user application even has any way to access leftover data anyway, so perhaps this discussion will only be relevant in a future version of Conduit. At any rate, any feedback you could give me on this issue would be greatly appreciated. Thanks, Myles

2 6

strange GHCi type inference behavior involving map and partially applied functions
by Ting Lei 16 Apr '12

16 Apr '12

Hi All, I found a really strange case where GHC and GHCi behave differently in inferring types. It took me hours to figure this out. The following program {-# LANGUAGE NoMonomorphismRestriction #-} g x i = x ++ show i [a,b] = map g ["X","Y"] will not load without "NoMonomorphismRestriction". With that option, it will load and return the correct types (as expected): *Main> :t [a,b] [a,b] :: Show a => [a -> [Char]] *Main> a 1 "X1" However, if I do the same thing GHCi, the type inferencing seems to have been messed up: *Main> let g x i = x ++ show i *Main> let [a,b] = map g ["X","Y"] *Main> :t [a,b] [a,b] :: [() -> [Char]] *Main> :t map g ["X","Y"] map g ["X","Y"] :: Show a => [a -> [Char]] Note how in the last two instances the terms on the left and right-hand sides of the definition return different types. Also, the correct return type should be a list of unary functions taking an (Show a) as the parameter. Now the result is unusable: *Main> a 1 <interactive>:52:3: No instance for (Num ()) arising from the literal `1' Possible fix: add an instance declaration for (Num ()) In the first argument of `a', namely `1' In the expression: a 1 In an equation for `it': it = a 1 I am using GHCi 7.4.1 under windows. I also tried this under GHC 7.0x Is this a GHCi bug or could anyone please explain why this can of strange behavior happens? If this is a bug, could anyone with an account help file a bug for this? Thanks in advance, Ting

4 4

Re: [Haskell-cafe] [Haskell] ANNOUNCE: notcpp-0.0.1
by Steffen Schuldenzucker 16 Apr '12

16 Apr '12

On 04/13/2012 10:49 PM, Ben Millwood wrote: > I'm pleased to announce my first genuinely original Hackage package: > notcpp-0.0.1! > > http://hackage.haskell.org/package/notcpp > > [...] Why is it > scopeLookup :: String -> Q Exp with n bound to x :: T => @scopeLookup n@ evaluates to an Exp containing @Just x@ , not > scopeLookup :: String -> Q (Maybe Exp) with n bound to x :: T => @scopeLookup n@ evaluates to Just (an Exp containing @x@) ? Shouldn't n's being in scope be a compile time decision? That would also make the "openState: runtime name resolution has its drawbacks :/"[1] a compile time error. -- Steffen [1] http://hackage.haskell.org/packages/archive/notcpp/0.0.1/doc/html/NotCPP-Sc…

2 1

Re: [Haskell-cafe] How helpful is h-99 (and should we complete the missing ones)?
by Daniel Hlynskyi 15 Apr '12

15 Apr '12

> > So here's my question: how useful is h-99 (are they overrated as learning > tools)? I find myself solve most of them in a "from the scratch" fashion > (e.g., no Monad, no Applicative, no Functor aside from List and a few > Maybe). Some of them are paper-worthy, for example the prime problems. I > hope some guru-level Haskeller could do away the missing few, and maybe > dive deeper into the surface to produce more insights (like the knights > travel page or the sieve paper, which are both beautiful). As another new-haskeller I say: Yes & No. "Yes" for necessity of several described algorithms and gained intuition for real programming. "No" for needed ammount of work to understand pitfalls of Haskell when real programming. And of-course, problems and solutions are not annotated with there typical real world aplications, they are not obvious for average beginners. Why would I make Binary tree balanced, when I don't know, what I'll gain (except balanced binary tree)?

2 1

[Announce] wxHaskell 0.90
by Jeremy O'Donoghue 14 Apr '12

14 Apr '12

Hi Haskellers, I am delighted to announce the release of wxHaskell 0.90. This release represents a significant milestone for us as it includes support for wxWidgets 2.9.x. The release is avalable from Hackage and as a darcs repo from http://code.haskell.org/wxhaskell. Build and installation instructions have been updated on the Haskell wiki at http://www.haskell.org/haskellwiki/Wxhaskell. Highlights of the new release: - Builds and runs cleanly on 64 bit platforms (particularly MacOS X Lion). - The wxWidgets C wrapper is now built as a DLL on all platforms. - This is reported to enable meaningful use of wxHaskell in GHCi, at least on OS X and Windows. - It also theoretically allows wxc to be used independently of wxHaskell as the basis of a wxWidgets wrapper for other programming languages. Some D language hackers have expressed an interest in this. - New controls: - Styled Text Control (actually, this is reinstated as it was 'lost' a while back during cabalization) - OpenGL support - PropertyGrid control - Many events added in anticipation of wrapping more controls in the near future. There were many contributors to this release, the most notable being Dave Tapley (with the generous support of Mentics Inc.). Dave was responsible for the refactoring of wxc and PropertyGrid support. Eric Kow put in quite a bit of work with Kenny Frodo, Doaitse Swierstra and Alessandro Vermeulen on MacOS support. There were a couple of contributions from long-time wxHaskell contributor shelarcy, and bug reports, fixes and support from a larger community than I ever realised we had. Support for wxWidgets 2.8.x will continue in a 'maintenance mode' continuing from the wxHaskell 0.13 codeline. If you continue to use the old codeline, please take note of the changes to the procedure to get the correct version for your needs. This is also documented at http://www.haskell.org/haskellwiki/Wxhaskell. Thanks to everyone involved. Best regards Jeremy

2 1

Final CFP: 16th Brazilian Symposium on Programming Languages
by Simon Thompson 14 Apr '12

14 Apr '12

============================================================ CALL FOR PAPERS 16th BRAZILIAN SYMPOSIUM ON PROGRAMMING LANGUAGES Natal, Rio Grande do Norte, Brazil September 24-28, 2012 http://www.cbsoft.dimap.ufrn.br ============================================================ IMPORTANT DATES Paper abstract submission (15 lines): April 27th, 2012 (extended) Full paper submission: May 4th, 2012 (extended) Notification of acceptance: June 4th, 2012 Final papers due: June 29th, 2012 INTRODUCTION The 16th Brazilian Symposium on Programming Languages, SBLP 2012, will be held in Natal, Brazil, on September 24-28, 2012. SBLP provides a venue for researchers and practitioners interested in the fundamental principles and innovations in the design and implementation of programming languages and systems. The symposium will be part of the 3rd Brazilian Conference on Software: Theory and Practice, CBSoft 2012, http://www.cbsoft.dimap.ufrn.br, which will host four traditional, well-established symposia: * XXVI Brazilian Symposium on Software Engineering (SBES) * XVI Brazilian Symposium on Programming Languages (SBLP) * XV Brazilian Symposium on Formal Methods (SBMF) * VI Brazilian Symposium on Components, Software Architecture and Software Reuse (SBCARS) SBLP 2012 invites authors to contribute with technical papers related (but not limited) to: * Program generation and transformation, including domain-specific languages and model-driven development in the context of programming languages. * Programming paradigms and styles, including functional, object-oriented, aspect-oriented, scripting languages, real-time, service-oriented, multithreaded, parallel, and distributed programming. * Formal semantics and theoretical foundations, including denotational, operational, algebraic and categorical. * Program analysis and verification, including type systems, static analysis and abstract interpretation. * Programming language design and implementation, including new programming models, programming language environments, compilation and interpretation techniques. SUBMISSIONS Contributions should be written in Portuguese or English. We solicit papers that should fall into one of two different categories: full papers, with at most 15 pages, or short papers, with at most 5 pages. We encourage the submission of short papers reporting on partial results of on-going master dissertations or doctoral theses. All accepted papers will be published in the conference proceedings distributed in a digital media by the CBSOFT organizers. Full papers submitted in English will be published in a volume of the Lecture Notes in Computer Science (LNCS), by Springer, to be distributed in the conference. For this reason, all papers must be prepared using the LNCS template, available at http://www.springer.com/computer/lncs?SGWID=0-164-6-793341-0. As in previous editions, a journal special issue, with selected papers from accepted contributions, is anticipated. Selected papers from 2003 to 2008 editions of SBLP were published in special issues of the Journal of Universal Computer Science, by Springer. The post-proceedings of SBLP from 2009 to 2011, also with selected papers from the conference proceedings, are being edited as special issues of Science of Computer Programming, published by Elsevier. Submissions should be done using SBLP 2012 installation of the EasyChair conference management system at http://www.easychair.org/conferences/?conf=sblp2012. GENERAL CO-CHAIRS NÈlio Cacho, UFRN Gibeon Aquino, UFRN Martin Musicante, UFRN PROGRAMME CHAIRS Francisco Heron de Carvalho Junior, UFC Luis Soares Barbosa, Univ. do Minho PROGRAMME COMMITTEE * Alberto Pardo, Univ. de La Republica * Alex Garcia, IME * Alvaro Freitas Moreira, UFRGS * AndrÈ Rauber Du Bois, UFPel * Andre Santos, UFPE * Carlos Camarao, UFMG * Christiano Braga, UFF * Fernando Castor Filho, UFPE * Fernando Quint„o Pereira, UFMG * Francisco Heron de Carvalho Junior, UFC (co-chair) * Joao Saraiva, Universidade do Minho * Jo„o F. Ferreira, Teesside University * Jonathan Aldrich, Carnegie Mellon Univ. * Jose Luiz Fiadeiro, Univ. of Leicester * Lucilia Figueiredo, UFOP * Luis Soares Barbosa, Univ. do Minho (co-chair) * Manuel AntÛnio Martins, Univ. de Aveiro * Marcelo A. Maia, UFU * Marcello Bonsangue, Leiden Univ/CWI * Marcelo d'Amorim, UFPE * Marco Tulio Valente, UFMG * Mariza A. S. Bigonha, UFMG * Martin A. Musicante, UFRN * Noemi Rodriguez, PUC-Rio * Paulo Borba, UFPE * Peter Mosses, Swansea University * Qiu Zongyang, Peking University * Rafael Dueire Lins, UFPE * Renato Cerqueira, PUC-Rio * Ricardo Massa, UFPE * Roberto S. Bigonha, UFMG * Roberto Ierusalimschy, PUC-Rio * Sandro Rigo, UNICAMP * Sergio Soares, UFPE * Simon Thompson, Univ. of Kent * Varmo Vene, Univ. de Tartu Simon Thompson | Professor of Logic and Computation School of Computing | University of Kent | Canterbury, CT2 7NF, UK s.j.thompson(a)kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt

1 0

Re: [Haskell-cafe] [Haskell] ANNOUNCE: notcpp-0.0.1
by Facundo Domínguez 14 Apr '12

14 Apr '12

Hi, > scopeLookup :: String -> Q Exp The example provided here [1] fails at runtime is no name can be found in scope. Would it make more sense to have scopeLookup :: [String] -> Q Exp and have compilation fail if no name in the list is in scope? By the way, the library brings an interesting approach to conditional compilation. Facundo [1] http://hackage.haskell.org/packages/archive/notcpp/0.0.1/doc/html/NotCPP-Sc…

1 0

Re: [Haskell-cafe] [Haskell] ANNOUNCE: notcpp-0.0.1
by Henning Thielemann 14 Apr '12

14 Apr '12

On Fri, 13 Apr 2012, Ben Millwood wrote: > But I never liked using CPP: it completely defeats haskell-src-exts > and hence things like SourceGraph, and anyway it's not designed for > Haskell and doesn't at all understand its structure, or fit with its > syntax. With a little thought, I wondered if creative use of template > haskell might not achieve the same goal. It turned out it did, and > emboldened with this knowledge I set out to write a new package making > this technique available to others. I never liked CPP in Haskell, too. The problem is: I also do not like Template Haskell. :-) Whereever possible I use a Cabal flag and a conditional Hs-Source-Dirs. http://www.haskell.org/haskellwiki/Cabal/Developer-FAQ#Adapt_to_different_s…

2 1

is this an arrow?
by Johannes Waldmann 13 Apr '12

13 Apr '12

Dear Cafe, I have the following types: type Computer a b = ( a -> IO ( Maybe b ) ) type Transformer a b c d = Computer a ( b, c -> d ) For example, a SAT solver: minisat :: Computer CNF Assignment, and when I use it to solve an application problem via transformation to SAT, I need t :: Transformer Problem SAT Assignment Solution Now - what is the proper abstraction? Is this an arrow somehow? And is there already a type and a library that would contain useful combinators like some of these: http://autolat.imn.htwk-leipzig.de/gitweb/?p=box;a=blob;f=src/exotic/Strate… Thanks - J.W.

2 1

Can cabal detect property of the platform ?
by Vincent Hanquez 13 Apr '12

13 Apr '12

Hi Cafe, Is there a way to have (some) cabal flags to autoconfigure themselves ? For example, a SSE flag, i want the configure to default to on when the building machine has SSE instruction available, and default to off otherwise. (of course, it wouldn't affect the user ability to override the default with -f) It doesn't appears possible just using the cabal file. Is there a way with the Setup.hs maybe ? or some other cunning plan ? -- Vincent

1 0

open source project for student
by Dan Cristian Octavian 13 Apr '12

13 Apr '12

Hello, I am a second year computer science student who is very interested in working on a haskell open source project. I have no particular focus on a certain type of application. I am open to ideas and to exploring new fields. What kind of project should I look for considering that I am a beginner? (Any particular project proposals would be greatly appreciated). Is the entry bar too high for most projects out there for somebody lacking experience such as me so that I should try getting some experience on my own first? Would it be a better idea to try to hack on my own project rather than helping on an existing one? Thank you very much for your help.

4 4

prettyprint with IO
by Warren Harris 13 Apr '12

13 Apr '12

I wrote a parsec parser that does symbols lookups during the parsing process (ParsecT String Store IO a). Now I'd like to write a pretty printer that does the reverse. Unfortunately there doesn't appear to be a transformer version of Text.PrettyPrint.HughesPJ. Can anyone suggest a way to do this? Thanks, Warren

4 4

I Need a Better Functional Language!
by Grigory Sarnitskiy 13 Apr '12

13 Apr '12

Hello! I've just realized that Haskell is no good for working with functions! First, what are 'functions' we are interested at? It can't be the usual set-theoretic definition, since it is not constructive. The constructive definition should imply functions that can be constructed, computed. Thus these are computable functions that should be of our concern. But computable functions in essence are just a synonym for programs. One could expect from a language that bears 'functional' as its characteristic to be able to do everything imaginable with functions. However, the only thing Haskell can do with functions is to apply them to arguments and to feed them as arguments, run in parallel (run and concatenate programs). Obviously, that's not all of the imaginable possibilities. One also can rewrite programs. And write programs that rewrite programs. And write programs that rewrite programs that rewrite the first programs and so on. But there is no such possibility in Haskell, except for introducing a DSL. So now I wonder, what are the languages that are functional in the sense above? With a reasonable syntax and semantics, thus no assembler. I guess Lisp might be of this kind, but I'm not sure. In addition, I'm not a fan of parentheses. What else? Pure? Mathematica? Maxima? Note, that the reflectivity is important.

13 14

Is type class 'Addressable' already exists.
by 陈文龙 12 Apr '12

12 Apr '12

To get element in List,Map... in python's way. Python: > strMap["apple"] Haskell: > strMap # "apple" https://gist.github.com/2364395 {-# LANGUAGE TypeFamilies #-} module Addressable where import qualified Data.Map as M import Prelude class Addressable a where type Key a type Value a (#!) :: a -> Key a -> Value a (#) :: a -> Key a -> Maybe (Value a) instance Addressable [a] where type Key [a] = Int type Value [a] = a (#!) = (!!) xs # i | i < 0 = Nothing [] # _ = Nothing (x:_) # 0 = Just x (_:xs) # n = xs # (n-1) instance (Ord k) => Addressable (M.Map k v) where type Key (M.Map k v) = k type Value (M.Map k v) = v a #! i = a M.! i a # i = M.lookup i a main :: IO () main = do let strMap = M.fromList [("one","1"),("two","2"),("three","3")] let strList = ["1","2","3"] print $ strMap # "two" -- Just "2" print $ strMap #! "two" -- "2" print $ strList # 0 -- Just "1" print $ strList #! 0 -- "1" print $ strMap # "no-exist" -- Nothing print $ strList # 100 -- Nothing print $ strMap #! "no-exist" -- error print $ strList #! 100 -- error

2 3

Haskell Weekly News: Issue 222
by Daniel Santa Cruz 12 Apr '12

12 Apr '12

Welcome to issue 222 of the HWN, an issue covering crowd-sourced bits of information about Haskell from around the web. This issue covers the week of April 1 to 7, 2012. Quotes of the Week * tgeeky_: "What I cannot create, I do not understand." -- Richard Feynman, on his blackboard when he died in 1988. * elliott: ... [a] is more of a control structure than a data structure. * Cale: Basically, we've known how to implement first class functions efficiently for 20 or 30 years now, and we've known about their importance to abstraction in programming since before the advent of electronic computers. There's no excuse to still be writing new programs in languages without them. * edwardk: When someone throws an exception at you, duck. * luite: I think it uses levenshtein distance (he invented this distance because nobody could spell his name correctly) * edwardk: 'hey ghc devs can you fix this thing that might or might not be a bug so we can break a huge pile of invariants in your compiler to put go faster stripes on something nobody uses? k thx' Top Reddit Stories * Tfoo, my simple Five in a Row game. Online, with server-sent events, deployed to Heroku, open source. Domain: tfoo.herokuapp.com, Score: 49, Comments: 18 On Reddit: [1] http://goo.gl/Klevh Original: [2] http://goo.gl/PtjKk * Interacting with inner-functions in GHCi [StackOverflow] Domain: stackoverflow.com, Score: 48, Comments: 12 On Reddit: [3] http://goo.gl/23l0G Original: [4] http://goo.gl/2H5kI * ANN: acme-http. 221,693.0 req/s on the PONG benchmark. Domain: groups.google.com, Score: 42, Comments: 4 On Reddit: [5] http://goo.gl/XROlu Original: [6] http://goo.gl/PuOt3 * Recent haskell-mode changes screencast Domain: youtube.com, Score: 39, Comments: 15 On Reddit: [7] http://goo.gl/JyX0s Original: [8] http://goo.gl/VWLIF * An Haskell tutorial. What do you think? Domain: yannesposito.com, Score: 39, Comments: 47 On Reddit: [9] http://goo.gl/eLiQT Original: [10] http://goo.gl/yBDnQ * Galois' Open-Source code available on github Domain: corp.galois.com, Score: 38, Comments: 3 On Reddit: [11] http://goo.gl/xoz4K Original: [12] http://goo.gl/OhlaA * Wadler’s Law Revisited Domain: comonad.com, Score: 27, Comments: 9 On Reddit: [13] http://goo.gl/8p9As Original: [14] http://goo.gl/7iB53 * With Linux supporting x32 ABI, should GHC follow suit? Domain: self.haskell, Score: 23, Comments: 6 On Reddit: [15] http://goo.gl/Nkuob Original: [16] http://goo.gl/Nkuob * cabal-meta: transcending to dependency heaven Domain: yesodweb.com, Score: 22, Comments: 27 On Reddit: [17] http://goo.gl/nsVhn Original: [18] http://goo.gl/U2cDK * [Haskell-cafe] A Modest Records Proposal Domain: haskell.org, Score: 21, Comments: 7 On Reddit: [19] http://goo.gl/MvbRq Original: [20] http://goo.gl/RgaRU Top StackOverflow Questions * What is the best way to test and interact with inner functions defined inside a toplevel function? votes: 44, answers: 1 Read on SO: [21] http://goo.gl/2H5kI * How can a Windows service application be written in Haskell? votes: 15, answers: 1 Read on SO: [22] http://goo.gl/kz8TA * What does ':..' mean in Haskell? votes: 12, answers: 2 Read on SO: [23] http://goo.gl/Whi8a * Is the whole Map copied when a new binding is inserted? votes: 10, answers: 3 Read on SO: [24] http://goo.gl/OabLu * Haskell functions left-to-right votes: 10, answers: 1 Read on SO: [25] http://goo.gl/rhCm3 * How can I avoid writing boilerplate code for functions performing pattern matching? votes: 9, answers: 3 Read on SO: [26] http://goo.gl/6cvXJ * Controlling how test data is generated in QuickCheck votes: 8, answers: 1 Read on SO: [27] http://goo.gl/BNSug * Can I get warnings about overly-restrictive type signatures? votes: 8, answers: 1 Read on SO: [28] http://goo.gl/X7PkN * Slowdown when using parallel strategies in Haskell votes: 8, answers: 1 Read on SO: [29] http://goo.gl/ghV3C * Dealing with boilerplate in Haskell votes: 7, answers: 2 Read on SO: [30] http://goo.gl/Um4Fm Until next time, Daniel Santa Cruz References 1. http://tfoo.herokuapp.com/ 2. http://www.reddit.com/r/haskell/comments/rx20z/tfoo_my_simple_five_in_a_row… 3. http://stackoverflow.com/questions/9987739/what-is-the-best-way-to-test-and… 4. http://www.reddit.com/r/haskell/comments/rr7se/interacting_with_innerfuncti… 5. https://groups.google.com/group/happs/browse_thread/thread/9b078d23b59a7374 6. http://www.reddit.com/r/haskell/comments/ro77b/ann_acmehttp_2216930_reqs_on… 7. http://www.youtube.com/watch?v=E6xIjl06Lr4 8. http://www.reddit.com/r/haskell/comments/rtctu/recent_haskellmode_changes_s… 9. http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/ 10. http://www.reddit.com/r/haskell/comments/rw61r/an_haskell_tutorial_what_do_… 11. http://corp.galois.com/blog/2012/4/4/galois-open-source-projects-on-github.… 12. http://www.reddit.com/r/haskell/comments/rt8m3/galois_opensource_code_avail… 13. http://comonad.com/reader/2012/wadlers-law-revisited/ 14. http://www.reddit.com/r/haskell/comments/rpyhr/wadlers_law_revisited/ 15. http://www.reddit.com/r/haskell/comments/rpbcx/with_linux_supporting_x32_ab… 16. http://www.reddit.com/r/haskell/comments/rpbcx/with_linux_supporting_x32_ab… 17. http://www.yesodweb.com/blog/2012/04/cabal-meta 18. http://www.reddit.com/r/haskell/comments/rurn4/cabalmeta_transcending_to_de… 19. http://www.haskell.org/pipermail/haskell-cafe/2012-April/100527.html 20. http://www.reddit.com/r/haskell/comments/rnwgn/haskellcafe_a_modest_records… 21. http://stackoverflow.com/questions/9987739/what-is-the-best-way-to-test-and… 22. http://stackoverflow.com/questions/10037654/how-can-a-windows-service-appli… 23. http://stackoverflow.com/questions/9996740/what-does-mean-in-haskell 24. http://stackoverflow.com/questions/10002956/is-the-whole-map-copied-when-a-… 25. http://stackoverflow.com/questions/10003796/haskell-functions-left-to-right 26. http://stackoverflow.com/questions/10024455/how-can-i-avoid-writing-boilerp… 27. http://stackoverflow.com/questions/9977734/controlling-how-test-data-is-gen… 28. http://stackoverflow.com/questions/9986508/can-i-get-warnings-about-overly-… 29. http://stackoverflow.com/questions/10009361/slowdown-when-using-parallel-st… 30. http://stackoverflow.com/questions/9969638/dealing-with-boilerplate-in-hask…

1 0

Nice article on FP and concurrency from a born-again C++ programmer
by Obscaenvs 11 Apr '12

11 Apr '12

http://fpcomplete.com/the-downfall-of-imperative-programming/ /F

1 0

Memory leak from close fields in conduit
by Michael Snoyman 11 Apr '12

11 Apr '12

Hi all, Hideyuki Tanaka alerted me[1] to a memory leak in conduit. Long story short: it appears that Pipe composition leads to collection of a large number of `return ()` actions for unnecessary memory cleanup. We came up with a possible solution: a Finalize type[2]. In both of our testing, this eliminates the memory leak in question. So now I have a few questions: 1. Does anyone have a different idea on how to approach this problem? 2. Are there any refinements to be applied to the solution? 3. Technically, this is an API breakage, but (a) conduit 0.4 was released very recently, (b) this is a fairly important change, and (c) the real-world breakage from this is very minimal. Will anyone call foul if I release such a change as 0.4.1? Just to stress 3c: I compiled all of Yesod against this modified version of conduit, and only http-conduit had to be tweaked at all. Michael [1] https://github.com/snoyberg/conduit/issues/40 [2] https://github.com/snoyberg/conduit/commit/ebc7a68e0f1f0c1b80c0105916b00060…

1 0

Installing REPA
by Dominic Steinitz 11 Apr '12

11 Apr '12

Hi, I'm trying to install REPA but getting the following. Do I just install base? Or is it more complicated than that? Thanks, Dominic. Tests-MacBook-Pro:PDE Test$ cabal install repa Resolving dependencies... cabal: cannot configure repa-2.2.0.1. It requires base ==4.4.* For the dependency on base ==4.4.* there are these packages: base-4.4.0.0 and base-4.4.1.0. However none of them are available. base-4.4.0.0 was excluded because of the top level dependency base -any base-4.4.1.0 was excluded because of the top level dependency base -any Tests-MacBook-Pro:PDE Test$ cabal --version cabal-install version 0.10.2 using version 1.10.1.0 of the Cabal library Tests-MacBook-Pro:PDE Test$ Tests-MacBook-Pro:PDE Test$ ghc --version The Glorious Glasgow Haskell Compilation System, version 7.0.3

7 12

building ghc on arch linux ARM?
by . 11 Apr '12

11 Apr '12

Hi Cafe, I hope this is the right place to ask this kind of stuff. I would like to try ghc on a panda board (armv7l) with arch linux. There is apparently no pre-built package, so I was trying the instructions to build, from here: <http://hackage.haskell.org/trac/ghc/wiki/Building/Porting>. However, I still seem to need a ghc and ghc-pkg installed: I am getting this error message: .... checking for tar... /bin/tar checking for gpatch... no checking for patch... /usr/bin/patch checking for dtrace... no checking for HsColour... no checking for xmllint... no configure: WARNING: cannot find xmllint in your PATH, you will not be able to validate your documentation checking for xsltproc... no configure: WARNING: cannot find xsltproc in your PATH, you will not be able to build the HTML documentation checking for dblatex... no configure: WARNING: cannot find dblatex in your PATH, you will not be able to build the PDF and PS documentation checking for ghc-pkg matching ... configure: error: Cannot find matching ghc-pkg --------- Does anyone know if it is possible to build ghc without ghc on this platform? I was using the tarball sources for ghc 7.4.1. Thanks, Christian

8 17

Reconstructing a tree from a list of its paths (to leaves)
by Arnaud Bailly 11 Apr '12

11 Apr '12

Hello, I am manipulating labeled multiway trees, some kind of "lightweight" XML notation. One thing I would like to be able to do is manipulating a tree as a list of (Path, Value). Generating such a list is easy but I am a little bit surprised to find it harder to reconstruct a tree, given such a list assuming some sensible properties (list is ordered, for example). I got the intuition this has already been tackled in one way or another in a functional setting in Haskell (I code in Java but using mostly functional constructs), but don't know where to look. Thanks for your pointers and help, Regards, Arnaud

3 5

XMPP library recommendations
by John Goerzen 11 Apr '12

11 Apr '12

Hi folks, I'm looking for suggestions for XMPP libraries. So far I have found three on Hackage. Thanks to the authors of these - I think a lot of good can come from XMPP in Haskell. However, all of them appear to be minimally maintained, if at all: * XMPP - only one upload, over 2 years ago. Does not support TLS (required by many modern servers). Does not support SASL (also required by many modern servers). After finding the options on a test server to disable the requirements for TLS and SASL, it worked. * network-protocol-XMPP - uploaded recently to fix 7.4 build issue, not much other recent activity. Refuses to connect to a test account with "Received empty challenge" (this does not appear to be an accurate error message, but rather a bug in XML parsing). A bit more low-level than I'm looking for. * haskell-xmpp - only one upload, over 1 year ago. Connects and works. I like the design. Is hard-coded to write debug messages to stdout, making it a bit of a problem for programs that use stdout (though a one-liner mod to the code would fix that). Says it's "alpha" and "work in progress". What experience do people have with these? Any recommendations? Thanks, -- John

1 0

ANN: Selenium WebDriver client for Haskell
by Adam Curtis 11 Apr '12

11 Apr '12

The first release of the webdriver package has been uploaded to Hackage. Selenium is a test suite that allows you to automate web browsers on a variety of platforms. The webdriver package acts as a client library that speaks Selenium's WebDriver protocol, using a simple monadic interface. This alpha release has received a month of testing through my own usage, and has most of the capabilities of the official Selenium clients, with more to come. Future plans include utilizing the http-conduit and attoparsec-conduit packages for memory efficient JSON parsing, and using the reflection package to safely handle multiple versions of the WebDriver protocol through implicit configurations. For more information, see http://hackage.haskell.org/package/webdriver

2 1

Mixing Unboxed Mutable Vectors and Parsers
by Myles C. Maxfield 10 Apr '12

10 Apr '12

CC: Maintainers of STMonadTrans, Vector, and JuicyPixels Hello, I am writing a Haskell Attoparsec parser which will modify 2-d arrays of small values (Word8, Int8, etc.). My first idea was to simply parse all the deltas, and later apply them to the input list. However, I can't do that because the value of the deltas depend on the value they're modifying. My first pass at this program used a function of the form: p :: [[Word8]] -> Parser [[Word8]] This approach works, however, the program uses far too much memory. Some quick testing shows that lists of Word8s are ~52.6x larger than unboxed vectors of Word8s, and boxed vectors of Word8s are ~7.5x larger than unboxed vectors of Word8s. A better approach would be to use Data.Vector.Unboxed.Mutable and do the mutations inline with the parser. Because mutable vectors require a monad in PrimMonad to do the mutations inside of, I'd have to use a monad transformer to combine Parser and something in PrimMonad. Attoparsec doesn't support being used as a monad transformer, so I can't say something like p :: (PrimMonad m, UM.Unbox a) => M.MVector (PrimState m) (UM.MVector (PrimState m) a) -> ParserT m () I can't use Parsec (instead of Attoparsec) because I require streaming semantics -- eventually I'm going to hook this up to Data.Conduit and parse directly from the net. There is STT (in the package STMonadTrans), however, so I could potentially make the function result in STT Parser (). However, STT doesn't work with Data.Vector.Mutable or Data.Vector.Unboxed.Mutable, because STT isn't a member of the PrimMonad class (as far as I can tell). STT itself doesn't define unboxed mutable vectors (only boxed mutable vectors), but I feel that giving up unboxing isn't really an option because of the memory footprint. As a general observation, it seems silly to have two different mutable vector implementations, one for STT and the other for PrimMonad. So here are my questions: 1. Is it possible to implement PrimMonad with STT? I looked around for a little while, but couldn't find anything that did this. 2. Otherwise, is it reasonable to try to implement unboxed mutable vectors in STT? I feel this is probably going down the wrong path. 3. Are there any parsers that support streaming semantics and being used as a monad transformer? This would require rewriting my whole program to use this new parser, but if that's what I have to do, then so be it. Thanks, Myles C. Maxfield

4 5

Call for Participation: Tests and Proofs (TAP 2012) in Prague
by Achim D. Brucker 10 Apr '12

10 Apr '12

Apologies for duplicates. ======================================================================== CALL FOR PARTICIPATION TESTS and PROOFS 2012 (TOOLS EUROPE 2012) 6th International Conference on Tests & Proofs May 31 - June 1, 2012, Prague, Czech Republic http://lifc.univ-fcomte.fr/tap2012/ Co-located with: ICMT 2012, SC 2012, MSEPT 2012 as part of TOOLS 2012: http://toolseurope2012.fit.cvut.cz/ ======================================================================== The TAP conference is devoted to the convergence of proofs and tests. It combines ideas from both sides for the advancement of software quality. Keynote Speakers ================ * Andreas Kuehlmann <http://www.eecs.berkeley.edu/%7Ekuehl/>, Coverity The Technology and Psychology of Testing Your Code as You Develop It (abstract <http://lifc.univ-fcomte.fr/tap2012/abstract_talk_Kuehlmann.pdf>) * Corina Pasareanu <http://ti.arc.nasa.gov/profile/pcorina/>, NASA Ames Research Center Combining Model Checking and Symbolic Execution for Software Testing (abstract <http://lifc.univ-fcomte.fr/tap2012/abstract_talk_Pasareanu.pdf>) * Mehdi Jazayeri, University of Lugano. Software Composition: Why, what, and how Registration: ============= Early registration, at a reduced price, will be open until 25 April 2012. http://toolseurope2012.fit.cvut.cz/index.php/registration.html Organization: ============= Conference Chair Bertrand Meyer, ETH Zurich, Eiffel Software, and ITMO Program Chairs Achim D. Brucker, SAP Research, Germany Jacques Julliand, University of Franche-Comté Local Organization Pavel Tvrdik, CTU Prague Michal Valenta, CTU Prague Jindra Vojikova, CTU Prague Jan Chrastina, CTU Prague Program: ======== Thursday 31th May, 09:00-10:30: Invited Talk * Andreas Kuehlmann, Coverity: The Technology and Psychology of Testing Your Code as You Develop It Thursday, 11:00-13:00: Paper session Model-Based Testing * Malte Lochau, Ina Schaefer, Jochen Kamischke and Sascha Lity. Incremental Model-based Testing of Delta-oriented Software Product Lines * Hernan Ponce De Leon, Stefan Haar and Delphine Longuet. Conformance Relations for Labeled Event Structures * Joseph Kiniry, Daniel M. Zimmerman and Ralph Hyland. Testing Library Specifications by Verifying Conformance Tests * Chedor Sebastien, Thierry J?ron and Morvan Christophe. Test generation from recursive tiles systems Thursday, 14:30-15:30: Paper session Scenario and UML-Based Testing * Nadia Creignou, Uwe Egly and Martina Seidl. A Framework for the Specification of Random SAT and QSAT Formulas * Jens Brüning, Martin Gogolla, Lars Hamann and Mirco Kuhlmann. Evaluating and Debugging OCL Expressions in UML Models * Uwe Egly, Sebastian Gabmeyer, Martina Seidl, Hans Tompits, .... Towards Scenario-Based Testing of UML Diagrams Thursday, 16:00-17:00: Tutorial * Nikolay Kosmatov, Nicky Williams. Automated Structural Testing with PathCrawler Friday 1st June, 09:00-10:30: Invited Talk of SC * Mehdi Jazayeri, University of Lugano. Software Composition: Why, what, and how Friday 11:00-13:00: Invited Talk of TAP * Corina Pasareanu. NASA. Combining Model Checking and Symbolic Execution for Software Testing Friday, 14:30-15:30: Paper session Test and Model-checking * Martin Sulzmann and Axel Zechner Constructive Finite Trace Analysis with Linear Temporal Logic * Alessandro Armando, Roberto Carbone, Giancarlo Pellegrino, Alessio Merlo and Davide Balzarotti. From Model-checking to Automated Testing of Security Protocols: Bridging the Gap Friday, 16:00-17:30: Paper session Test of Complex Data Structures * Valerio Senni and Fabio Fioravanti. Generation of test data structures using Constraint Logic Programming * Valeria Bengolea, Nazareno Aguirre, Darko Marinov and Marcelo Frias. Coverage Criteria on RepOK to Reduce Bounded Exhaustive Test Suites * Matthieu Carlier, Catherine Dubois and Arnaud Gotlieb. A first step in the design of a formally verified constraint-based testing tool: FocalTest -- Dr. Achim D. Brucker, SAP Research, Vincenz-Priessnitz-Str. 1, D-76131 Karlsruhe Phone: +49 6227 7-52595, http://www.brucker.ch

1 0

ANN: plugins-1.5.2.1
by Jeremy Shaw 09 Apr '12

09 Apr '12

Hello! I am pleased to announce the release of plugins-1.5.2.1: http://hackage.haskell.org/package/plugins The plugins library provides facilities to compile and dynamically load/link Haskell code into a running Haskell application. (The related, plugins-auto package adds support for file watching via inontify and automatic recompilation and reloading, http://hackage.haskell.org/package/plugins) There are three important changes in this release: 1. Support for GHC 7.0, 7.2. and 7.4. We have not *knowingly* dropped support for GHC 6.12. So, if you still use an older compiler and we broke it.. we might be willing to fix it still :) 2. New maintainer: Don Stewart has graciously allowed me to take over the project. I do not have any immediate plans for big changes. But I do plan to: keep it compiling, apply patches in a timely manner, and deal with other minor bug fixes. I would certainly love to see some major improvements. I believe plugins predates the GHC API and, accordingly, does not use it as well as it could. If someone wanted to give plugins some major love, that would be awesome. While plugins has not much recent development, there are still a lot of people that are using it, or would like to. 3. the source has moved to patch-tag and darcs 2, http://patch-tag.com/r/stepcut/plugins patch-tag only supports darcs 2 format repositories, so this forced me to run darcs convert to switch from darcs 1 to darcs 2 format. In the end that is a good thing. The only downside is that I can not directly apply any darcs 1 patches to the repo now. But I doubt there are many floating around anyway. And I can still apply them the hard way. - jeremy

1 1

Guide for converting existing code to Conduit 0.4?
by Erik de Castro Lopo 09 Apr '12

09 Apr '12

Hi all, Is there some sort of a guide for converting existing code Conduit 0.4? What happened to Control.Monad.Trans.Resource.with? What happens to stuff that used to to have a type "C.Source m a" which now seems to need type "C.Pipe Void a (ResourceT m) a"? Cheers, Erik -- ---------------------------------------------------------------------- Erik de Castro Lopo http://www.mega-nerd.com/

4 7

Category Theory Questions
by Sergiu Ivanov 09 Apr '12

09 Apr '12

Hello, I have a question not that directly related to Haskell, but I still think this is a good place to ask it. I am currently studying category theory by the book Joy of Cats. Are there any people whom I could ask some questions related to category theory from time to time? Or could I just post my questions here directly? The reason I'm asking is that I seen very nice discussions related to category theory on this list. I hope to be able to deal with most of the stuff myself, but having someone to discuss the matters with is always nice :-) Sergiu [0] katmat.math.uni-bremen.de/acc/acc.pdf

4 4

Re: [Haskell-cafe] Too much inlining on text package
by wren ng thornton 08 Apr '12

08 Apr '12

On 3/16/12 12:22 PM, Aleksey Khudyakov wrote: > Disclaimer. I'm no expert in text internals. > > Because it's told to do so. This is an unfortunate feature of stream > fusion. It does eliminate intermediate data structures but it requires > that everything is inlined. There are ways of mitigating that, however. In particular, the standard style is to have things inline aggressively before stage 0 or 1, and then in the last stage to "inline" things back to an indirect call to the library. This is used ubiquitously in GHC's list fusion, and is essential for stream-fusion since the intermediate stream form is a pessimation when it can't partake in fusion. -- Live well, ~wren

6 8