- Haskell - Haskell.org

haskell.org downtime
by John Peterson 25 May '04

25 May '04

We've been having hardware problems with haskell.org. We'll be offline for a while today while we swap in new hardware. Sorry for any inconvenience. John

1 0

AFP 2004 - Deadline Extension
by Varmo Vene 24 May '04

24 May '04

5th International Summer School on Advanced Functional Programming AFP 2004 Tartu, Estonia, 14-21 August 2004 http://www.cs.ut.ee/afp04 Call for Participation ******** EXTENDED DEADLINE ******** Early registration: June 11, 2004 Background and objectives AFP is a series of international summer schools which aims to bring computer scientist, in particular young researchers and programmers, up to date with the latest advances in practical functional programming. The main focus of the school is on the interface between results presented at programming conferences and the programming in the real world. This is the fifth event in the series organized by the Department of Computer Science of the Tartu University in conjuction with the Centre for Dependable Computing. The previous schools were held in Båstad (Sweden, 1995), Olympia (Washington, USA, 1996), Braga (Portugal, 1998) and Oxford (UK, 2002). Programme The scientific programme of AFP'04 consists of short courses by renowned experts of the field and a student session. The school offers eight main courses, each composed of lectures and accompanied by lab sessions. The course list is the following: John Hughes (Chalmers University of Technology): Arrows Conor McBride (University of Durham): Epigram: dependent types for practical programming Alberto Pardo (University de la Republica, Montevideo): Combining datatypes and effects Rinus Plasmeijer (University of Nijmegen): Generic programming techniques for the construction of graphical user interfaces A strongly typed functional operating system based on dynamics Bernie Pope (University of Melbourne): Declarative debugging with Buddha Doaitse Swierstra (Utrecht University) Oege de Moor (Oxford University): First-class aspects in Haskell Peter Thiemann (University of Freiburg): Server-side Web programming in WASH Simon Thompson (University of Kent): Refactoring Functional Programs In addition, there will be some introductory and intermediate functional programming courses serving as a preparation for the advanced courses. The purpose of the student session is to give students an opportunity to present their work and get feedback. Everyone intending to give a presentation should submit an extended abstract (max 10 pp) along with the registration form. Venue Tartu, with 100,000 inhabitants, is the second largest city in Estonia, situated 180 km south-east from Tallinn. Tartu University, founded 1632, is one of the oldest universities in Northern Europe. The school will be held in the new building of the Faculty of Mathematics and Computer Science. Tartu is accessible from Tallinn by coach. The coaches run very frequently (1-2 departures per hour) and the ride takes 2-2.5 hrs. Tallinn, with 400,000 inhabitants, is the capital city of Estonia, that used to be a member of the Hansa League. Tallinn's medieval Old Town is on the UNESCO World Heritage List. There are direct flights to Tallinn from London, Paris, Amsterdam, Frankfurt, Hamburg, Berlin, Prague, Warsaw, Moscow, Copenhagen, Oslo, Stockholm, Helsinki. Important dates June 11, 2004 Early registration deadline July 9, 2004 Late registration deadline Registration and cost The registration is done through internet http://www.cs.ut.ee/afp04. The deadline for registration is July 9, 2004 and the registration fee is 330 EUR. For early registrants, until May 14, there is a reduced registration fee 280 EUR. The registration fee includes course materials distributed during the school, revised lecture notes published by Springer after the school, lunches, refreshments for coffee breaks and conference dinner. Programme committee / organizing committee Varmo Vene (Tartu University) Tarmo Uustalu (Inst. of Cybernetics, Tallinn) Johan Jeuring (Utrecht University) Sponsors Centers of Excellence in Research Programme of Ministry of Education and Research of Estonia Further information Details on the submission of abstracts, registration procedure and cost are available from the school webpage, http://www.cs.ut.ee/afp04. Questions should be sent to afp04(a)cs.ut.ee.

1 0

ANNOUNCE: HOC (Haskell to Objective-C Binding) 0.7
by André Pang 19 May '04

19 May '04

