Results 1 
6 of
6
Lightweight linear types in system F o
 In TLDI
, 2010
"... We present System F ◦ , an extension of System F that uses kinds to distinguish between linear and unrestricted types, simplifying the use of linearity for generalpurpose programming. We demonstrate through examples how System F ◦ can elegantly express many useful protocols, and we prove that any p ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
(Show Context)
We present System F ◦ , an extension of System F that uses kinds to distinguish between linear and unrestricted types, simplifying the use of linearity for generalpurpose programming. We demonstrate through examples how System F ◦ can elegantly express many useful protocols, and we prove that any protocol representable as a DFA can be encoded as an F ◦ type. We supply mechanized proofs of System F ◦ ’s soundness and parametricity properties, along with a nonstandard operational semantics that formalizes common intuitions about linearity and aids in reasoning about protocols. We compare System F ◦ to other linear systems, noting that the simplicity of our kindbased approach leads to a more explicit account of what linearity is meant to capture, allowing otherwiseconflicting interpretations of linearity (in particular, restrictions on aliasing versus restrictions on resource usage) to coexist peacefully. We also discuss extensions to System F ◦ aimed at making the core language more practical, including the additive fragment of linear logic, algebraic datatypes, and recursion.
E.: Uniqueness typing simplified—technical appendix
"... This technical report is an appendix to Uniqueness Typing Simplified [7], in which we show how uniqueness typing can be simplified by treating uniqueness attributes as types of a special kind, allowing arbitrary boolean expressions as attributes, and avoiding subtyping. In the paper, we define a sma ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
This technical report is an appendix to Uniqueness Typing Simplified [7], in which we show how uniqueness typing can be simplified by treating uniqueness attributes as types of a special kind, allowing arbitrary boolean expressions as attributes, and avoiding subtyping. In the paper, we define a small core uniqueness type system (a derivative of the simply typed lambda calculus) that incorporates these ideas. We also outline how soundness with respect to the callbyneed semantics [11] can be proven, but we do not give any details. This report describes the entire proof, which is written using the proof assistant Coq [3]. The proof itself (as
Resource Typing in Guru
 Proceedings of the 4th ACM Workshop Programming Languages meets Program Verification, PLPV 2010
"... This paper presents a resource typing framework for the Guru verifiedprogramming language, in which abstractions for various kinds of program resources can be defined. Implemented examples include referencecounted data, mutable arrays, and heapallocated mutable aliased data. The approach enables ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
This paper presents a resource typing framework for the Guru verifiedprogramming language, in which abstractions for various kinds of program resources can be defined. Implemented examples include referencecounted data, mutable arrays, and heapallocated mutable aliased data. The approach enables efficient, typesafe programming with mutable and aliased data structures, with explicit deallocation (not garbage collection). We evaluate performance of the approach with two verified benchmarks, one involving mutable arrays, and another involving FIFO queues.
Side Effects
"... This section covers basic topics and illustrates the technical notion of a computational effect with several mathematical and programming examples. In everyday language, a “side effect ” refers to the unintended or unforeseen consequences of an action. By analogy, in order to identify the side effec ..."
Abstract
 Add to MetaCart
This section covers basic topics and illustrates the technical notion of a computational effect with several mathematical and programming examples. In everyday language, a “side effect ” refers to the unintended or unforeseen consequences of an action. By analogy, in order to identify the side effect of a given computation, it is first necessary to isolate the
Second supervisor:
, 2010
"... Static program analysis and compile time program optimizations are important aspects of functional language compilers. Strictness optimization is a big part of a Haskell compiler, it is interesting from a research perspective, as well as being needed for practical performance issues. In this thesis ..."
Abstract
 Add to MetaCart
(Show Context)
Static program analysis and compile time program optimizations are important aspects of functional language compilers. Strictness optimization is a big part of a Haskell compiler, it is interesting from a research perspective, as well as being needed for practical performance issues. In this thesis we explore a new, typed intermediate language designed for doing static program analysis. This language is well suited to implementing optimizing transformations. We implement strictness optimization for firstorder functions, and see how we can safely combine this optimization with other optimizations. Finally, we discuss how we can extend the language to implement strictness optimization for higherorder functions. 3 4
General Terms
"... Alms is a generalpurpose programming language that supports practical affine types. To offer the expressiveness of Girard’s linear logic while keeping the type system light and convenient, Alms uses expressive kinds that minimize notation while maximizing polymorphism between affine and unlimited t ..."
Abstract
 Add to MetaCart
Alms is a generalpurpose programming language that supports practical affine types. To offer the expressiveness of Girard’s linear logic while keeping the type system light and convenient, Alms uses expressive kinds that minimize notation while maximizing polymorphism between affine and unlimited types. A key feature of Alms is the ability to introduce abstract affine types via MLstyle signature ascription. In Alms, an interface can impose stiffer resource usage restrictions than the principal usage restrictions of its implementation. This form of sealing allows the type system to naturally and directly express a variety of resource management protocols from specialpurpose type systems. We present two pieces of evidence to demonstrate the validity of our design goals. First, we introduce a prototype implementation of Alms and discuss our experience programming in the language. Second, we establish the soundness of the core language. We also use the core model to prove a principal kinding theorem.