- Haskell - Haskell.org

ANNOUNCE: hinotify 0.1
by Lennart Kolmodin 04 Oct '06

04 Oct '06

Greetings! I'm pleased to announce hinotify 0.1, a library to inotify[1] which has been part of the Linux kernel since 2.6.13. inotify provides file system event notification, simply add a watcher to a file or directory and get an event when it is accessed or modified. The API basically consists of: inotify_init :: IO INotify inotify_add_watch :: INotify -> [EventVariety] -- different events to listen on -> FilePath -- file/directory to watch -> (Event -> IO ()) -- event handler -> IO WatchDescriptor inotify_rm_watch :: INotify -> WatchDescriptor -> IO () A sample program: > import System.Directory > import System.IO > > import System.INotify > > main :: IO () > main = do > inotify <- inotify_init > print inotify > home <- getHomeDirectory > wd <- inotify_add_watch inotify > [Open,Close,Access,Modify,Move] > home > print > print wd > putStrLn "Listens to your home directory. Hit enter to terminate." > getLine > inotify_rm_watch inotify wd The code is available via www: http://haskell.org/~kolmodin/code/hinotify/download/hinotify-0.1.tar.gz and via darcs: darcs get http://haskell.org/~kolmodin/code/hinotify/ The API is available at: http://haskell.org/~kolmodin/code/hinotify/docs/api/ The library is very young and I'm most grateful for feedback on the API, and what else you might have to suggest. Cheers, Lennart Kolmodin [1] http://www.kernel.org/pub/linux/kernel/people/rml/inotify/

1 0

Replacing and improving pattern guards with PMC syntax
by kahl＠cas.mcmaster.ca 04 Oct '06

04 Oct '06

