In the last ten years declaration-free programming languages with a polymorphic typing discipline (ML, B) have been developed to approximate the flexibility and conciseness of dynamically typed languages (LISP, SETL) while retaining the safety and execution efficiency of conventional statically typed languages (Algol68, Pascal). These polymorphic languages can be type checked at compile time, yet allow functions whose arguments range over a variety of types. We investigate several polymorphic type systems, the most powerful of which, termed Milner-Mycroft Calculus, extends the so-called let-polymorphism found in, e.g., ML with a polymorphic typing rule for recursive definitions. We show that semi-unification, the problem of solving inequalities over firstorder terms, characterizes type checking in the Milner-Mycroft Calculus to polynomial time, even in the restricted case where nested definitions are disallowed. This permits us to extend some infeasibility results for related combinato...

Introducing types into a logic programming language leads to the need for typed unification within the computation model. In the presence of polymorphism and higher-order features, this aspect forces analysis of types at run-time. We propose extensions to the Warren Abstract Machine (WAM) that permit such analysis to be done with reasonable efficiency. Much information about the structures of types is present at compile-time, and we show that this information can be used to considerably reduce the work during execution. We illustrate our ideas in the context of a typed version of Prolog. We describe a modified representation for terms, new instructions and additional data areas that in conjunction with existing WAM structures suffice to implement this language. The nature of compiled code is illustrated through examples, and the kind of run-time overheads that are incurred for processing types is analyzed, especially in those cases where others have shown that type checking can be eliminated during execution. The ideas

