- Haskell - Haskell.org

lazy patterns versus where-clauses
by Peter Padawitz 21 Jun '07

21 Jun '07

Is f(~p(x))=e(x) semantically equivalent to: f(z)=e(x) where p(x)=z?

3 2

The Monad.Reader (8) - Second Call for Copy
by Wouter Swierstra 20 Jun '07

20 Jun '07

Call for Copy The Monad.Reader - Issue 8 It is not too late to consider writing something for the next issue of The Monad.Reader. The deadline for Issue 8 is ** July 27, 2007 ** It doesn't matter if you're an established academic or if you have only just started learning Haskell, if you have something to say, please write article for The Monad.Reader. * The Monad.Reader * The Monad.Reader is a electronic magazine about all things Haskell. It is less-formal than journal, but somehow more enduring than a wiki- page. There have been a wide variety of articles, including: exciting code fragments, intriguing puzzles, book reviews, tutorials, and even half-baked research ideas. * Submission Details * Get in touch with me if you intend to submit something -- the sooner you let me know what you're up to, the better. Please submit articles for the next issue to me by e-mail (wss at cs.nott.ac.uk). Articles should be written according to the guidelines available from http://www.haskell.org/haskellwiki/The_Monad.Reader Please submit your article in PDF, together with any source files you used. The sources will be released together with the magazine under a BSD license. If you would like to submit an article, but have trouble with LaTeX please let me know and we'll sort something out. All the best, Wouter This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Final Call for Tutorial: IEEE/WIC/ACM WI-IAT'07
by Jia Hu 19 Jun '07

19 Jun '07

[Apologies if you receive this more than once] ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2007 IEEE/WIC/ACM International Conference on Web Intelligence and Intelligent Agent Technology (WI-IAT 2007) Silicon Valley, USA, November 2-5, 2007 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++ Call for Tutorials ++++++++++++++++++ The 2007 IEEE/WIC/ACM International Joint Conference on Web Intelligence (WI'07) and Intelligent Agent Technology (IAT'07) takes place on November 2-5, 2007, in Silicon Valley, the center of high tech and web technology. The IEEE/WIC/ACM 2007 joint conference is organized by San Jose State University, and sponsored by IEEE Computer Society Technical Committee on Intelligent Informatics (TCII), Web Intelligence Consortium (WIC), and ACM-SIGART. Homepage: http://www.cs.sjsu.edu/wi07/wi/?index=tutorial and http://www.cs.sjsu.edu/wi07/iat/?index=tutorial WI 2007 and IAT 2007 will include tutorials providing in-depth background on subjects that are of broad interest to the intelligent agent community. Both short (2 hours) and long (half day) tutorials will be considered. The following is a *non-exclusive* list of preferred topic areas for tutorial proposals: Web Intelligence: - Intelligent/Semantic Web Services - Intelligent Wireless Web and Ubiquitous Computing - Rules and Inference Engines for the Web - Semantic Web Concepts and Techniques for Security and Trust - Service-Oriented Computing - Social Networks and Social Intelligence - e-learning and e-science - Web Intelligence and Education Intelligent Agent Technology: - Agent-Based Modeling and Simulation - Agent Technologies in e-Business Systems - Agent-Mediated Knowledge Management - Peer-to-Peer Models for Multi-Agent Systems - Agent-Based Grid Computing Submission Details: Proposals for tutorials should consist of an outline and background information on the presenter(s). The tutorial outline should be limited to 2 pages and contain the following information: 1. Title and abstract of the tutorial 2. Proposed duration: 2 hours or half-day 3. Intended audience: to whom is the tutorial of interest 4. Prerequisite knowledge: what the attendees should already know 5. Detailed outline The background information on the presenter(s) should be limited to 1-2 pages and contain: 1. Names, affiliations, homepages and contact details 2. Short biographies 3. Information about previous tutorials given by the same presenters (title, location, number of attendees, etc.) Tutorial materials such as handouts and slides should be included if already available, but are not required for submission. Please send your proposal to pawan(a)cs.smu.ca or Pawan.Lingras(a)smu.ca Important Dates: July 1, 2007 Tutorial submissions July 10, 2007 Acceptance notices October 1, 2007 Camera-ready copy of tutorial handouts November 2-5, 2007 WI-IAT'07 tutorials Tutorial Chair: Pawan Lingras, Saint Mary's University, Canada Email: pawan(a)cs.smu.ca or Pawan.Lingras(a)smu.ca +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1 0

PhD on refactoring at Oxford
by Oege.de.Moor＠comlab.ox.ac.uk 17 Jun '07

17 Jun '07

