System E is a recently designed type system for the #- calculus with intersection types and expansion variables. During automatic type inference, expansion variables allow postponing decisions about which non-syntax-driven typing rules to use until the right information is available and allow implementing the choices via substitution.

Useful type inference must be faster than normalization. Otherwise, you could check safety conditions by running the program. We analyze the relationship between bounds on normalization and type inference. We show how the success of type inference is fundamentally related to the amnesia of the type system: the nonlinearity by which all instances of a variable are constrained to have the same type.

We investigate the precision of static, compile-time analysis, and the necessary analytic tradeoff with the

More than being just a tool for expressing algorithms, a well-designed programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore of importance to understand how such choices effect the expressibility of programming languages. The paper pursues the very low complexity programs by presenting a first-order function algebra BC # that captures exactly LF, the functions computable in logarithmic space. This gives insights into the expressiveness of recursion. Moreover, it can be useful for the automatic analysis of programs' resource usage and the separation of complexity classes. The important technical features of BC # are (1) a separation of variables into safe and normal variables where recursion can only be done over the latter; (2) linearity of the recursive call; and (3) recursion with a variable step length (course-of-value recursion). Unlike formulations LF via Turin Machines, BC # makes no references to outside resource measures, e.g., the size of the memory used. This appears to be the first such characterization of LF-computable functions (not just predicates). The proof that all BC #-programs can be evaluated in LF is of separate interest to programmers: it trades space for time and evaluates recursion with at most one recursive call without a call stack.

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 consider the problem of functional programming with data in external memory, in particular as it appears in sublinear space computation. Writing programs with sublinear space usage often requires one to use special implementation techniques for otherwise easy tasks, e.g. one cannot compose functions directly for lack of space for the intermediate result, but must instead compute and recompute small parts of the intermediate result on demand. In this paper, we study how the implementation of such techniques can be supported by functional programming languages. Our approach is based on modelling computation by interaction using the Int construction of Joyal, Street & Verity. We derive functional programming constructs from the structure obtained by applying the Int construction to a term model of a given functional language. The thus derived functional language is formulated by means of a type system inspired Baillot & Terui’s Dual Light Affine Logic. We assess its expressiveness by showing that it captures LOGSPACE. 1