- Haskell - Haskell.org

CUFP: Call for Participation
by Kathleen Fisher 03 Aug '06

03 Aug '06

[ Apologies for multiple postings; please forward to potentially interested parties ] CALL FOR PARTICIPATION Registration is now open! http://regmaster2.com/conf/icfp2006.html CUFP 2006 THE THIRD COMMERCIAL USERS OF FUNCTIONAL PROGRAMMING WORKSHOP "Functional programming as a means, not an end" Portland, Oregon, USA September 21st 2006 Co-located with ICFP Functional languages have been under academic development for over 25 years, and are still proving to be very fertile ground for programming language research. Consequently, most of the development focus of these languages is driven by academic and theoretical questions. More recently, however, functional languages have been very successfully used in commercial, industrial, and government settings, as well as in the open-source community. In these settings, the advantages of functional languages have provided dramatic leverage. The goal of CUFP is to act as a voice for commercial users of functional programming languages and technology. It aims to help functional programming become increasingly viable as a technology for use in the commercial, industrial, governmental, and open-source space by providing a forum for FP professionals to share their experiences and ideas, whether business, management or engineering. It also aims to enable the formation and strengthening of relationships and alliances that further the commercial use of functional languages. Providing user feedback to language designers and implementors is not a primary goal of the workshop, though it will be welcome if it occurs. Program ------- The meeting will last a full day, with a mix of invited and submitted presentations, plus discussion sessions. Confirmed speakers include: *Richard Cleis* on embedding PLT Scheme in device controllers for the Air Force. *Roope Kaivola* on his work for Intel constructing functional models and the verifying hardware against such models using reFLect, Intel's reflective functional language. *J. Garrett Morris* on Aetion Technologies and how they use Haskell to rapidly prototype new systems and to develop generic software foundations that enable them to extend to new markets quickly. *Erik Stenman* on Kreditor, a company that successfully sells invoicing services to web shops; all of their software is written in Erlang. *Clifford Besher* on his work at Linspire on using functional languages for all of their tools and his efforts to promote the use of Haskell/FP within the open source community. *Steve Sims* on Reactive Systems, a company that licenses an automated testing tool for embedded software, mostly written in SML. *Yaron Minsky* on Jane Street Capital, a proprietary trading company, whose trading systems and infrastructure are all implemented in OCaml. There will be no published proceedings, as the meeting is intended to be more a discussion forum than a technical interchange. See http://www.galois.com/cufp/ for more information, including the most recent schedule information. Program Committee ----------------- Andy Adams-Moran. adams-moran at galois.com (Co-Chair) Mike Ashley. mashley at beckman.com Matthias Felleisen. matthias at ccs.neu.edu Kathleen Fisher. kfisher at research.att.com (Chair) Jim Grundy. jim_grundy at ichips.intel.com John Hughes. rjmh at cs.chalmers.se Stephen Weeks. sweeks at sweeks.com Ulf Wiger. ulf.wiger at ericsson.com

1 0

CFP for Practical Aspects of Declarative Languages: 9th Symposium
by Simon Marlow 03 Aug '06

03 Aug '06

