The concept of relations over sets is generalized to relations over an arbitrary category, and used to investigate the abstraction (or logical-relations) theorem, the identity extension lemma, and parametric polymorphism, for Cartesian-closed-category models of the simply typed lambda calculus and PL-category models of the polymorphic typed lambda calculus. Treatments of Kripke relations and of complete relations on domains are included.

Abstract † We introduce a new paradigm for the integration of functional and logic programming. Unlike most current research, our approach is not based on extending unification to general-purpose equation solving. Rather, we propose a computation delaying mechanism called residuation. This allows a clear distinction between functional evaluation and logical deduction. The former is based on the λ-calculus, and the latter on Horn clause resolution. In clear contrast with equation-solving approaches, our model supports higher-order function evaluation and efficient compilation of both functional and logic programming expressions, without being plagued by non-deterministic term-rewriting. In addition, residuation lends itself naturally to process synchronization and constrained search. Besides unification (equations), other residuations may be any ground-decidable goal, such as mutual exclusion (inequations), and comparisons (inequalities). We describe an implementation of the residuation paradigm as a prototype language called Le Fun—Logic, equations, and Functions.

This is a preprint of a paper that has been submitted to Information and Computation.

Introduction to the Polymorphic Lambda Calculus John C. Reynolds Carnegie Mellon University December 23, 1994 The polymorphic (or second-order) typed lambda calculus was invented by Jean-Yves Girard in 1971 [11, 10], and independently reinvented by myself in 1974 [24]. It is extraordinary that essentially the same programming language was formulated independently by the two of us, especially since we were led to the language by entirely different motivations. In my own case, I was seeking to extend conventional typed programming languages to permit the definition of "polymorphic" procedures that could accept arguments of a variety of types. I started with the ordinary typed lambda calculus and added the ability to pass types as parameters (an idea that was "in the air" at the time, e.g. [4]). For example, as in the ordinary typed lambda calculus one can write f int!int : x int : f(f (x)) to denote the "doubling" function for the type int, which accepts a function from integers