- Haskell-Cafe - Haskell.org

[OT] A nice organized collection of threads in Haskell-Cafe
by Vimal 11 Dec '07

11 Dec '07

Hi, I am working on a product to analyze posts made in Forums, Usenet and discussion mailing lists like Haskell-Cafe. For this, I require the messages to be accessible in this format: <forum> (* example: Haskell-cafe *) [ list of - <thread> [ list of - <post> </post> ] </thread> ] </forum> as XML. However, I find that that the messages (in haskell-cafe/usenet) themselves aren't organized in this fashion. I would like to know if there is any way in which I can get the archives in this fashion. Thanks, -- ~Vimal RLE :) encode = map (length &&& head) . group decode = concatMap (uncurry replicate)

6 12

RE: [Haskell] Nested guards?
by Simon Peyton-Jones 11 Dec '07

11 Dec '07

[redirecting to Haskell Cafe] | > It is clear that this situation must not stay this way. Bit by bit, | > disciples of Perl and Python discover Haskell and demand that Haskell will | > be plastered with syntactic sugar until the simplicity of the functional | > approach isn’t visible anymore. Sadly, they seem to be successful with this | > as syntax extensions like parallel list comprehensions show. I think it is helpful to distinguish "superficial" complexity from "deep" complexity. All of Haskell's syntactic sugar is just that: it can be translated into a small purely-functional language using straightforward translation schemes. Even something relatively complicated like the "order by/group by" extension that Phil and I proposed at this year's Haskell workshop, has an easy translation that takes a dozen or two lines to give in full detail. In contrast, something like higher order functions, or mutable state, is deep complexity. Both have a pervasive effect on the language semantics and on its implementation. (The effect of mutable state is much, much worse, but they are both deep.) Concerning Haskell, I'm quite relaxed about superficial complexity, as you'll have seen from what happens in GHC. Section 3.6 of the History of Haskell paper addresses this point specifically [1]. You may disagree with the choice made by the Haskell committee at the time, and with subsequent developments, but it was quite a conscious choice, and one not without its advantages. Simon [1] http://research.microsoft.com/%7Esimonpj/papers/history-of-haskell/history.…

7 9

What is the role of $!?
by PR Stanley 11 Dec '07

11 Dec '07

Hi What is the role of $! ? As far as I can gather it's something to do with strict application. Could someone explain what it is meant by the term strict application please? Thanks, Paul

20 26

Software Tools in Haskell
by Tommy McGuire 10 Dec '07

10 Dec '07

In the "if anyone is interested,..." department.... For reasons that remain unclear, early this fall I started translating Brian W. Kernighan and P.J. Plaugher's classic _Software Tools in Pascal_ into Haskell. I have completed most of it, up to the second part of chapter 8 which presents a proto-m4 preprocessor. I have the code online including notes, comments, descriptions, and a few alternate approaches. Attractions include: * A fair gamut of the usual Unix suspects: proto-cat, proto-wc, proto-tr, proto-compress, proto-ar, proto-grep, etc. * A usable editor, if you consider a de-featured ed-alike to be usable. * A simple monadic regular expression engine. * Zippers, Parsec, the State monad, the StateT monad transformer, and other attempts to sully Computing Science's brightest jewels. * Lots and lots of really bad Haskell, including a fair bit that is a direct translation of 30-year old Pascal (see xindex in translit, Ch. 2, if you need to skip lunch). Programming really has advanced, you know. Anyway, the URL is: http://www.crsr.net/Programming_Languages/SoftwareTools Questions and comments would be appreciated, especially suggestions for how to make the code cleaner and more understandable. Flames and mockery are welcome, too, but only if they're funny---remember, I've been staring at Haskell, Pascal (plus my job-related Perl, CORBA, and C++) for a while; there's no telling what my mental state is like. [I had intended to wait until I had the whole thing done to make this announcement, but I recently moved and have not made much forward progress since, other than putting what I had done online.] -- Tommy M. McGuire mcguire(a)crsr.net

1 0

Re: type class question
by Peter Padawitz 10 Dec '07

10 Dec '07

