Results 1  10
of
10
A Core Calculus of Dependency
 IN PROC. 26TH ACM SYMP. ON PRINCIPLES OF PROGRAMMING LANGUAGES (POPL
, 1999
"... Notions of program dependency arise in many settings: security, partial evaluation, program slicing, and calltracking. We argue that there is a central notion of dependency common to these settings that can be captured within a single calculus, the Dependency Core Calculus (DCC), a small extension ..."
Abstract

Cited by 228 (25 self)
 Add to MetaCart
Notions of program dependency arise in many settings: security, partial evaluation, program slicing, and calltracking. We argue that there is a central notion of dependency common to these settings that can be captured within a single calculus, the Dependency Core Calculus (DCC), a small extension of Moggi's computational lambda calculus. To establish this thesis, we translate typed calculi for secure information flow, bindingtime analysis, slicing, and calltracking into DCC. The translations help clarify aspects of the source calculi. We also define a semantic model for DCC and use it to give simple proofs of noninterference results for each case.
Flexible Type Analysis
 In 1999 ACM International Conference on Functional Programming
, 1999
"... Runtime type dispatch enables a variety of advanced optimization techniques for polymorphic languages, including tagfree garbage collection, unboxed function arguments, and flattened data structures. However, modern typepreserving compilers transform types between stages of compilation, making ty ..."
Abstract

Cited by 76 (20 self)
 Add to MetaCart
Runtime type dispatch enables a variety of advanced optimization techniques for polymorphic languages, including tagfree garbage collection, unboxed function arguments, and flattened data structures. However, modern typepreserving compilers transform types between stages of compilation, making type dispatch prohibitively complex at low levels of typed compilation. It is crucial therefore for type analysis at these low levels to refer to the types of previous stages. Unfortunately, no current intermediate language supports this facility. To fill this gap, we present the language LX, which provides a rich language of type constructors supporting type analysis (possibly of previousstage types) as a programming idiom. This language is quite flexible, supporting a variety of other applications such as analysis of quantified types, analysis with incomplete type information, and type classes. We also show that LX is compatible with a typeerasure semantics. 1 Introduction Typedirected co...
A Uniform Type Structure for Secure Information Flow
, 2002
"... The \picalculus is a formalism of computing in which we can compositionally represent dynamics of major programming constructs by decomposing them into a single communication primitive, the name passing. This work reports our experience in using a linear/affine typed \picalculus for the analysis a ..."
Abstract

Cited by 76 (11 self)
 Add to MetaCart
The \picalculus is a formalism of computing in which we can compositionally represent dynamics of major programming constructs by decomposing them into a single communication primitive, the name passing. This work reports our experience in using a linear/affine typed \picalculus for the analysis and development of type systems of programming languages, focussing on secure information flow analysis. After presenting a basic typed calculus for secrecy, we demonstrate its usage by a sound embedding of the dependency core calculus (DCC) and by the development of a novel type discipline for imperative programs which extends both a secure multithreaded imperative language by Smith and Volpano and (a callbyvalue version of) DCC. In each case, the embedding gives a simple proof of noninterference.
Secrets of the Glasgow Haskell Compiler inliner
 Journal of Functional Programming
, 1999
"... Higherorder languages, such as Haskell, encourage the programmer to build abstractions by composing functions. A good compiler must inline many of these calls to recover an efficiently executable program. In principle, inlining is dead simple: just replace the call of a function by an instance of i ..."
Abstract

Cited by 47 (6 self)
 Add to MetaCart
Higherorder languages, such as Haskell, encourage the programmer to build abstractions by composing functions. A good compiler must inline many of these calls to recover an efficiently executable program. In principle, inlining is dead simple: just replace the call of a function by an instance of its body. But any compilerwriter will tell you that inlining is a black art, full of delicate compromises that work together to give good performance without unnecessary code bloat. The purpose of this paper is, therefore, to articulate the key lessons we learned from a fullscale "production" inliner, the one used in the Glasgow Haskell compiler. We focus mainly on the algorithmic aspects, but we also provide some indicative measurements to substantiate the importance of various aspects of the inliner. 1 Introduction One of the trickiest aspects of a compiler for a functional language is the handling of inlining. In a functionallanguage compiler, inlining subsumes several other optimisatio...
Parametricity and Unboxing with Unpointed Types
, 1996
"... . In lazy functional languages, ? is typically an element of every type. While this provides great flexibility, it also comes at a cost. In this paper we explore the consequences of allowing unpointed types in a lazy functional language like Haskell. We use the type (and class) system to keep tr ..."
Abstract

Cited by 22 (2 self)
 Add to MetaCart
. In lazy functional languages, ? is typically an element of every type. While this provides great flexibility, it also comes at a cost. In this paper we explore the consequences of allowing unpointed types in a lazy functional language like Haskell. We use the type (and class) system to keep track of pointedness, and show the consequences for parametricity and for controlling evaluation order and unboxing. 1 Introduction Ever since Scott and others showed how to use pointed CPOs (i.e. with bottoms) to give meaning to general recursion, both over values (including functions), and over types themselves, functional languages seem to have been wedded to the concept. Languages like Haskell [5] model types by appropriate CPOs and, because nonterminating computations can happen at any type, all the CPOs are pointed. This gives significant flexibility. In particular, values of any type may be defined using recursion. 1.1 Parametricity There are associated costs, however. When reason...
Designing a securitytyped language with certificatebased declassification
 In Proc. of the 10th European Symposium on Programming, Lecture Notes in Computer Science
, 2005
"... This paper presents a calculus that supports information ow security policies and certi catebased declassi cation. The decentralized label model and its downgrading mechanisms are concisely expressed in the polymorphic lambda calculus with subtyping (System F). We prove a conditioned version of th ..."
Abstract

Cited by 20 (6 self)
 Add to MetaCart
This paper presents a calculus that supports information ow security policies and certi catebased declassi cation. The decentralized label model and its downgrading mechanisms are concisely expressed in the polymorphic lambda calculus with subtyping (System F). We prove a conditioned version of the noninterference theorem such that authorization for declassi cation is justi ed by digital certi cates from publickey infrastructures. Note to the reviewers: An earlier version of this paper appears in European Symposium on Programming (ESOP), 2005. The main di erence is that the present version (1) contains detailed inference rules and proofs, and (2) formalizes noninterference with xpoints and divergence, (3) implements and typechecks a distributed bank example in the monadic style.
Functional programming with apomorphisms (corecursion
 Proceedings of the Estonian Academy of Sciences: Physics, Mathematics
, 1998
"... Abstract. In the mainstream categorical approach to typed (total) functional programming, functions with inductive source types defined by primitive recursion are called paramorphisms; the utility of primitive recursion as a scheme for defining functions in programming is well known. We draw attenti ..."
Abstract

Cited by 9 (1 self)
 Add to MetaCart
Abstract. In the mainstream categorical approach to typed (total) functional programming, functions with inductive source types defined by primitive recursion are called paramorphisms; the utility of primitive recursion as a scheme for defining functions in programming is well known. We draw attention to the dual notion of apomorphisms — with coinductive target types defined by primitive corecursion and show on examples that primitive corecursion is useful in programming. Key words: typed (total) functional programming, categorical program calculation, (co)datatypes, (co)recursion forms. 1.
CallByPushValue: Decomposing CallByValue And CallByName
"... We present the callbypushvalue (CBPV) calculus, which decomposes the typed callbyvalue (CBV) and typed callbyname (CBN) paradigms into finegrain primitives. On the operational side, we give bigstep semantics and a stack machine for CBPV, which leads to a straightforward push/pop reading of ..."
Abstract

Cited by 8 (3 self)
 Add to MetaCart
We present the callbypushvalue (CBPV) calculus, which decomposes the typed callbyvalue (CBV) and typed callbyname (CBN) paradigms into finegrain primitives. On the operational side, we give bigstep semantics and a stack machine for CBPV, which leads to a straightforward push/pop reading of CBPV programs. On the denotational side, we model CBPV using cpos and, more generally, using algebras for a strong monad. For storage, we present an O’Hearnstyle “behaviour semantics” that does not use a monad. We present the translations from CBN and CBV to CBPV. All these translations straightforwardly preserve denotational semantics. We also study their operational properties: simulation and full abstraction. We give an equational theory for CBPV, and show it equivalent to a categorical semantics using monads and algebras. We use this theory to formally compare CBPV to Filinski’s variant of the monadic metalanguage, as well as to Marz’s language SFPL, both of which have essentially the same type structure as CBPV. We also discuss less formally the differences between the CBPV and monadic frameworks.
Cycle Therapy: A Prescription For Fold . . .
 IN PROC. 3RD INT'L CONF. PRINCIPLES & PRACTICE DECLARATIVE PROGRAMMING
, 2001
"... Cyclic data structures can be tricky to create and manipulate in declarative programming languages. In a declarative setting, a natural way to view cyclic structures is as denoting regular trees, those trees which may be infinite but have only a finite number of distinct subtrees. This paper shows ..."
Abstract
 Add to MetaCart
Cyclic data structures can be tricky to create and manipulate in declarative programming languages. In a declarative setting, a natural way to view cyclic structures is as denoting regular trees, those trees which may be infinite but have only a finite number of distinct subtrees. This paper shows how to implement the unfold (anamorphism) operator in both eager and lazy languages so as to create cyclic structures when the result is a regular tree as opposed to merely infinite lazy structures. The usual fold (catamorphism) operator when used with a strict combining function on any infinite tree yields an undefined result. As an alternative, this paper defines and show how to implement a cycfold operator with more useful semantics when used with a strict function on cyclic structures representing regular trees. This paper also introduces an abstract data type (cycamores) to simplify the use of cyclic structures representing regular trees in both eager and lazy languages. Implementions of cycamores in both SML and Haskell are presented.
Witnessing (Co)datatypes
"... Datatypes and codatatypes are useful for specifying and reasoning about (possibly infinite) computational processes. The interactive theorem prover Isabelle/HOL has recently been extended with a definitional package that supports both. Here we describe a complete procedure for deriving nonemptiness ..."
Abstract
 Add to MetaCart
Datatypes and codatatypes are useful for specifying and reasoning about (possibly infinite) computational processes. The interactive theorem prover Isabelle/HOL has recently been extended with a definitional package that supports both. Here we describe a complete procedure for deriving nonemptiness witnesses in the general mutually recursive, nested case—nonemptiness being a proviso for introducing new types in higherorder logic. The nonemptiness problem also provides an illuminating case study that shows the package in action, tracing its journey from abstract category theory to handson functionality.