- Haskell - Haskell.org

ACM PPDP'06 call for papers
by Simon Marlow 30 Jan '06

30 Jan '06

[ posting on behalf of Agostino Cortesi <cortesi(a)unive.it> ] ................................................................ PPDP 2006 Preliminary Call For Papers 8th ACM-SIGPLAN International Symposium on Principles and Practice of Declarative Programming Venice, Italy, July 10-12, 2006 http://www.dsi.unive.it/ppdp2006/ ................................................................ IMPORTANT DATES Submission 15 March 2006 Notification 22 April 2006 SCOPE: PPDP 2006 is a forum for the declarative programming communities, gathering researchers working on logic, constraint and functional programming, but also on other programming language paradigms like visual programming, executable specification languages, database languages, AI and knowledge representation languages for the "semantic web". MAIN TOPICS: Logic, Constraint, and Functional Programming; Database, AI and Knowledge Representation Languages; Visual Programming; Executable Specification for Languages; Applications of Declarative Programming; Methodologies Program Design and Development; Declarative Aspects of Object-Oriented Programming; Concurrent Extensions to Declarative Languages; Declarative Mobile Computing; Paradigm Integration; Proof Theoretic and Semantic Foundations; Type and Module Systems; Program Analysis and Verification; Program Transformation; Abstract Machines and Compilation; Programming Environments. PROCEEDINGS: Proceedings will be published by ACM Press. RELATED EVENTS: PPDP 2006 will be co-located with the 33rd International Colloquium on Automata, Languages and Programming (ICALP 2006), which will take place on July 9-16, 2006 (http://icalp06.dsi.unive.it) CONFERENCE CHAIR: Annalisa Bossi, U. Ca' Foscari di Venezia PROGRAM CHAIR: Michael Maher, National ICT Australia PROGRAM COMMITTEE: Nick Benton (Microsoft Research, UK) Annalisa Bossi (U. Ca' Foscari di Venezia, Italy) Manuel Chakravarty (U. NSW, Australia) Bart Demoen (K. U. Leuven, Belgium) Moreno Falaschi (U. Udine, Italy) Radha Jagadeesan (DePaul U., USA) Bharat Jayaraman (SUNY Buffalo, USA) Yukiyoshi Kameyama (U. Tsukuba, Japan) Andy King (U. Kent, UK) Francois Laburthe (Bouyges, France) David Sands (Chalmers U., Sweden) Christian Schulte (KTH, Sweden) Pascal Van Hentenryck (Brown U., USA) Roland Yap (NUS, Singapore) =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- prof. agostino cortesi tel. 0039 041 234.8450 dipartimento di informatica fax 0039 041 234.8419 universita' ca' foscari mail cortesi(a)dsi.unive.it via torino 155 url www.dsi.unive.it/~cortesi 30170 Venezia location: studio n.1

1 0

AMAST 2006 Final Call for Papers (extended deadlines)
by Varmo Vene 28 Jan '06

28 Jan '06

