Escher is a general-purpose, declarative programming language that integrates the best features of both functional and logic programming languages. It has types and modules, higher-order and meta-programming facilities, concurrency, and declarative input/output. The main design aim is to combine in a practical and comprehensive way the best ideas of existing functional and logic languages, such as Haskell and Godel. In fact, Escher uses the Haskell syntax and is most straightforwardly understood as an extension of Haskell. Consequently, this paper discusses Escher from this perspective. It provides an introduction to the Escher language, concentrating largely on the issue of programming style and the Escher programming idioms not provided by Haskell. Also the extra mechanisms needed to support these idioms are discussed.

We analyze basic shortcomings of existing proposals for type checking and type inferencing in logic programming languages. A new type system is presented using simple and declarative type annotations. It includes parametric polymorphism and subtyping. Static type checking and inferencing within the new type system is able to detect more programming errors than in other comparable systems. Our approach is independent of a specific resolution calculus and therefore applicable to a wide range of logic languages. A type inferencing algorithm is presented for reconstructing variable typings. As a concrete instance, the results were applied to unrestricted standard Prolog with type annotations, for which a type checking and type inferencing tool is available. This report is part of the documentation for a type checking tool available at !URL:http://www.fernuni-hagen.de/pi8/typical/?. It is complemented by a report "On the Use of Types in Logic Programming" [Mey96]. Research supported by ...

RELFUN reciprocally extends Horn RELations and call-by-value FUNctions just enough to yield a unified operator concept. Relations acquire application nesting and higher-order notation; functions acquire non-groundness and non-determinism. Relations are defined by Horn-like clauses implicitly returning true; functions are defined by rules with an additional returned-value premise. This minimal relationalfunctional kernel permits common extensions without duplicate features in logic and functional languages. Procedural and model-theoretic semantics are developed for kernel RELFUN, transferring the Herbrand models of (Horn-clause) relational programming to (first-order) functional programming. The compiler system reuses the register X1 of the Warren Abstract Machine for value returning, statically flattening general nestings while optimizing first-argument nestings. Applications include a (hyper)graph library, a CAD-to-NC transformer, and sharable knowledge bases. Key words: Functional pr...

This paper defines a clean multi-layer architecture for the design of knowledge-based synthesis systems within the logic programming paradigm. The intent is to provide an integrated logical framework for modeling the different kinds of knowledge involved during synthesis processes, a workbench of inference-based generic methods for the constructive solution of knowledge acquisition and synthesis tasks. As major advantages, evolutionary synthesis processes, the re-usability of knowledge chunks, and multiple views are facilitated and correctness criteria are provided. The approach depends upon the definition of hierarchically organized abstraction layers: domain, domain abstractions, and finally, distributed knowledge sources. Each layer is partitioned into data type, declarative, and operational specifications. For the interaction between heterogenous representation schemes and abstract representations the concept of logical viewpoints is introduced.

Regular types are a powerful tool for computing very precise descriptive types for logic programs. However, in the context of real-life, modular Prolog programs, the accurate results obtained by regular types often come at the price of efficiency. In this paper we propose a combination of techniques aimed at improving analysis efficiency in this context. As a first technique we allow optionally reducing the accuracy of inferred types by using only the types defined by the user or present in the libraries. We claim that, for the purpose of verifying type signatures given in the form of assertions the precision obtained using this approach is sufficient, and show that analysis times can be reduced significantly. Our second technique is aimed at dealing with situations where we would like to limit the amount of reanalysis performed, especially for library modules. Borrowing some ideas from polymorphic type systems, we show how to solve the problem by admitting parameters in type specifications. This allows us to compose new call patterns with some precomputed analysis info without losing any information. We argue that together these two techniques contribute to the practical and scalable analysis and verification of types in Prolog programs.

Abstract not found