Nothing Special   »   [go: up one dir, main page]

skip to main content
10.1145/1016850acmconferencesBook PagePublication PagesicfpConference Proceedingsconference-collections
ICFP '04: Proceedings of the ninth ACM SIGPLAN international conference on Functional programming
ACM2004 Proceeding
Publisher:
  • Association for Computing Machinery
  • New York
  • NY
  • United States
Conference:
ICFP04: ACM SIGPLAN International Conference on Functional Programming Snow Bird UT USA September 19 - 21, 2004
ISBN:
978-1-58113-905-1
Published:
19 September 2004
Sponsors:
Next Conference
October 12 - 18, 2025
Singapore , Singapore
Reflects downloads up to 04 Feb 2025Bibliometrics
Skip Abstract Section
Abstract

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.

Skip Table Of Content Section
Article
The C—compiler infrastructure
Article
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, ...

SESSION: Session I
Article
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 ...

Article
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 ...

Article
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 ...

SESSION: Session II
Article
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 ...

Article
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 ...

Article
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 ...

SESSION: Session III
Article
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 ...

Article
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 ...

Article
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 ...

SESSION: Session IV
Article
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 ...

Article
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 ...

Article
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 ...

SESSION: Session V
Article
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 ...

Article
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 ...

Article
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 ...

SESSION: Session VI
Article
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 ...

Article
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 ...

Article
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 ...

SESSION: Session VII
Article
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 ...

Article
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 ...

Article
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 ...

SESSION: Session VIII
Article
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 ...

Article
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 ...

Contributors
  • The U.S. Military Academy at West Point
  • Tufts University
  1. Proceedings of the ninth ACM SIGPLAN international conference on Functional programming
    Please enable JavaScript to view thecomments powered by Disqus.

    Recommendations

    Acceptance Rates

    Overall Acceptance Rate 333 of 1,064 submissions, 31%
    YearSubmittedAcceptedRate
    ICFP '14852833%
    ICFP '131334030%
    ICFP '12883236%
    ICFP '11923336%
    ICFP '03952425%
    ICFP '02762432%
    ICFP '01662335%
    ICFP '001102422%
    ICFP '99812531%
    ICFP '98773039%
    ICFP '97782532%
    ICFP '96832530%
    Overall1,06433331%