NEWS: - Extended deadlines: * Submission of abstracts: 3 February 2006 * Submission of full papers: 10 February 2006 FINAL CALL FOR PAPERS 11th International Conference on Algebraic Methodology and Software Technology, AMAST '06 colocated with MPC '06 Kuressaare, Estonia, 5-8 July 2006 http://cs.ioc.ee/mpc-amast06/amast/ Background The major goal of the AMAST conferences is to promote research that may lead to the setting of software technology on a firm, mathematical basis. This goal is advanced by a large international cooperation with contributions from both academia and industry. The virtues of a software technology developed on a mathematical basis have been envisioned as being capable of providing software that is (a) correct, and the correctness can be proved mathematically, (b) safe, so that it can be used in the implementation of critical systems, (c) portable, i.e., independent of computing platforms and language generations, and (d) evolutionary, i.e., it is self-adaptable and evolves with the problem domain. The previous conferences were held in Iowa City, Iowa, USA (1989, 1991 and 2000), Twente, The Netherlands (1993), Montreal, Canada (1995), Munich, Germany (1996), Sydney, Australia (1997), Manaus, Amazonia, Brazil (1998), Reunion Island, France (2002) and Stirling, UK (2004, colocated with MPC' 04). The 2006 conference will be held at Kuressaare, Estonia, colocated with MPC '06. The conference series has become widely known for disseminating academic and industrial achievements within the broad AMAST areas of interest. Through these meetings AMAST has attracted an international following among researchers and practitioners interested in software technology, programming methodology and their algebraic and logical foundations. Important dates * Submission of abstracts: 3 February 2006 (extended) * Submission of full papers: 10 February 2006 (extended) * Notification of authors: 17 March 2006 * Camera-ready version: 14 April 2006 Topics Topics of interest include, but are not limited to, the following: * Software technology: systems software technology, application software technology, concurrent and reactive systems, formal methods in industrial software development, formal techniques for software requirements/design, evolutionary software/adaptive systems. * Programming methodology: logic programming, functional programming, object paradigms, constraint programming and concurrency, program verification and transformation, programming calculi, specification languages and tools, formal specification and development case studies. * Algebraic and logical foundations: logic, category theory, relation algebra, computational algebra, algebraic foundations for languages and systems, coinduction, theorem proving and logical frameworks for reasoning, logics of programs, algebra and coalgebra. * Systems and tools (for system demonstrations or ordinary papers): software development environments, support for correct software development, system support for reuse, tools for prototyping, component based software development tools, validation and verification, computer algebra systems, theorem proving systems. Submission and publication Two kinds of submissions are solicited for this conference: technical papers and system demonstrations. Papers may report academic or industrial progress, and papers which deal with both are especially well-regarded. Submission is in two stages. Abstracts (plain text) must be submitted by 3 February 2006 (extended). Full papers (pdf) adhering to the llncs style and not longer than 15 pages (6 pages for system demonstrations) must be submitted by 10 February 2006 (extended). The web-based submission system is open. Papers must report previously unpublished work and not be submitted concurrently to another conference with refereed proceedings. Accepted papers must be presented at the conference by one of the authors. All papers will be refereed by the programme committee, and will be judged based on their significance, technical merit, and relevance to the conference. The proceedings of AMAST '06 will be published in the Lecture Notes in Computer Science series of Springer-Verlag. Programme Committee Michael Johnson, Macquarie University (co-chair) Varmo Vene, University of Tartu (co-chair) Luís Barbosa, Universidade do Minho Gilles Barthe, INRIA Sophia-Antipolis Michel Bidoit, École Normale Supérieure de Cachan Gregor v. Bochmann, University of Ottawa Manfred Broy, Technische Universität München Cristian Calude, University of Auckland Christine Choppy, Université Paris Nord Arthur Fleck, University of Iowa Marcelo Frias, Universidad de Buenos Aires Nicolas Halbwachs, Université Grenoble I / CNRS Anne Haxthausen, Technical University of Denmark Antonia Lopes, Universidade de Lisboa Michael Mislove, Tulane University Peter Mosses, University of Wales Swansea Monica Nesi, Università degli Studi di L'Aquila Rocco De Nicola, Università degli Studi di Firenze Anton Nijholt, Universiteit Twente Dusko Pavlovic, Kestrel Institute Jaco van de Pol, CWI Charles Rattray, University of Stirling Teodor Rus, University of Iowa Giuseppe Scollo, Università degli Studi di Catania Carolyn Talcott, SRI International Andrzej Tarlecki, Warsaw University Ken Turner, University of Stirling Irek Ulidowski, University of Leicester Martin Wirsing, Ludwig-Maximilians-Universität München AMAST steering committee Egidio Astesiano, Universita degli Studi di Genova Robert Berwick, MIT Zohar Manna, Stanford University Michael Mislove, Tulane University Anton Nijholt, University of Twente Maurice Nivat, Universite Paris 7 Charles Rattray, University of Stirling Teodor Rus, University of Iowa Giuseppe Scollo, Universita degli Studi di Catania Michael Sintzoff, Universite Catholique de Louvain Jeannette Wing, Carnegie Mellon University Martin Wirsing, Ludwig-Maximilians-Universitaet Muenchen Michael Johnson, Macquarie University (chair) Venue Kuressaare (pop. 16000) is the main town on Saaremaa, the second-largest island of the Baltic Sea. Kuressaare is a charming seaside resort on the shores of the Gulf of Riga highly popular with Estonians as well as visitors to Estonia. The scientific sessions of MPC/AMAST 2006 will take place at Saaremaa Spa Hotel Meri, one among the several new spa hotels in the town. The social events will involve a number of sites, including the 14th-century episcopal castle. Accommodation will be at Saaremaa Spa Hotels Meri and Ruutli. To get to Kuressaare and away, one must pass through Tallinn (pop. 402000), Estonia's capital city. Tallinn is famous for its picturesque medieval Old Town, inscribed on UNESCO's World Heritage List. Local organizers MPC/AMAST 2006 is organized by Institute of Cybernetics, a research institute of Tallinn Univ. of Technology. The local organizers are Tarmo Uustalu (chair), Monika Perkmann, Juhan Ernits, Ando Saabas, Olha Shkaravska, Kristi Uustalu. Contact email addresses: mike(at)ics.mq.edu.au, varmo(at)cs.ut.ee.