UNIVERSITY OF OXFORD COMPUTING LABORATORY Programming Tools Group Oxford University Computing Laboratory has a fully funded three year research studentship working in the Programming Tools Group with the abc team: http://progtools.comlab.ox.ac.uk http://aspectbench.org PROJECT SUMMARY Software systems are rarely written from scratch: they evolve over long periods of time. When a change is made, this often affects many different locations in a system, and it is hard to make a change consistently. For that reason, automated tools to help the process of software change are desirable. "Refactoring" refers to the process of restructuring an existing piece of software, often prior to introducing new functionality, or to take advantage of a new technology. Refactoring must preserve the behaviour of existing code, and tools that help in refactoring both assist in the restructuring process and in checking that the behaviour has not changed. Unfortunately today's refactoring tools are very hard to construct, they are still quite limited in functionality, and they often contain bugs. This project aims to construct a framework for better refactoring tools. In particular, the work is driven by refactorings for a new set of language features, called `aspect-oriented programming' that have recently been added to Java. Our framework will be based on developments in three separate areas of computer science: * "strategies" to control the process of rewriting program code, from the term rewriting community * "reference attribute grammars" to specify the conditions that guarantee behaviour is preserved, from the compilers community * "incremental evaluation" of declarative rules, from the functional and logic programming community. The quality of our framework will be assessed by coding selected case studies using alternative methods. In particular, we shall implement several refactorings directly in Eclipse, the leading development environment for writing aspect-oriented programs in industry. SELECTION CRITERIA The PhD student will be concerned with the theoretical foundations of the refactoring framework, for instance proofs of correctness for refactorings, and also for the incremental evaluation mechanism. We are thus looking for someone with good mathematical skills, in particular regarding formal properties of type systems and program analyses. Candidates must have an outstanding undergraduate or master's degree in computer science. More generally, candidates must satisfy the usual requirements: http://web.comlab.ox.ac.uk/oucl/prospective/dphil/dphil-criteria.pdf for doing a doctorate at Oxford. HOW TO APPLY The deadline for applications has been extended to July 17, 2007, but earlier applications will be reviewed immediately, so candidates are encouraged to apply as soon as possible. Previous applicants need not re-apply. To apply you need to download the University's application form from: http://www.admin.ox.ac.uk/postgraduate/apply/forms You will need to submit references and a transcript with your application. It is also required to submit a research proposal: in this proposal, please elaborate on the reasons why you are interested in this project, and the research questions you find most exciting and important to address within the scope of the project. To make a convincing proposal, you may wish to consult some of the suggested reading below. Please submit your application to: Mrs. Julie Sheppard Secretary for Graduate Studies Oxford University Computing Laboratory Wolfson Building Parks Road Oxford OX1 3QD United Kingdom AND NOT TO THE ADDRESS ON THE APPLICATION FORM FURTHER INFORMATION We are happy to discuss any of the above informally with prospective candidates. Just email one or all of the project leaders: Oege de Moor (oege(a)comlab.ox.ac.uk) Torbjorn Ekman (torbjorn(a)comlab.ox.ac.uk) Mathieu Verbaere (matv(a)comlab.ox.ac.uk) SUGGESTED READING Avgustinov et al, Semantics of Static Pointcuts in AspectJ, POPL 2007 http://progtools.comlab.ox.ac.uk/members/oege/publications/documents/pcsema… Ekman and Hedin. Rewritable Reference Attributed Grammars, ECOOP 2004. http://www.cs.lth.se/gorel/publications/2004-ReRAGs-LNCS.pdf Verbaere, Ettinger and De Moor. JunGL: a Scripting Language forRefactoring, ICSE 2006 http://progtools.comlab.ox.ac.uk/publications/icse06jungl Visser. Program Transformation with Stratego/XT: Rules, Strategies, Tools and Systems in StrategoXT-0.9. Domain-specific program generation. http://www.cs.uu.nl/research/techreps/UU-CS-2004-011.html

1 0

class functional depency inference?
by Hugo Pacheco 16 Jun '07

16 Jun '07

Hi, I have resumed my problem to the following. In this small example, the type checker always complains, and do need to write something similar that would use the functional dependency to infere the type b. class SomeClass a b | a -> b instance SomeClass Int Bool test :: SomeClass a b => a -> b test 1 = True Cheers, hugo

2 2

Re: Wanted: tricks for conflicting instances
by oleg＠pobox.com 16 Jun '07

16 Jun '07