One of the problems of pattern matching in Haskell is that it might well be regarded as not very declarative: function definition lines cease being generalisable equations, and the definition of the rewriting strategy involved in Haskell pattern matching extends over about three pages, no matter whether you look in the Haskell report, or for a definition of the ``functional rewriting strategy'' in the theoretical literature. <shameless plug> To fix exactly this problem was my original goal when I started developing a family of Pattern Matching Calculi, see http://www.cas.mcmaster.ca/~kahl/PMC/ . </shameless plug> (Other pattern matching calculi in the literature have different goals.) The original calculus, which I shall call ``PMC'' for the remainder of this message, is a confluent rewriting system with a normalising strategy that incorporates Haskell pattern matching --- the confluence proof has been mechanised using Isabelle. So far I never considered it important to devise a concrete syntax for PMC, but triggered by the current pattern guards thread on haskell-prime, I now try to give a PMC syntax that blends well with Haskell. PMC ``automatically'' includes the ``expression pattern'' of pattern guards, but organised differently, see below. I am now presenting a series of syntactic extensions to Haskell. without assuming that the reader is familiar with PMC, but I will also explain how these extensions relate with PMC. One of my gripes with Haskell pattern matching is that the anonymous variant, namely case expressions, has an application to an argument built in, and therefore does not by itself produce a function. However, lambda-abstraction already allows single-alternative pattern matching, so I propose to relax this to multi-alternative pattern matching: > length = \ > [] -> 0 > x : xs -> 1 + length xs (Lists of alternatives correspond to the ``matchings'' of PMC, and concatenation of those lists (using ``;'' or layout) corresponds to matching alternative in PMC. ``\ m'' then corresponds to ``{| m |}'' in PMC. ) For multi-argument pattern matching, I propose to allow nested matchings: > zip = \ > x : xs -> y : ys -> (x,y) : zip xs ys > _ -> _ -> [] > take' = \ > 0 -> _ -> [] > n -> { [] -> [] > ; x : xs -> x : take (pred n) xs > } This means that the alternative ``->'' now can have either an expression or a list of alternatives as its right argument. (Having an expression there corresponds to ``lifting'' $\leftharpoonup \_ \rightharpoonup$ in PMC.) Pattern guards now can be seen as a special case of alternatives-level argument application (``argument supply'' $\righttriangle$ in PMC). I find it useful to write the argument first, as in PMC. I see two options of writing argument supply in Haskell: either using new keywords, giving rise to the syntax production alt -> match exp with alts or using a keyword infix operator: alt -> exp |> alts (Using this kind of argument supply instead of pattern guards also has the advantage that multiple alternatives become possible.) I start with Simon Peyton Jones' standard example: > clunky env v1 v2 | Just r1 <- lookup env v1 > , Just r2 <- lookup env v2 = r1 + r2 > | otherwise = v1 + v2 This could now be written using either ``match _ with _'': > clunky env v1 v2 = \ > match lookup env v1 with > Just r1 -> match lookup env v2 with > Just r2 -> r1 + r2 > v1 + v2 or infix ``_ |> _'': > clunky env v1 v2 = \ > lookup env v1 |> Just r1 -> > lookup env v2 |> Just r2 -> r1 + r2 > v1 + v2 Note that the syntactic structure is different from pattern guards; here is the fully parenthesised version: > clunky env v1 v2 = \ > { lookup env v1 |> { Just r1 -> > { lookup env v2 |> { Just r2 -> r1 + r2 }}} > ; v1 + v2 > } Boolean guards are matches against True: > take = \ > 0 -> _ -> [] > n -> match n > 0 with > True -> > { [] -> [] > ; x : xs -> x : take (pred n) xs > } > _ -> error "take: negative argument" But Boolean guards can also be kept as syntactic sugar: > take = \ > 0 -> _ -> [] > n | n > 0 -> > { [] -> [] > ; x : xs -> x : take (pred n) xs > } > | otherwise -> error "take: negative argument" Now we have all the syntax in place --- PMC's ``failure'' is of course the empty alternative (allowed in Haskell 98). For the grammar, the relevant productions in Haskell 98 are: exp10 -> \ apat1 ... apatn -> exp (lambda abstraction, n>=1) | "case" exp "of" { alts } (case expression) alts -> alt1 ; ... ; altn (n>=1) alt -> pat "->" exp [where decls] | pat gdpat [where decls] | (empty alternative) gdpat -> gd "->" exp [ gdpat ] gd -> | exp This would change to the following, where I propose to rename ``alt'' to ``match'' for ``matching'' as in PMC, since this is now a full-fledged syntactic category of importance similar to that of expressions (PMC works essentially because of this separation of syntactic categories): exp10 -> \ { matchs } (lambda abstraction) | "case" exp "of" { matchs } (case expression) matchs -> match1 ; ... ; matchn (alternative, n>=1) match -> expr (result) | pat "->" { matchs } [where decls] (pattern matching) | pat gdpat [where decls] (pat. mat. w. Boolean guards) | (empty alternative) | "match" exp "with" { matchs } (pattern argument supply) gdpat -> gd "->" { matchs } [ gdpat ] gd -> | exp (case expressions would than be syntactic sugar: > case exp of {matchs} = \ match exp with {matchs} ) These productions imply that we would loose multiple abstraction: \ x y z -> 3 becomes \ x -> y -> z -> 3 . For reasons of declarativity, I am also tempted to argue that ``='' should only be allowed for one-line definitions, so we would write: > f 0 -> 1 > f n -> n * f (n - 1) An easy-to-remember motto for this could be ``if it can fall through, use ->''. This would of course break every single textbook and tutorial, so I won't insist... No matter whether with ``->'' or with ``='', the above would of course be syntactic sugar for: > f = \ > 0 -> 1 > n -> n * f (n - 1) LAWS ==== The most important nice thing is that we can now use equational reasoning for expressions involving pattern matching. The PMC laws (see the papers for more explanation) translate into the syntax presented above as follows (note that most of these equations are between matchings, i.e., between (lists of) alternatives, and only some are between expressions): --------------------------------------------------------------------- Failure as unit: > {- empty alternative -} ; alts = alts Failure lifting: > \ { } = undefined Result lifting: > \ { exp } = exp Argument propagation into matching: > (\ { alts }) exp = \ { match exp with { alts } } Argument propagation into expression: > match arg with { exp } = exp arg First match wins (no backtracking after first success): > exp ; alts = exp Failure-strictness of argument supply: > match arg with { } = {- empty alternative -} Distributivity of argument supply over alternative: > match arg with { alts1 ; alts2 } = > match arg with { alts1 } ; match arg with { alts2 } beta (v is a variable): > match arg with { v -> { alts } } = alts[v \ arg] -- substitution Match when matching the same constructor: > match c(e1,...,en) with {c(p1,...,pn) -> {alts}} > = match e1 with {p1 -> ... -> match en with pn -> {alts}} Mismatch when matching different constructors: > match c(e1,...,em) with {d(p1,...,pn) -> {alts}} > = {- empty alternative -} Strictness of matching against constructors: > match undefined with {c(p1,...,pn) -> {alts}} = undefined --------------------------------------------------------------------- Together with Strictness of function application in the function: > undefined arg = undefined -- already in Haskell , these laws, when oriented as rules, produce a confluent rewriting system, and the standard definition of strong head normal form induces a normalising strategy. Besides extending syntactic convenience even beyond pattern guards, adopting the abstract syntax of PMC would therefore also simplify the definition of the semantics of pattern matching in Haskell, and extend the scope of equational reasoning to pattern matching. For the concrete syntax I have no strong feelings, but hope that I provided a starting point for discussion. Wolfram

