December 2012 - Haskell-Cafe

ANNOUNCE: tie-knot library
by Petr P 14 Dec '12

14 Dec '12

Dear Haskellers, I'd like to announce a small library "tie-knot": "Ties the knot" on a given set of structures that reference each other by keys - replaces the keys with their respective values. Takes Map k (v k) and converts into Map k v' where v' is the fixed point of v. Motivation: I needed to assemble a finite-state machine from an external description where each node was described by some identifier. I needed a simple library that would replace all key referencess with the actual values. See https://github.com/ppetr/tie-knot for examples. Hackage: http://hackage.haskell.org/package/tie-knot - Petr Pudlak

13 18

How to start with GHC development?
by Janek S. 14 Dec '12

14 Dec '12

Dear list, I would like to learn about internals of GHC and contribute to its development in the future. I read a couple of papers that give a very general overview of GHC (chapter from AoS, papers about inliner and multicore support) and I'm thinking what direction should I pursue now. I was thinking about: a) getting GHC sources, reading the commentary on the GHC wiki and hacking the code b) reading SPJs "Implementing Functional Languages: a tutorial" c) reading SPJs "The Implementation Of Functional Languages" book I would definitely go for a), but I don't know if I'll manage to understand the code without knowing how functional languages are compiled. I have a rather basic knowledge of compilers in general - I took Stanford's online course on Compilers at Coursera. Should I get more theoretical knowledge? Any advice is greatly appreciated. Janek

5 8

Second Call for Copy: Monad.Reader #21
by Edward Z. Yang 13 Dec '12

13 Dec '12

Second Call for Copy: The Monad.Reader - Issue 21 ------------------------------------------------- Whether you're an established academic or have only just started learning Haskell, if you have something to say, please consider writing an article for The Monad.Reader! The submission deadline for Issue 21 will be: **Tuesday, January 1** Less than half a month away, but that's what Christmas break is for, right? :-) The Monad.Reader ~~~~~~~~~~~~~~~~ The Monad.Reader is a electronic magazine about all things Haskell. It is less formal than journal, but somehow more enduring than a wiki- page. There have been a wide variety of articles: exciting code fragments, intriguing puzzles, book reviews, tutorials, and even half-baked research ideas. Submission Details ~~~~~~~~~~~~~~~~~~ Get in touch with me if you intend to submit something -- the sooner you let me know what you're up to, the better. Please submit articles for the next issue to me by e-mail (ezyang(a)mit.edu) Articles should be written according to the guidelines available from http://themonadreader.wordpress.com/contributing/ Please submit your article in PDF, together with any source files you used. The sources will be released together with the magazine under a BSD license. If you would like to submit an article, but have trouble with LaTeX please let me know and we'll work something out.

1 0

ANNOUNCE: hoodle : Pen note-taking program written in haskell
by Ian-Woo Kim 13 Dec '12

13 Dec '12

Hi, Haskellers! I am happy to announce hoodle : pen note-taking program written in haskell. Hoodle is a continuation of the development of hxournal. I renamed it to hoodle, apparently meaning Haskell + doodle. It has undergone many changes and bug fixes. Hopefully, this program is now useful to users. See how it works in action : http://www.youtube.com/watch?v=Z2wzpyxsVSU Hoodle has been uploaded on hackage and is installable using cabal. After the installation of gtk2hs, you can install it by simply typing > cabal install hoodle As a default, pdf annotation is turned off, but if you have installed poppler, then you can install hoodle with pdf-annotation function by typing > cabal install -fpoppler hoodle-render hoodle-core hoodle Hoodle Homepage is http://ianwookim.org/hoodle Have fun with hoodle! Thanks. best, Ian-Woo Kim

1 0

Kernel Loops in Accelerate
by Clark Gaebel 13 Dec '12

13 Dec '12

Hi Trevor (and cafe), I've been playing more and more with accelerate, and I find it quite annoying that there are no loops. It makes implementing many algorithms much harder than it should be. For example, I would love to submit a patch to fix issue #52 [0] on github by implementing MWC64X [1], but it's very hard to port the OpenCL code on that page when it's impossible to write kernel expressions with loops. Also, that means there are no high-level combinators I'm used to for my sequential code (such as map and fold) that would work on an accelerate CUDA kernel. As a nice strawman example, how would one implement the following kernel in accelerate, assuming 'rand_next', 'rand_get', and 'rand_skip' can all be implemented cheaply? : typedef uint64_t rand_state; __device__ rand_state rand_next(rand_state s); __device__ uint32_t rand_get(rand_state s); __device__ rand_state rand_skip(rand_state s, uint64_t distance); __device__ uint32_t round_to_next_pow2(uint32_t n); // Fills an array with random numbers given a random seed, // a maximum random number to generate, and an output // array to put the result in. The output will be in the range // [0, rand_max). __kernel__ void fill_random(rand_state start_state, uint32_t rand_max, uint32_t* out) { rand_state current_state = start_state; int i = blockDim.x*blockIdx.x + threadIdx.x; // assumes we skip less than 1 million times per element... current_state = rand_skip(current_state, i*1e6); uint32_t mask = round_to_next_pow2(rand_max) - 1; uint32_t result; do { result = rand_get(current_state); current_state = rand_next(current_state); } while(result & mask >= rand_max); out[i] = result; } // note: code was neither debugged, run, nor compiled. Thanks, - Clark [0] https://github.com/AccelerateHS/accelerate/issues/52 [1] http://cas.ee.ic.ac.uk/people/dt10/research/rngs-gpu-mwc64x.html

