Abstract not found

Techniques for reasoning about extensional properties of functional programs are well understood, but methods for analysing the underlying intensional or operational properties have been much neglected. This paper begins with the development of a simple but useful calculus for time analysis of non-strict functional programs with lazy lists. One limitation of this basic calculus is that the ordinary equational reasoning on functional programs is not valid. In order to buy back some of these equational properties we develop a non-standard operational equivalence relation called cost equivalence, by considering the number of computation steps as an `observable' component of the evaluation process. We define this relation by analogy with Park's definition of bisimulation in CCS. This formulation allows us to show that cost equivalence is a contextual congruence (and thus is substitutive with respect to the basic calculus) and provides useful proof techniques for establishing cost-equivalen...

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 an extension of the lambda-calculus with differential constructions motivated by a model of linear logic discovered by the first author and presented in [Ehr01]. We state and prove some basic results (confluence, weak normalization in the typed case), and also a theorem relating the usual Taylor series of analysis to the linear head reduction of lambda-calculus.

“Concepts ” are an essential language feature needed to support generic programming in the large. Concepts allow for succinct expression of bounds on type parameters of generic algorithms, enable systematic organization of problem domain abstractions, and make generic algorithms easier to use. In this paper we formalize the design of a type system and semantics for concepts that is suitable for non-type-inferencing languages. Our design shares much in common with the type classes of Haskell, though our primary influence is from best practices in the C ++ community, where concepts are used to document type requirements for templates in generic libraries. The technical development in this paper defines an extension to System F and a type-directed translation from the extension back to System F. The translation is proved sound; the proof is written in the human readable but machine checkable Isar language and has been automatically verified by the Isabelle proof assistant. This document was generated directly from the Isar theory files using Isabelle’s support for literate proofs.

First and foremost I thank my parents for all their love and for teaching me to enjoy learning. I especially thank my wife Katie for her support and understanding through this long and sometimes stressful process. I also thank Katie for insisting on good error messages for G! My advisor, Andrew Lumsdaine, deserves many thanks for his support and guidance and for keeping the faith as I undertook this long journey away from scientific computing and into the field of programming languages. I thank my thesis committee: R. Kent Dybvig, Daniel P. Friedman, Steven D. Johnson, and Amr Sabry for their advice and encouragement. A special thanks goes to Ronald Garcia, Christopher Mueller, and Douglas Gregor for carefully editing and catching the many many times when I accidentally skipped over the important stuff. Thanks to Jaakko and Jeremiah for hours of stimulating discussions and arguments concerning separate compilation and concept-based overloading. Thanks to David Abrahams for countless hours spent debating the merits of one design over another while jogging through the hinterlands of Norway. Thanks to Alexander Stepanov and David Musser for getting all this started, and thank you for the encouragement over the years. Thanks to Matthew Austern, his book Generic Programming in the STL was both an inspiration

Lazy evaluation of functional programs incurs time and memory overheads, and restricts parallelism compared with programs that are evaluated strictly. A number of analysis techniques, such as abstract interpretation and projection analysis, have been developed to find out information that can alleviate these overheads. This paper formalises an evaluation model, the evaluation transformer model of reduction, which can use information from these analysis techniques, and proves that the resulting reduction strategies produce the same answers as those obtained using lazy evaluation.

This paper investigates a method to represent database objects as typed expressions in programming languages. A simple typed language supporting non-flat records, higher-order relations, and natural join expressions is defined. A denotational semantics of this language is then presented. Expressions are interpreted into a domain containing Smyth’s powerdomain. In order to give semantics to types, a new model of types, a filter model is proposed. Types are then interpreted as filters in a domain. The type inference system of the language is shown to be sound in this model. 1

This paper describes a language which facilitates programming for mobile computation i.e., computation in which code migrates and continues to run across network nodes. Such languages allow us to develop novel distributed applications (such as workflow systems, flexible software distribution, and intelligent search systems) more easily and efficiently. However, many of existing programming language systems are often insufficient because they lack the support for concise description of migration and formal models for reasoning about program's properties including type safety and security. Our goal is to construct a programming language system which adequately supports mobile computation on a solid theoretical basis. As an attempt to achieve that, we have designed a programming language based on ML which has well-founded theoretical bases. The features of this language include: transparent migration, dynamic linking with distributed resources by means of contexts, and semantics consistent with the original ML. Especially, our notion of contexts allows us to succinctly describe the interaction between mobile code and environments at destination nodes. We briefly explain a simple semantic model based on Plotkin's v -calculus and tuple spaces. Though our model currently guarantees only type soundness, we believe that theoretical results such as prevention of security violation (of Heintze and Rieckes' SLam Calculus) can be incorporated into our system rather easily.

In this paper we address the issue of understanding sequential and parallel composition of agents from a logical viewpoint. We use the methodology of abstract logic programming in linear logic, where computations are proof searches in a suitable fragment of linear logic. While parallel composition has a straightforward treatment in this setting, sequential composition is much more difficult to be obtained. We define and study a logic programming language, SMR, in which the causality relation among agents forms a seriesparallel order; top agents are recursively rewritten by series-parallel structures of new agents. We show a declarative and simple treatment of sequentialization, which smoothly integrates with parallelization, by translating SMR into linear logic in a complete way. This means that we obtain a full two ways correspondence between proofs in linear logic and computations in SMR; thus we have full correspondence between the two formalisms. Our case study is very general per ...