Conal Elliott wrote: > The problem is that instance selection (in GHC at least) ignores the > contexts... Is it plausible to improve instance selection to use > contexts? I imagine doing so would require some kind of backtracking > search. Indeed the instance selection depends only on the types but not on their constraints. That is a feature of Haskell, and it is a useful feature (as shown in the HList paper). Still, as Jeff said, instance selection based on contexts and backtracking compile-time search are possible. For example, the article http://okmij.org/ftp/Haskell/poly2.txt says: We also show how to write typeclass instances with back-tracking: if one instance does not apply, the typechecker will chose the `next' instance -- in the precise meaning of `next'. The following article about controlling instance selection and resolving ambiguous overloading might also be helpful: http://okmij.org/ftp/Haskell/typecast.html#ambiguity-resolution

1 0

ANN: Uniplate 1.0
by Neil Mitchell 15 Jun '07

15 Jun '07

Hi, I am pleased to announce Uniplate (formerly known as Play), a library for boilerplate removal requiring only Haskell 98 (for normal use) and optionally multi-parameter type classes (for more advanced features). This library has been tested with Yhc, Hugs and GHC. The Uniplate library can do some of the same things as Scrap Your Boilerplate (SYB), and has functions that can be used in a similar manner to everywhere and everything. LINKS Project home page: http://www-users.cs.york.ac.uk/~ndm/uniplate/ Hackage release: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/uniplate-1.0 Haddock docs: http://www.cs.york.ac.uk/fp/haddock/uniplate/ Short Manual: http://www.cs.york.ac.uk/fp/darcs/uniplate/uniplate.htm Draft Paper: http://www-users.cs.york.ac.uk/~ndm/downloads/draft-uniplate-15_jun_2007.pdf The manual contains a basic overview of some bits of the library, the paper goes into more detail, but is intended to still be a readable introduction to the library. A SHORT EXAMPLE Given an Int expression data type: data Expr = Add Expr Expr | Val Int | Sub Expr Expr | Var String | Mul Expr Expr | Neg Expr | Div Expr Expr We can extract all the variables using the function: variables :: Expr -> [String] variables (Var x ) = [x] variables (Val x ) = [] variables (Neg x ) = variables x variables (Add x y) = variables x ++ variables y variables (Sub x y) = variables x ++ variables y variables (Mul x y) = variables x ++ variables y variables (Div x y) = variables x ++ variables y Or we can use the Uniplate library: variables :: Expr -> [String] variables x = [y | Var y <- universe x] THANKS TO: Colin Runciman, Bjorn Bringert, Jules Bean, Eric Mertens, Tom Shackell and Stefan O'Rear for various help and feedback. The Uniplate library has been used in Yhc, Catch, Hoogle and other projects. Please direct any follow-up discussion to haskell-cafe. Thanks Neil

1 0

ICFP07 Accepted Papers
by Matthew Fluet (ICFP Publicity Chair) 15 Jun '07

15 Jun '07

