Results 1  10
of
15
Cayenne  a Language With Dependent Types
 IN INTERNATIONAL CONFERENCE ON FUNCTIONAL PROGRAMMING
, 1998
"... Cayenne is a Haskelllike language. The main difference between Haskell and Cayenne is that Cayenne has dependent types, i.e., the result type of a function may depend on the argument value, and types of record components (which can be types or values) may depend on other components. Cayenne also co ..."
Abstract

Cited by 241 (0 self)
 Add to MetaCart
Cayenne is a Haskelllike language. The main difference between Haskell and Cayenne is that Cayenne has dependent types, i.e., the result type of a function may depend on the argument value, and types of record components (which can be types or values) may depend on other components. Cayenne also combines the syntactic categories for value expressions and type expressions; thus reducing the number of language concepts. Having dependent types and combined type and value expressions makes the language very powerful. It is powerful enough that a special module concept is unnecessary; ordinary records suffice. It is also powerful enough to encode predicate logic at the type level, allowing types to be used as specifications of programs. However, this power comes at a cost: type checking of Cayenne is undecidable. While this may appear to be a steep price to pay, it seems to work well in practice.
Dynamic Slicing in the Presence of Unconstrained Pointers
, 1991
"... Program slices are useful in debugging. Most work on program slicing to date has concentrated on finding slices of programs involving only scalar variables. Pointers and composite variables do not lend themselves well to static analysis, especially when the language involved is not stronglytyped. W ..."
Abstract

Cited by 57 (3 self)
 Add to MetaCart
Program slices are useful in debugging. Most work on program slicing to date has concentrated on finding slices of programs involving only scalar variables. Pointers and composite variables do not lend themselves well to static analysis, especially when the language involved is not stronglytyped. When debugging a program, however, we are interested in analyzing the program behavior for testcases that reveal a fault. In this paper, we present a uniform approach to handling pointers and composite variables suchas arrays, records, and unions for the purpose of obtaining dynamic program slices. The dynamic approach proposed works well even when the language involved allows unconstrained pointers and performs no runtime checks, as in C.
The Implementation of ALF  a Proof Editor based on MartinLöf's Monomorphic Type Theory with Explicit Substitution
, 1995
"... This thesis describes the implementation of ALF, which is an interactive proof editor based on MartinLöf's type theory with explicit substitutions. ALF is a general purpose proof assistant, in which different logics can be represented. Proof objects are manipulated directly, by the usual editi ..."
Abstract

Cited by 45 (0 self)
 Add to MetaCart
This thesis describes the implementation of ALF, which is an interactive proof editor based on MartinLöf's type theory with explicit substitutions. ALF is a general purpose proof assistant, in which different logics can be represented. Proof objects are manipulated directly, by the usual editing operations. A partial proof is represented as an incomplete proof object, i.e., a proof object containing placeholders. A modular type/proof checking algorithm for complete proof objects is presented, and it is proved sound and complete assuming some basic meta theory properties of the substitution calculus. The algorithm is extended to handle incomplete objects in such a way that the type checking problem is reduced to a unication problem, i.e., the problem of finding instantiations to the placeholders in the object. Placeholders are represented together with their expected type and local context. We show that checking the correctness of instantiations can be localised, which means that it is e...
The Recursive Record Semantics of Objects Revisited
 Journal of Functional Programming
, 2001
"... In a callbyvalue language, representing objects as recursive records requires using an unsafe fixpoint. We design, for a core language including extensible records, a type system which rules out unsafe recursion and still supports the reconstruction of a principal type. We illustrate the expressiv ..."
Abstract

Cited by 37 (1 self)
 Add to MetaCart
In a callbyvalue language, representing objects as recursive records requires using an unsafe fixpoint. We design, for a core language including extensible records, a type system which rules out unsafe recursion and still supports the reconstruction of a principal type. We illustrate the expressive power of this language with respect to objectoriented programming by introducing a sublanguage for "mixinbased" programming.
A slicingbased approach for locating type errors
 ACM TRANSACTIONS ON SOFTWARE ENGINEERING AND METHODOLOGY
, 1997
"... ..."
A Natural Semantics for Eiffel Dynamic Binding
, 1996
"... This article formally defines Eiffel dynamic binding in presence of... ..."
Abstract

Cited by 18 (1 self)
 Add to MetaCart
This article formally defines Eiffel dynamic binding in presence of...
A Formal Semantics for Sisal Arrays
"... We present a formal definition of the dynamic semantics of arrays in the functional language Sisal 2.0. We adopt a logical setting: the structural operational style of Natural Semantics, using the Typol inference rules within the Centaur system, a generic programming environment. From the formal ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
We present a formal definition of the dynamic semantics of arrays in the functional language Sisal 2.0. We adopt a logical setting: the structural operational style of Natural Semantics, using the Typol inference rules within the Centaur system, a generic programming environment. From the formal specifications, a development and visualization environment for Sisal programming is generated. This semantic definition should allow for a precise comparison of array facilities in similar languages. Moreover, this work is the basis for a formal description of program transformations (e.g. parallelizations) which are crucial in the compilation techniques of functional languages such as Sisal.
PMC: A Programming Language for Embedded Systems
 In Proc. Int. Workshop Formal Methods for Industrial Critical Systems
, 1999
"... The process algebra pmc (Processes with Multiple Clocks) extends Milner's ccs with a notion of qualitative time called clocks. The algebra has been used for specifying industrial size casestudies. Based on the algebra pmc, we introduce a programming language (also named PMC) for embedded syste ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
The process algebra pmc (Processes with Multiple Clocks) extends Milner's ccs with a notion of qualitative time called clocks. The algebra has been used for specifying industrial size casestudies. Based on the algebra pmc, we introduce a programming language (also named PMC) for embedded systems. The language features pointtopoint communication, multisynchronization, local deterministic parallel composition, global nondeterministic parallel composition, and a restricted form of mixed input/output guarded choice. The expression language includes constructors, tuples, and patterns as known from SML. The language is strongly typed. The PMC language provides the user with a clean, yet flexible, separation between the abstract programming of an embedded system, and the lowlevel, hardware specific details of for instance device drivers. We have a prototype compiler that compiles PMC to Java byte code. Concurrency does not necessarily give rise to considerable computation overhead. In im...
Integrating Paradigms via Interaction Nets (Extended Abstract)
"... In this paper we begin a study of the integration of programming paradigms using Lafont's interaction nets as a unifying framework. Interaction nets are a very simple kind of rewrite system based on rewriting of networks. Because of their linear logic foundation they give a refined view of comp ..."
Abstract
 Add to MetaCart
In this paper we begin a study of the integration of programming paradigms using Lafont's interaction nets as a unifying framework. Interaction nets are a very simple kind of rewrite system based on rewriting of networks. Because of their linear logic foundation they give a refined view of computation; they have been used for the implementation of programming languages based on the lambdacalculus, and recently for the implementation of term rewriting systems. Here we study the implementation of languages based on combinations of the lambdacalculus and term rewriting systems. We show that interaction nets give a uniform implementation and semantic framework for this kind of language, which we hope to extend also to other programming paradigms.