October 2006 - Haskell

HaWiki closing in one month; migrate content to HaskellWiki now!
by Ian Lynagh 05 Oct '06

05 Oct '06

Hi all, HaWiki[1] has been deprecated since the beginning of this year[2] when the new HaskellWiki[3] was introduced. However, we are now in the situation where we have both wikis running in parallel, which occasionally causes confusion to users, and means we have outdated information lying around on the old wiki. We have therefore decided that the old wiki will be taken down at the end of this month. If there is any information on it that you think should be kept but has not yet been migrated to the new wiki, this is the time to act! We have made a page for handling the migration, listing all the pages on the old wiki: http://www.haskell.org/haskellwiki/HaWiki_migration If you migrate a page, or find that it has already been migrated, then remove it from the list. Remember you need to check licences before moving content to the new wiki! Thanks Ian and Shae [1] http://www.haskell.org/hawiki/ [2] http://www.haskell.org/pipermail/haskell/2006-January/017287.html [3] http://www.haskell.org/haskellwiki/Haskell

6 5

ANNOUNCE: Haskell XML Toolbox Version 6.0
by Uwe Schmidt 05 Oct '06

05 Oct '06

Haskell XML Toolbox 6.0 I would like to announce a new version of the Haskell XML Toolbox for processing XML. main new features: * works with ghc 6.4.2 * better XPath integration * separate documentation for filter API and arrow API * arrow API slightly simplified More information and download: http://www.fh-wedel.de/~si/HXmlToolbox/index.html Please email comments, bugs, etc. to hxmltoolbox(a)fh-wedel.de Uwe -- University of Applied Sciences, Wedel, Germany http://www.fh-wedel.de/~si/index.html

4 4

A Funded Ph.D Position in Durham
by Shengchao Qin 05 Oct '06

05 Oct '06

UNIVERSITY OF DURHAM DEPARTMENT OF COMPUTER SCIENCE EPSRC funded Ph.D. studentship (3.5 years) Applications are invited for a Ph.D. student to work on an EPSRC funded project entitled "resource analysis and verification for dependable embedded software" in the Department of Computer Science. The aim of the project is to build a resource (memory and time) analysis and verification system for object-oriented programs running in embedded devices. Prospective candidates will have a good honours (or equivalent) degree in Computer Science or other relevant topics. The successful applicant should have a good background in some of the following areas: program analysis, type system/theory, software verification, embedded systems. This fully funded studentship provides a tax-free living allowance at the standard EPSRC rate (0512,300 p.a. for 06/07) and student tuition fees at the UK/EU student rate. Overseas applicants may have to sort out tuition fee difference via other means. The studentship is expected to start in January 2007, or as soon as possible thereafter. Closing date: 1 December 2006 More specific details about the project can by obtained by contacting Dr Shengchao Qin at shengchao.qin(a)durham.ac.uk Applications should be sent to Dr S Qin, Computer Science Department, Durham University, Science Labs, South Road, Durham, DH1 3LE, United Kingdom.

1 0

Call for Participation: APLAS'06
by Manuel M T Chakravarty 04 Oct '06

04 Oct '06

