In this paper a language-based approach to functionally correct imperative programming is proposed. The approach is based on a programming language called RSP1, which combines dependent types, general recursion, and imperative features in a type-safe way, while preserving decidability of type checking. The methodology used is that of internal verification, where programs manipulate programmer-supplied proofs explicitly as data. The fundamental technical idea of RSP1 is to identify problematic operations as impure, and keep them out of dependent types. The resulting language is powerful enough to verify statically non-trivial properties of imperative and functional programs. The paper presents the ideas through the examples of statically verified merge sort, statically verified imperative binary search trees, and statically verified directed acyclic graphs. This paper is an extended version of [30].

Abstract not found

“The primary goal of the TAL type system is to provide a fully automatic way to verify that programs will not violate the primitive abstractions of the language. ” [1] This is the basic goal of any type system. Quick Review of TAL TAL, however, does this at the assembly code level. But assembly language is untyped, so we need to supply typing annotations: {r1:int, r2:int, r3:int, r4:code(...)} prod: mov r3, 0

Abstract. Dependent type systems allow semantic properties to be expressed in types that carry important information about program values. The type systems in mainstream languages such as Java are effective but have a limited expressive power. We propose to extend a simple Java-like language with indexed types, a form of dependent types defined on index expressions that can statically detect many programming errors. Index types take the form of type annotations in the generics style, so as to express semantic properties in a fashion familiar to object-oriented programmers. For example, Polynomial⟨3 ⟩ is an instance of Polynomial⟨nat degree⟩, where degree has type nat, which is the type of all polynomials of some degree. Expressions in index types currently represent integer values only. Index types may be associated with class definitions, and may be used to constrain base types in fields or local variables, in arguments to methods or in return types. As opposed to conventional types, indexed types may change over a program lifetime. We discuss introducing indirection into type environments to provide support to type check references to mutable objects. 1