About HOC ========= HOC is a Haskell to Objective-C binding. In a nutshell, it enables you to use Objective-C objects and frameworks from Haskell, and also enables you to write Objective-C objects in Haskell. You can write full-blown applications in HOC and use all of the Foundation, AppKit and Cocoa frameworks' classes (including all of the AppKit's GUI objects), combining Objective-C tools such as Mac OS X's Interface Builder to build the GUI graphically while writing controllers for the GUI in Haskell. You can even mix and match custom objects written in Objective-C with objects written in Haskell, depending on which language you find more suitable for the task. HOC comes some sample GUI programs: you can find screenshots of these HOC programs at <http://hoc.sourceforge.net/screenshots/>. The Haskell interfaces produced by HOC are strongly typed (Objective-C classes are mapped to Haskell's typed system), can be automatically generated from Objective-C header files, and are designed to integrate well with existing Haskell code, taking advantage of features such as type classes and partial application to make its Haskell API as easy to use and as "Haskell-like" as possible. HOC's primary platform is Mac OS X, although it has been lightly tested with the free GNUstep platform on Linux. HOC requires the Glasgow Haskell Compiler (GHC) 6.2 or later. Note: If you have heard of a Haskell to Objective-C binding named Mocha, HOC is effectively a working version of Mocha, which was never completed due to time constraints. A previous version of HOC (0.1) was mentioned briefly on the glasgow-haskell-users mailing list on January 2003, but is a very different beast to the current incarnation: HOC 0.1 was more of an experiment with Template Haskell than a serious implementation. Wolfgang Thaller, the primary author of HOC, has collaborated greatly with Andre Pang, who was the primary author of Mocha, to forge a new HOC that we hope you will find achieves all the ambitious goals that Mocha strived for, and more. Mocha is dead, long live HOC! More information on HOC (including where you can download it!) is available on its homepage, at: http://hoc.sourceforge.net/ Authors ======= Wolfgang Thaller <wolfgang.thaller(a)gmx.net> Andre Pang <ozone(a)algorithm.com.au> Enjoy! -- % Andre Pang : trust.in.love.to.save

1 0

CFP: CLIMA V - 5th International Workshop on Computational Logic in Multi-Agent Systems
by João Leite 19 May '04

19 May '04