4 4

Summer of Code Summit and Haskell
by dons＠cse.unsw.edu.au 04 Oct '06

04 Oct '06

Hey all, The Google Summer of Code is now wrapping up, and Haskell.org's projects have been quite successful. The full details will available soon in a report we're preparing (next week some time), though quite likely you have already seen the various student projects previously announced to the community. As part of the analysis of this year's SoC, Google is holding a Summer of Code summit, at Google Headquarters, next weekend. The purpose of the summit is to bring together mentors from successful organizations to discuss how to improve the GSoC, and how Google can do more for open source development. Two representatives of the Haskell.org Summer of Code mentors have been chosen by the Haskell SoC team to represent the SoC effort, and the community at large, at this event: Shae Erisson and myself. We'll be attending the 1 day summit, and plan to present a short, focused talk introducing Haskell, and describing how the distributed, open source community around Haskell has been built. As part of this, we're seeking the community's advice and ideas on how well the Haskell community "works" as a (somewhat anarchic) organisation, how we're progressing, what things have been done well, and what needs to be done better. Also, for those who were involved with the Summer of Code, whether as mentors or students, how could that be improved from the Haskell community's point of view? The best way to contribute would be to email your thoughts to us directly. Cheers, Don Stewart & Shae Erisson

2 1

Evil code
by Thomas Davie 04 Oct '06

04 Oct '06

Hello list, I am in the process of testing a debugger, and need some examples to throw at it. It's based on hat, so the normal rules about nothing that uses glasgow extensions or ffi apply. But I'm hitting a bit of a wall. Do any of you have some examples of nasty uses of higher order code. For example CPS, or non-IO monads. TIA Bob

4 4

Haskell Packages 6.6?
by Isaac Jones 03 Oct '06

03 Oct '06

Hello good Haskell Hackers. We're pretty well along the way to getting cabal-install and friends working nicely. We've got almost 30 packages in the database. Let's imagine something that would be awesome. A set of Haskell packages which are all known to work together with a particular version of cabal (the one that GHC comes with), and a particular version of GHC. GHC version 6.6 will be released soon, and I think we should try to make this happen. Currently, we have a set of 27 "unstable" packages. They may or may not work with each-other and such: http://hackage.haskell.org/packages/ I just created an empty directory "testing". I propose that we start testing packages, starting with the cabal release candidate that'll go into GHC 6.6, and make sure they work nicely together. Once they're known to work, we can migrate them from the "unstable" directory to the "testing" directory. Once we have a sufficient collection of packages, and once ghc 6.6 is released, we can make a snapshot of this directory, call it "stable-6.6" or something. Then if you have ghc 6.6 and cabal-install, you should be able to "cabal-install p" for any package, and it'll definitely work. So what will we need for this to happen? 1. An installed version of ghc 6.6 on the hackage/darcs server. Maybe in a chroot or something. Maybe from the nightly build tree or the previous snapshot? 2. Some initial set of packages (maybe just cabal-install) to start off. 3. Some script that goes through and builds all of the "unstable" packages in dependency order. I think cabal-install can do this already. In fact, it would be ideal if we used cabal-install for this. 4. The script should also run ./setup haddock and ./setup test. If the packages seem to work w/ 6.6 and the other packages in "testing", it should get migrated from "unstable" to "testing". 5. A web interface (lemmih is working on it) 6. A script to upload packages to "unstable" (Paolo is working on it). 7. Someone to spearhead all of this! peace, isaac p.s. here are the packages we have currently in the database: parsedate-2006.6.4 Haskell library for parsing dates and times cgi-2006.8.5 A Haskell library for writing CGI programs HDBC-odbc-1.0.1.0 lambdabot-4.0 bzlib-0.2 Compression and decompression in the bzip2 format HDBC-sqlite3-1.0.1.0 hask-home-2006.3.23 Generate homepages for cabal packages XmlRpc-2006.6.26 hnop-0.1 Haskell No Operation fps-0.7 HDBC-postgresql-1.0.1.0 rss-2006.7.12 A library for generating RSS 2.0 feeds. HTTP-2006.7.7 Crypto-3.0.3 DES, Blowfish, AES, SHA1, MD5, RSA, X.509 Identity and Attribute Certificates, General ASN.1 Support, Base64, PKCS8, PKCS1v15, Hexdump, Support for Word128, Word192 and Word256 and Beyond, PKCS5 Padding, Various Encryption Modes e.g. Cipher Block Chaining all in one package.plugins-1.0 fastcgi-2006.8.5 A Haskell library for writing FastCGI programs zlib-0.2 Compression and decompression in the gzip and zlib formats HDBC-1.0.1 xhtml-2006.7.5 A Haskell XHTML combinator library darcs-graph-0.1 gd-2006.7.12 A Haskell binding to a subset of the GD graphics library hmp3-1.1 Djinn-2005.12.14 A haskell proof generator iconv-0.2 Perform character set conversion exif-2006.7.11 A Haskell binding to a subset of libexif HaXml-1.13.1 Utilities for manipulating XML documents