** I am sorry if you receive multiple copies of this CFP ** Call for Participation 4th Asian Symposium on Programming Languages and Systems November 8-10, 2006 Sydney, Australia http://www.cse.unsw.edu.au/~aplas06/ http://www.kb.ecei.tohoku.ac.jp/aplas2006/ Scope of the Conference ----------------------- APLAS aims at stimulating programming language research by providing a forum for the presentation of recent results and the exchange of ideas and experience in topics concerned with programming languages and systems. APLAS is based in Asia, but is an international forum that serves the worldwide programming languages community. The APLAS series is sponsored by the Asian Association for Foundation of Software (AAFS), which has recently been founded by Asian researchers in cooperation with many researchers from Europe and the USA. The past formal APLAS symposiums were successfully held in Tsukuba (2005, Japan), Taipei (2004, Taiwan) and Beijing (2003, China) after three informal workshops held in Shanghai (2002, China), Daejeon (2001, Korea) and Singapore (2000). Conference Registration ----------------------- Registration information for APLAS 2006 is now available at http://www.cse.unsw.edu.au/~aplas06/registration.html Conference Location ------------------- APLAS'06 will be on the campus of the University of New South Wales in Sydney, Australia. The City of Sydney is with over 4 million population the largest city of Australia, and with its many attractions, it is one of the main cultural centres of Australia. Conference Program ------------------ 8 Nov (Wed) ------------ 915- 930 Opening note 930-1030 Invited talk #1 Type Processing by Constraint Reasoning Peter Stucky 1100-1230 Session 1 Principal Type Inference for GHC-Style Multi-Parameter Type Classes Martin Sulzmann, Tom Schrijvers and Peter J Stuckey Private row types: abstracting the unnamed Jacques Garrigue Type and Effect System for Multi-Staged Exceptions Hyunjun Eo, Ik-Soon Kim and Kwangkeun Yi 1400-1530 Session 2 Relational Reasoning for Recursive Types and References Nina Bohr and Lars Birkedal Proof Abstraction for Imperative Languages William L. Harrison Reading, Writing and Relations Nick Benton, Andrew Kennedy, Martin Hofmann and Lennart Beringer 1600-1700 Session 3 A Fine-Grained Join Point Model for More Reusable Aspects Yusuke Endoh, Hidehiko Masuhara and Akinori Yonezawa Automatic Testing of Higher Order Functions Pieter Koopman and Rinus Plasmeijer 9 Nov (Thu) ------------ 930-1030 Invited talk #2 Event Driven Software Quality Jens Palsberg 1110-1230 Session 4 Widening Polyhedra with Landmarks Axel Simon and Andy King Comparing completeness properties of static analyses and their logics David Schmidt Polymorphism, Subtyping, Whole Program Analysis and Accurate Data Types in Usage Analysis Tobias Gedell, Jorgen Gustavsson and Josef Svenningsson 1400-1530 Session 5 A Modal Language for the Safety of Mobile Values Sungwoo Park An Analysis for Proving Temporal Properties of Biological Systems Roberta Gori and Francesca Levi Computational Secrecy by Typing for the Pi Calculus Martin Abadi, Ricardo Corin and Cedric Fournet 1545-1715 Poster session 10 Nov (Fri) ------------ 930-1030 Invited tutorial Scheme with Classes, Mixins, and Traits Matthew Flatt 1100-1230 Session 6 Using Metadata Transformations to Integrate Class Extensions in an Existing Class Hierarchy Markus Lumpe Combining Offline and Online Optimizations: Register Allocation and Method Inlining Hiroshi Yamauchi and Jan Vitek A Localized Tracing Scheme for Garbage Collection Yannis Chicha and Stephen M. Watt 1400-1530 Session 7 A Pushdown Machine for Recursive XML Processing Keisuke Nakano and Shin-Cheng Mu XML Validation for Context-Free Grammars Yasuhiko Minamide and Akihiko Tozawa A Practical String Analyzer by the Widening Approach Tae-Hyoung Choi, Hyun-Ha Kim, Oukseh Lee and Kyung-Goo Doh 1600-1700 Session 8 A bytecode logic for JML and Types Lennart Beringer and Martin Hofmann On Jones-Optimal Specializers: A Case Study Using Unmix Johan Gade and Robert Glueck 1700-1715 Closing note Organization ------------- GENERAL CO-CHAIRS Manuel Chakravarty (University of New South Wales, Australia) Gabriele Keller (University of New South Wales, Australia) PROGRAM CHAIR Naoki Kobayashi (Tohoku University) PROGRAM COMMITTEE Kung Chen (National Chengchi University, Taiwan) Wei-Ngan Chin (National University of Singapore, Singapore) Patrick Cousot (ENS, France) Masahito Hasegawa (Kyoto University, Japan) Jifeng He (United Nations University, Macau) Haruo Hosoya (University of Tokyo, Japan) Bo Huang (Intel China Software Center, China) Naoki Kobayashi (chair) (Tohoku University, Japan) Oege de Moor (Oxford University, UK) George Necula (University of California at Berkeley, USA) Martin Odersky (EPFL, Switzerland) Tamiya Onodera (IBM Research, Tokyo Research Laboratory, Japan) Yunheung Paek (Seoul National University, Korea) Sriram Rajamani (Microsoft Research, USA) Andrei Sabelfeld (Chalmers University of Technology, Sweden) Zhong Shao (Yale University, USA) Harald Sondergaard (University of Melbourne, Australia) Nobuko Yoshida (Imperial College London, UK)

1 0

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 04 Oct '06

04 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