July 2007 - Haskell-Cafe

Re: Re[4]: [Haskell-cafe] Newbie question about tuples
by Peter Verswyvelen 22 Jul '07

22 Jul '07

Thanks Bulat, but now you scattered my hopes that GHC would magically do all these optimizations for me ;-) I must say that although the performance of Haskell is not really a concern to me, I was a bit disappointed that even with all the tricks of the state monad, unboxing, and no-bounds-check, the matrix-vector multiplication was still 7 to 8 times slower than the C version. And at the end of the paper, it's only a factor 4 slower. Okay, going from 300x slower to 4x slower is impressive, but why is it *still* 4x slower? It would be interesting to compare the assembly code generated by the C compiler versus the GHC compiler; after all, we're just talking about a vector/matrix multiplication, which is just a couple of lines of assembly code... And now I'm again talking about performance, nooo! ;-) >http://www.cse.unsw.edu.au/~chak/papers/afp-arrays.ps.gz

3 8

[OT] Install ghc6-doc fails
by J. Pablo Fernández 22 Jul '07

22 Jul '07

Hello, This may be a bit off topic, but maybe someone here has importante related information. I am running Kubuntu, the lattests stable version, but I am running unstable Haskell packages, that is, I fetch the dsc, diff and tarballs and build the debs myself of what will come in the next version of Kubuntu. So I have the advantage of running recent versions, and at the same time, keeping packages (which come usefull when I want to remove everything, or when mainstream software is too weird). But, installing the ghc6-doc packages gives me this error: (Reading database ... 156024 files and directories currently installed.) Preparing to replace ghc6-doc 6.6.1-2 (using ghc6-doc_6.6.1-2_all.deb) ... Unpacking replacement ghc6-doc ... Setting up ghc6-doc (6.6.1-2) ... haddock: Warning: The interface file "base/base.haddock" could not be read. Maybe it's from a later version of Haddock? haddock: Warning: The interface file "Cabal/Cabal.haddock" could not be read. Maybe it's from a later version of Haddock? haddock: Warning: The interface file "filepath/filepath.haddock" could not be read. Maybe it's from a later version of Haddock? haddock: Warning: The interface file "parsec/parsec.haddock" could not be read. Maybe it's from a later version of Haddock? haddock: Warning: The interface file "readline/readline.haddock" could not be read. Maybe it's from a later version of Haddock? haddock: Warning: The interface file "regex-base/regex-base.haddock" could not be read. Maybe it's from a later version of Haddock? haddock: Warning: The interface file "regex-compat/regex-compat.haddock" could not be read. Maybe it's from a later version of Haddock? haddock: Warning: The interface file "regex-posix/regex-posix.haddock" could not be read. Maybe it's from a later version of Haddock? haddock: Data.Binary.getWord8: end of file dpkg: error processing ghc6-doc (--install): subprocess post-installation script returned error exit status 1 Errors were encountered while processing: ghc6-doc I am running the lattest haddock (0.8), so the problem might be something else. Any ideas what the problem might be? Thank you. -- J. Pablo Fernández <pupeno(a)pupeno.com> (http://pupeno.com)

1 1

Re: [Haskell-cafe] Haskell & monads for newbies
by Andrew Coppin 21 Jul '07

21 Jul '07

Peter Verswyvelen wrote: > Ouch, I should not have brought up these monads again! I should have known better ;-) > Mmm... ;-) > I hope the Haskell community understands that for outsiders / newbies who want to learn or just look at Haskell and then do some Googling, all this monad talk looks a bit euh "strange"? Yeah. I spent time on another forum trying to explain Haskell. I wrote a fifty-mile long post that's basically a complete beginner's introduction to the language. Every reply was of the form "wow, did you write all that yourself? That's really good! You should write stuff for a living... Haskell sounds kinda cool, but... monads look very hard, and basically everything I write programs for is mainly about I/O..." I'm sure others have seen something similar... > Maybe in the next version of Haskell monads should be called something different SPJ suggested "warm fuzzy thing". ;-) > and then all these tutorials and discussions about monads will then be silently forgotten over time ;-) > Oh, I don't know about that... (I for one still haven't figured out how to work monad transformers, for example. And they look useful...)

9 15

how can I call GHC.init and GHC.initPackages?
by Vadim 21 Jul '07

21 Jul '07

Hi all, The following lines of code: import GHC main :: [PackageIdentifier] -> IO () main pkgs = GHC.defaultErrorHandler defaultDynFlags $ do GHC.init (Just GHC_LIBDIR) interactive pkgs seemingly worked in GHC 6.6 but they do not work in 6.6.1 anymore with error message: [1 of 1] Compiling Hide.Hide ( src/Hide/Hide.hs, dist/build/Hide/Hide.o ) src/Hide/Hide.hs:34:9: Not in scope: `GHC.init' src/Hide/Hide.hs:44:18: Not in scope: `GHC.initPackages' ******************** setup build failed for packages/baseApp Thanks for any help on the subject. Vadim.

1 0

gui libs? no thanks, i'm just browsing.. ;-)
by Claus Reinke 21 Jul '07

21 Jul '07

gui libs are wonderful, but haskell sometimes has too few and sometimes has too many. and those we have do not work with every haskell implementation. and when they do work (usually with ghc, these days), they need to be rebuilt whenever ghc is updated, even if the gui lib hasn't changed at all (one gui lib binding per ghc version). still, we put up with that when we need all those gui lib features, because we have to, and we're happy to live in one of those periods when there are such bindings to full-featured gui libraries. but what about quick and dirty/cheap and cheerful graphics? over the years, HGL/SOEGraphics has served as a persistent reminder that things keep changing, and that when they do, something breaks. even if all people want to do is draw some simple graphics, or animations. i don't have a solution, but i'd like to throw another alternative into the ring, based on the ongoing fight between web browsers and other guis for world dominance.. the idea is well known: build your app as a server, and put an ajax-based gui in front of it, even if server and browser run on the same machine. attached is a silly quick&dirty demo of some of the relevant concepts, including a fake haskell http-server, an html/canvas/httprequest/ javascript-based gui, and some simple graphics/buttons/text. tested on windows, with opera 9.01 and ghc 6.6.1. it will probably not work with other browsers, but it should work with opera on other platforms, or with other haskell implementations supporting Network. (you might have to hardcode the file name at the top of the source if not using ghc; to make it work with other browsers, you need workarounds for standard browser incompatibilities) to run, load Canvas.hs into ghci and call main. then start up opera, and visit 'http://localhost:8000/start' (to change that port number, change both 'main' in the haskell source, and 'get' in the html source). that should yield an html page with further instructions. have a look, and please let me know if it works on your os/ haskell implementation, and what you think about the idea. i won't do it myself, but perhaps someone could code up SOEGraphics based on this?-) and if not, this might still help out some of you who need simple low-overhead guis (things can get hairy very quickly if you need more than simple guis)? some of you might have to fight through implementing browser- based guis for their day jobs anyhow, but may want to put haskell behind those guis; or you might find haskell prototyping an easier sell, if the gui can be reused for the "real" implementation.. claus further reading/download: Opera browser (windows, macos, solaris, linux, ..) http://www.opera.com/download/ html 5 -- working draft, june 2007 (3.14.11 canvas element) http://www.whatwg.org/specs/web-apps/current-work/#the-canvas canvas tutorial http://developer.mozilla.org/en/docs/Canvas_tutorial http://developer.mozilla.org/en/docs/Drawing_Graphics_with_Canvas

7 15

Re: Haskell-Cafe Digest, Vol 47, Issue 189
by Kyle L Bittinger 20 Jul '07

20 Jul '07

I wrote a short perl script to convert literate Haskell emails into pdf's. It requires lhs2TeX and pdflatex and might not work on Windows. You can darcs get http://rwf.mit.edu/~kyle/src/lhs-email/ I've tested it on a couple of articles from Oleg's FTP site - the source and pdf output are in the folder above (not checked into darcs). I wrote this in a few hours because I (personally) have trouble reading long articles in fixed-width fonts. I also like to print the longer emails to study offline. BE WARNED that this is written in hacked-up-outofcontrol-line-noise perl, so don't look at the source if that gives you seizures. The script might be tangentially related to this thread: http://thread.gmane.org/gmane.comp.lang.haskell.cafe/18020/focus=18020 --Kyle

1 0

Producing MinimumValue
by Alexteslin 20 Jul '07

20 Jul '07

Hello, I am trying to define a function as part of the exercises that gives a result of a minimum value of the input list of ints. Such as this: minimumValue :: [Int] -> Int minimumValue ns ... using either filter or map functions but Not foldr1, because the exercise precedes the section on foldr1. I am confused because using filter - it generates a list on some constraint function for each element. Any hints will be very appreciated. Thank you -- View this message in context: http://www.nabble.com/Producing-MinimumValue-tf4106379.html#a11677240 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

14 27

List minimum - performance question
by Dusan Kolar 20 Jul '07

20 Jul '07

Hello all, Inspired by exercise on the minimal value of a given list I tried myself produce several versions of such a function: exercise: using just ($), head, filter, null, id, map, (<) without explicit recursion definition direct-forward: direct implementation using forward recursion, if-then-else, (<) direct-backward: direct implementation using backward recursion, if-then-else, (<) foldl: using foldl, lambda abstraction, if-then-else, (<) foldr: using foldr, lambda abstraction, if-then-else, (<) From a recursion point of view, I see a similarity between direct-forward and foldl. Of course, the same similarity is between direct-backward and foldr. Am I right? If yes, then there is something strange in the results I have gained (see below). I did my measurements in winhugs (Version: Sep 2006) for lists of length 10, 100, 1000 and 50 elements. I tested on list with the same constant, list where the first number is minimal (these two cases are from this point of view similar/the same), lists, where some element in the "middle" is minimal, and finally lists, where the last element is the minimal one. As for constant and first minimal element list I got the same result, we can join them and have just three categories of lists, let's call them first, mid, last. Even if I know that using number of reductions and number of cells does not provide exact results, I assume that impact of parameter and printing of the result is the same for all tested functions and is either constant for the result printing (always number 1 in the result) and at most linear in the parameter processing (I would assume no direct impact here, just algorithm influence, is that right?). Thus, the results may be compared. First of all, the time/reduction complexity (n is a length of the list): first mid last exercise 9n+34 <not evaluated> 4.5n^2+21.5n+17 direct-forward 7n+15 7n+15 7n+15 direct-backward 7n+15 7n+15 7n+15 foldl 8n+14 8n+14 8n+14 foldr 8n+14 8n+14 8n+14 There is nothing special on the results, the exercise solution was not evaluated for the middle element lists as the position of the minimal value in the list is a parameter of the function. Now, let me show results for number of used cells: first mid last exercise 10n+54 <not evaluated> 5n^2+29n+26 direct-forward 8n+24 8n+25 9n+23 direct-backward 9n+22 9n+22 9n+22 foldl 11n+22 11n+22 11n+22 foldr 10n+23 10n+23 10n+23 Again, roughly looking at the results, there is nothing special, average space complexity is as it may be expected. Looking at the exact formulas, there are two things that come strange to me: 1) From a recursion point of view, there are pairs direct-forward ~ foldl and direct-backward ~ foldr. Nevertheless, from a space consumption point of view, this doesn't hold and the pairs are swapped. Why? Is this a winhugs specialty? Is this due to reduction strategy? Laziness? 2) Direct-forward implementation provides three different formulas. Why? Why the mid formula is fixed no matter where the minimal value is? Thanks for any answers/hints/references. Especially, if this is RTFM one. ;-) Dusan P.S. I know, that sources may be helpful, but as this is an exercise I don't want to provide them directly to the list. ;-) But I can provide them, of course. :-)