2 2

Re: Haskell Weekly News: September 27, 2006
by Cyril Schmidt 03 Oct '06

03 Oct '06

That's really good news. Big thank-you to the CUFP committee! Having seen the proceedings of Haskell Workshop 1995 published in 2006, I was prepared to wait much longer ;-) Cheers, Cyril > The slides will be available at http://www.galois.com/cufp very soon > (maybe even today). I don't have Howard's yet, as they have to undergo > Credit Suisse's publication process, but I'll put them up when I get them. > > Cheers, > > Andy, on behalf of the CUFP PC > >

1 0

Haskell training course?
by Wim Vanderbauwhede 03 Oct '06

03 Oct '06

Hello list, Does anyone know of a good Haskell training course in the UK? TIA, Wiim -- If it's pointless, what's the point? If there is a point to it, what's the point? (Tibor Fischer, "The Thought Gang")

2 1

Common library for generic programming
by Johan Jeuring 03 Oct '06

03 Oct '06

Dear haskellers, Generic programming has been around for more than 10 years now. We think a lot of progress has been made in the last decade. As an example, there are more than 10 proposals for libraries or language extensions only for Haskell. The success of generic programming has also caused a problem: although generic programming has been applied in several applications, it lacks actual users for real-life projects (HaRe using Strafunski is maybe an exception). This is understandable: choosing a particular approach to generic programming for a real-life project is rather risky: few approaches that have been developed over the last decade are still supported, and there is a high risk that the chosen approach will not be supported anymore, or that at least it will change in a backwards incompatible way in a couple of years time. We have recently started an initiative to design a common library for generic programming, which should work together with most of the Haskell compilers, and for which we hope to guarantee support for a longer period. If you want to get involved (or just want to see the discussion), you can subscribe to the mailing list generics(a)haskell.org, see http://www.haskell.org/mailman/listinfo/generics -- Johan Jeuring and Andres Loeh

2 1

CfP: PAPP 2007
by grelck＠isp.uni-luebeck.de 03 Oct '06

03 Oct '06

