Results 1  10
of
11
A Syntactic Approach to Type Soundness
 INFORMATION AND COMPUTATION
, 1992
"... We present a new approach to proving type soundness for Hindley/Milnerstyle polymorphic type systems. The keys to our approach are (1) an adaptation of subject reduction theorems from combinatory logic to programming languages, and (2) the use of rewriting techniques for the specification of the la ..."
Abstract

Cited by 634 (25 self)
 Add to MetaCart
(Show Context)
We present a new approach to proving type soundness for Hindley/Milnerstyle polymorphic type systems. The keys to our approach are (1) an adaptation of subject reduction theorems from combinatory logic to programming languages, and (2) the use of rewriting techniques for the specification of the language semantics. The approach easily extends from polymorphic functional languages to imperative languages that provide references, exceptions, continuations, and similar features. We illustrate the technique with a type soundness theorem for the core of Standard ML, which includes the first type soundness proof for polymorphic exceptions and continuations.
Practical Soft Typing
, 1994
"... Soft typing is an approach to type checking for dynamically typed languages. Like a static type checker, a soft type checker infers syntactic types for identifiers and expressions. But rather than reject programs containing untypable fragments, a soft type checker inserts explicit runtime checks t ..."
Abstract

Cited by 11 (1 self)
 Add to MetaCart
Soft typing is an approach to type checking for dynamically typed languages. Like a static type checker, a soft type checker infers syntactic types for identifiers and expressions. But rather than reject programs containing untypable fragments, a soft type checker inserts explicit runtime checks to ensure safe execution. Soft typing was first introduced in an idealized form by Cartwright and Fagan. This thesis investigates the issues involved in designing a practical soft type system. A soft type system for a purely functional, callbyvalue language is developed by extending the HindleyMilner polymorphic type system with recursive types and limited forms of union types. The extension adapts Remy's encoding of record types with subtyping to union types. The encoding yields more compact types and permits more efficient type inference than Cartwright and Fagan's early technique. Correctness proofs are developed by employing a new syntactic app...
Laziness without all the hard work: combining lazy and strict languages for teaching
 In FDPE ’05: Proceedings of the 2005 workshop on Functional and declarative programming in education
, 2005
"... Students have trouble understanding the difference between lazy and strict programming. It is difficult to compare the two directly, because popular strict languages and popular lazy languages differ in their syntax, in their type systems, and in other ways unrelated to the lazy/strict evaluation di ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
Students have trouble understanding the difference between lazy and strict programming. It is difficult to compare the two directly, because popular strict languages and popular lazy languages differ in their syntax, in their type systems, and in other ways unrelated to the lazy/strict evaluation discipline. While teaching programming languages courses, we have discovered that an extension to PLT Scheme allows the system to accommodate both lazy and strict evaluation in the same system. Moreover, the extension is simple and transparent. Finally, the simple nature of the extension means that the resulting system provides a rich environment for both lazy and strict programs without modification. Categories and Subject Descriptors D.3.m [Programming Languages]:
Languages, Theory
"... We describe the implementation of firstclass polymorphic delimited continuations in the programming language Scala. We use Scala’s pluggable typing architecture to implement a simple type and effect system, which discriminates expressions with control effects from those without and accurately track ..."
Abstract
 Add to MetaCart
(Show Context)
We describe the implementation of firstclass polymorphic delimited continuations in the programming language Scala. We use Scala’s pluggable typing architecture to implement a simple type and effect system, which discriminates expressions with control effects from those without and accurately tracks answer type modification incurred by control effects. To tackle the problem of implementing firstclass continuations under the adverse conditions brought upon by the Java VM, we employ a selective CPS transform, which is driven entirely by effectannotated types and leaves pure code in direct style. Benchmarks indicate that this highlevel approach performs competitively.
Spatial Computing in MGS
"... Abstract. This short paper motivates and introduces the tutorial on MGS and spatial computing presented at UCNC 2012. ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. This short paper motivates and introduces the tutorial on MGS and spatial computing presented at UCNC 2012.
On the Orthogonality of Assignments and Procedures in Algol
 In Proc. 20th ACM Symposium on Principles of Programming Languages