Jules Bean wrote: > Peter Padawitz wrote: > >>>> So the fundep would solve the problem. >>> >> But, actually, it doesn't :-( > > But actually, it does! Indeed... Sorry, I think I left intE out of the cycle. This might be the reason why it did not work before. > Ben Franksen's answer from yesterday compiles fine for me if I add the > missing fundep, block -> command. > > Your original code compiles without error, given the fundep. Exact > code I compiled attached at the bottom of this document. You may have > to repair long lines! > > Incidentally, I question why the "compFoo" are methods. Why not just > make them polymorphic functions? They don't look like you expect > instances to change them. The code continues to compile if I make them > functions and amend their signatures as required. I put compFoo into the class for the same reason why /= is part of the class Eq: both functions are unique as soon as the others have been instantiated. > > {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-} > > type Block = [Command] > data Command = Skip | Assign String IntE | Cond BoolE Block Block | > Loop BoolE Block > data IntE = IntE Int | Var String | Sub IntE IntE | Sum [IntE] | > Prod [IntE] > data BoolE = BoolE Bool | Greater IntE IntE | Not BoolE > > class Java block command intE boolE | block -> command, command -> > intE, intE -> boolE, boolE -> block > where block_ :: [command] -> block > skip :: command > assign :: String -> intE -> command > cond :: boolE -> block -> block -> command > loop :: boolE -> block -> command > intE_ :: Int -> intE > var :: String -> intE > sub :: intE -> intE -> intE > sum_ :: [intE] -> intE > prod :: [intE] -> intE > boolE_ :: Bool -> boolE > greater :: intE -> intE -> boolE > not_ :: boolE -> boolE > compBlock :: Block -> block > compBlock = block_ . map compCommand > compCommand :: Command -> command > compCommand Skip = skip > compCommand (Assign x e) = assign x (compIntE e) > compCommand (Cond be cs cs') = cond (compBoolE be) (compBlock > cs) (compBlock cs') > compCommand (Loop be cs) = loop (compBoolE be) (compBlock cs) > compIntE :: IntE -> intE > compIntE (IntE i) = intE_ i > compIntE (Var x) = var x > compIntE (Sub e e') = sub (compIntE e) (compIntE e') > compIntE (Sum es) = sum_ (map compIntE es) > compIntE (Prod es) = prod (map compIntE es) > compBoolE :: BoolE -> boolE > compBoolE (BoolE b) = boolE_ b > compBoolE (Greater e e') = greater (compIntE e) (compIntE e') > compBoolE (Not be) = not_ (compBoolE be)

3 7

help
by Ryan Bloor 10 Dec '07

10 Dec '07

hi I am writing a basic Parser from scratch. So far I have functions;# removeSpaces# match - which checks if a string is a substring of another# orParser which combines two parser's abilities# Basic pasrers like... parseInt, parseTrue, parseFalse, parseBoolusing the orParser on True and False.What I want to do now is have a parseBinaryOp that recognises:parseBinaryOp "+" "(5 + 2) if" >>>gives>> [(EInt 5, EInt 2, "if")]So I think that I have to split the initial string into four parts."+" becomes op'(' becomes tokenF')' becomes tokenB"5" becomes e1"2" becomes e2parseBinaryOp :: String -> String -> [(Expr, Expr, String)]parseBinaryOp op str = let (tokenF,e1,op,e2,tokenB) =I am not sure how to go about separating the string for how I need itusing my other functiuons. Ryan _________________________________________________________________ The next generation of MSN Hotmail has arrived - Windows Live Hotmail http://www.newhotmail.co.uk

2 1

Do real programs need IO? (was IO is a bad example for Monads)
by Conal Elliott 10 Dec '07

10 Dec '07

On Dec 9, 2007 10:07 AM, Daniel Fischer <daniel.is.fischer(a)web.de> wrote: > Interactive programmes without using IO? Cool :) And how! > I think you misunderstood Lennart. Thanks for checking. In this case, I think I understood Lennart fine and that he was saying what you're saying. > Would you deny that any useful programme has to do at least some of the following: > -accept programme arguments at invocation > -get input, be it from a keyboard, mouse, reading files, pipes... > -output a result or state info, to the monitor, a file, a pipe... === If by "programme", you mean the code I write, then I'm happy to deny that my programme has to do these things. Examples below. If you include a stateful RTS, then no I don't deny it. > I think Lennart was referring to that, you HAVE to know a little IO to write > programmes, at least getArgs, getLine, putStr(Ln), readFile, writeFile, > appendFile. And therefore some use of the IO monad has to be taught > relatively early. Explicit imperative programming is just one way to deal with input & output, not the only way. As proof, see FRP, Pan, or TV programs, which contain uses of none of these functions. (Nor could they, as these libraries are functional, having IO-free types and semantics.) Moreover, use of imperative programming sacrifices some of the semantic simplicity & composability that makes FP so appealing. That's why I'd like to see this belief in its necessity dispelled. That said, I don't think the existing functional (non-IO) approaches to interaction are quite there yet with the flexibility of imperative programming. It will take more work to get them there, and that work is mostly likely to be pursued by people who doubt the necessity of IO for writing "real programs". In that sense, Lennart's and your statements are self-fulfilling prophechies, as are mine. BTW, if you haven't seen it already, please check out http://haskell.org/haskellwiki/TV . The TV (tangible values) approach includes a simple algebra of interfaces (input/output) and keeps separable from the core computation. The separability allows the interface parts to be composed in parallel with the core part. For instance, when two function-valued TVs are composed, the interfaces are peeled off, so that the core functions can be composed directly. The output half of one interface and the matching input half of the other are discarded. The remaining input and output halves are recombined into a new interface, which is used as the interface of the composed TV. The core interface algebra can be used for text stream i/o, GUIs, and many other possible styles of information passing. I mention TV, because it's an example of combining the purity & composability I love about FP with the usability a "real" app. For more about this combination, please see my Google tech talk "Tangible Functional Programming: a modern marriage of usability and composability" ( http://conal-elliott.blogspot.com/2007/11/tangible-functional-programming-m…) That talk focus on end-user composability, but the essential points apply as well to explicit programming. As I mentioned before, TV (a) is currently less flexible than imperative/IO programming, and (b) has the composability, guaranteed safety, and amenability to reasoning of pure functional programming. Cheers, - Conal Am Sonntag, 9. Dezember 2007 18:31 schrieb Conal Elliott: > > > IO is important because you can't write any real program without using > > > it. > > > > Ouch! I get awfully discouraged when I read statements like this one. > The > > more people who believe it, the more true it becomes. If you want to do > > functional programming, instead of imperative programming in a > functional > > language, you can. For instance, write real, interactive programs in > FRP, > > phooey, or TV. And if you do, you'll get semantic simplicity, powerful > & > > simpler reasoning, safety and composability. > > > > - Conal > > > On Dec 8, 2007 1:26 AM, Lennart Augustsson <lennart(a)augustsson.net> wrote: > > [...] > > IO is important because you can't write any real program without using it. > > So why not teach enough of it to get people off the ground straight away? > > People who hang around long enough to do some more Haskell programming > > will run into the other monads sooner or later. But IO is an unavoidable step to > > writing Haskell programs.