========================================================================== FIRST CALL FOR PAPERS CLIMA V Fifth International Workshop on Computational Logic in Multi-Agent Systems September 29 and 30, 2004, Lisbon, Portugal http://centria.di.fct.unl.pt/~jleite/climaV/index.htm Submission Deadline: June 25th (abstracts due June 20th) Co-located with JELIA'04 =========================================================================== CALL FOR PAPERS Multi-agent systems are communities of problem-solving entities that can perceive and act upon their environments to achieve their individual goals as well as joint goals. The work on such systems integrates many technologies and concepts in artificial intelligence and other areas of computing. For this reason, over recent years, the agent paradigm gained popularity in many sub-fields of computer science. A full spectrum of multi-agent systems applications have been and are being developed; from search engines to educational aids to electronic commerce and trade, e-procurement, recommendation systems, simulation and routing, to cite only some. Although commonly implemented by means of imperative languages, mainly for reasons of efficiency, the agent concept has recently increased its influence in the research and development of computational logic based systems. Computational logic provides a well-defined, general, and rigorous framework for studying syntax, semantics and procedures, for attending implementations, environments, tools, and standards, and for linking together specification and verification of properties of computational systems. The purpose of this workshop is to discuss techniques, based on computational logic, for representing, programming and reasoning about multi-agent systems in a formal way. Following the workshop on Multi-Agent Systems in Logic Programming affiliated with ICLP'99, the first CLIMA workshop took place in London, UK, affiliated with CL'2000. The 2001 edition of CLIMA, took place in Paphos, Cyprus, affiliated with ICLP'01. CLIMA'02 took place in Copenhagen, Denmark, and was affiliated with ICLP'02 and part of FLOC'02. The fourth edition of the workshop, CLIMA IV, took place in Fort Lauderdale, USA, and was co-located with LPNMR-7 and SAIM'04. We solicit unpublished papers that address formal approaches to multi-agent systems. the approaches as well as being formal must make a significant contribution to the practice of multi-agent systems. relevant techniques include, but are not limited to, the following: * logical foundations of multi-agent systems * knowledge and belief representation and updates in multi-agent systems * agent and multi-agent hypothetical reasoning and learning * extensions of logic programming for multi-agent systems * nonmonotonic reasoning in multi-agent systems * theory and practice of argumentation for agent reasoning and interaction * operational semantics and execution agent models * model checking algorithms, tools, and applications for multi-agent logics * semantics of interaction and agent communication languages * distributed constraint satisfaction in multi-agent systems * temporal reasoning for multi-agent systems * modal logic approaches to multi-agent systems * logic based programming languages for multi-agent systems * distributed theorem proving for multi-agent systems * logic based implementations of multi-agent systems * decision theory for multi-agent systems * specification and verification of formal properties of agent systems SUBMISSION INSTRUCTIONS We welcome and encourage the submission of high quality, original papers, which are not simultaneously submitted for publication elsewhere. Please refer to the workshop web pages for further instructions concerning the submission procedures. IMPORTANT DATES * Submission of Abstracts: June 20th, 2004 * Submission of Papers: June 25th, 2004 * Notification of Acceptance: July 30th, 2004 * Final version due: September 6th, 2004 * CLIMA IV: September 29-30th, 2004 PROCEEDINGS The post-proceedings of the previous edition of CLIMA were published by Springer-Verlag as a volume of the Lecture Notes on Artificial Intelligence series. We are currently negotiating the publication of the post-proceedings of CLIMA V. Please watch the website for more information. PROGRAM COMMITTEE * José Alferes, New University of Lisbon, Portugal * Gerd Brewka, University of Leipzig, Germany * Jürgen Dix, Technical University of Clausthal, Germany * Klaus Fischer, DFKI, Germany * Michael Fisher, University of Liverpool, UK * James Harland, Royal Melbourne Institute of Technology, Australia * Katsumi Inoue, National Institute of Informatics, Japan * Sverker Janson, Swedish Institute of Computer Science, Sweden * João Leite, New University of Lisbon, Portugal * Yves Lespérance, York University, Canada * John Jules Ch. Meyer, University of Utrecht, The Netherlands * Leora Morgenstern, IBM, USA * Wojciech Penczek, Polish Academy of Sciences, Poland * Jeremy Pitt, Imperial College, UK * Enrico Pontelli, New Mexico State University, USA * Fariba Sadri, Imperial College, UK * Ken Satoh, National Institute of Informatics, Japan * Renate Schmidt, The University of Manchester, UK * Tran Cao Son, New Mexico State University, USA * Francesca Toni, Imperial College, UK * Paolo Torroni, University of Bologna, Italy * Wiebe Van Der Hoek, University of Liverpool, UK * Makoto Yokoo, Kyushu University, Japan * Cees Witteveen, Delft University of Technology, The Netherlands WORKSHOP ORGANIZERS: * João Leite, New University of Lisbon, Portugal (jleite(a)di.fct.unl.pt) * Paolo Torroni, University of Bologna, Italy (ptorroni(a)deis.unibo.it) INQUIRIES: Please send program suggestions and inquires to either of the organizers.

1 0

Queues / Lists with unbound tails
by andrew cooke 18 May '04

18 May '04

