Computer Languages最新文献

Current implementation techniques for functional languages differ considerably from those for logic languages. This complicates the development of flexible and efficient abstract machines that can be used for the compilation of declarative languages combining concepts of functional and logic programming. We propose an abstract machine, called the JUMP-machine, which systematically integrates the operational concepts needed to implement the functional and logic programming paradigm. The use of a tagless representation for heap objects, which originates from the Spineless Tagless G-machine, supports the integration of different concepts. In this paper, we provide a functional logic kernel language and show how to translate it into the abstract machine language of the JUMP-machine. Furthermore, we define the operational semantics of the machine language formally and discuss the mapping of the abstract machine to concrete machine architectures. We tested the approach by writing a compiler for the functional logic language GTML. The obtained performance results indicate that the proposed method allows to implement functional logic languages efficiently.

Languages that integrate functional and logic programming styles with a complete operational semantics are based on narrowing. In order to avoid useless computations, lazy narrowing strategies have been proposed in the past. This paper presents an improvement of lazy narrowing by incorporating deterministic simplification steps into lazy narrowing derivations. These simplification steps reduce the search space so that in some cases infinite search spaces are reduced to finite ones. We consider two classes of programs where this strategy can be applied. Firstly, we show soundness and completeness of our strategy for functional logic programs based on ground confluent and terminating rewrite systems. Then, we show similar results for constructor-based weakly orthogonal (not necessarily terminating) rewrite systems. Finally, we demonstrate the improved operational behavior by means of several examples. Since most functional logic languages are based on programs belonging to one of these classes, our result is a significant step to improve the operational semantics of existing functional logic languages.

This paper presents a new language that integrates the real-time and distributed paradigms within the framework of a concurrent logic language. Concurrent logic languages (CLLs) are capable of expressing concurrence, communication and nondeterminism in a natural way. That is, the intrinsic parallel semantics of the concurrent logic languages makes them well-suited for distributed programming. The proposed language is particularly suitable for loosely coupled systems and it contains mechanisms for distributed and real-time process control. A new execution model for concurrent logic languages is presented, which enables efficient distributed execution and real-time control. The model is introduced by giving an operational semantics for the language and the new model's implementation is discussed, including the definition of a new abstract machine and its implementation on a network of Unix workstations. Although the sequential core is not optimized, some previous results are discussed, showing the feasibility of the language's execution model for distributed real-time systems. The language is currently being used as the kernel language for a distributed simulation and validation tool for communication protocols.

One of the key features of logic programming is the notion of goal-directed provability. In intuitionistic logic, the notion of uniform proof has been used as a proof-theoretic characterization of this property. Whilst the connections between intuitionistic logic and computation are well known, there is no reason per se why a similar notion cannot be given in classical logic. In this paper we show that there are two notions of goal-directed proof in classical logic, both of which are suitably weaker than that for intuitionistic logic. We show the completeness of this class of proofs for certain fragments, which thus form logic programming languages. As there are more possible variations on the notion of goal-directed provability in classical logic, there is a greater diversity of classical logic programming languages than intuitionistic ones. In particular, we show how logic programs may contain disjunctions in this setting. This provides a proof-theoretic basis for disjunctive logic programs, as well as characterising the “disjunctive” nature of answer substitutions for such programs in terms of the provability properties of the classical connectives Λ and Λ.

Visual Occam (VISO) is a visual programming language for concurrent programming. It uses message passing for interprocess communication and processes are disjoint. The VISO language uses a modular approach to visual programming which simplifies the specification of programs. It has a graphical syntax based on the language Occam. The petri net formalism is used to represent the semantics of the VISO language. This paper describes the design and implementation of the VISO language. It presents syntax, semantics, and a number of concurrent programs specified in the VISO language. Also, it discusses how synchronous communication can be expressed in petri nets.

In the past decade, there has been much research effort dedicated to combine the object-oriented programming paradigm and the logic programming paradigm. Most of this effort sheds light upon the philosophy of multiparadigm programming as a near ideal mental model for a wide class of problem domains. In this paper we propose a scheme for object and logic integration—the OLI scheme. This scheme contributes to the multiparadigm programming philosophy by putting forward a multiparadigm design methodology and describing a multiparadigm programming language. Above all, the OLI scheme integrates the object-oriented and the logic programming paradigms at the design and language levels with a precise and well-balanced interface so that each paradigm shares an equal and cooperating partnership in problem analysis and problem solving. An important property of the OLI language is that programmers can program either in one of the paradigms alone or in a mixed paradigm without sacrificing expressiveness and efficiency. We give a formal definition of the OLI language and study its semantics both from the logical perspective and the object-oriented perspective. By viewing objects as an enrichment of the Herbrand universe, we define the declarative and operational semantics of OLI. We show that OLI's operational semantics, a generalized form of SLD-resolution, is sound and complete. From the object-oriented point of view, the logic part of OLI is simply an object with logic programs as states and methods for performing logical deduction.

The paper discusses how atomic actions based on forward error recovery in the form of concurrent exception handling and resolution can be programmed within standard conventional languages (Ada and Ada 95). We express the main characteristics of the general atomic action scheme in terms of these languages and discuss a set of templates and programmers' conventions which would allow the programming of atomic actions within Ada and Ada 95. We offer an approach to implementing a resolution procedure (function) and outline other approaches. The scheme is very flexible in that it gives an opportunity for programmers to use any sort of the resolution procedure. We introduce a general concept of self-checking programming, which allows the kind of failure assumption necessary for simplifying the atomic action support, and discuss how it can be applied (to Ada, in particular). It is shown how this approach helps to solve the deserter process problem. We outline the main improvements which can be made in the scheme when Ada 95 is used. We believe that this paper discusses important practical questions because it seems unlikely that an existing practical language will have concurrent exception handling of the level sufficient for supporting atomic actions based on forward error recovery.

This paper presents a language based on the logic programming paradigm that supports objects, messages and inheritance. The object-oriented extension is fairly simple: objects are clusters of processes, objects' state is represented by logical variables, message-passing communication between objects is performed via multi-head clauses, and inheritance is mapped into clause union. The language implementation is obtained by translating logic objects into a concurrent logic language based on multi-head clauses, taking advantage of its distributed implementation on a massively parallel architecture. The runtime support realizes some interesting features such as intensional messages and the transparency of object allocation, object migration and parallelism.

This paper presents a type-inference system for Scheme that is designed to be used by students in an introductory programming course. The major goal of the work is to present a type system that is simple enough to be used by beginner students, yet is powerful enough to express the ideas of polymorphism, abstract data types (ADTs), and higher-order procedures. The system also performs some rudimentary syntax checking. The system uses subtyping, but only in a primitive fashion. It has a type datum which is a supertype of all types, and a type poof which is a subtype of all types. It uses intersection types to control the use of datum and to generate simple but accurate types.

BaLinda Lisp is a parallel Lisp dialect employing a shared memory model of parallel processing together with a subset of the Linda tuple space operators. Also included in the design is speculative processing. The aim is to have shared memory multiprocessing with the tuple space acting as the main data structure through which synchronization is done. The result is a flexible programming language. In this paper, we shall describe the design philosophy of BaLinda Lisp, discuss its implementation on three multiprocessing platforms, give examples of programs written in BaLinda Lisp and discuss future work on the language.