, 1993
"... According to folklore, Algol is an "orthogonal" extension of a simple imperative programming language with a callbyname functional language. The former contains assignments, branching constructs, and compound statements; the latter is based on the typed calculus. In an attempt to formal ..."
Abstract
 Add to MetaCart
According to folklore, Algol is an "orthogonal" extension of a simple imperative programming language with a callbyname functional language. The former contains assignments, branching constructs, and compound statements; the latter is based on the typed calculus. In an attempt to formalize the claim of "orthogonality", we define a simple version of Algol and an extended calculus. The calculus includes the full firule and rules for the reduction of assignment statements and commands. It has the usual properties, e.g., it satisfies a ChurchRosser and Strong Normalization Theorem. In support of the claim that the imperative and functional components are orthogonal to each other, we show that the proofs of these theorems are combinations of separate ChurchRosser and Strong Normalization theorems for each sublanguage. An acclaimed consequence of Algol's orthogonal design is the idea that the evaluation of a program has two distinct phases. The first phase corresponds to an unrolling ...
SPCF: Its Model, Calculus, and Computational Power (Preliminary Version)
, 1992
"... SPCF is an idealized sequential programming language, based on Plotkin's language PCF, that permits programmers and programs to observe the evaluation order of procedures. In this paper, we construct a fully abstract model of SPCF using a new mathematical framework suitable for defining fully a ..."
Abstract
 Add to MetaCart
SPCF is an idealized sequential programming language, based on Plotkin's language PCF, that permits programmers and programs to observe the evaluation order of procedures. In this paper, we construct a fully abstract model of SPCF using a new mathematical framework suitable for defining fully abstract models of sequential functional languages. Then, we develop an extended typed calculus to specify the operational semantics of SPCF and show that the calculus is complete for the constantfree sublanguage. Finally, we prove that SPCF is computationally complete: it can express all the computable (recursively enumerable) elements in its fully abstract model. 1 SPCF: Observing Sequentiality Most contemporary programming languages, e.g., Scheme, Pascal, Fortran, C, and ML, are "sequential", that is, they impose a serial order on the evaluation of parts of programs. Unfortunately, the familiar mathematical models for sequential languages based on continuous functions do not capture this pro...
Under consideration for publication in J. Functional Programming
, 2007
"... We combine ideas from types for continuations, effect systems and monads in a very simple setting by defining a version of classical propositional logic in which doublenegation elimination is combined with a modality. The modality corresponds to control effects, and it includes a form of effect mas ..."
Abstract
 Add to MetaCart
(Show Context)
We combine ideas from types for continuations, effect systems and monads in a very simple setting by defining a version of classical propositional logic in which doublenegation elimination is combined with a modality. The modality corresponds to control effects, and it includes a form of effect masking. Erasing the modality from formulas gives classical logic. On the other hand, the logic is conservative over intuitionistic logic. 1
Chapter 5: On the Orthogonality of Assignments and Procedures in ALGOL
, 1996
"... Contents 1 Introduction 102 2 An Idealized Dialect 102 2.1 Syntax and Informal Semantics 103 2.2 Semantics and Calculus 105 2.3 Characteristics of eval 107 3 Postponement 109 4 Strong Normalization 113 5 Extensions and Alternatives 115 Acknowledgements 116 References 116 A ChurchRosser Theorem for ..."
Abstract
 Add to MetaCart
(Show Context)
Contents 1 Introduction 102 2 An Idealized Dialect 102 2.1 Syntax and Informal Semantics 103 2.2 Semantics and Calculus 105 2.3 Characteristics of eval 107 3 Postponement 109 4 Strong Normalization 113 5 Extensions and Alternatives 115 Acknowledgements 116 References 116 A ChurchRosser Theorem for ia 118 B Uniform Evaluation 120 C Postponement 121 D Strong Normalization 123 Preliminary version appeared in Conference Record of the Twentieth Annual ACM SIGPLANSIGACT Symposium on Principles of Programming Languages, pages 57#70, Charleston, South Carolina, 1993. ACM, New York. 102 Chapter 5. Orthogonality of Assignments and Procedures in ALGOL 1 Introduction According to folklore, Algol 60 #orthogonally# extends a simple imperative programming language with a typed calculus. The underlying imperative language consists of a standard collection of