August 2009 - Haskell-Cafe

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

Text.Html introduction
by Colin Paul Adams 19 Aug '09

19 Aug '09

http://www.haskell.org/ghc/docs/latest/html/libraries/xhtml/Text-XHtml.html says: "Based on the original Text.Html library by Andy Gill. See http://www.cse.ogi.edu/~andy/html/intro.htm for an introduction to that library. " But that link gives a not-found page. Anyone know where it is know? -- Colin Adams Preston Lancashire

4 3

simulation in the haskell way
by Eric Wong 19 Aug '09

19 Aug '09

Hello, Haskellers! I'm relatively new to haskell and due to my strong imperative background, it's really a pain to learn haskell. But I'm really indulged in it. :) Now I think I understand the basics of Haskell very well, such as the type system and monad. And for those data-flow kind of applications, I can easily structure the problem in a functional way and sketch out an intuitive picture of the computation. But for simulation kind-of problems, in which I think OO really fits the best, what's the haskell way to structure such problems? I once thought maybe I can use the State monad to simulate objects. But it's really hard for me to implement, because I think State monad is used to simulate a global shared state, is it right? Then what's the best way to simulate private states or just instead how to solve simulation problems such as a physical engine using the haskell way? Best regards. Eric

9 17

Re: [Haskell-beginners] Start file with associated prog (windows only?)
by Max Desyatov 18 Aug '09

18 Aug '09

Bernhard Lehnert <b.lehnert(a)gmx.de> writes: >> Windows has a command "start" which you can use e.g. via System.Process.proc. > > Thank you, Magnus - this is exactly what I was looking for. (By the way, > someone should implement something like this for GNOME and KDE, > too ;-) ) You can do that using MIME, look at /etc/mailcap, it already contains all what you need to run appropriate process for exact MIME-type. As long as it's supported in your distribution.

2 1