- Haskell-Cafe - Haskell.org

Generics for constructing Rows
by Max Desyatov 20 Aug '09

20 Aug '09

Sorry for a type and probably confusing you, it must be: > readRow l = gmap (\(Left (Just ri)) -> Right $ l `atMay` ri >>= readMay) instead of > l `atMay` c

1 0

Planning for a website
by Colin Paul Adams 20 Aug '09

20 Aug '09

I'm intending to replace my current website - which uses Drupal, with a hand-written-in-Haskell version this autumn, for a number of reasons (a principal one is the lack of an upgrade path in Drupal). So I'm currently looking into the libraries available to see how much I'll have to write myself. One problem will be to get GHC ported to DragonFly BSD, but that can wait until I have a test version of the site working on Linux. The next major challange is to implement something like Drupal's Image and Image Gallery modules. That doesn't seem to be a great problem, as the exif and GD libraries seem to cover everything I'll need. So my major decision is what framework and html-generating libraries to use. There is such a wide choice on the Haskell Wiki. But I guess some are more maintained than others. For instance, WASH attracts me, with it's guarantee of valid generated pages, but it isn't clear to me that it's actively maintained (last date I can see on the web pages is 2006). HappStack is obviously currently maintained, and since it seems to have a blogging module in development, that is attractive. HASP is maintained too, I think. Has anyone written a comparison of the various libraries, or gone through the same decision process recently? -- Colin Adams Preston Lancashire

8 11

Control.Parallel on 6.10.4 - Mac OS X version
by Kevin Smith 20 Aug '09

20 Aug '09

I'm using the Control.Parallel package on ghc version 6.10.4 and I don't seem to be getting any parallel threads or sparks created at all with the "-threaded" compilation option using runtime flags "+RTS -N2". I'm using simple examples from the paper "A Tutorial on Parallel and Concurrent Programming in Haskell" by Jones and Singh. I'm running on an Intel Mac core 2 duo. Does anyone know how I can check if the parallel functionality in ghc is working on my 6.10.4 ghc package installed on this platform ? I installed it from the "supported" runtime pkg for OS X from the ghc website. thanks

2 2

Re: [Haskell-cafe] gbp sign showing as unknown character by GHC
by Iain Barnett 19 Aug '09

19 Aug '09