2 2

Control.bimap?
by Gregory Guthrie 13 Dec '12

13 Dec '12

I found a nice idiom for a graph algorithm where the pairs of nodes representing links could be merged into node lists by something like: ns = nub $ map fst g --head nodes ne = nub $ map snd g -- tail nodes And found a nicer approach: (ns,ne) = (nub***nub) unzip g Or perhaps: (ns.ne) = bimap nub nub $ unzip g -- from Control.Bifunctor The SO reference I saw described bimap as a way to map a function over a pair, and it seemed like a great match, but I cannot find the bimap function, and cabal reports no package Control.Bifunctor. ?? -------------------------------------------------------

4 5

Yesod double free or corruption
by Andras Gyomrey 12 Dec '12

12 Dec '12

Hi, i got the following error using "yesod devel" it happened after adding the file which seems to have invalid content (not true). What should i do? Andras Gyomrey

2 1

reviving HaNS (haskell network stack)
by Carter Schonwald 12 Dec '12

12 Dec '12

Hey All, I noticed that the really cool HaNS work (a mostly pure HS + bits of C networking stack) seems to have languished for quite some time, and the absence of a publicly visible repo certainly doesnt help! accordingly, i've taken the most recent code snapshot from the galois archive repo and created a copy on github! https://github.com/cartazio/HaNS I'll be having a go at trying to get things to build on ghc 7.6 + seeing about doing travisCI integration over the next few days, but if anyone else might be interested in helping out, that'd be welcome! cheers -Carter

1 1

Large, numerical calculations in Haskell
by Emil Hedevang 12 Dec '12

12 Dec '12

Hi Haskell Cafe, I need to perform very large numerical computations requiring tens of GB of memory. The computations consist essentially of generation of random numbers and discrete convolutions of large arrays of random numbers with somewhat smaller kernel arrays. Should I use Haskell and call some C libraries when necessary? Should I just write everything in C? Or should I use e.g. Chapel (chapel.cray.com)? To be more specific, a very large array X is filled with random numbers drawn independently from some distribution. Then, the discrete convolution Y = K * X of X with a somewhat smaller kernel array K is calculated. Typical sizes of X and K could be 1000 x 1000 x 1000 and 100 x 100 x 100, respectively. The storage of X alone requires 8 GB of memory. Luckily I have recently been blessed with a well-equipped workstation with 128 GB RAM and two 8-core Xeon E5-2650 running at 2.0 GHz. I see immediate opportunities for parallelism. Firstly, parallel random number generators could be employed to populate the array X (e.g. SPRNG). Secondly, since the size of the kernel K is much smaller than the size of the array X, the discrete convolution can split into several smaller convolutions (see e.g. Kim and Strintzis (1980)). Finally, the discrete convolutions can be computed efficiently using Fourier methods (using e.g. FFTW). It seems fairly straightforward to implement it all in C, perhaps with some OpenMP pragmas scattered around in the code, since the heavy numerics would be performed in preexisting libraries (SPRNG and FFTW), I would like to use Haskell, since I like Haskell and find it tremendously fascinating, but I will not use it for the sake of just using it. I am willing to pay a small price in terms of performance, say, twice the run time, if I in turn will get more convenience and less suffering while coding. Therefore, would you claim it to be feasible to use Haskell? I suppose it very much depends on the quality of the Haskell FFI bindings to parallel random number generators and fast Fourier transforms. Unfortunately, I find it difficult to assess these qualities. Best regards, Emil Hedevang

3 3

How is default method signatures supposed to be used together with Generics
by Johan Tibell 12 Dec '12

12 Dec '12

Hi, I noticed that you're not required to export the types mentioned in the default method signature. For example, you could have: default hashWithSalt :: (Generic a, GHashable (Rep a)) => Int -> a -> Int hashWithSalt salt = ghashWithSalt salt . from and not export the GHashable class. However, if users try to define an instance of Hashable but forget to derive Generic: data Foo a = Foo a String deriving (Eq) -- Oops, forgot Generic here instance (Hashable a) => Hashable (Foo a) they get a pretty bad error message: Test.hs:10:10: Could not deduce (Generic (Foo a), Data.Hashable.Class.GHashable (GHC.Generics.Rep (Foo a))) arising from a use of `Data.Hashable.Class.$gdmhashWithSalt' from the context (Hashable a) bound by the instance declaration at Test.hs:10:10-41 Possible fix: add (Generic (Foo a), Data.Hashable.Class.GHashable (GHC.Generics.Rep (Foo a))) to the context of the instance declaration or add instance declarations for (Generic (Foo a), Data.Hashable.Class.GHashable (GHC.Generics.Rep (Foo a))) In the expression: (Data.Hashable.Class.$gdmhashWithSalt) In an equation for `hashWithSalt': hashWithSalt = (Data.Hashable.Class.$gdmhashWithSalt) In the instance declaration for `Hashable (Foo a)' Exporting GHashable would help a little bit in that users would at least know what this GHashable class that the error talks about is. What's best practice? -- Johan

3 4