Please, accept our apologies if you receive multiple copies. ========================================= Fourth International Workshop on Practical Aspects of High-level Parallel Programming (PAPP 2007) part of The International Conference on Computational Science May 27-30, 2007, University of Beijing, China http://f.loulergue.free.fr/PAPP2007/index.html ========================================= Aims and scope Computational Science applications are more and more complex to develop and require more and more computing power. Parallel and grid computing are solutions to the increasing need for computing power. High level languages offer a high degree of abstraction which ease the development of complex systems. Moreover, being based on formal semantics, it is possible to certify the correctness of critical parts of the applications. Algorithmic skeletons, parallel extensions of functional languages such as Haskell and ML, parallel logic and constraint programming, parallel execution of declarative programs such as SQL queries, etc. have produced methods and tools that improve the price/performance ratio of parallel software, and broaden the range of target applications. The PAPP workshop focuses on practical aspects of high-level parallel programming: design, implementation and optimization of high-level programming languages and tools (performance predictors working on high-level parallel/grid source code, visualisations of abstract behaviour, automatic hotspot detectors, high-level GRID resource managers, compilers, automatic generators, etc.), applications in all fields of computational science, benchmarks and experiments. Research on high-level grid programming is particularly relevant. The PAPP workshop is aimed both at researchers involved in the development of high level approaches for parallel and grid computing and computational science researchers who are potential users of these languages and tools. Topics We welcome submission of original, unpublished papers in English on topics including: * high-level models (CGM, BSP, MPM, LogP, etc.) and tools for parallel and grid computing * high-level parallel language design, implementation and optimisation * functional, logic, constraint programming for parallel, distributed and grid computing systems * algorithmic skeletons, patterns and high-level parallel libraries * generative (e.g. template-based) programming with algorithmic skeletons, patterns and high-level parallel libraries * applications in all fields of high-performance computing (using high-level tools) * benchmarks and experiments using such languages and tools Paper submission and publication Prospective authors are invited to submit full papers in English presenting original research. Submitted papers must be unpublished and not submitted for publication elsewhere. Papers will go through a rigorous reviewing process. Each paper will be reviewed by at least three referees. The accepted papers will be published in the Springer-Verlag Lecture Notes in Computer Science (LNCS) series, as part of the ICCS proceedings. Submission must be done through the ICCS website: http://www.iccs-meeting.org/iccs2007/papers/upload.php. We invite you to submit a full paper of 8 pages formatted according to the rules of LNCS, describing new and original results, no later than December 12, 2006. Submission implies the willingness of at least one of the authors to register and present the paper. An early email to papp2007 at free.fr with your intention to submit a paper would be greatly appreciated (especially if you have doubts about the relevance of your paper). Accepted papers should be presented at the workshop. Authors will be invited to submit extended and revised versions of their papers. Accepted manuscripts will be published in a special issue of Scalable Computing: Practice and Experience. Important Dates * December 12, 2006 - Full paper due * February 3, 2007 - Notification * February 19, 2007 - Camera-ready paper due * July 2007 - Journal version due * September 2007 - Referee reports * October 2007 - Revision of papers, final notification * November 2007 - Final paper due Programme committee * Marco Aldinucci (Univ. of Pisa, Italy) * Anne Benoit (ENS Lyon, France) * Armelle Bonenfant (Univ. of St Andrews, UK) * Frédéric Gava (Univ. Paris XII Val de Marne, France) * Alexandros Gerbessiotis (NJIT, USA) * Clemens Grelck (Univ. of Luebeck, Germany / Univ. of Hertfordshire, UK) * Zhenjiang Hu (Univ. of Tokyo, Japan) * Rita Loogen (Univ. of Marburg, Germany) * Frédéric Loulergue (Univ. Orléans, France) * Susanna Pelagatti (Univ. of Pisa, Italy) * Casiano Rodriguez Leon (Univ. La Laguna, Spain) Organizers * Dr. Anne BENOIT Laboratoire d'Informatique du Parallelisme Ecole Normale Supérieure de Lyon 46 Allée d'Italie 69364 Lyon Cedex 07 - France * Pr. Frederic LOULERGUE Laboratoire d'Informatique Fondamentale d'Orléans Université d'Orléans Batiment IIIA - Rue Léonard de Vinci - BP6759 45067 Orléans Cedex 2 - France -- Dr. Clemens Grelck University of Hertfordshire Dept of Computer Science College Lane, Hatfield, AL10 9AB United Kingdom

1 0

Haskell Weekly News: October 03, 2006
by dons＠cse.unsw.edu.au 03 Oct '06

03 Oct '06