Hi, I'm trying to write a simple fifo queue of fixed length (containing type Maybe a - it would be initialised to Nothings) where pushing an item pops the "last" item "off the end". data Queue a = QUEUE (Maybe a -> (Queue a, Maybe a)) queue :: Maybe a -> Queue a queue n1 = QUEUE (\n2 -> (queue n2, n1)) consQ :: Queue a -> Queue a -> Queue a consQ (QUEUE q1) (QUEUE q2) = QUEUE (\n -> let (q1', n1) = q1 n (q2', n2) = q2 n1 in (consQ q1' q2', n2)) works, and lets me construct arbitrary length queues, but the push/pop operation is O(n) (I believe) in the length of the queue. I don't have Okasaki's book with me, but I'm pretty sure he gives a solution that has two lists, with the second inverted via an operation that is either amortized O(1), or inverted stepwise using lazy evaluation. However, it seems to me that there should be another solution, with a lazily constructed list whose tail does not yet exist. The queue would consiste of the head of the list (which is the "tail" of the queue!) and a closure that extends the list tail (ie the queue head). Pushing an element would involve invoking the closure, extending the tail of the (lazily constructed) list, and returning another closure to continue the process. The return ("pop") value would be the head of the list, with the next item carried forward as the next return value. I think this would be simple to implement in Prolog or Oz, for example, where the last element of a list can be unbound. I assume the same is possible in Haskell using laziness and closures. However, I cannot nail it down. Can anyone help? Apologies for the unclear description. If I could describe the solution clearly then I could write the code and wouldn't need to ask :o) Thanks, Andrew -- ` __ _ __ ___ ___| |_____ work web site: http://www.ctio.noao.edu/~andrew / _` / _/ _ \/ _ \ / / -_) personal web site: http://www.acooke.org/andrew \__,_\__\___/\___/_\_\___| list: http://www.acooke.org/andrew/compute.html

3 6

Updates using Field Labels
by Gregory Wright 17 May '04

17 May '04

Hi, I have a program that processes files and builds up records for later insertion into a database. (The actual program uses a lexer and some helper functions to extract the necessary information from the files; the attached program reproduces the behavior in question.) When I run the real program or the attached sample program I get the error Fail: ios.hs:50: Missing field in record construction Main.sigPriority (This is using GHC-6.2.1 on Mac OS X 10.3.3 built from darwinports.) I don't understand the reason for this error message. It seems to be more constraining than my reading of section 3.15.3 of the Report (Updates Using Field Labels). There is a workaround: explicitly update the field sigPriority. I had hoped that that would not be necessary. Could someone explicate this? Best Wishes, Greg Gregory Wright Antiope Associates LLC gwright(a)antiope.com

2 3

ANNOUNCE: cpphs-0.2
by Malcolm Wallace 17 May '04

17 May '04

cpphs-0.2 --------- Cpphs is a re-implementation (in Haskell) of the C pre-processor. Version 0.1 dealt only with conditional compilation (#if and friends) and file inclusion (#include). Version 0.2 now also implements the rest of cpp's functionality, namely in-line symbol replacement and macro expansion (#define and friends). I believe this to be a reasonably complete and correct implementation, and have tested it on some non-trivial examples from the standard libraries (e.g. Foreign.Storable and HOpenGL). Nevertheless, there will be bugs and I encourage you to find them and report them. http://www.cs.york.ac.uk/fp/cpphs/ ---- Why re-implement cpp? Rightly or wrongly, the C pre-processor is widely used in Haskell source code. It enables conditional compilation for different compilers, different versions of the same compiler, and different OS platforms. It is also occasionally used for its macro language, which can enable certain forms of platform-specific detail-filling, such as the tedious boilerplate generation of instance definitions and FFI declarations. However, there are two problems with cpp, aside from the obvious aesthetic ones: * For some Haskell systems, notably Hugs on Windows, a true cpp is not available by default. * Even for the other Haskell systems, the common cpp provided by the gcc 3.x series is changing subtly in ways that are incompatible with Haskell's syntax. There have always been problems with, for instance, string gaps, and prime characters in identifiers. These problems are only going to get worse. So, it seemed right to attempt to provide an alternative to cpp, both more compatible with Haskell, and itself written in Haskell so that it can be distributed with compilers. Share and Enjoy, Malcolm

3 2

SOS Workshop - final CfP
by Wan.Fokkink＠cwi.nl 17 May '04

17 May '04

Call for Papers Structural Operational Semantics http://www.cs.auc.dk/~luca/SOS-WORKSHOP/ A Satellite Workshop of CONCUR 2004 30 August, 2004, London, United Kingdom Structural operational semantics (SOS) provides a framework for giving operational semantics to programming and specification languages. A growing number of programming languages from commercial and academic spheres have been given usable semantic descriptions by means of structural operational semantics. Because of its intuitive appeal and flexibility, structural operational semantics has found considerable application in the study of the semantics of concurrent processes. Moreover, it is becoming a viable alternative to denotational semantics in the static analysis of programs, and in proving compiler correctness. Recently, structural operational semantics has been successfully applied as a formal tool to establish results that hold for classes of process description languages. This has allowed for the generalization of well-known results in the field of process algebra, and for the development of a meta-theory for process calculi based on the realization that many of the results in this field only depend upon general semantic properties of language constructs. The proposed SOS workshop aims to be a forum for researchers, students and practitioners interested in new developments and directions for future investigation in the field of structural operational semantics. One of the specific goals of the workshop is to establish synergies between the concurrency and programming language communities working on the theory and practice of SOS. The workshop will also mark the publication of a special issue of the Journal of Logic and Algebraic Programming, devoted to SOS. Together with original research papers on SOS, this special issue will feature a definitive version of Gordon Plotkin's 1981 DAIMI memo on SOS, together with a piece by Plotkin on the origins of SOS. Specific topics of interest include (but are not limited to): * programming languages * process algebras * higher-order formalisms * rule formats for operational specifications * meaning of operational specifications * comparisons between denotational, axiomatic and SOS * compositionality of modal logics with respect to operational specifications * congruence with respect to behavioural equivalences * conservative extensions * derivation of proof rules from operational specifications * software tools that automate, or are based on, SOS Papers reporting on applications of SOS to software engineering and other areas of computer science are welcome. Paper submission: We solicit unpublished papers reporting on original research on the general theme of SOS. Prospective authors are invited to submit a pdf or postscript file with their extended abstract, whose length should not exceed 15 pages, by email to all of the co-chairs at their respective email addresses. The email message with the submission should also include, in plain text, contact information for the author(s), together with the title and abstract of the submission. Submissions are to be received by Sunday, 6 June, 2004. Authors will be notified of acceptance by Wednesday, 30 June, 2004. Submissions from the PC members are allowed. Proceedings: Preliminary proceedings containing the abstracts of the talks will be published as a volume in the BRICS Notes Series, and will be available at the meeting. The final proceedings of the workshop will appear as a volume in the ENTCS series. If the quality and quantity of the submissions warrant it, the co-chairs plan to arrange a special issue of an archival journal devoted to full versions of selected papers from the workshop. Important Dates: * Submission: Sunday 6 June 2004 * Notification: Wednesday 30 June 2004 * Final version: Friday July 16 2004 * Workshop: Monday 30 August 2004 Invited Speakers: Andrew Pitts (Cambridge, United Kingdom) Gordon Plotkin (Edinburgh, United Kingdom) (To be confirmed) Program Committee: Luca Aceto (BRICS, Aalborg, Denmark, co-chair) Wan Fokkink (CWI, The Netherlands, co-chair) Rob van Glabbeek (NICTA, Sydney, Australia) Ralf Laemmel (CWI, The Netherlands) Peter Mosses (BRICS, Aarhus, Denmark) David Sands (Chalmers, Sweden) Alex Simpson (Edinburgh, United Kingdom) Simone Tini (Insubria, Italy) Irek Ulidowski (Leicester, United Kingdom, co-chair) Erik de Vink (Eindhoven, The Netherlands) Organizing Committee: Luca Aceto, email: luca AT cs.auc.dk, Wan Fokkink, email: wan AT cwi.nl, Irek Ulidowski, email iu3 AT mcs.le.ac.uk

1 0

FST&TCS 2004 Call for Papers
by R. Ramanujam 16 May '04

16 May '04

---------------------------------------------------------------- FST&TCS 2004 The 24th Conference on Foundations of Software Technology and Theoretical Computer Science December 16--18, 2004, Chennai, INDIA CALL FOR PAPERS * Important dates: Submissions: 21st June 2004 Notification: 20th August 2004 * Satellite Workshops: December 13--15, 2004. Algorithms for dynamic data, coordinated by S. Muthukrishnan and Pankaj Agarwal. Logic for dynamic data, coordinated by Uday Reddy. * Invited Speakers: Javier Esparza Piotr Indyk Pavel Pevzner John C. Reynolds Denis The'rien * For details see: http://www.fsttcs.org/ ----------------------------------------------------------------

1 0

Re: [Haskell] ANNOUNCE: HaRP (Haskell Regular Patterns) version 0.1
by Niklas Broberg 16 May '04

16 May '04

>What about > >foo [/ (/ 2 (/ a _ /)* 3 /)* /] = a > >? What is the type of a here? I think it should be [[Int]]. Not quite, the type of a will be [Int]. The only context dependency of variable types is the difference between linear and non-linear contexts. In linear context, variables have the types you would normally expect in standard Haskell. In non-linear context, the type is a list of what it would otherwise be, regardless of what and how many enclosing non-linear regular pattern operators. If you want a full trace of where the items in a come from, you need to do it in several steps: foo [/ (/ 2 b@:(/ _ _ /)* 3 /)* /] = map (map bar) b -- here b :: [[[Int]]] where bar [a, _] = a The reason for b having type [[[Int]]] is that it binds to a pattern of type [[Int]] (a repeating * enclosing a sequence). In general: binding explicitly preserves the trace of the pattern it binds to; binding implicitly preserves no trace at all. To see why this is so, consider the following analogy: bar :: Maybe (Maybe (Maybe Int)) -> (Maybe (Maybe Int), Maybe Int, Int) bar (Just a@(Just b@(Just c))) = (a,b,c) When binding a , you look at the type of the subpattern it binds to. When looking at the value held by a on the right hand side, there is no way to trace the context it appeared in before the pattern match. When binding c, you also look at the subpattern it binds to, i.e. the pattern c is equivalent to the pattern c@_. There is no trace of where it comes from. Now look at this regular pattern: foo [/ a@:(/ _ b@:(/ _ c /) /) /] = (a,b,c) What is the type of foo? Well, the type of c is whatever it binds to, which is just an element of the list (assuming Int). But since it is bound in non-linear context, its type will be [Int]. This form of context dependence is the only one we ever need to consider, where a variable is bound implicitly. And the only question is, does it have a list type or not? Another way to look at it is to see that c is equivalent to c@:_ in non-linear context and c@_ in linear context. b is bound explicitly using the @: operator, so the type of b is a list of whatever it binds to. No context dependence. What it binds to is a a sequence, i.e. a list, so the type of b will be [[Int]]. a is bound explicitly using the @: operator, so the type of a is a list of what it binds to. No context dependece here either. It too binds to a list, so its type will be [[Int]]. Thus, foo :: ([[Int]], [[Int]], [Int]) >And then which special syntax for implicit binding am I supposed to use? >Is it > >foo [/ (/ 2 (/ a@:(/_ _/) _ /)* 3 /)* /] = a > >or maybe > >foo [/ (/ 2 (/ a@::(/_ _/) _ /)* 3 /)* /] = a The former. We have added the @: operator as a a non-linear counterpart of the linear @. Adding more : won't add more levels of lists... >? And what's the type? [[[Int]]]? Not quite right here either, the type will be [[Int]]. The first enclosing list comes from the fact that the subsequence (/ ... /) has type list (whatever will be matched against it is a sequence of items), and the second enclosing list comes from the use of the non-linear binding operator @:. Hopefully I make sense (more than before?). I'm starting to think maybe our context dependent approach to implicit bindings isn't very good after all since it seems to confuse a lot of people. Perhaps variables bound inside regular patterns should always be non-linear... of course that would still be context dependent when compared to normal Haskell patterns, but perhaps still less confusing? Anyway, thanks for the interest and the comments =) /Niklas _________________________________________________________________ The new MSN 8: advanced junk mail protection and 2 months FREE* http://join.msn.com/?page=features/junkmail

3 2