Results 11  20
of
30
Reflections on Reflections
, 1997
"... In the functional programming literature, compiling is often expressed as a translation between source and target program calculi. In recent work, Sabry and Wadler proposed the notion of a reflection as a basis for relating the source and target calculi. A reflection elegantly describes the situati ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
In the functional programming literature, compiling is often expressed as a translation between source and target program calculi. In recent work, Sabry and Wadler proposed the notion of a reflection as a basis for relating the source and target calculi. A reflection elegantly describes the situation where there is a kernel of the source language that is isomorphic to the target language. However, we believe that the reflection criteria is so strong that it often excludes the usual situation in compiling where one is compiling from a higherlevel to a lowerlevel language. We give a detailed analysis of several translations commonly used in compiling that fail to be reflections. We conclude that, in addition to the notion of reflection, there are several relations weaker a reflection that are useful for characterizing translations. We show that several familiar translations (that are not naturally reflections) form what we call a reduction correspondence. We introduce the more genera...
Detecting and removing dead code using rank 2 intersection
 IN INTERNATIONAL WORKSHOP:&QUOT;TYPES'96&QUOT;, SELECTED PAPERS, LNCS 1512. SPINGERVERLAG
, 1998
"... In this paper we extend, by allowing rank 2 intersection types, the type assignment system for the detection and elimination of dead code in typed functional programs presented by Coppo et al Giannini and the rst author in the Static Analysis Symposium '96. The main application of this method i ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
In this paper we extend, by allowing rank 2 intersection types, the type assignment system for the detection and elimination of dead code in typed functional programs presented by Coppo et al Giannini and the rst author in the Static Analysis Symposium '96. The main application of this method is the optimization of programs extracted from proofs in logical frameworks, but it could be used as well in the elimination of dead code determined by program specialization. This system rely on annotated types which allow to exploit the type structure of the language for the investigation of program properties. The detection of dead code is obtained via annotated type inference, which canbe performed in a complete way, by reducing it to the solution of a system of inequalities between annotation variables. Even though the language considered in the paper is the simply typedcalculus with cartesian product, ifthenelse, xpoint, and arithmetic constants we can generalize our approach to polymorphic languages like Miranda, Haskell, and CAML.
A Unified Approach to Strictness Analysis and Optimising Transformations
, 1996
"... We present an inference system for translating programs in a PCFlike source language into a variant of Moggi's computational lambda calculus. This translation combines a simple strictness analysis with its associated optimising transformations into a single system. The correctness of the trans ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
We present an inference system for translating programs in a PCFlike source language into a variant of Moggi's computational lambda calculus. This translation combines a simple strictness analysis with its associated optimising transformations into a single system. The correctness of the translation is established using a logical relation between the denotational semantics of the source and target languages.
A Computational Formalization for Partial Evaluation (Extended Version)
, 1996
"... We formalize a partial evaluator for Eugenio Moggi's computational metalanguage. This formalization gives an evaluationorder independent view of bindingtime analysis and program specialization, including a proper treatment of call unfolding, and enables us to express the essence of " ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
We formalize a partial evaluator for Eugenio Moggi's computational metalanguage. This formalization gives an evaluationorder independent view of bindingtime analysis and program specialization, including a proper treatment of call unfolding, and enables us to express the essence of "controlbased bindingtime improvements" for let expressions. Specifically,
Semantic Predicate Types and Approximation for Classbased Object Oriented Programming
"... Abstract. We define a small functional calculus that expresses classbased object oriented features and is modelled on the similar calculi of Featherweight Java [34] and Middleweight Java [15], which are ultimately based upon the Java programming language. We define a predicate system, similar to th ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
(Show Context)
Abstract. We define a small functional calculus that expresses classbased object oriented features and is modelled on the similar calculi of Featherweight Java [34] and Middleweight Java [15], which are ultimately based upon the Java programming language. We define a predicate system, similar to the one defined in [10], and show subject reduction and expansion, and argue that program analysis systems can be built on top of this system. Generalising the concept of approximant from the Lambda Calculus, we show that all expressions that we can assign a predicate to have an approximant that satisfies the same predicate. From this, a characterisation of (head)normalisation follows. 1
Factoring an adequacy proof (preliminary report
 Functional Programming, Glasgow 1993, Workshops in Computing
, 1993
"... This paper contributes to the methodology of using metalogics for reasoning about programming languages. As a concrete example we consider a fragment of ML corresponding to callbyvalue PCF and translate it into a metalogic which contains (amongst other types) computation types and a fixpoint type. ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
This paper contributes to the methodology of using metalogics for reasoning about programming languages. As a concrete example we consider a fragment of ML corresponding to callbyvalue PCF and translate it into a metalogic which contains (amongst other types) computation types and a fixpoint type. The main result is a soundness property (⋆): if the denotations of two programs are provably equal in the metalogic, they have the same operationally observable behaviour. As usual, this follows from a computational adequacy result. In early notes, Plotkin showed how such proofs could be factored into two stages, the first nontrivial and the second (essentially) routine; our contribution is to rework his suggestion within a new framework. We define a metalogic, which incorporates computation and fixpoint types, and specify a modular translation of the ML fragment. Our proof of (⋆) factors into two parts. First, the term language of the metalogic is equipped with an operational semantics and a (generic) computational adequacy result obtained. Second, a simple syntactic argument establishes a correspondence between the operational behaviour of an object program and of its denotation. The first part is not routine but is proved once and for all. The second is a detailed but essentially trivial calculation that is easily adaptable to other object languages. Such a factored proof is important because it promises to scale up more easily than a monolithic one. We show that it may be adapted to an object language with callbyname functions and one with a simple exception mechanism. 1
Monads and eects
 Lecture Notes in Computer Science
, 2002
"... Abstract. A tension in language design has been between simple semantics on the one hand, and rich possibilities for sideeects, exception handling and so on on the other. The introduction of monads has made a large step towards reconciling these alternatives. First proposed by Moggi as a way of st ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. A tension in language design has been between simple semantics on the one hand, and rich possibilities for sideeects, exception handling and so on on the other. The introduction of monads has made a large step towards reconciling these alternatives. First proposed by Moggi as a way of structuring semantic descriptions, they were adopted by Wadler to structure Haskell programs, and now oer a general technique for delimiting the scope of eects, thus reconciling referential transparency and imperative operations within one programming language. Monads have been used to solve longstanding problems such as adding pointers and assignment, interlanguage working, and exception handling to Haskell, without compromising its purely functional semantics. The course will introduce monads, eects and related notions, and exemplify their applications in programming (Haskell) and in compilation (MLj). The course will present typed metalanguages for monads and related categorical notions, and describe how they can be further rened by introducing eects.
Type Theory and Projections for Static Analysis
, 1995
"... A system of annotated types is proposed as a means of describing and inferring static information, such as strictness and constancy, about functional programs. An abstract semantics is given in terms of projections. A close connection between annotated type assignment and projection analysis is demo ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
A system of annotated types is proposed as a means of describing and inferring static information, such as strictness and constancy, about functional programs. An abstract semantics is given in terms of projections. A close connection between annotated type assignment and projection analysis is demonstrated.
Foundations for Partial Evaluation of Functional Programs with Computational Effects
 ACM Computing Surveys
, 1998
"... ing with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works, requires prior specific permission and/or a fee. Permissions may be requested from Publications Dept, ACM Inc., 1515 Broadway, New York, N ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
ing with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works, requires prior specific permission and/or a fee. Permissions may be requested from Publications Dept, ACM Inc., 1515 Broadway, New York, NY 10036 USA, fax +1 (212) 8690481, or permissions@acm.org. 2 \Delta J. Hatcliff e 2 Terms[ ml ] e ::= x j pnq j tick j x : e j @ e0 e1 j unit e j let x ( e1 in e2 2 Types[ ml ] ::= nat j 1 ! e 2 j e \Gamma 2 Assumptions[ ml ] \Gamma ::= \Delta j \Gamma; x : \Gamma ` ml x : \Gamma(x) \Gamma ` ml pnq : nat \Gamma ` ml tick : f nat \Gamma; x : 1 ` ml e : e 2 \Gamma ` ml x : e : 1 ! e 2 \Gamma ` ml e0 : 1 ! e 2 \Gamma ` ml e1 : 1 \Gamma ` ml @ e0 e1 : e 2 monadic constructs: \Gamma ` ml e : \Gamma ` ml unit e : e \Gamma ` ml e 1 : e 1 \Gamma; x : 1 ` ml e 2 : e 2 \Gamma ` ml let x ( e1 in e2 : e 2 Fig. 1. The computational metalanguage ml input/output, and robust...
Intersection Types, λmodels, and Böhm Trees
"... This paper is an introduction to intersection type disciplines, with the aim of illustrating their theoretical relevance in the foundations of λcalculus. We start by describing the wellknown results showing the deep connection between intersection type systems and normalization properties, i.e. ..."
Abstract
 Add to MetaCart
This paper is an introduction to intersection type disciplines, with the aim of illustrating their theoretical relevance in the foundations of λcalculus. We start by describing the wellknown results showing the deep connection between intersection type systems and normalization properties, i.e., their power of naturally characterizing solvable, normalizing, and strongly normalizing pure λterms. We then explain the importance of intersection types for the semantics of λcalculus, through the construction of filter models and the representation of algebraic lattices. We end with an original result that shows how intersection types also allow to naturally characterize tree representations of unfoldings of λterms (Böhm trees).