Abstract. We define a small functional calculus that expresses class-based object oriented features and is modelled on the similar calculi of Featherweight Java [34] and Middleweight Java [15], which are ultimately based upon the Java programming language. We define a predicate system, similar to the one defined in [10], and show subject reduction and expansion, and argue that program analysis systems can be built on top of this system. Generalising the concept of approximant from the Lambda Calculus, we show that all expressions that we can assign a predicate to have an approximant that satisfies the same predicate. From this, a characterisation of (head-)normalisation follows. 1

We show that typability for a natural form of polymorphic recursive typing for rank-2 intersection types is undecidable. Our proof involves characterizing typability as a context free language (CFL) graph problem, which may be of independent interest, and reduction from the boundedness problem for Turing machines. We also show a property of the type system which, in conjunction with the undecidability result, disproves a misconception about the Milner-Mycroft type system. We also show undecidability of a related program analysis problem. 1

Intersection type systems realize a finite polymorphism where di#erent types for a term are itemized explicitly. We analyze System-I, a rank-bounded intersection type system where intersection is not associative, commutative, or idempotent (ACI), but includes a substitution mechanism employing expansion variables that facilitates modular program composition and flow analysis. This type system is used in a prototype intersection type compiler for the Church project [15]. We prove that the problem of type inference is exactly as hard as the problem of normalization: the worst-case cost of both is an elementary function, where the iterated exponential depends on the rank. The key to these results is that simply-typed terms must be linear without ACI, but have the usual nonelementary power with ACI. Further, type inference is always synonymous with normalization: the cost of computing the principal typing of any term is exactly the cost of computing its normal form. These results do not hold when AC, and particularly I, is added.

Abstract. We identify a restricted class of terms of the lambda calculus, here called weak linear, that includes the linear lambda-terms keeping their good properties of strong normalization, non-duplicating reductions and typability in polynomial time. The advantage of this class over the linear lambda-calculus is the possibility of transforming general terms into weak linear terms with the same normal form. We present such transformation and prove its correctness by showing that it preserves normal forms. 1

Abstract. The Rank 2 Intersection Type System is the intersection type system with more impact in the area of functional programming languages. This system includes the powerful type system of the functional language ML keeping the decidability of type inference. The Simple Type System is the basis of every type system for programming languages. In this paper we prove that it is possible to transform any term typable by a Simple type in the Rank 2 Intersection Type System into a new term typable in the Simple Type System with the same type. We define that transformation independently of any type information. Then we prove the correctness of the presented transformation, in the sense that it preserves types of terms typable by Simple Types. 1

It is known that inferring an exact intersection typing for a #-term (i.e., a typing where the intersection operator is not idempotent) is equivalent to strong #-normalisation of that term. Intersection typing derivations can provide very precise information about program behaviour, making them --- in principle --- an attractive framework for program analysis. The recent innovation of expansion variables greatly simplifies the production of such typing derivations, allows their production for all #-normalising terms and allows inference to be done in a truly compositional way --- a big advantage for programs where components are updated frequently and separately. We present a new, truly compositional, exact intersection typing inference procedure for the recent, expansion variable-based, System E framework. Inference uses a confluent rewrite system to solve instances of a unification problem with expansion variables. Moreover, we explain precisely how the inferred typing-derivation describes the evaluation of the term, showing that the typing derivation most accurately describes its call-by-name evaluation via a linear transformation. For other evaluation strategies, di#erent inference algorithms will be required. 1

Interpretation is an implicit part of today’s programming; it has great power but is overused and has significant costs. For example, interpreters are typically significantly hard to understand and hard to reason about. The methodology of “Totally Functional Programming” (TFP) is a reasoned attempt to redress the problem of interpretation. It incorporates an awareness of the undesirability of interpretation with observations that definitions and a certain style of programming appear to offer alternatives to it. Application of TFP is expected to lead to a number of significant outcomes, theoretical as well as practical. Primary among these are novel programming languages to lessen or eliminate the use of interpretation in programming, leading to better-quality software. However, TFP contains a number of lacunae in its current formulation, which hinder development of these outcomes. Among others, formal semantics and type-systems for TFP languages are yet to be discovered, the means to reduce interpretation in programs is to be determined, and a detailed explication is needed of interpretation, definition, and the differences between the two. Most important of all however is the need to develop a complete understanding of the nature of interpretation. In this work, suitable type-systems for TFP languages are identified, and guidance given regarding the construction of appropriate formal semantics. Techniques, based around the ‘fold’ operator, are identified and developed for modifying programs so as to reduce the amount of interpretation they contain. Interpretation as a means of language-extension is also investigated. v Finally, the nature of interpretation is considered. Numerous hypotheses relating to it considered in detail. Combining the results of those analyses with discoveries from elsewhere in this work leads to the proposal that interpretation is not, in fact, symbol-based computation, but is in fact something more fundamental: computation that varies with input. We discuss in detail various implications of this characterisation, including its practical application. An often more-useful property, ‘inherent interpretiveness’, is also motivated and discussed in depth. Overall, our inquiries act to give conceptual and theoretical foundations for practical TFP.