4 8

I'm translating <All about Monads> to Chinese
by Albert Lee 10 Dec '07

10 Dec '07

I have been confussed by monad for a long time. and I can't stand for it any more. so I start to translate the tutorial <All About Monads> to my mother language Chinese. My English is not good enough, so this work is only for my own study~ I know there are some other Chinese fellow in this list, wish it would be helpful. I will work for one chapter everyday. the address is: http://www.kamang.net

3 2

Re: [Haskell] IVars
by Conal Elliott 10 Dec '07

10 Dec '07

(moving to haskell-cafe) > readIVar' :: IVar a -> a > readIVar' = unsafePerformIO . readIVar > so, we do not need readIVar'. it could be a nice addition to the libraries, maybe as "unsafeReadIVar" or "unsafeReadMVar". The same argument applies any to pure function, doesn't it? For instance, a non-IO version of succ is unnecessary. My question is why make readIVar a blocking IO action rather than a blocking pure value, considering that it always returns the same value? - Conal On Dec 8, 2007 11:12 AM, Marc A. Ziegert <coeus(a)gmx.de> wrote: > many many answers, many guesses... > let's compare these semantics: > > readIVar :: IVar a -> IO a > readIVar' :: IVar a -> a > readIVar' = unsafePerformIO . readIVar > > so, we do not need readIVar'. it could be a nice addition to the > libraries, maybe as "unsafeReadIVar" or "unsafeReadMVar". > but the other way: > > readIVar v = return $ readIVar' v > > does not work. with this definition, readIVar itself does not block > anymore. it's like hGetContents. > and... > > readIVar v = return $! readIVar' v > > evaluates too much: > it wont work if the stored value evaluates to 1) undefined or 2) _|_. > it may even cause a 3) deadlock: > > do > writeIVar v (readIVar' w) > x<-readIVar v > writeIVar w "cat" > return x :: IO String > > readIVar should only return the 'reference'(internal pointer) to the read > object without evaluating it. in other words: > readIVar should wait to receive but not look into the received "box"; it > may contain a nasty undead werecat of some type. (Schrödinger's Law.) > > - marc > > > > > > Am Freitag, 7. Dezember 2007 schrieb Paul Johnson: > > Conal Elliott wrote: > > > Oh. Simple enough. Thanks. > > > > > > Another question: why the IO in readIVar :: IVar a -> IO a, instead > > > of just readIVar :: IVar a -> a? After all, won't readIVar iv yield > > > the same result (eventually) every time it's called? > > Because it won't necessarily yield the same result the next time you run > > it. This is the same reason the stuff in System.Environment returns > > values in IO. > > > > Paul. > > _______________________________________________ > > Haskell mailing list > > Haskell(a)haskell.org > > http://www.haskell.org/mailman/listinfo/haskell > > > > >

4 6

ANNOUNCE: xmonad 0.5: a tiling window manager
by Don Stewart 10 Dec '07

10 Dec '07

The xmonad dev team is pleased to announce the 0.5 release of xmonad! http://xmonad.org xmonad is a tiling window manager for X. Windows are arranged automatically to tile the screen without gaps or overlap, maximising screen use. Window manager features are accessible from the keyboard: a mouse is optional. xmonad is extensible in Haskell, allowing for powerful customisation. Custom layout algorithms, key bindings and other extensions may be written by the user in config files. Layouts are applied dynamically, and different layouts may be used on each workspace. Xinerama is fully supported, allowing windows to be tiled on several physical screens. Features: * Very stable, fast, small and simple. * Automatic window tiling and management * First class keyboard support: a mouse is unnecessary * Full support for tiling windows on multi-head displays * Full support for floating windows * XRandR support to rotate, add or remove monitors * Per-workspace layout algorithms * Per-screens custom status bars * Easy, powerful customisation and reconfiguration in Haskell * Large extension library * Extensive documentation and support for hacking Get it! More information, screenshots, documentation, tutorials and community resources are available from the xmonad home page: http://xmonad.org The 0.5 release, and its dependencies, are available from hackage.haskell.org, here: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/xmonad **The headlines** xmonad 0.5 is a major new release of xmonad, allowing, for the first time, dynamic extension in Haskell without requiring recompilation. Extension and configuration of xmonad is now faster, simpler, and more flexible. All configuration is done via the ~/.xmonad/xmonad.hs file. Example config files and screenshots are available on the wiki: http://haskell.org/haskellwiki/Xmonad/Config_archive This marks the final break from its dwm origins. As a result, xmonad is now also much easier to package, distribute and extend, as recompilation of xmonad is not required to extend it. New features: * xmonad is now a library, as is the collection of xmonad extensions * xmonad is configured by editing ~/.xmonad/xmonad.hs * simpler layout hooks type and interface * small EDSL for writing window management rules * support for ghc 6.8.x * xmonad now requires Cabal 1.2 or newer * small bug fixes Extensions: xmonad comes with a huge library of extensions (now more than 5 times the size of xmonad), contributed by viewers like you. Extensions enable pretty much arbitrary window manager behaviour to be implemented by users, in Haskell, in the config files. Examples include: * ion-like window tabs * status bar support * X property and hints support * altnerative layout algorithms For more information on using and writing extensions see the webpage. The library of extensions is available from hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/xmonad-contrib Brought to you by the xmonad team: Spencer Janssen Don Stewart Jason Creighton Andrea Rossato David Roundy Brent Yorgey with code contributions from: Brandon Allbery Chris Mears Shachaf Ben-Kiki Eric Mertens Alec Berryman Neil Mitchell Gwern Branwen Devin Mullins Joachim Breitner Daniel Neri Alexandre Buisse Stefan O'Rear Nick Burlett Simon Peyton Jones Peter De Wachter Hans Philipp Annen Aaron Denney Karsten Schoelzel Nelson Elhage Michael Sloan Shae Erisson Ivan Tarasov Joachim Fasting Alex Tarkovsky Michael Fellinger Christian Thiemann David Glasser Joe Thornber Kai Grossjohann Matsuyama Tomohiro Dave Harrison Daniel Wagner Juraj Hercek Ferenc Wagner Sam Hughes Jamie Webb Miikka Koskinen Klaus Weidner David Lazar nornagon Lucas Mai timthelion Robert Marlow Valery V. Vorotyntsev Dougal Stanton Joel Suovaniemi Mats Jansborg Dmitry Kurochkin Clemens Fruhwirth As well as the support of many others on the #xmonad and #haskell IRC channels, and the wider Haskell and window manager communities. Thanks to everyone for their support!

1 0