1 0

Maintaining the community
by dons＠cse.unsw.edu.au 19 Jul '07

19 Jul '07

As we sit here riding the Haskell wave: http://www.cse.unsw.edu.au/~dons/tmp/cafe.png with nearly 2000 (!) people reading haskell-cafe@, perhaps its time to think some more about how to build and maintain this lovely Haskell community we have. Just yesterday I received an email: "I posted it to Haskell-Cafe and received loads of brilliant responses. Wow, those guys are awesome. I'm definitely going to learn Haskell now." Which is *exactly* the kind of (view of the) community we want to build and encourage, so we can keep the Haskell project growing into the future. I think the main thing we need to remember is to help train new experts in the community, to be fluent in the culture, ensuring that expertise and a knowledge of the culture diffuses through the new people arriving. That is, to help people progress from newbie, to intermediate, to expert, and thus ensure the culture is maintained (avoiding `Eternal September'). This graphic[1] sums the main issue up nicely, in my view: http://headrush.typepad.com/photos/uncategorized/buildingausercommunity.jpg And the steps to follow (people can think about how best they apply to them) (also from [1]): * Encourage newer users--especially those who've been active askers--to start trying to answer questions We're pretty good with this, but we can be *explicit* about it. If you're taking a lot from the community, please put a lot back in (in terms of writing about it, contributing answers, new libraries, and so on). I note this is also exactly what the Summer of Code helps do too -- we've had several people paid to progress from newbie to expert, thanks to the SoC. * Give tips on how to answer questions Answering politely, and in detail, explaining common misunderstandings is better than one word replies. * Adopt a near-zero-tolerance "Be Nice" policy when people answer questions We are very good here already, both on email and IRC. * Teach and encourage the more advanced users (including moderators) how to correct a wrong answer while maintaining the original answerer's dignity. This is hard, perhaps people can think some more about this. * Re-examine your reward/levels strategy for your community This is also important: on the IRC channel we actually use participation data (http://www.cse.unsw.edu.au/~dons/irc/haskell-07.html) to determine who gets moderator privledges. For the community in general, rewards are along the lines of "going to the hackathon", "becoming the domain expert for some library". Cheers and happy hacking, Don [1]. http://headrush.typepad.com/creating_passionate_users/2006/12/how_to_build_…

