- Sponsor:
- sigplan
This volume contains the papers presented at ICFP 2004, the Ninth ACM SIGPLAN International Conference on Functional Programming. The meeting took place on 19-21 September, 2004 in Snowbird, Utah. The scope of ICFP includes all languages that encourage programming with functions, including both purely applicative and imperative languages, as well as languages that support objects and concurrency. The topics covered range from principles to practice, from foundations to features, and from abstractions to applications.The call for papers led to 80 submissions from 15 countries. We received 43 papers from North America (USA), 33 from Europe (Estonia, France, Germany, Great Britain, Ireland, Italy, the Netherlands, Sweden, and Switzerland), 10 from Asia (China, India, Japan, and Singapore), and 3 from Australia. These counts total more than 80 as several papers had authors from more than one continent. Seven submissions had at least one author from industry, and 21 had authors from more than one institution. From these submissions, the program committee selected 21 for presentation.At least three committee members read and wrote a review for each submission. In addition, an external expert reviewed almost every paper. As an experiment, we sent the collected reviews to the authors in advance of the program committee meeting. Authors were given up to 500 words to correct errors in their reviews. On the whole, both the authors and the program committee members thought this experiment was successful and should be continued in the future. There was a reasonably strong feeling that the restriction to factual errors should be removed, allowing authors to say whatever they wished within their 500 words. The program committee selected the papers contained in this volume at a one-day meeting held in Florham Park, New Jersey. All committee members attended the meeting in person.We used the CyberChairPro system to manage the paper submission and review process. I am grateful to Richard van de Stadt for his help in running the system.
Proceeding Downloads
Galois: high assurance software
As a company, Galois began its life with the mission simply of supplying functional programming services, building tools and products for clients, leveraging the productivity of functional languages and the abilities of our engineers. This went well, ...
Making a fast curry: push/enter vs. eval/apply for higher-order languages
Higher-order languages that encourage currying are implemented using one of two basic evaluation models: push/enter or eval/apply. Implementors use their intuition and qualitative judgements to choose one model or the other.Our goal in this paper is to ...
Improving the static analysis of embedded languages via partial evaluation
Programs in embedded languages contain invariants that are not automatically detected or enforced by their host language. We show how to use macros to easily implement partial evaluation of embedded interpreters in order to capture invariants encoded in ...
Searching for deadlocks while debugging concurrent haskell programs
This paper presents an approach to searching for deadlocks in Concurrent Haskell programs. The search is based on a redefinition of the IO monad which allows the reversal of Concurrent Haskells concurrency primitives. Hence, it is possible to implement ...
A type-theoretic foundation of continuations and prompts
There is a correspondence between classical logic and programming language calculi with first-class continuations. With the addition of control delimiters (prompts), the continuations become composable and the calculi are believed to become more ...
Relating models of backtracking
Past attempts to relate two well-known models of backtracking computation have met with only limited success. We relate these two models using logical relations. We accommodate higher-order values and infinite computations. We also provide an ...
Don't make the wrong mistakes: programming as debugging
Sometimes it's worth doing things badly in order to do them fast. When is this the right plan? Are some kinds of mistakes worse than others? Could the right infrastructure make trial and error programming more effective? How will it play out in the ...
Regular expression patterns
We extend Haskell with regular expression patterns. Regular expression patterns provide means for matching and extracting data which goes well beyond ordinary pattern matching as found in Haskell. It has proven useful for string manipulation and for ...
Multi-return function call
It is possible to extend the basic notion of "function call" to allow functions to have multiple return points. This turns out to be a surprisingly useful mechanism. This paper conducts a fairly wide-ranging tour of such a feature: a formal semantics ...
Implementing functional logic languages using multiple threads and stores
Recent functional logic languages such as Curry and Toy combine lazy functional programming with logic programming features including logic variables, non-determinism, unification, narrowing, fair search, concurrency, and residuation. In this paper, we ...
Monadic regions
Region-based type systems provide programmer control over memory management without sacrificing type-safety. However, the type systems for region-based languages, such as the ML-Kit or Cyclone, are relatively complicated, so proving their soundness is ...
Translating dependency into parametricity
Abadi et al. introduced the dependency core calculus (DCC) as a unifying framework to study many important program analyses such as binding time, information flow, slicing, and function call tracking. DCC uses a lattice of monads and a nonstandard ...
Types for path correctness of XML queries
If a subexpression in a query will never contribute data to the query answer, this should be regarded as an error. This principle has been recently accepted into mainstream XML query languages, but was still waiting for a complete treatment. We provide ...
Types, potency, and idempotency: why nonlinearity and amnesia make a type system work
Useful type inference must be faster than normalization. Otherwise, you could check safety conditions by running the program. We analyze the relationship between bounds on normalization and type inference. We show how the success of type inference is ...
Numbering matters: first-order canonical forms for second-order recursive types
We study a type system equipped with universal types and equire-cursive types, which we refer to as F͘. We show that type equality may be decided in time O(nlog n), an improvement over the previous known bound of O(n2 ). In fact, we show that two more ...
20 years of industrial functional programming
It is now 20 years since the Ericsson Computer Science Laboratory (CSLab) was formed, and 20 years since CSLab started performing the programming language experiments that eventually led to the development of the Erlang programming language. For 15 ...
From process logic to program logic
We present a process logic for the p -calculus with the linear/affine type discipline [6, 7, 31, 32, 33, 59, 60]. Built on the preceding studies on logics for programs and processes, simple systems of assertions are developed, capturing the classes of ...
Verification of safety properties for concurrent assembly code
Concurrency, as a useful feature of many modern programming languages and systems, is generally hard to reason about. Although existing work has explored the verification of concurrent programs using high-level languages and calculi, the verification of ...
A sound (and complete) model of contracts
Even in statically typed languages it is useful to have certain invariants checked dynamically. Findler and Felleisen gave an algorithm for dynamically checking expressive higher-order types called contracts. If we postulate soundness (in the sense that ...
A nanopass infrastructure for compiler education
Compilers structured as a small number of monolithic passes are difficult to understand and difficult to maintain. Adding new optimizations often requires major restructuring of existing passes that cannot be understood in isolation. The steep learning ...
Functional morphology
This paper presents a methodology for implementing natural language morphology in the functional language Haskell. The main idea behind is simple: instead of working with untyped regular expressions, which is the state of the art of morphology in ...
Slideshow: functional presentations
Among slide-presentation systems, the dominant application offers essentially no abstraction capability. Slideshow, an extension of PLT Scheme, represents our effort over the last several years to build an abstraction-friendly slide system. We show how ...
Generics for the masses
A generic function is a function that can be instantiated on many data types to obtain data type specific functionality. Examples of generic functions are the functions that can be derived in Haskell, such as show, read, and '=='. The recent years have ...
Scrap more boilerplate: reflection, zips, and generalised casts
Writing boilerplate code is a royal pain. Generic programming promises to alleviate this pain by allowing the programmer to write a generic "recipe" for boilerplate code, and use that recipe in many places. In earlier work we introduced the "Scrap your ...
- Proceedings of the ninth ACM SIGPLAN international conference on Functional programming