--------------------------------------------------------------------------- Haskell Weekly News http://haskell.org/haskellwiki/HWN Issue 43 - October 03, 2006 --------------------------------------------------------------------------- Welcome to issue 43 of HWN, a weekly newsletter covering developments in the Haskell community. The proceedings of the first Haskell Workshop are now available online, and work has begun on a unified library for generics in Haskell. Announcements * Proceedings Haskell Workshop 1995. Henrik Nilsson [1]announced that in celebration of the 10th [2]Haskell Workshop that took place recently, the proceedings of the very first Haskell workshop, in La Jolla 1995, have now been made available on [3]the Haskell Workshop home page. Thanks to Paul Hudak for help locating the proceedings and arranging for them to be scanned into PDF. 1. http://article.gmane.org/gmane.comp.lang.haskell.general/14312/ 2. http://haskell.org/haskell-workshop 3. http://haskell.org/haskell-workshop/1995 * Common library for generic programming. Johan Jeuring and Andres Loeh [4]announced an initiative to design a common library for generic programming, which should work together with most of the Haskell compilers, and for which they hope to guarantee support for generics in Haskell into the future. If you want to get involved (or just want to see the discussion), you can subscribe to [5]the generics mailing list. Check the [6]Haskell research wiki for some background on generics. 4. http://article.gmane.org/gmane.comp.lang.haskell.general/14304/ 5. http://www.haskell.org/mailman/listinfo/generics 6. http://haskell.org/haskellwiki/Research_papers/Generics * GHC 6.6 Second Release Candidate. Ian Lynagh [7]announced that the Second Release Candidate phase for GHC 6.6 is underway. Get testing! 7. http://article.gmane.org/gmane.comp.lang.haskell.glasgow.user/10823 * Lazy functional language for the JVM. Luke Evans [8]announced that the research group at Business Objects has developed a lazily evaluated, strongly-typed language called CAL, with many similarities to Haskell, targeting the JVM, to facilitate representing certain kinds of business logic as reusable, composable pieces. 8. http://thread.gmane.org/gmane.comp.lang.haskell.general/14296/ Haskell' This section covers the [9]Haskell' standardisation process. * [10]Pattern guards * [11]Improving pattern guard syntax 9. http://hackage.haskell.org/trac/haskell-prime 10. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1680/focus=1680 11. http://article.gmane.org/gmane.comp.lang.haskell.prime/1704 Discussion * Typeclass versus Prolog programming. Oleg Kiselyov [12]wrote further on the connection between typeclass hacking and logic programming. 12. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/15401/ * Irrefutable patterns for existential types. Several Haskellers [13]discussed, in a long thread, issues relating to irrefutable patterns when combined with existentials or GADTs. [14]Read more. 13. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/15564/ 14. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/15633/ * GHC on the Mac. Simon Peyton-Jones [15]sought contributors to help maintain [16]GHC on the Mac. 15. http://thread.gmane.org/gmane.comp.lang.haskell.glasgow.user/10801/ 16. http://haskell.org/ghc * Smallest Double. Tamas Papp [17]initiated a thread regarding finding the smallest Double such that 1+x /= x, for a numerics problem. 17. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/15573/focus=15573 * Migrating content to the new wiki. Ian Lynagh [18]forced an action to finally close down the old hawiki, and move all content to the new haskell wiki. Work to be done is [19]here. 18. http://article.gmane.org/gmane.comp.lang.haskell.general/14314 19. http://www.haskell.org/haskellwiki/HaWiki_migration Blog noise Haskell news from the blogosphere. * [20]Functional programming for the rest of us * [21]Coming soon: Perl 6 * [22]Arrows, like monads, are monoids * [23]OOP is dead 20. http://www.defmacro.org/ramblings/fp.html 21. http://www.samag.com/documents/s=10093/sam0609j/0609j.htm 22. http://lambda-the-ultimate.org/node/1750 23. http://kawagner.blogspot.com/2006/08/oop-is-dead-part-2.html Quotes of the Week * Bill Wood: It became obvious that when a Prolog program is tuned by removing non-determinism it moves towards a functional program. * Bjarne Stroustrup: Any verbose and tedious solution is error-prone because programmers get bored. [S 9.4 of C++, 2nd edition] * Hamilton Richards: It's fair to say that functional programming requires a very different mind-set, but once you've mad e the `jump`, programming in conventional languages feels like doing arithmetic in Roman numerals. * Larry Wall: Take Lisp, you know it's the most beautiful language in the world -- at least up until Haskell came along. * dons: Welcome to computer science, we count from 0. * glguy: This is like Web 5GL. I like it! * sjanssen: Quoth the Prelude, Chapter 6, verse 4: Yeah verily shall repeat floweth cons cells over. Code Watch * Fri Sep 29 09:07:17 PDT 2006 simonpj. Remove Linear Implicit Parameters, and all their works. Linear implicit parameters have been in GHC quite a while, but we decided they were a mis-feature and scheduled them for removal. This patch does the job. About the Haskell Weekly News Each week, new editions are posted to [24]the Haskell mailing list as well as to [25]the Haskell Sequence and [26]Planet Haskell. [27]RSS is also available, and headlines appear on [28]haskell.org. To help create new editions of this newsletter, please see the [29]contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn 24. http://www.haskell.org/mailman/listinfo/haskell 25. http://sequence.complete.org/ 26. http://planet.haskell.org/ 27. http://sequence.complete.org/node/feed 28. http://haskell.org/ 29. http://haskell.org/haskellwiki/HWN

1 0