2009/8/19 David Leimbach <leimy2k(a)gmail.com> > Interesting... GHCI bug? Didn't the readline dependency go away not too > long ago? Could it be related? > I just tried this Prelude> putStrLn "\£" ghc: panic! (the 'impossible' happened) (GHC version 6.10.4 for i386-unknown-linux): charType: '\163' Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug So perhaps I should put in a bug report, as that shouldn't happen (it doesn't with some other characters I tried), unless anyone has a different idea? I'm running Arch Linux with xmonad and using roxterm, so perhaps it's something to do with my setup? Iain

4 4

Observations about foldM
by Jason McCarty 19 Aug '09

19 Aug '09

[This message is literate Haskell] Hi -cafe, I was trying to use Monad.foldM in the State monad recently and ran into some performance issues. They were eventually fixed with seq, but along the way I made some discoveries, which I thought I would share. The Report defines foldM as foldM :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a foldM f z [] = return z foldM f z (x:xs) = f z x >>= \z' -> foldM f z' xs It turns out that foldM is essentially a right fold. Define f' = \h t -> flip f h >=> t. The operator (>=>) is (reverse) Kleisli composition, defined in Control.Monad as f >=> g = \x -> f x >>= g. Now foldM f z xs = foldr f' return xs z. Proof. On the empty list, foldM f z [] = return z [definition of foldM] = foldr f' return [] z [definition of foldr] Now fix a list xs and inductively assume that foldM f z xs = foldr f' return xs z for all z. Then for any z and x, foldM f z (x:xs) = f z x >>= \z' -> foldM f z' xs [definition of foldM] = f z x >>= \z' -> foldr f' return xs z' [inductive hypothesis] = f z x >>= foldr f' return xs [eta-conversion(*)] = flip f x z >>= foldr f' return xs [definition of flip] = (\z' -> flip f x z' >>= foldr f' return xs) z [beta-reduction] = (flip f x >=> foldr f' return xs) z [definition of >=>] = (f' x (foldr f' return xs)) z [definition of f'] = foldr f' return (x:xs) z [definition of foldr] (*) The eta-conversion preserves strictness as long as return /= _|_, since f >=> g is in WHNF. Interestingly, foldM can also be written as a left fold. To see this, note that it is a theorem that foldr f z xs = foldl f z xs as long as f is associative and z is a unit for f. Since (>=>) is associative with unit return, we have foldr (\h t -> flip f h >=> t) return = foldr (>=>) return . map (flip f) [foldr/map fusion] = foldl (>=>) return . map (flip f) [by the theorem] = foldl (\t h -> t >=> flip f h) return [foldl/map fusion] Therefore foldM f z xs = foldr f' return xs z = foldl f'' return xs z, where f'' = \t h -> t >=> flip f h. But this doesn't mean these all have the same performance characteristics. Exercise for the reader: find examples where the foldr version performs better than the foldl version and vice-versa. I've noticed this distinction between State and [] in particular. They both may require use of seq in the function f to prevent stack overflow. Here is a module implementing these versions of foldM. It seems reasonable to have versions with <=< and with f unflipped as well, but those could be derived from the functions below. > module FoldM (foldrM, foldr1M, foldlM, foldl1M) where > import Control.Monad((>=>)) > -- foldrM nests to the right: > -- foldrM f z [x1, ..., xn] = (flip f x1 >=> (... >=> (flip f xn)...)) $ z > foldrM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a > foldrM f z xs = foldr (\h t -> flip f h >=> t) return xs z Surprisingly, this may or may not be faster than the equivalent foldrM f z = return z >>= foldr (\h t -> flip f h >=> t) return xs depending on the monad. But they're both slower than foldM. > foldr1M f (x:xs) = foldrM f x xs > -- foldlM nests to the left: > -- foldlM f z [x1, ..., xn] = (...(flip f x1) >=> ...) >=> flip f xn) $ z > foldlM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a > foldlM f z xs = foldl (\t h -> t >=> flip f h) return xs z Again, this is apparently faster or slower than either of foldlM f z xs = return z >>= foldl (\t h -> t >=> flip f h) return xs foldlM f = foldl (\t h -> t >>= flip f h) . return depending on the monad. > foldl1M f (x:xs) = foldlM f x xs -- Jason McCarty <jmccarty(a)sent.com>

5 5

ANN: Typeful/Text/HTMLs (for AngloHaskell/for scrap?)
by Jon Fairbairn 19 Aug '09

19 Aug '09

A while ago I wrote this rather pedantic html library (it guarantees standards compliance via types, even down to the nesting restrictions). I announced it on the libraries list, but chronic fatigue gets in the way of following things up, so I haven't taken it any further until recently. And recently there have been other efforts in the HTML area that may make it out of date. Anyway, I think there are one or two useful ideas in it, and if I manage to get to AngloHaskell, I'd like to discuss it a bit, hence the announcement (rather closer to AH than I intended). You can get the whole thing with darcs get --partial http://homepage.ntlworld.com/jon.fairbairn/Typeful/Text/nHTMLs It should build with ghc 6.10 and haddock 2.4.2 or you can browse the documentation starting at <http://homepage.ntlworld.com/jon.fairbairn/Typeful/Text/HTMLs/Documentation…> and AngloHaskell people who are interested might want to look at <http://homepage.ntlworld.com/jon.fairbairn/Typeful/Text/HTMLs/TODO> -- Jón Fairbairn Jon.Fairbairn(a)cl.cam.ac.uk

2 4

Where do I put the seq?
by Peter Verswyvelen 19 Aug '09

19 Aug '09

In an attempt to get a deeper understanding of several monads (State, ST, IO, ...) I skimmed over some of the research papers (but didn't understand all of it, I lack the required education) and decided to write a little program myself without using any prefab monad instances that should mimic the following: main = do putStrLn "Enter your name:" x <- getLine putStr "Welcome " putStrLn x putStrLn "Goodbye!" But instead of using IO, I wanted to make my own pure monad that gets evaluated with interact, and does the same. However, I get the following output: Enter your name: Welcome ...... So the Welcome is printed too soon. This is obvious since my monad is lazy, so I tried to put a seq at some strategic places to get the same behavior as IO. But I completely failed doing so, either the program doesn't print anything and asks input first, or it still prints too much output. Of course I could just use ST, State, transformers, etc, but this is purely an exercise I'm doing. So, I could re-read all papers and look in detail at all the code, but maybe someone could help me out where to put the seq or what to do :-) The code is at http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316 Oh btw, the usage of DList here might not be needed; intuitively it felt like the correct thing to do, but when it comes to Haskell, my intuition is usually wrong ;-) Thanks a lot, Peter Verswyvelen

2 7

Hugs used in circuit simulations code
by Fernan Bolando 19 Aug '09

19 Aug '09

Hi all thanks to everyone that reviewed my code. The good news 1. I happy to say that it has become useful enough for me to use it in some matlab type caluculations. includes transient and dc op 2. The simple pivtoing code I added into the DSP Lu appears to be useable for this application. The bad news 1. If you dont use some strategy in simplifying circuits and use the simulator only, it would take a considerable amount of time to converge. A simple 10x10 non linear matrix will take 13 minutes. In a high-end circuit simulator this would have taken less than a second. What is everybodies expereience in speed difference between C and interpreted haskell? I am hoping to achieve at least 10x an equivalent C code. So if a 10x10 matrix takes 1 second for C I want it to take 10seconds for hugs. regards fernan -- http://www.fernski.com

4 4

Some trouble with AttoParsec.
by Jason Dusek 19 Aug '09

19 Aug '09

The linked to text demoes a seemingly impossible error when processing a lazy byte string with AttoParsec: I check to see if the ByteString is null, take the last character and get an exception. -- Jason Dusek http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8309#a8309

1 2

Type family signatures
by Thomas van Noort 19 Aug '09

19 Aug '09

Hello, I have a question regarding type family signatures. Consider the following type family: type family Fam a :: * Then I define a GADT that takes such a value and wraps it: data GADT :: * -> * where GADT :: a -> Fam a -> GADT (Fam a) and an accompanying unwrapper: unwrap :: GADT (Fam a) -> (a, Fam a) unwrap (GADT x y) = (x, y) When Fam is declared using the first notation, type family Fam a :: * GHC HEAD gives the following error message: Main.hs:9:21: Couldn't match expected type `a' against inferred type `a1' `a' is a rigid type variable bound by the type signature for `unwrap' at Main.hs:8:20 `a1' is a rigid type variable bound by the constructor `GADT' at Main.hs:9:8 In the expression: x In the expression: (x, y) In the definition of `unwrap': unwrap (GADT x y) = (x, y) However, when Fam is declared as (moving the a to the other side of the :: and changing it into *), type family Fam :: * -> * everything is ok. So, it seems to me that GHC HEAD considers both signatures to be really different. However, I do not quite understand the semantic difference in my example, other than that Fam needs to be fully satisfied in its named type arguments. Note that GHC 6.10.3 does not accept the latter signature for Fam since it requires at least one index for some reason, that's why I'm using GHC HEAD. Regards, Thomas

5 7