this paper. The research of Pollard and Franz was supported by a grant from the National Science Foundation (IRI-8806913). (Empty Category Principle and Subjacency) and so forth. Patterns of cross-linguistic variation are accounted for by means of the parametrization of these principles. The methodological distinction between these two approaches is widely supposed to be that rules enumerate possibilities, while principles eliminate possibilities. But it is quite difficult to distinguish formally between a parametrized disjunctive principle and a collection of schematic rules only one of which can apply to a given structure. Consider, for example, the distinction between categorial grammar application schemata, basic ID rules of GPSG, and the C-structure constraints of LFG, on the one hand, and the disjunctive clauses of ¯ X Theory or the Empty Category Principle on the other. It should also be borne in mind that so-called rule-based approaches often employ not only rules but also global constraints on representations which behave similarly to principles, such as the Head Feature Convention and the Control Agreement Principle of GPSG or the Completeness and Function-Argument Biuniqueness Conditions of LFG. HPSG belongs to the "unification-based" family of linguistic theories, but differs from LFG and GPSG in that grammars are formulated entirely in terms of universal and language-specific principles expressed as constraints on feature structures, which in turn are taken to represent possible linguistic objects. As shown by Pollard and Sag (1987), constraints on feature structures can be used to do the same duty as many of the principles and rules of GPSG, LFG and GB. Unlike rule-based theories, in HPSG, immediate dominance and linear precedence conditions (traditional...

Contents 1 Introduction : : : : : : : : : : : : : : : : : : : : : : : : : : : : 2 2 The expressive power of second order Logic : : : : : : : : : : : 3 2.1 The language of second order logic : : : : : : : : : : : : : 3 2.2 Expressing size : : : : : : : : : : : : : : : : : : : : : : : : 4 2.3 Defining data types : : : : : : : : : : : : : : : : : : : : : 6 2.4 Describing processes : : : : : : : : : : : : : : : : : : : : : 8 2.5 Expressing convergence using second order validity : : : : : : : : : : : : : : : : : : : : : : : : : 9 2.6 Truth definitions: the analytical hierarchy : : : : : : : : 10 2.7 Inductive definitions : : : : : : : : : : : : : : : : : : : : : 13 3 Canonical semantics of higher order logic : : : : : : : : : : : : 15 3.1 Tarskian semantics of second order logic : : : : : : : : : 15 3.2 Function and re

The NU-Prolog Debugging Environment (Nude) is a collection of integrated tools for locating bugs in both pure and non-logical NU-Prolog programs. It has static analyses and user-driven dynamic analyses including a four-port debugger and a declarative debugger. This document is a guide to using the environment. Contents 1 introduction 3 1.1 Nude at a glance : : : : : : : : : : : : : : : : : : : : : : : : : : : 3 1.2 limitations of Nude : : : : : : : : : : : : : : : : : : : : : : : : : 4 2 background on debugging 4 2.1 traditional Prolog debugging : : : : : : : : : : : : : : : : : : : : 4 2.2 declarative debugging : : : : : : : : : : : : : : : : : : : : : : : : 5 2.2.1 how does it work? : : : : : : : : : : : : : : : : : : : : : : 5 2.2.2 what problems are there? : : : : : : : : : : : : : : : : : : 5 3 components of Nude 6 3.1 static analyses : : : : : : : : : : : : : : : : : : : : : : : : : : : : 6 3.1.1 Nit : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 7 3.1.2 th...

. Precise mode information is important for compiler optimisations and in program development tools. Within the framework of abstract compilation, the precision of a mode analysis depends, in part, on the expressiveness of the abstract domain and its associated abstraction function. This paper considers abstract domains for polymorphically typed logic programs and shows how specialised domains may be constructed for each type in the program. These domains capture the degree of instantiation to a high level of precision. By providing a generic definition of abstract unication, the abstraction of a program using these domains is formalised. The domain construction procedure is fully implemented using the Godel language and tested on a number of example programs to demonstrate the viability of the approach. Note: Some proofs have been omitted for space reasons. They can be found in the full version of this paper [17]. 1 Introduction 1.1 Background Typed logic programming languages su...

. Unification has long been used as a mechanism for type checking and type inference for Hindley-Milner types in functional programming. The programmer defines the possible types, and the compiler uses unification to check and infer types for function definitions. In constraint logic programming it is natural to extend the functional programming case by allowing overloading of predicate and function definitions, that is, ad-hoc polymorphism. Mycroft and O'Keefe showed how to check predicate type declarations under these assumptions. In this paper, we show how to infer predicate types, by translating a constraint logic program with given types into a logic program over types. The program can then be used to check and infer the possible types for the predicates and variables appearing in the original program. Since executing the translated program can be inefficient when there are highly disjunctive type definitions, we use methods of propagation based constraint solving and memoing to ...

Mercury is a new purely declarative logic programming language that requires programmers to write declarations for every predicate in the program. Although the main motivation for this requirement is that it allows the compiler to catch most programmer errors, it also allows the Mercury code generator to rely on the presence of type, mode and determinism information about every predicate in the program. The code generator exploits a new execution algorithm based on the availability of this information as well as some novel techniques (lazy code generation, follow-code migration, the use of a compile-time failure continuation stack) to produce very high quality code. This code is in C and is therefore quite portable. Benchmarks show that the Mercury implementation produces much faster code than wamcc, Quintus Prolog, SICStus Prolog and Aquarius Prolog.

Abstract. In the recent years rule-based programming in terms of declarative logic programming has formed the basis for many Artificial Intelligence (AI) applications and is well integrated in the mainstream information technology capturing higher-level decision logics. Typically, the standard rule systems and rule-based logic programming languages such as Prolog derivatives are based on the untyped theory of predicate calculus with untyped logical objects (untyped terms), i.e. the logical reasoning algorithms apply pure syntactical reasoning. From a rule engineering perspective this is a serious restriction which lacks major Software Engineering principles such as data abstraction or modularization, which become more and more important when rule applications grow larger and more complex. To support such principles in logic programming and capture the rule engineer’s intended meaning of a logic program, types and typed objects play an important role. Moreover, from a computational point of view, the use of types drastically reduces the search space, i.e. proofs can be kept at a more abstract level and it offers the option to restrict the application of rules and to

The paper presents a novel approach to the analysis of typed logic programs. We assume regular type descriptions of logic program variables provided by regular tree grammars. Types are used to identify components of terms which can be equated during the programs execution. This information is