1 0

MPC 2006 Final Call for Papers (extended deadlines)
by Tarmo Uustalu 28 Jan '06

28 Jan '06

NEWS: - Extended deadlines: * Submission of abstracts: 3 February 2006 * Submission of full papers: 10 February 2006 FINAL CALL FOR PAPERS 8th International Conference on Mathematics of Program Construction MPC '06 Kuressaare, Estonia, 3-5 July 2006 http://cs.ioc.ee/mpc-amast06/mpc/ colocated with AMAST '06 Background The biennial MPC conferences aim to promote the development of mathematical principles and techniques that are demonstrably useful and usable in the process of constructing computer programs. Topics of interest range from algorithmics to support for program construction in programming languages and systems. The previous conferences were held in Twente, The Netherlands (1989), Oxford, UK (1992), Kloster Irsee, Germany (1995), Marstrand, Sweden (1998), Ponte de Lima, Portugal (2000), Dagstuhl, Germany (2002) and Stirling, UK (2004, colocated with AMAST '04). The 2006 conference will be held at Kuressaare, Estonia, colocated with AMAST '06. Invited speakers Robin Cockett, University of Calgary Olivier Danvy, Aarhus Universitet Oege de Moor, University of Oxford Important dates * Submission of abstracts: 3 February 2006 (extended) * Submission of full papers: 10 February 2006 (extended) * Notification of authors: 17 March 2006 * Camera-ready version: 14 April 2006 Topics Papers are solicited on mathematical methods and tools put to use in program construction. Topics of interest range from algorithmics to support for program construction in programming languages and systems. Some typical areas are type systems, program analysis and transformation, programming language semantics, program logics. Theoretical contributions are welcome provided their relevance for program construction is clear. Reports on applications are welcome provided their mathematical basis is evident. Submission and publication Submission is in two stages. Abstracts (plain text) must be submitted by 3 February 2006 (extended). Full papers (pdf) adhering to the llncs style must be submitted by 10 February 2006 (extended). There is no official page limit, but authors should strive for brevity. The web-based submission system is open. Papers must report previously unpublished work and not be submitted concurrently to another conference with refereed proceedings. PC members may submit. Accepted papers must be presented at the conference by one of the authors. The proceedings of MPC '06 will be published in the Lecture Notes in Computer Science series of Springer-Verlag. After the conference, the authors of the best papers will be invited to submit revised versions to a special issue of the Science of Computer Programming journal of Elsevier. Programme committee Tarmo Uustalu, Institute of Cybernetics, Tallinn (chair) Roland Backhouse, University of Nottingham Eerke Boiten, University of Kent Venanzio Capretta, University of Ottawa Sharon Curtis, Oxford Brookes University Jules Desharnais, Université de Laval Jeremy Gibbons, University of Oxford Lindsay Groves, Victoria University of Wellington Ian Hayes, University of Queensland William Harrison, University of Missouri Johan Jeuring, Universiteit Utrecht Dexter Kozen, Cornell University Christian Lengauer, Universität Passau Lambert Meertens, Kestrel Institute Bernhard Möller, Universität Augsburg Shin-Cheng Mu, University of Tokyo José Oliveira, Universidade do Minho Alberto Pardo, Universidad de la República Ross Paterson, City University London Ingrid Rewitzky, University of of Stellenbosch Varmo Vene, University of Tartu Satellite workshops Two workshops will be held in conjunction with MPC 2006 as satellites on 2 July 2006: 5th International Workshop on Constructive Methods for Parallel Programming, CMPP 2006 Workshop on Mathematically Structured Functional Programming, MSFP 2006 Venue Kuressaare (pop. 16000) is the main town on Saaremaa, the second-largest island of the Baltic Sea. Kuressaare is a charming seaside resort on the shores of the Gulf of Riga highly popular with Estonians as well as visitors to Estonia. The scientific sessions of MPC/AMAST 2006 will take place at Saaremaa Spa Hotel Meri, one among the several new spa hotels in the town. The social events will involve a number of sites, including the 14th-century episcopal castle. Accommodation will be at Saaremaa Spa Hotels Meri and Rüütli. To get to Kuressaare and away, one must pass through Tallinn (pop. 402000), Estonia's capital city. Tallinn is famous for its picturesque medieval Old Town, inscribed on UNESCO's World Heritage List. Local organizers MPC/AMAST 2006 is organized by Institute of Cybernetics, a research institute of Tallinn University of Technology. The local organizers are Tarmo Uustalu (chair), Monika Perkmann, Juhan Ernits, Ando Saabas, Olha Shkaravska, Kristi Uustalu. Contact email address: mpc06(at)cs.ioc.ee.

1 0

page names on the new Haskell wiki
by Wolfgang Jeltsch 28 Jan '06

28 Jan '06

Hello, the names of the pages of the new MediaWiki-driven Haskell wiki are often rather directory names than "article titles" as they are on Wikipedia. For example, the page "Books and tutorials about Haskell" isn't named "Books and tutorials about Haskell" or "Books and tutorials" but just "Books". Another example is the GHC documentation page which is named "GHC/Documentation". Here the slash is used to express a hierarchy as it's done in UNIX path names, for example. But Wikipedia uses the slash just where it is used normally. For example, the term "I/O" contains a slash and the Wikipedia article about I/O is named "I/O". I propose that we stick to the Wikipedia convention and choose page names which are a short description of the page's topic in normal (English) language. Remember, that the page name is not only part of the page's URL but also displayed as a title on the page and in the window's title bar. What do you think? Best wishes, Wolfgang

3 4

Scripting language: is Haskell a good choice?
by Jules Jacobs 27 Jan '06

27 Jan '06

Hi, I would like to create a scripting language, similar to Ruby, Perl and Python. Pugs, written in Haskell, is a Perl6 implementation. Is Haskell a good choice for me? I have no experience with Haskell (yet), but I like the concept of functional programming. Because Haskell will probably be too slow for the final implementation, I will have to rewrite it in C or maybe D. Haskell can be very useful as a test/prototype implementation, where speed is not very important. But will I be able to create a clean, and easy to understand implementation in Haskell? The scripting language will be object oriented, and imperative. Is that a problem because Haskell is functional, or is there be an obvious and nice way to implement an imperative scripting language? The language is very dynamic, and the source-tree needs to be in memory because it is modifiable at run-time. Would it be good to do this in Haskell, and port it to C if I like the implementation, or start in C? Keep the parser/lexer for the source code in Haskell, but port only the interpreter to C? What would be a good place to start? I am reading Yet Another Haskell tutorial, and I've read the first 6 of two dozen lessons in Haskell. What to do next, practice/read more/start with the implementation of the scripting language? Thanks in advance, Jules

7 8

Discrete event simulation
by Paul Johnson 26 Jan '06

26 Jan '06

Hi, I'm going slowly nuts here. Maybe someone can help me out. I want to do some fairly straightforward discrete event simulation. Tasks do side effects, probably in the ST monad. Every so often the current task calls "delay n" where n is a number of seconds. This puts the task back on a list of schedulable processes that is ordered by time, and then takes the head of the list and starts executing it. Part of this will be some kind of synchronisation primitive. I don't much care what it is, but somewhere I need a way to make a process wait until something happens rather than just a constant time. I think I want to use something like type Task r s a = ContT r (ST s) a But I can't see how to actually do it. I've read All About Monads. I've googled for anything to do with continuations and coroutines. I'm stuck. Can someone show me how to do it. Thanks, Paul.

5 4

Incoherent instances can make ST monad unsound
by oleg＠pobox.com 26 Jan '06

26 Jan '06

In the recent message about regions I wrote: > Typeable constraint has reduced the problem of 'region nesting' to the > regular problem of the 'linearity' of computations -- which is already > solved in ST monad. We can add that pervasive 's' type parameter to > our Q and IOM types. However, the simpler approach is just to use our > 'mark' as that 's' parameter. A small qualification should be added: although adding the 's' parameter in addition to the unexported Z parameter we had before is sound in all circumstances, the `simpler approach' may actually fail: it is possible to declare an instance "Typeable a" -- and given enough extensions, persuade GHC *and* Hugs to accept the code. The problem with IO regions would be the least of our worries however: in these circumstances, many things break, including the ST monad. One can indeed break the essential guarantee of the ST monad -- for example, create a top level STRef *and* fruitfully use in arbitrary ST computations. The enclosed code does exactly that. Thus, unsafePerformST becomes expressible in Haskell, given enough features. The presence of top-level mutable cells breaks the referential transparency. Hopefully the authors of Haskell' and Haskell2 would attach all-upper-case warnings to these extensions. The code below runs with GHC 6.4.1 (extensions are indicated inline). It also runs with Hugs, as hugs -98 +O /tmp/st.hs {-# OPTIONS -fglasgow-exts #-} {-# OPTIONS -fallow-undecidable-instances #-} {-# OPTIONS -fallow-overlapping-instances #-} {-# OPTIONS -fallow-incoherent-instances #-} module STTest where import Control.Monad.ST import Data.Typeable import Data.STRef import Data.Dynamic instance Typeable a where typeOf _ = mkTyConApp (mkTyCon "Anything goes") [] -- test1 = runST ( newSTRef 'a' ) leakedST = runST ( newSTRef 'a' >>= return . toDyn ) test3 :: Char test3 = runST (readSTRef $ ((fromDyn leakedST undefined)::STRef s Char)) {- result: *STTest> leakedST <<STRef Anything goes Char>> *STTest> test3 'a' -}

2 1

ANNOUNCE: C-- compiler frontend release
by Robert Dockins 26 Jan '06

26 Jan '06

Fellow Haskellers and C-- enthusiasts, I am pleased to announce the initial alpha release of a C-- frontend (parser, pretty printer, and semantic checker) written in Haskell. My goal when beginning this project was to create a modular frontend that could be used both by people writing and by those targeting C-- compilers. This implementation attempts to follow the C-- spec as exactly as possible. Please enjoy. You can get the source from the darcs source repository with the following command: darcs get --partial --tag '0.1' http://www.eecs.tufts.edu/~rdocki01/cmm/ or you may simply browse the source at the above address. Cmm Frontend -========================- == What is it? This package is a C-- frontend, including a lexer (scanner), parser, pretty-printer and semantic checker. It also includes a unit test suite. == Why do I care? The Cmm frontend allows you to target C-- easily by using the pretty printer or to fill in the backend of a C-- compiler without having to deal with the uninteresting details of parsing. == How is it licensed? The Cmm frontent is avaliable under a BSD3 license. See the LICENSE file for details. == How do I build it? Cmm frontend uses a Cabal build system. The follwing commands assume you have a haskell interpreter in your system path named 'runhaskell'. All commands are run from this directory. To install for the whole system: runhaskell Setup.hs configure runhaskell Setup.hs build runhaskell Setup.hs install To install for a single user: runhaskell Setup.hs configure --prefix=/home/<username> runhaskell Setup.hs build runhaskell Setup.hs install --user To build the API docs: runhaskell Setup.hs haddock == Who is responsable for this mess? You can send bug reports, rants and comments to: Robert Dockins <robdockins AT fastmail.fm> Rob Dockins Speak softly and drive a Sherman tank. Laugh hard; it's a long way to the bank. -- TMBG

1 0

Switch to MediaWiki
by John Peterson 25 Jan '06

25 Jan '06

We have finally finished moving nearly all of the top level haskell.org content over to the new wiki. Sometime soon switch to the new pages will happen. But meanwhile, there's a lot of work to do in the new wiki. Many of the pages on the old site were very out of date. The wiki pages are just as out of date, but at least you can fix them easily. The Links to Haskell people and projects is in pretty sad shape - a lot of people have moved and the links point many dead web pages. If you're listed, please check that your link is up to date. Even better, make yourself little user page in the wiki (every login has an associated user page), direct the link to that, and then you can throw your links and maybe a very short Haskell bio there. If you're not on the list just add yourself - we're not fussy. If there are links to group pages or companies missing you can add those. The Haskell in Education page is pretty outdated. It hasn't been seen to for a long time. I think that there's no longer much need to have a thumbnail sketch of each class at haskell.org but a link to your class homepage would be nice. You can always add a wiki page for your class and place information there. I expect this page will reorganize soon but if you get a link on it we'll make sure it stays on the site. Pages on jobs and consultants seem to be a bit out of date too - please edit as needed. The overall organization of the front page is definitely up for grabs - I believe there are too many links and we could simplify this. Be bold in your edits. Anyone with a good sense of style is welcome to add some MediaWiki templates to make things more interesting. We killed off most of the tables in the transition - some more tables would certainly help organize the site. And if you want to do some new logos, go for it. The old wiki will stay around - we have no intention of turning it off. However, I find the new wiki much nicer and hope that people will willingly migrate to the new one. Thanks to everyone who has helped with this, especially Ashley who did most of the hard work. I believe that haskell.org will stay much more current now. Olaf and I certainly won't miss getting email messages about broken links or new libraries. The new wiki is at http://haskell.org/haskellwiki/ - go have fun with it. I don't know when we'll make the switch but it will be soon. We most definitely will not be requiring that other haskell.org pages move to the wiki or change the url of anything currently hosted there. John

1 0

Simple IO Regions
by oleg＠pobox.com 25 Jan '06

25 Jan '06

This message shows a very simple implementation of Monadic Regions (for the particular case of IO and reading the file). The technique *statically* guarantees that neither a file handle nor any computation involving the handle can leak outside of the region that created it. Therefore, the handle can be safely closed (and its resources disposed of) whenever control leaves the corresponding 'withFile' block. Many handles can be open simultaneously, the type system enforces the proper nesting of their regions. The technique has no run-time overhead and induces no run-time errors. Unlike the previous implementation of monadic regions, only the basic extensions (higher-ranked types and one two-parameter type class) are used. No undecidable instances, no functional dependencies (let alone overlapping instances) are required. In fact, the implementation uses only one trivial typeclass and one trivial instance. Perhaps such an approach to File IO can be more widely used? It trivially generalizes to database IO and other kinds of IO. The motivation for monadic regions has been best explained by: Brandon Moore wrote on Haskell Cafe: > I'm assuming you understand how the type on runST and the STRef > operations ensure that, even though you *can* smuggle out an STRef in > the result from runST, you will never be able to use it again. > > The idea was to do the equivalent thing with databases: use fancy types > to ensure that handle can only be used inside to origination withDB or > withCursor or whatever, and the bracketing function can release the > resource on the way out, without worrying about it being used again. Benjamin Franksen wrote: > I think this is an extremely good idea. I have been very frustrated > with finalizers because of their limitations (can't rely on them being > called at all), so have (reluctantly) been using the unsafe bracket > version. Making it safe via a type system trick is really the way to > go. Let us start with the tests > {-# OPTIONS -fglasgow-exts #-} > > module IORegionsTest where > > import IORegions -- see below > > test0 = withFile "/etc/motd" (const $ return True) > > reader q = do > c1 <- qGetChar q > c2 <- qGetChar q > return [c1,c2] > > test1 = withFile "/etc/motd" reader > test1r = runIOM test1 >>= print Instead of handles, we have Qs -- marked handles. The are created by the function withFile and used similar to regular handles. A special IOM monad is a newtype away from the regular IO. The phantom type parameter of the IOM monad maintains the marks of the regions. *IORegionsTest> :t reader reader :: (Monad (IOM marks), IORegions.IN mark marks) => Q mark -> IOM marks [Char] the type of the reader shows that it takes a marked handle and yields a marked IO computation. The constraint IN assures that the computation must be marked with the mark of the handle. If we attempt to leak the handle: *> test2 = withFile "/tmp/i.hs" (\q -> return q) we get Inferred type is less polymorphic than expected Quantified type variable `mark' escapes In the second argument of `withFile', namely `(\ q -> return q)' The following is OK: we perform the computation and return its result: > test3 = withFile "/etc/motd" (\q -> (qGetChar q)) If we attempt to return the unperformed computation itself: *> test4 = withFile "/tmp/i.hs" (\q -> return (qGetChar q)) we get Could not deduce (IORegions.IN mark marks1) from the context (IORegions.IN mark marks) arising from use of `qGetChar' at IORegionsTest.h... As we said earlier, more than one handle can be at play at the same time: > reader2 q1 q2 = do > c1 <- qGetChar q1 > c2 <- qGetChar q2 > return [c1,c2] > test5 = withFile "/etc/motd" (\q1 -> > withFile "/etc/motd" (\q2 -> reader2 q1 q2)) > > test5r = runIOM test5 >>= print Incidentally, the inferred type of reader2 is *IORegionsTest> :t reader2 reader2 :: (Monad (IOM marks), IORegions.IN mark1 marks, IORegions.IN mark marks) => Q mark -> Q mark1 -> IOM marks [Char] Obviously, the resulting computation is marked with the marks of both argument handles. With two handles, we can actually return a handle -- provided we return an outermost handle from the innermost region (but not the other way around). For example, the following is wrong *> test6 = withFile "/etc/motd" *> (\q2 -> *> do *> q' <- withFile "/etc/motd" (\q -> return q) *> qGetChar q') but the following is OK: > test7 = withFile "/etc/motd" > (\q2 -> > do > q' <- withFile "/etc/motd" (\q -> return q2) > qGetChar q') Ditto for the computation: The following is the improper leakage and leads to a type error: *> test8 = withFile "/etc/motd" *> (\q2 -> *> do *> a <- withFile "/etc/motd" (\q -> return (qGetChar q)) *> a) But the following is fine: > test9 = withFile "/etc/motd" > (\q2 -> > do > a <- withFile "/etc/motd" (\q -> return (qGetChar q2)) > a) > > test9r = runIOM test9 >>= print -- The file IORegions.hs follows. {-# OPTIONS -fglasgow-exts #-} -- Simple IO Regions module IORegions (runIOM, qGetChar, withFile, -- Only types are exported, not their data constructors! Q, IOM) where import Control.Exception import System.IO -- The marked IO monad. The data constructor is not exported. -- The type 'marks' is purely phantom (and is never instantiated, actually) newtype IOM marks a = IOM (IO a) deriving Monad unIOM (IOM x) = x -- The marked IO handle. The data constructor is not exported. newtype Q mark = Q Handle -- |IN mark marks| asserts that |mark| is a member of the mark set |marks| -- The mark set is really a set, and the best of all, it's typechecker -- that maintains it. We don't need to do anything at all. class IN a b instance IN () b -- Reading from a marked handle. The mark must be within the marks -- associated with the IOM monad qGetChar :: (IN mark marks) => Q mark -> IOM marks Char qGetChar (Q h) = IOM $ hGetChar h -- There must not be an operation to close a marked handle! -- withFile takes care of opening and closing (and disposing) of -- handles. -- Open the file, add the markset constraint for the duration of the body, -- and make sure the marked handle does not escape. -- The marked handle is closed on normal or abnormal exit from the -- body -- The type system guarantees the strong lexical scoping of -- withFile. That is, we can assuredly close all the handles after -- we leave withFile because we are assured that no computations with -- marked handles can occur after we leave withFile. withFile :: FilePath -> (forall mark. IN mark marks => Q mark -> IOM marks a) -> IOM marks a withFile filename proc = IOM( bracket (openFile filename ReadMode) (hClose) (\handle -> unIOM $ proc ((Q handle) :: Q ()))) -- Running the IOM monad runIOM :: (forall mark. IOM mark a) -> IO a runIOM = unIOM

4 7