A decision procedure for common Lisp'sSUBTYPEP predicate

The Common Lisp Object System (CLOS) has received some praise and some criticism, both deserved. One of the most controversial features of standard CLOS is its linearly-ordered "class precedence list", which is used to linearly order the execution of its "combination" methods. In addition to the problems already known regarding the linear ordering of superclasses, we show that the standard CLOS class precedence ordering produces gratuitously complex and non-intuitive behavior. We then show that a slight modification of the standard ordering rules produces a linear ordering which can achieve most of the goals of CLOS more efficiently, and without impacting most programs. We describe a subset of CLOS called Static CLOS which preserves much of the praise due CLOS, while eliminating some of the criticism. Static CLOS is tuned for delivery of debugged code, rather than for prototype development. This "delivery" CLOS determines as many methods as possible at compile-time using "type inference" techniques. While these techniques generally result in faster-executing code, the space requirements can grow quite large. We argue that this space explosion can be partially ameliorated through the use of our modified class precedence ordering.

The Persistent Lisp language was defined and an implementation, UCL+P, 1 was designed and constructed. Persistent Lisp is a superset of Common Lisp which fully supports the development of programs manipulating persistent data while maintaining Lisp semantics across the storage/retrieval of values. Persistence features provided are concurrent atomic transactions, demand loading of values, and transparent load and store of persistent values. All Common Lisp data types (with the exception of streams) can be made persistent. Nonsymbolic values are initially created as transient values on the runtime heap. When a transaction completes, transient values which are reachable from a persistent symbol become persistent. The package mechanism has been extended to add a persistence attribute to packages. When symbols are interned in a package with the persistence attribute, they become persistent, as do values reachable from them. UCL+P was created to support these features, by making extensive low-level modifications to the UCL compiler and runtime system. A new runtime data structure, the indirection vector, was created to support the relocation of newly persistent values from the runtime heap to the persistent heap.

When you write programs, the type system of your choice of language is very important. Types allow you to organize your application data in a structured way that can be persisted into various data stores. When you write applications, especially business applications, you organize your application data using various types and persist the values of those types into persistence storage. When you write applications with Go, it is important to understand its type system and its design philosophy. Go provides various built-in types such as int, uint, float64, string, and bool. Data structures for storing collections of values such as arrays, slices, and maps are known as composite types because they are made up of other types—built-in types and user-defined types. In addition to the built-in types provided by Go, you can create your own types by combining with other types. This chapter contains recipes for user-defined types in Go.

The paper describes the refinement algorithm for the Calculus of (Co)Inductive Constructions (CIC) implemented in the interactive theorem prover Matita. The refinement algorithm is in charge of giving a meaning to the terms, types and proof terms directly written by the user or generated by using tactics, decision procedures or general automation. The terms are written in an "external syntax" meant to be user friendly that allows omission of information, untyped binders and a certain liberal use of user defined sub-typing. The refiner modifies the terms to obtain related well typed terms in the internal syntax understood by the kernel of the ITP. In particular, it acts as a type inference algorithm when all the binders are untyped. The proposed algorithm is bi-directional: given a term in external syntax and a type expected for the term, it propagates as much typing information as possible towards the leaves of the term. Traditional mono-directional algorithms, instead, proceed in a bottom-up way by inferring the type of a sub-term and comparing (unifying) it with the type expected by its context only at the end. We propose some novel bi-directional rules for CIC that are particularly effective. Among the benefits of bi-directionality we have better error message reporting and better inference of dependent types. Moreover, thanks to bi-directionality, the coercion system for sub-typing is more effective and type inference generates simpler unification problems that are more likely to be solved by the inherently incomplete higher order unification algorithms implemented. Finally we introduce in the external syntax the notion of vector of placeholders that enables to omit at once an arbitrary number of arguments. Vectors of placeholders allow a trivial implementation of implicit arguments and greatly simplify the implementation of primitive and simple tactics.

Part 1 Objects and subtypes: user-defined types and procedural data structures as complementary approaches to data abstraction, John C. Reynolds using category theory to design implicit conversions and generic operators, John C. Reynolds. Part 2 Type inference: type inference for records in a natural extension of ML, Didier Remy type inference for objects with instance variables and inheritance, Mitchell Wand static type inference for parametric classes, Atsushi Ohori and Peter Buneman. Part 3 Coherence: a modest model of records, inheritance, and bounded quantification, Kim B. Bruce and Giuseppe Longo inheritance as implicit coercion, Val Breazu-Tannen et al coherence of subsumption, minimum typing and type-checking in F<, Pierre-Louis Curien and Giorgio Ghelli. Part 4 Record calculi: operations on records, Luca Cardelli and John C. Mitchell typing record concatenation for free, Didier Remy extensible records in a pure calculus of subtyping, Luca Cardelli bounded quantification is undecidable, Benjamin C. Pierce. Part 5 Inheritance: two semantic models of object-oriented languages, Samuel N. Kamin and Uday S. Reddy inheritance is not subtyping, William R. Cook et al toward a typed foundation for method specialization and inheritance, John C. Mitchell.

Complexity, convexity and combinations of theories