45 111

Type hacking help
by Chris Smith 19 Jul '07

19 Jul '07

I've just written my first real piece of type system hacking in Haskell. I think it turned out okay, but if any of you more experienced folk have suggestions, I'd appreciate them. Code follows. More explanation is at http://cdsmith.wordpress.com/2007/07/19/parsing-cfgs-and-type-hacking/ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE NoMonomorphismRestriction #-} data Var a = Var String data RHS a b = RHS a b (&) = RHS -- a convenient operator infixr 5 & {- (Action a b c) means the following: A production with a right hand side of type: a may be associated with a semantic rule of type: b to produce a rule with semantic result type: c -} class Action a b c | a b -> c, a c -> b instance Action (Var x) (x -> y) y instance Action Char y y instance Action () y y instance (Action a b c) => Action (RHS (Var x) a) (x -> b) c instance (Action a b c) => Action (RHS Char a) b c {- The RuleSet monad is used to define rules of a grammar in a convenient 'do' notation. -} data Rule = forall a b c. (Action a b c) => Rule (Var c, a, b) data RuleSet x = RuleSet ([Rule], x) instance Monad RuleSet where a >>= k = let RuleSet (r1, v1) = a RuleSet (r2, v2) = k v1 in RuleSet (r1 ++ r2, v2) return x = RuleSet ([], x) (==>) :: (Action a b c) => Var c -> a -> b -> RuleSet () (==>) lhs rhs sem = RuleSet ([Rule (lhs, rhs, sem)], ()) infixr 4 ==> {- Grammar. A grammar is a set of rules together with a start symbol. -} data Grammar a = Grammar (Var a) [Rule] grammar s (RuleSet (rs, x)) = Grammar s rs {- Sample grammar. The parentheses in the let bindings are required: they force the rules to be monomorphic, which is needed for type checking to work properly. -} g = let ( expr ) = Var "expression" ( term ) = Var "term" ( termmore ) = Var "term operator" ( fact ) = Var "factor" ( factmore ) = Var "factor operator" ( digit ) = Var "digit" ( digits ) = Var "digits" in grammar expr $ do expr ==> term & termmore $ \x y -> y x termmore ==> () $ \x -> x termmore ==> '+' & term & termmore $ \x y z -> y (x + z) termmore ==> '-' & term & termmore $ \x y z -> y (x - z) term ==> fact & factmore $ \x y -> y x factmore ==> () $ \x -> x factmore ==> '*' & fact & factmore $ \x y z -> y (x * z) factmore ==> '/' & fact & factmore $ \x y z -> y (x / z) fact ==> '(' & expr & ')' $ \x -> x fact ==> digit & digits $ \x y -> y x digits ==> () $ \x -> x digits ==> digit & digits $ \x y z -> y (10*x + z) digit ==> '0' $ 0 digit ==> '1' $ 1 digit ==> '2' $ 2 digit ==> '3' $ 3 digit ==> '4' $ 4 digit ==> '5' $ 5 digit ==> '6' $ 6 digit ==> '7' $ 7 digit ==> '8' $ 8 digit ==> '9' $ 9 Thanks, -- Chris Smith

1 0