Accepted Papers ICFP 2007: International Conference on Functional Programming http://www.informatik.uni-bonn.de/~ralf/icfp07.html Freiburg, Germany, 1-3 October 2007 The ICFP 2007 Program Chair and Committee are pleased to announce that the following papers have been accepted for the conference. Additional information regarding the final program, invited speakers, and registration will be forthcoming. However, the Local Arrangements Chair offers the following advice regarding hotel reservations: * As September and October is Freiburg's main tourist season, it is important that participants book hotel rooms early. The blocks of hotel rooms reserved for ICFP participants will be held until August 1. It is expected that many downtown hotels will be fully booked at the time of the conference. [However, there should be little to no penalty for cancelling a hotel room reservation after August 1.] More details regarding accommodation and travel may be obtained from the ICFP 2007 Local Information webpage: http://proglang.informatik.uni-freiburg.de/ICFP2007/ Accepted papers ~~~~~~~~~~~~~~~ A Generic Usage Analysis with Subeffect Qualifiers by Jurriaan Hage, Stefan Holdermans, Arie Middelkoop Experience Report: A Haskell interpreter for CellML by Jonathan Cooper, Steve McKeever A type directed translation of MLF to System-F by Daan Leijen A Type System for Recursive Modules by Derek Dreyer Adding Delimited and Composable Control to a Production Programming Environment by Matthew Flatt, Gang Yu, Robert Bruce Findler, Matthias Felleisen Bidirectionalization Transformation based on Automatic Derivation of View Complement Functions by Kazutaka Matsuda, Zhenjiang Hu, Keisuke Nakano, Makoto Hamana, Masato Takeichi Experience Report: Building an Eclipse-based IDE for Haskell by Leif Frenzel Compiling with Continuations, Continued by Andrew J. Kennedy Constructor specialisation for Haskell programs by Simon Peyton Jones Evaluating High-Level Distributed Language Constructs by Jan Nystrom, Phil Trinder, David King Extensible Pattern Matching via a Lightweight Language Extension by Don Syme, Gregory Neverov, James Margetson Faster laziness using dynamic pointer tagging by Simon Marlow, Alexey Rodriguez, Simon Peyton Jones Feedback Directed Implicit Parallelism by Tim Harris, Satnam Singh Finger Trees in Russell by Matthieu Sozeau Functional Pearl: The Great Escape by David Herman Experience Report: Functional Programming in C-Rules by Jeremy Wazny Inductive Reasoning about Effectful Data Types by Andrzej Filinski, Kristian Stoevring iTasks: Executable Specifications of Interactive Work Flow Systems for the Web by Rinus Plasmeijer, Peter Achten, Pieter Koopman Lazy Call-By-Value Evaluation by Frank Huch, Bernd Brassel, Sebastian Fischer, Michael Hanus, German Vidal McErlang: A Model Checker for a Distributed Functional Programming Language by Lars-Åke Fredlund, Hans Svensson On Barron and Strachey's Cartesian Product Function by Michael Spivey, Olivier Danvy Ott: Effective Tool Support for the Working Semanticist by Peter Sewell, Francesco Zappa Nardelli, Scott Owens, Gilles Peskine, Thomas Ridge, Susmit Sarkar, Rok Strnisa Relating Complexity and Precision in Control Flow Analysis by David Van Horn, Harry Mairson Experience Report: Scheme in Commercial Web Application Development by Noel Welsh, David Gurnell Stream Fusion: From Lists to Streams to Nothing at All by Duncan Coutts, Roman Leshchinskiy, Don Stewart Tangible Functional Programming by Conal Elliott Termination Analysis and Call Graph Construction for Higher-Order Functional Programs by Damien Sereni The Portable R6RS Syntax System by Abdulaziz Ghuloum, R. Kent Dybvig Experience Report: The Reactis Validation Tool by Steve Sims, Daniel C. DuVarney Type-safe Higher-order Channels in ML-like Languages by Sungwoo Park User-Friendly Functional Programming for Web Mashups by Rob Ennals, David Gay Experience Report: Using Functional Programming to Manage a Linux Distribution by Clifford Beshers, David Fox, Jeremy Shaw

1 0

DoCon soft announcement
by Serge D. Mechveliani 15 Jun '07

15 Jun '07

Software Announcement --------------------- The Algebraic Domain Constructor DoCon, Version 2.09, written in Haskell, is available, together with its source program, on Internet at the following addresses: http://www.botik.ru/~mechvel/ click at docon-2.09 (Russian site), ftp.botik.ru/pub/local/Mechveliani/docon/ (same site), http://www.haskell.org/docon/distrib/ (USA site) The difference to previous (2.08) release is small: * it is ported to the latest (on 2007) Glasgow Haskell version of 6.6.1, * it has a simpler installation code, due to that it relies on the commands `configure', `build', `install' of the Cabal support for `making', * several bugs are fixed, * the implementation for decomposing to elementary symmetrics is improved. ----------------- Serge Mechveliani mechvel(a)botik.ru

1 0

Wanted: tricks for conflicting instances
by Conal Elliott 15 Jun '07

15 Jun '07

In playing with compositions involving functors & cofunctors, I've run into a conflict in the instances I want to provide. I imagine this sort of problem is well-known, and I'd like to hear what kinds of strategies people apply. Here's a definition of type composition: newtype O g f a = O { unO :: g (f a) } and a cofunctor class: class Cofunctor cof where cofmap :: (a -> b) -> (cof b -> cof a) We can compose functors to get a functor, cofunctors to get a functor, and functor & cofunctor in either order to get a cofunctor. instance (Functor g, Functor f) => Functor (O g f) where fmap h (O gf) = O (fmap (fmap h) gf) instance (Cofunctor g, Functor f) => Cofunctor (O g f) where cofmap h (O gf) = O (cofmap (fmap h) gf) instance (Functor g, Cofunctor f) => Cofunctor (O g f) where cofmap h (O gf) = O (fmap (cofmap h) gf) instance (Cofunctor g, Cofunctor f) => Functor (O g f) where fmap h (O gf) = O (cofmap (cofmap h) gf) I've wanted all four of those instances. The problem is that instance selection (in GHC at least) ignores the contexts. Without context, the first and fourth instances conflict, as do the second and third. Thus I statically choose two of the four rules and comment out the other two. Depending on my application, sometimes I like my choices, and sometimes I don't. Are there work-arounds to get the flexibility I want out of GHC? Is it plausible to improve instance selection to use contexts? I imagine doing so would require some kind of backtracking search. Thanks, - Conal

2 1