On the 16th of June the ACM SIGPLAN Workshop on Memory System Performance (MSP'02) was held in Berlin, Germany. MSP'02 is a new workshop that focuses on software techniques to address the memory wall.Given current technology trends that forecast a rapidly growing processor-memory speed imbalance, optimizing a program's memory system performance has become increasingly important. Much research has focused on improving the cache performance of scientific programs that use arrays as their primary data structure. Unfortunately, these techniques are not a complete solution for general purpose programs, which manipulate more complex and dynamic data structures. While recent research has begun to address this problem, much work remains to be done.The focus of this workshop is on all aspects of improving the memory system performance of general-purpose programs. This includes novel techniques for profiling memory system behavior, new analyses (both static and dynamic) for identifying and understanding memory-related performance problems, and finally optimizations for improving memory system performance. Software, hardware as well as hybrid approaches are encouraged. In addition, studies of application that describe problems and experience with memory performance related issues in specific application domains are of interest. The objective of the workshop is to bring together programming language researchers in the areas of program analysis and compiler optimization, computer architects, operating system researchers, and application programmers. We hope that this will be the first in a series of workshops that will encourage collaboration across these fields while at the same time expand program optimization research towards an area of great practical importance.MSP'02 features an invited talk and presentations of ten refereed papers. The papers were selected out of fifteen submissions. Fifteen PC members and additional external reviewers prepared multiple written reviews for each submission. The recommendations of the referees determined an initial set of papers selected for acceptance. The members of the program committee were then given the option to resolve differences in opinion for the papers they refereed based on the written reviews during the program committee tele-conferenee meeting. After the resolution process, the 10 papers included in the workshop proceedings were selected for presentation and publication.

The development of the interval analysis theory and its applications in solving applied problems led to the need to collect, store and extract efficiently interval-significant data in relational databases. Modern relational database management systems (DBMS) either allow to work with built-in data types which however are not friendly for use or provide the ability to create your own user-defined data types in several ways. The article describes the creation of a user-defined data type iInterval, functions and aggregates to work with interval data in MS SQL Server using the Common Language Runtime (CLR).

Predicting the future is an essential component of decision-making. In most situations, however, there is not enough information to make accurate predictions. A theory of causal reasoning for predictive inference under uncertainty is developed. A common type of prediction that involves reasoning about persistence is emphasized: whether or not a proposition once made true remains true at some later time. A decision procedure with a polynomial-time algorithm for determining the probability of the possible consequences of a set of events and initial conditions is provided. The integration of simple probability theory with temporal projection circumvents problems in dealing with persistence by nonmonotonic temporal reasoning schemes. These ideas have been implemented in a prototype system that refines a database of causal rules in the course of applying those rules to construct and carry out plans in a manufacturing domain.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The authors aim to automatically interface C++ and Fortran 95 code, with either language playing the role of main and with user-defined types from one language available in the other. To physically interface C++ and Fortran 95 they: ensure that procedure names are visible and sensible across the language interface; reduce procedure arguments to the common set of built-in types available in both languages; and ensure that the proper code initialization takes place in both languages.

The R programming language combines a number of features considered hard to analyze and implement efficiently: dynamic typing, reflection, lazy evaluation, vectorized primitive types, first-class closures, and extensive use of native code. Additionally, variable scopes are reified at runtime as first-class environments. The combination of these features renders most static program analysis techniques impractical, and thus, compiler optimizations based on them ineffective. We present our work on PIR, an intermediate representation with explicit support for first-class environments and effectful lazy evaluation. We describe two dataflow analyses on PIR: the first enables reasoning about variables and their environments, and the second infers where arguments are evaluated. Leveraging their results, we show how to elide environment creation and inline functions.

Python is a popular, dynamic language for data science and scientific computing. To ensure efficiency, significant numerical libraries are implemented in static native languages. However, performance suffers when switching between native and non-native code, especially if data has to be converted between native arrays and Python data structures. As GPU accelerators are increasingly used, this problem becomes particularly acute. Data and control has to be repeatedly transferred between the accelerator and the host.

One purpose of type checking in programming languages is to guarantee a degree of independence: programs should not depend on the way stacks are represented, only on the behavior of stacks with respect to push and pop operations. In languages with abstract data type declarations, representation independence should hold for user-defined types as well as built-in types. We study the representation independence properties of a typed functional language (second-order lambda calculus) with polymorphic functions and abstract data type declarations in which data type implementations (packages) may be passed as function parameters and returned as results. The type checking rules of the language guarantee that two data type implementations P and Q are equivalence whenever there is a correspondence between the behavior of the operations of P and the behavior of the operations of Q.

Axioms as generic rewrite rules in C++ with concepts

This paper presents an extended Common LISP implementation of a PROLOG interpreter named CL-Prolog, giving a detailed description of the major problems met and the principal data structures and algorithms used for their solution.A sort of PROLOG virtual processor has been implemented whose instructions are defined using LISP as microcode; particular attention is payed to the the Memory Management Unit and the basic Control Mechanism.The reader is supposed to be accustomed with PROLOG Programming and the evaluation of the first order Logic Predicates.The main characteristics of CL-Prolog are:- Clean separation from the host language.- Tail recursion handling and binding mechanism optimization.- Portability, flexibility, and extendibility of basic model.- Interaction between PROLOG code and host LISP interpreter.Interpreter's core is separated in three big modules in order to cut off the different issues :- the reader, the evaluator, and the resources manager -Finally the introduction of a double-stack recursion management has sped up the Backtracking mechanism; the resulting overall performances of this interpreter are really comparable to other commercial one even when they are implemented using procedural languages, supposed faster, confirming the possibility of using very high level languages as effective tools for real implementations.