[ posting on behalf of Gopal Gupta <gupta(a)utdallas.edu> ] ====================================================================== CALL FOR PAPERS Ninth International Symposium on Practical Aspects of Declarative Languages 2007 (PADL '07) http://www.informatik.uni-kiel.de/~mh/padl07 Nice, France January 14-15, 2007 Co-located with ACM POPL'07 ====================================================================== Declarative languages build on sound theoretical foundations to provide attractive frameworks for application development. These languages have been successfully applied to a wide array of different real-world situations, including database management, active networks, software engineering, web applications, decision support systems, or music composition. New developments in theory and implementation have opened up new application areas. At the same time, the application of declarative languages to novel problems raises numerous interesting research issues. Well-known questions include designing for scalability, language extensions for application deployment, and programming environments. Thus, applications often drive the progress in the theory and implementation of declarative systems, and benefit from this progress as well. PADL is a forum for researchers and practioners to present original work emphasizing novel applications and implementation techniques for all forms of declarative concepts, including, functional, logic, constraints, etc. Topics of interest include: * innovative applications of declarative languages; * declarative domain-specific languages and applications; * practical applications of theoretical results; * new language developments and their impact on applications; * evaluation of implementation techniques on practical applications; * novel uses of declarative languages in the classroom; and * practical experiences PADL 07 welcomes new ideas and approaches pertaining to applications and implementation of declarative languages, and is not limited to the scope of the past eight PADL symposia. PADL 07 will be co-located with the ACM POPL. ---------------------------------------------------------------------- IMPORTANT DATES AND SUBMISSION GUIDELINES Abstract Submission: August 30, 2006 Paper Submission: September 3, 2006 (strict) Notification: October 2, 2006 Final Manuscript: October 22, 2006 Symposium: January 14-15, 2007 All submissions must be original work written in English. Submissions must be unpublished and not submitted for publication elsewhere. Work that already appeared in unpublished or informally published workshops proceedings may be submitted. Authors should submit an electronic copy of the full paper (written in English) in Postscript (Level 2) or PDF via the web page of PADL 07. Papers must be no longer than 15 pages, written in 11-point font and with single spacing. Since the final proceedings will be published as Lecture Notes in Computer Science by Springer Verlag, submissions should adhere to the LNCS paper formatting guidelines. Each submission must include on its first page the paper title; authors and their affiliations; contact author's email and postal addresses, telephone and fax numbers, abstract, and three to four keywords. The keywords will be used to assist us in selecting appropriate reviewers for the paper. If electronic submission is impossible, please contact the program chair for information on how to submit hard copies. ---------------------------------------------------------------------- MOST PRACTICAL PAPER AWARD The Most Practical Paper award will be given to the submission that is judged by the programm committee to be the best in terms of practicality, originality, and clarity of presentation. The program committee may choose not to make an award; or may make multiple awards. ---------------------------------------------------------------------- PROGRAM COMMITTEE Matthias Blume (Toyota Technological Institute at Chicago, USA) Manuel Chakravarty (University of New South Wales, Australia) Marc Feeley (University of Montreal, Canada) Hai-Feng Guo (University of Nebraska at Omaha, USA) Gopal Gupta (University of Texas at Dallas, USA) Michael Hanus (University of Kiel, Germany, Chair) Michael Leuschel (University of Duesseldorf, Germany) Simon Peyton Jones (Microsoft Research, Cambridge, UK) Enrico Pontelli (New Mexico State University, USA) German Puebla (Technical University of Madrid, Spain) Francesca Rossi (University of Padova, Italy) Michel Rueher (University of Nice, France) Christian Schulte (Royal Institute of Technology, Sweden) Zoltan Somogyi (University of Melbourne, Australia) Peter Stuckey (University of Melbourne, Australia) Doaitse Swierstra (Utrecht University, The Netherlands) Simon Thompson (University of Kent, UK) Pascal Van Hentenryck (Brown University, USA) German Vidal (Technical University of Valencia, Spain) ---------------------------------------------------------------------- CONTACTS: For information about papers and submissions, please contact the Program Chair: Michael Hanus PC Chair - PADL 2007 Institut fuer Informatik University of Kiel D-24098 Kiel, Germany Email: mh(a)informatik.uni-kiel.de For other information about the conference, please contact: Gopal Gupta Department of Computer Science University of Texas at Dallas Dallas, TX, U.S.A. Email: gupta(a)utdallas.edu Sponsored by: COMPULOG Americas (http://www.cs.nmsu.edu/~complog) ----------------------------------------------------------------------

1 0

Re: [Haskell] Monadic parser combinators with logging
by Harald ROTTER 02 Aug '06

02 Aug '06

Thanks for the hint, I will try to implement the suggested monadic structure. As for the MonadState declaration: If I put instance MonadState PState Parser then ghci complains: Illegal instance declaration for 'MonadState PState Parser' (The instance type must be of form (T a b c) where T is not a synonym, and a,b,c are distict type variables) In the instance declaration for 'MonadState PState Parser' I found out that invoking ghci with "-fglasgow-exts" solves the issue nut I have to admit that I do not really understand what's so special about this instance declaration to make it require the extensions. Harald. Andrew Pimlott <andrew(a)pimlott.net To: Harald ROTTER <harald.rotter(a)sagem.com> > cc: haskell(a)haskell.org Subject: Re: [Haskell] Monadic parser combinators with logging 03.08.2006 02:54 Delivered date: 03.08.2006 02:54 On Wed, Aug 02, 2006 at 10:52:14AM +0200, Harald ROTTER wrote: > newtype Parser a = Parser { runParser :: (PState -> [(a, PState)])} > > as the parsing monad with the Parser state "PState" that contains the > remaining input after matching and possibly some additional user defined > state elements. I want to add logging such that the application of every > element parser/parser combinator gets recorded in a string. In the end I > want to print out the trace of all encountered parsers for successful and > for failed matches. > > I tried to use the WriterT transformer to add a writer monad on top of the > Parser monad but for failed matches (i.e. runParser gives []) the log is > also "lost" since WriterT gives a monad of "m (a,w)". Excellent observation! The order in which you apply monad transformers matters. "WriterT w Parser" keeps a separate output for each branch of the parser. If you stare at the definition of (>>=) for WriterT, you'll see why this must be so. Or, as you did, you can just look at the type. > What I would look for is "(m a, w)". Hmm, that looks like (if m is Parser) a parser plus some output. I think you'd rather have an answer plus some output, ie "([(a, PState)], w)". Hint: Consider newtype Parser m a = Parser { runParser :: (PState -> m [(a, PState)])} where m is a Monad. > How can I make the Parser monad given above an instance of MonadState ? (I > always get kind errors ...) Did you switch up the order of parameters or something? I don't get any error using instance MonadState Int Parser where ... Andrew

2 1

Monadic parser combinators with logging
by Harald ROTTER 02 Aug '06

02 Aug '06

Dear all, I am a Haskell newbie and I try to find my way through Monad territory. Actually I am studying the non-deterministic monadic parser combinators as descibed by Hutton and Meijer. Although I find this very elegant and concise I seem to have problems extending the parser monads. I use newtype Parser a = Parser { runParser :: (PState -> [(a, PState)])} as the parsing monad with the Parser state "PState" that contains the remaining input after matching and possibly some additional user defined state elements. I want to add logging such that the application of every element parser/parser combinator gets recorded in a string. In the end I want to print out the trace of all encountered parsers for successful and for failed matches. I tried to use the WriterT transformer to add a writer monad on top of the Parser monad but for failed matches (i.e. runParser gives []) the log is also "lost" since WriterT gives a monad of "m (a,w)". What I would look for is "(m a, w)". Finally, my questions: What is the most elegant way to achieve logging parsers ? Can I use the standard transformes or do I need to write my own transformers ? How can I make the Parser monad given above an instance of MonadState ? (I always get kind errors ...) Any hints are really appreciated. Thank you Harald Rotter.

2 1

ANN: TextRegexLazy-0.56, (=~) and (=~~) are here
by Chris Kuklewicz 02 Aug '06

02 Aug '06

Announcing: TextRegexLazy version 0.56 Where: Tarball from http://sourceforge.net/projects/lazy-regex darcs get --partial [--tag=0.56] http://evenmere.org/~chrisk/trl/stable/ License : BSD, except for DFAEngine.hs which is LGPL (derived from CTK light) Development/unstable version is at: darcs get [--partial] http://evenmere.org/~chrisk/trl/devel/ This is the version that has eaten John Meacham's JRegex library and survived to become strong. Thanks John! It now compiles against the posix regexp provided by the c library and the pcre library, in addition to the "full lazy" and the "DFA" backends. All 4 backends can accept regular expressions given as String and as ByteString. All 4 backends can run regular expressions against String and ByteString. In particular, the PosixRE and PCRE can run very efficiently against ByteString. (Though the input for the PosixRE needs to end in a \NUL character for efficiency). So there are 4*2*2 = 16 ways to use to provide input to this library. And the RegexContext class has at least 11 instances that both (=~) and (=~~) can target. So that is 4*2*2*11*2 = 352 things you can do with this library! Get your copy today! To run with cabal before 1.1.4 you will need to comment out the "Extra-Source-Files:" line in the TextRegexLazy.cabal file. The Example.hs file: > {-# OPTIONS_GHC -fglasgow-exts #-} > import Text.Regex.Lazy > import Text.Regex.Full((=~),(=~~)) -- or DFA or PCRE or PosixRE > > main = let b :: Bool > b = ("abaca" =~ "(.)a") > c :: [MatchArray] > c = ("abaca" =~ "(.)a") > d :: Maybe (String,String,String,[String]) > d = ("abaca" =~~ "(.)a") > in do print b > print c > print d This produces: > True > [array (0,1) [(0,(1,2)),(1,(1,1))],array (0,1) [(0,(3,2)),(1,(3,1))]] > Just ("a","ba","ca",["b"]) You can also use makeRegex and makeRegexOpts to compile and save a regular expression which will be used multiple times. Each of the 4 backends has a separate "Regex" data type with its own option types. For low level access, the WrapPCRE and WrapPosix modules expose a typesafe layer around the c libraries. You can query the "getVersion :: Maybe String" to see if the have been compiled into the library. It may be possible to use WrapPCRE and the UTF8 option flags to do unicode regex matching with PCRE. ( The Full and DFA backends use the Haskell unicode Char already ). Adding new types to String/ByteString is a matter of adding instances to the existing classes. Feedback and comments of any length is welcome. -- Chris Kuklewicz

2 3

Monadic parser combinators with logging
by Harald ROTTER 02 Aug '06

02 Aug '06

Dear all, I am a Haskell newbie and I try to find my way through Monad territory. Actually I am studying the non-deterministic monadic parser combinators as descibed by Hutton and Meijer. Although I find this very elegant and concise I seem to have problems extending the parser monads. I use newtype Parser a = Parser { runParser :: (PState -> [(a, PState)])} as the parsing monad with the Parser state "PState" that contains the remaining input after matching and possibly some additional user defined state elements. I want to add logging such that the application of every element parser/parser combinator gets recorded in a string. In the end I want to print out the trace of all encountered parsers for successful and for failed matches. I tried to use the WriterT transformer to add a writer monad on top of the Parser monad but for failed matches (i.e. runParser gives []) the log is also "lost" since WriterT gives a monad of "m (a,w)". What I would look for is "(m a, w)". Finally, my questions: What is the most elegant way to achieve logging parsers ? Can I use the standard transformes or do I need to write my own transformers ? How can I make the Parser monad given above an instance of MonadState ? (I always get kind errors ...) Any hints are really appreciated. Thank you Harald Rotter.

1 0

RE: Internships on GHC and Haskell at MSR Cambridge
by Simon Peyton-Jones 01 Aug '06

01 Aug '06

| MSR Cambridge now takes interns *year-round*, not just in the summer months. Simon Marlow and I | are keen to attract motivated and well-qualified folk to work with us on our research, and on improving | or developing GHC. PS: concerning the enclosed, if you are interested in an internship at MSR for the October-December 2006 period, you'll need to get weaving very quickly. Because of summer holidays etc, we'll be taking decisions in the week of 14 August, so you'll need to get your application (including references) in by 13 August. Simon | -----Original Message----- | From: Simon Peyton-Jones | Sent: 25 July 2006 10:56 | To: haskell-cafe(a)haskell.org; haskell(a)haskell.org; glasgow-haskell-users(a)haskell.org | Subject: Internships on GHC and Haskell at MSR Cambridge | | Gentle Haskellers | | Would you be interested in working for three months at Microsoft Research, Cambridge, on a project | related to GHC or Haskell? | | MSR Cambridge now takes interns *year-round*, not just in the summer months. Simon Marlow and I | are keen to attract motivated and well-qualified folk to work with us on our research, and on improving | or developing GHC. | | If you or one of your students is interested, you can find more details here | http://hackage.haskell.org/trac/ghc/wiki/Internships | | Our next empty slot is the Oct-Dec period, but you are welcome to apply for some later period. | | Simon PJ | | PS: There are lots of other programming-language folk at MSR (F#, security, probabilistic | languages...), and stuff beyond that (machine learning, systems and networks...); see | http://research.microsoft.com/aboutmsr/labs/cambridge/

1 0

AngloHaskell: Call for Participation
by Lemmih 01 Aug '06

01 Aug '06

Greetings fellow hackers, It is my great pleasure to call attention to the informal gathering of the Haskell community. The event will take place at Cambridge, UK, on Friday and Saturday the 4-5th of August. Don't miss this opportunity to: * associate IRC handles with faces, * drink beer, * ride unicycles and * much more. The event is of course free and non-haskellers are welcome as well. More information can be found here: http://haskell.org/haskellwiki/AngloHaskell -- Friendly, Lemmih

1 0

Non-drifting clock, anyone?
by ihope 31 Jul '06

31 Jul '06

Here it is, in all its greatly untested glory: http://pastebin.ca/109242 I don't know how much error it has, but the error won't stack up: if it's one second off, it will remain one second off until the end of time, or until your system clock drifts. But system clock drifts will be fixed by synchronizing your system clock with the outside world, except that if your clock jumps forward, this one will suddenly tick like mad, and if it jumps backward, this one will stop for a while... oh well.

1 0

Call for Participation: Scheme & Functional Programming Workshop 2006
by Robby Findler 31 Jul '06

31 Jul '06

Dear all, The Scheme and Functional Programming Workshop pre-registration deadline is in about 2 and a half weeks -- do be sure to register for ICFP and the workshop before then. Come to hear Manuel Serrano talk about HOP, his new language for programming the web, a status report from the R6RS editors, and presentations of the work below. I look forward to seeing you in Portland! http://scheme2006.cs.uchicago.edu/ Best, Robby ======================================== A Self-Hosting Evaluator using HOAS Eli Barzilay (Northeastern University) We demonstrate a tiny, yet non-trivial evaluator that is powerful enough to run practical code, including itself. This is made possible using a Higher-Order Abstract Syntax (HOAS) representation -- a technique that has become popular in syntax-related research during the past decade. With a HOAS encoding, we use functions to encode binders in syntax values, leading to an advantages of reflecting binders rather than re-implementing them. In Scheme, hygienic macros cover problems that are associated with binders in an elegant way, but only when extending the language, i.e., when we work at the meta-level. In contrast, HOAS is a useful object-level technique, used when we need to represent syntax values that contain bindings -- and this is achieved in a way that is simple, robust, and efficient. We gradually develop the code, explaining the technique and its benefits, while playing with the evaluator. >From Variadic Functions to Variadic Relations William E. Byrd and Daniel P. Friedman (Indiana University) Scheme makes it easy to define variadic functions, which take an arbitrary number of arguments; miniKanren, a logic programming language embedded in R5RS Scheme, makes it easy to define variadic relations. A variadic miniKanren relation takes two arguments: a list containing input arguments and an output argument. A fresh or partially-instantiated logic variable passed to a variadic relation can represent the list of input arguments. A relation may also be super-variadic---such a relation takes a list of lists of input arguments. We show the variadic and super-variadic relational equivalent of several variadic functions, examples of their use, and several abstractions over these relations. We also present a brief miniKanren overview, along with an R5RS-compliant implementation of the subset of miniKanren that we use. Experiences with Scheme in an Electro-Optics Laboratory Richard Cleis and Keith Wilson (Air Force Research Laboratory) The Starfire Optical Range is an Air Force Research Laboratory engaged in Atmospheric Research near Albuquerque, New Mexico. Since the late 1980's it has developed numerous telescope systems and auxiliary devices. Nearly all are controlled by C programs that became difficult to manage due to the large number of configurations required to support the experiments. To alleviate the problem, Scheme has been introduced in at least six distinct ways. This paper describes the uses of Scheme, emerging programming techniques, and general experiences of the past several years. Rapid Case Dispatch in Scheme William D. Clinger (Northeastern University) The case expressions of Scheme can and should be implemented efficiently. A three-level dispatch performs well, even when dispatching on symbols, and scales to large case expressions. A Stepper for Scheme Macros Ryan Culpepper, Matthias Felleisen (Northeastern University) Even in the days of Lisp's simple defmacro systems, macro developers did not have adequate debugging support from their programming environment. Modern Scheme macro expanders are more complex than Lisp's, implementing lexical hygiene, referential transparency for macro definitions, and frequently other source properties. Scheme implementations, however, have only adapted Lisp's inadequate macro inspection tools. Unfortunately, these tools rely on a rather naive model of the expansion process, thus leaving a large gap between Scheme's complex mode of expansion and what the programmer sees. In this paper, we present a macro debugger with full support for modern Scheme macros. To construct the debugger, we have extended the macro expander so that it issues a series of expansion events. A parser turns these event streams into derivations in a natural semantics for macro expansion. From these derivations, the debugger extracts a reduction-sequence (stepping) view of the expansion. A programmer can specify with simple policies which parts of a derivation to omit and which parts to show. Last but not least, the debugger includes a syntax browser that graphically displays the various pieces of information attached to syntactic tokens. Automatic construction of parse trees for lexemes Danny Dub\'e (Universit\'e Laval) and Anass Kadiri (EPITA, Paris France) Recently, Dub\'e and Feeley presented a technique that makes lexical analyzers able to build parse trees for the lexemes that match regular expressions. While parse trees usually demonstrate how a word is generated by a context-free grammar, these parse trees demonstrate how a word is generated by a regular expression, in an analogous fashion. This paper describes the adaptation and implementation of that technique in a concrete lexical analyzer generator. The adaptation of the technique includes extending it to the rich set of operators handled by the generator and reversing the direction of the parse trees construction so that it corresponds to the natural right-to-left direction of the Scheme lists construction. The implementation of the adapted technique includes modifications to both the generation-time and the run-time parts of the generator. Uses of the new addition and empirical measurements of its cost are presented. Extensions and alternatives to the technique are considered. Concurrency Oriented Programming in Termite Scheme Guillaume Germain, Marc Feeley, Stefan Monnier (Universit\'e de Montr\'eal) Termite is a language and system offering a simple and powerful tool for expressing distributed computation. It is based on a message-passing model of concurrency inspired by Erlang, and on a variant of the functional language Scheme. Our system is an appropriate tool for building custom protocols and abstractions for distributed computation. Its open network model allows for the building of non-centralized distributed applications. The possibility of failure is reflected in the model, and ways to handle them are proposed. The existence of first-class continuations is exploited in order to allow the expression of high-level concepts such as migration of processes. We describe the Termite model with its implications and describe sample applications built with Termite. We conclude with a discussion of the current implementation and its performance. An Incremental Approach to Compiler Construction Abdulaziz Ghuloum (Indiana University) Compilers are perceived to be magical artifacts, carefully crafted by the wizards, and unfathomable by the mere mortals. Books on compilers are better described as wizard-talk: written by and for a clique of all-knowing practitioners. Real-life compilers are too complex to serve as an educational tool. And the gap between real-life compilers and the educational toy compilers is too wide. The novice compiler writer stands puzzled facing an impenetrable barrier, ``better write an interpreter instead.'' The goal of this paper is to break that barrier. We show that building a compiler can be as easy as building an interpreter. The compiler we construct accepts a large subset of the Scheme programming language and produces assembly code for the Intel-x86 architecture, the dominant architecture of personal computing. The development of the compiler is broken into many small incremental steps. Every step yields a fully working compiler for a progressively expanding subset of Scheme. Every compiler step produces real assembly code that can be assembled then executed directly by the hardware. We assume that the reader is familiar with the basic computer architecture: its components and execution model. Detailed knowledge of the Intel-x86 architecture is not required. The development of the compiler is described in detail in an extended tutorial. Supporting material for the tutorial such as an automated testing facility coupled with a a comprehensive test suite are provided with the tutorial. It is our hope that current and future implementors of Scheme find in this paper the motivation for developing high-performance compilers and the means for achieving that goal. Sage: Hybrid Checking for Flexible Specifications Jessica Gronski (University of California, Santa Cruz (UCSC)), Kenneth Knowles (UCSC), Aaron Tomb (UCSC), Stephen N. Freund (Williams College), and Cormac Flanagan (UCSC) Software systems typically contain large APIs that are informally specified and hence easily misused. This paper presents the Sage programming language, which is designed to enforce precise interface specifications in a flexible manner. The Sage type system uses a synthesis of the type ``dynamic'', first-class types, and arbitrary refinement types. Since type checking for this expressive language is not statically decidable, Sage uses hybrid type checking, which extends static type checking with dynamic contract checking, automatic theorem proving, and a database of refuted subtype judgments. Interaction-Safe State for the Web Jay McCarthy and Shriram Krishnamurthi (Brown University) Recent research has demonstrated that continuations provide a clean basis to describe interactive Web programs. This account, however, provides only a limited description of state, which is essential to several Web applications. This state is affected by the numerous control operators (known as navigation buttons) in Web browsers, which make Web applications behave in unexpected and even erroneous ways. We describe these subtleties as discovered in the context of working Web applications. Based on this analysis we present linguistic extensions that accurately capture state in the context of the Web, presenting a novel form of dynamic scope. We support this investigation with a formal semantics and a discussion of applications. The results of this paper have already been successfully applied to working applications. Component Deployment with PLaneT: You Want it Where? Jacob Matthews (University of Chicago) For the past two years we have been developing PLaneT, a package manager built into PLT Scheme's module system that simplifies program development by doing away with the distinction between installed and uninstalled packages. In this paper we explain how PLaneT works and the rationales behind our major design choices, focusing particularly on our decision to integrate PLaneT into PLT Scheme and the consequences that decision had for PLaneT's design. We also report our experience as PLaneT users and developers and describe what have emerged as its biggest advantages and drawbacks. Scheme for Client-Side Scripting in Mobile Web Browsing, or AJAX-Like Behavior Without Javascript Ray Rischpater (Rocket Mobile, Inc.) I present an implementation of Scheme embedded within a Web browser for wireless terminals. Based on a port of TinyScheme integrated with RocketBrowser, an XHTML-MP browser running on Qualcomm BREW-enabled handsets, the resulting application can support the same use cases as traditional JavaScript-enabled browsers, including asynchronous programming recently popularized via AJAX (Asynchronous Javascript and XML). In addition to a comparison of the resulting script capabilities, I present the changes required to bring TinyScheme to Qualcomm BREW, including adding support for BREW components as TinyScheme data types. SHard: a Scheme to Hardware Compiler Xavier Saint-Mleux (Universit\'e de Montr\'eal), Marc Feeley (Universit\'e de Montr\'eal) and Jean-Pierre David (\'Ecole Polytechnique de Montr\'eal) Implementing embedded systems in hardware can have several benefits (performance, power usage, etc.). Current hardware/software co-design methodologies, which offer a language for describing hardware and another language for programming the software, put the burden of system partitioning on the developer, which is tedious and makes component transformation and reuse difficult. Our goal is to put most of this burden on the compiler through the use of a single, simple programming language. We describe a prototype compiler that compiles a functional subset of Scheme into a high-level description of dataflow parallel hardware. The compiler supports tail and non-tail function calls and higher-order functions. Our approach makes it possible to implement software algorithms in hardware with very few modifications (e.g. IO channel declaration). Performance results of our system are given for FPGA hardware. Gradual Typing for Functional Languages Jeremy G. Siek and Walid Taha (Rice University) Static and dynamic type systems have well-known strengths and weaknesses, and each is better suited for different programming tasks. There have been many efforts to integrate static and dynamic typing and thereby combine the benefits of both typing disciplines in the same language. The flexibility of static typing can be improved by adding a type Dynamic and a typecase form. The safety and performance of dynamic typing can be improved by adding optional type annotations or by performing type inference (as in soft typing). However, there has been little formal work on type systems that allow a programmer-controlled migration between dynamic and static typing. Thatte proposed Quasi-Static Typing, but it does not statically catch all type errors in completely annotated programs. Anderson and Drossopoulou defined a nominal type system for an object-oriented language with optional type annotations. However, developing a sound, gradual type system for functional languages with structural types is an open problem. In this paper we present a solution based on the intuition that the structure of a type may be partially known/unknown at compile-time and the job of the type system is to catch incompatibilities between the known parts of types. We define the static and dynamic semantics of a lambda-calculus with optional type annotations and we prove that its type system is sound with respect to the simply-typed lambda-calculus for fully-annotated terms. We prove that this calculus is type safe and that the cost of dynamism is ``pay-as-you-go''.

1 0