DOCSLIB.ORG

The Logtalk Handbook Release V3.48.0

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
The Logtalk Handbook Release V3.48.0 The Logtalk Handbook Release v3.48.0 Paulo Moura Jul 06, 2021 CONTENTS 1 User Manual 1 1.1 Declarative object-oriented programming.............................1 1.2 Main features.............................................2 1.2.1 Integration of logic and object-oriented programming..................2 1.2.2 Integration of event-driven and object-oriented programming.............2 1.2.3 Support for component-based programming.......................3 1.2.4 Support for both prototype and class-based systems...................3 1.2.5 Support for multiple object hierarchies..........................3 1.2.6 Separation between interface and implementation....................3 1.2.7 Private, protected and public inheritance.........................3 1.2.8 Private, protected and public object predicates......................4 1.2.9 Parametric objects.....................................4 1.2.10 High level multi-threading programming support....................4 1.2.11 Smooth learning curve...................................4 1.2.12 Compatibility with most Prolog systems and the ISO standard.............4 1.2.13 Performance.........................................4 1.2.14 Logtalk scope........................................5 1.3 Nomenclature............................................5 1.3.1 Prolog nomenclature....................................6 1.3.2 Smalltalk nomenclature..................................7 1.3.3 C++ nomenclature.....................................9 1.3.4 Java nomenclature..................................... 10 1.3.5 Python nomenclature.................................... 11 1.4 Messages............................................... 12 1.4.1 Operators used in message sending............................ 12 1.4.2 Sending a message to an object.............................. 13 1.4.3 Delegating a message to an object............................. 13 1.4.4 Sending a message to self ................................. 13 1.4.5 Broadcasting........................................ 13 1.4.6 Calling imported and inherited predicates........................ 14 1.4.7 Message sending and event generation.......................... 14 1.4.8 Sending a message from a module............................ 15 1.4.9 Message sending performance............................... 15 1.5 Objects................................................ 15 1.5.1 Objects, prototypes, classes, and instances........................ 15 1.5.2 Defining a new object.................................... 16 1.5.3 Parametric objects..................................... 19 1.5.4 Finding defined objects................................... 20 1.5.5 Creating a new object in runtime............................. 20 1.5.6 Abolishing an existing object................................ 21 i 1.5.7 Object directives...................................... 21 1.5.8 Object relationships..................................... 23 1.5.9 Object properties...................................... 24 1.5.10 Built-in objects....................................... 26 1.6 Protocols............................................... 26 1.6.1 Defining a new protocol.................................. 26 1.6.2 Finding defined protocols................................. 27 1.6.3 Creating a new protocol in runtime............................ 27 1.6.4 Abolishing an existing protocol.............................. 28 1.6.5 Protocol directives..................................... 28 1.6.6 Protocol relationships.................................... 29 1.6.7 Protocol properties..................................... 29 1.6.8 Implementing protocols.................................. 30 1.6.9 Built-in protocols...................................... 31 1.7 Categories.............................................. 31 1.7.1 Defining a new category.................................. 31 1.7.2 Hot patching........................................ 33 1.7.3 Finding defined categories................................. 35 1.7.4 Creating a new category in runtime............................ 35 1.7.5 Abolishing an existing category.............................. 36 1.7.6 Category directives..................................... 36 1.7.7 Category relationships................................... 37 1.7.8 Category properties..................................... 37 1.7.9 Importing categories.................................... 39 1.7.10 Calling category predicates................................. 40 1.7.11 Parametric categories.................................... 41 1.7.12 Built-in categories...................................... 41 1.8 Predicates............................................... 41 1.8.1 Reserved predicate names................................. 41 1.8.2 Declaring predicates.................................... 42 1.8.3 Defining predicates..................................... 51 1.8.4 Definite clause grammar rules............................... 56 1.8.5 Built-in methods...................................... 58 1.8.6 Predicate properties..................................... 62 1.8.7 Finding declared predicates................................ 63 1.8.8 Calling Prolog predicates.................................. 64 1.8.9 Defining Prolog multifile predicates............................ 68 1.8.10 Asserting and retracting Prolog predicates........................ 68 1.9 Inheritance.............................................. 70 1.9.1 Protocol inheritance.................................... 70 1.9.2 Implementation inheritance................................ 70 1.9.3 Public, protected, and private inheritance......................... 74 1.9.4 Multiple inheritance.................................... 75 1.9.5 Composition versus multiple inheritance......................... 75 1.10 Event-driven programming..................................... 75 1.10.1 Definitions.......................................... 76 1.10.2 Event generation...................................... 77 1.10.3 Communicating events to monitors............................ 77 1.10.4 Performance concerns................................... 77 1.10.5 Monitor semantics..................................... 77 1.10.6 Activation order of monitors................................ 78 1.10.7 Event handling....................................... 78 1.11 Multi-threading programming................................... 80 1.11.1 Enabling multi-threading support............................. 80 ii 1.11.2 Enabling objects to make multi-threading calls...................... 80 1.11.3 Multi-threading built-in predicates............................ 81 1.11.4 One-way asynchronous calls................................ 83 1.11.5 Asynchronous calls and synchronized predicates..................... 84 1.11.6 Synchronizing threads through notifications....................... 85 1.11.7 Threaded engines...................................... 85 1.11.8 Multi-threading performance............................... 87 1.12 Error handling............................................ 87 1.12.1 Raising Exceptions..................................... 87 1.12.2 Type-checking........................................ 88 1.12.3 Expected terms....................................... 89 1.12.4 Compiler warnings and errors............................... 89 1.12.5 Runtime errors....................................... 91 1.13 Reflection............................................... 92 1.13.1 Structural reflection.................................... 92 1.13.2 Behavioral reflection.................................... 93 1.14 Writing and running applications.................................. 93 1.14.1 Starting Logtalk....................................... 93 1.14.2 Running parallel Logtalk processes............................ 94 1.14.3 Source files......................................... 94 1.14.4 Multi-pass compiler..................................... 95 1.14.5 Compiling and loading your applications......................... 96 1.14.6 Loader files......................................... 96 1.14.7 Libraries of source files................................... 98 1.14.8 Settings files......................................... 99 1.14.9 Compiler linter....................................... 100 1.14.10 Compiler flags........................................ 100 1.14.11 Reloading source files.................................... 105 1.14.12 Batch processing...................................... 106 1.14.13 Optimizing performance.................................. 106 1.14.14 Portable applications.................................... 107 1.14.15 Conditional compilation.................................. 107 1.14.16 Avoiding common errors.................................. 107 1.14.17 Coding style guidelines................................... 107 1.15 Printing messages and asking questions.............................. 108 1.15.1 Printing messages...................................... 108 1.15.2 Message tokenization.................................... 109 1.15.3 Meta-messages....................................... 110 1.15.4 Intercepting messages................................... 110 1.15.5 Asking questions...................................... 111 1.15.6 Intercepting questions................................... 112 1.16 Term and goal expansion...................................... 113 1.16.1 Defining expansions.................................... 113 1.16.2 Expanding grammar rules................................. 115 1.16.3 Bypassing expansions.................................... 115 1.16.4 Hook objects........................................ 115
Load more

Recommended publications
  • From Plain Prolog to Logtalk Objects: Effective Code Encapsulation and Reuse
    From Plain Prolog to Logtalk Objects: Effective Code Encapsulation and Reuse Paulo Moura Dep. of Computer Science, Univ. of Beira Interior, Portugal Center for Research in Advanced Computing Systems INESC Porto, Portugal http://logtalk.org/ [email protected] ICLP 2009 Inivited Talk Someone said I need one... 2 Spoilers • Objects in a Prolog world • Logtalk design goals • Logtalk architecture • Logtalk versus Prolog and Prolog modules • Logtalk overview and quick tour • Some demos (if time allows) • Logtalk as a portable Prolog application • Logtalk programming support 3 A warning... • I have a laser and I’m not afraid to use it ... Beware of asking embarrassing questions! • But please feel free to interrupt and ask nice ones that make the speaker shine! 4 A bit of history... • Project started in January 1998 • First version for registered users in July 1998 • First public beta in October 1998 • First stable version in February 1999 5 Logtalk in numbers • Compiler + runtime: ~11000 lines of Prolog code • 37 major releases, 122 including minor ones • Current version: Logtalk 2.37.2 minor release number major release number second generation of Logtalk • ~1500 downloads/month (so many earthlings, so little time) 6 Logtalk distribution • Full sources (compiler/runtime, Prolog config files, libraries) • MacOS X (pkg), Linux (rpm), Debian (deb), and Windows (exe) installers XHTML and PDF User and Reference Manuals • (121 + 144 pages) • +90 programming examples • Support for several text editors and syntax highlighters (text services and code publishing) 7 Objects in Prolog?!? We’re being invaded! 8 Objects have identifiers and dynamic state! • It seems Prolog modules are there first: Identifier! :- module(broadcast, [...]).
    [Show full text]
  • On the Implementation of a Cloud-Based Computing Test Bench Environment for Prolog Systems †
    information Article On the Implementation of a Cloud-Based Computing Test Bench Environment for Prolog Systems † Ricardo Gonçalves, Miguel Areias * ID and Ricardo Rocha ID CRACS & INESC TEC and Faculty of Sciences, University of Porto, Rua do Campo Alegre, 1021/1055, 4169-007 Porto, Portugal; [email protected] (R.G.); [email protected] (R.R.) * Correspondence: [email protected] † This paper is an extended version of our paper published in the Symposium on Languages, Applications and Technologies 2017. Received: 13 September 2017; Accepted: 13 October 2017; Published: 19 October 2017 Abstract: Software testing and benchmarking are key components of the software development process. Nowadays, a good practice in large software projects is the continuous integration (CI) software development technique. The key idea of CI is to let developers integrate their work as they produce it, instead of performing the integration at the end of each software module. In this paper, we extend a previous work on a benchmark suite for the YAP Prolog system, and we propose a fully automated test bench environment for Prolog systems, named Yet Another Prolog Test Bench Environment (YAPTBE), aimed to assist developers in the development and CI of Prolog systems. YAPTBE is based on a cloud computing architecture and relies on the Jenkins framework as well as a new Jenkins plugin to manage the underlying infrastructure. We present the key design and implementation aspects of YAPTBE and show its most important features, such as its graphical user interface (GUI) and the automated process that builds and runs Prolog systems and benchmarks.
    [Show full text]
  • A Linguistic Symbiosis Approach to Bring the Declarative Power of Prolog to Java
    LogicObjects : A Linguistic Symbiosis Approach to Bring the Declarative Power of Prolog to Java Sergio Castro Kim Mens Paulo Moura RELEASeD lab RELEASeD lab Dept. of Computer Science ICTEAM Institute ICTEAM Institute University of Beira Interior Université catholique de Université catholique de & CRACS, INESC–TEC Louvain, Belgium Louvain, Belgium Portugal [email protected] [email protected] [email protected] ABSTRACT Although there exists some other work that focusses on Logic programming is well suited for declaratively solving facilitating the interaction from an object-oriented language computational problems that require knowledge representa- to a logic language, to the best of our knowledge this is the tion and reasoning. Object-oriented languages, on the other first approach that provides a truly transparent, automatic hand, are well suited for modeling real-world concepts and and customizable integration from the perspective of the profit from rich ecosystems developed around them, which object-oriented language. are often missing from logic languages. For applications that This paper is structured as follows: Section 2 presents a require both the declarative power of logic programming and problem of declarative nature and its implementation in a the rich modeling expressiveness and development environ- logic language. This will be referenced in the next sections. ments offered by object-oriented languages, there is a need Section 3 presents our framework and shows how it enables for reconciling both worlds. LogicObjects is our linguistic a transparent access from Java to our implementation in symbiosis framework for integrating Prolog within the Java logic. Section 4 discuss relevant related work and section 5 language.
    [Show full text]
  • Comparative Programming Languages CM20253
    We have briefly covered many aspects of language design And there are many more factors we could talk about in making choices of language The End There are many languages out there, both general purpose and specialist And there are many more factors we could talk about in making choices of language The End There are many languages out there, both general purpose and specialist We have briefly covered many aspects of language design The End There are many languages out there, both general purpose and specialist We have briefly covered many aspects of language design And there are many more factors we could talk about in making choices of language Often a single project can use several languages, each suited to its part of the project And then the interopability of languages becomes important For example, can you easily join together code written in Java and C? The End Or languages And then the interopability of languages becomes important For example, can you easily join together code written in Java and C? The End Or languages Often a single project can use several languages, each suited to its part of the project For example, can you easily join together code written in Java and C? The End Or languages Often a single project can use several languages, each suited to its part of the project And then the interopability of languages becomes important The End Or languages Often a single project can use several languages, each suited to its part of the project And then the interopability of languages becomes important For example, can you easily
    [Show full text]
  • A Simple Approach to Distributed Objects in Prolog
    A Simple Approach to Distributed Objects in Prolog Manuel Carro Manuel Hermenegildo Computer Science School Technical University of Madrid Boadilla del Monte, E-28660,Spain {mcarro,herme}@fi.upm.es Abstract. We present the design of a distributed object system for Prolog, based on adding remote execution and distribution capabilities to a previously existing object system. Remote execution brings RPC into a Prolog system, and its semantics is easy to express in terms of well-known Prolog builtins. The final distributed object design features state mobility and user-transparent network behavior. We sketch an implementation which provides distributed garbage collection and some degree of tolerance to network failures. We provide a preliminary study of the overhead of the communication mechanism for some test cases. Keywords: Objects, Distributed Execution, Remote Calis, Migration, Garbage Collection. 1 Introduction Distributed objects are the natural sequel to object oriented programming and distributed programming. They can be used to implement a wide range of software systems: remote databases, service migration to improve access speed, automatic caching, implementation of stateful agents, etc. A good deal of proposals combining distribution and objects have been developed in the realm of procedural and 00 languages; however, many of them boil down to adding convenient librarles to an existing host language which did not have any provisión for distributed execution [BGL98]. Among the proposals which address 00 and distribution from scratch we may cite Emerald [Jul88], Obliq [Car95], and, to some extent, Jini [We + OO]. Although there have been several proposals for coupling LP and 00 in the logic programming arena (e.g., SICStus objects [Swe99], Prolog++ [Mos94], LogTalk [MouOO], O'Ciao [PB02], and others), few proposal have been made, to the best of our knowledge, to couple objects and distribution.
    [Show full text]
  • 11 – Logic Paradigm and Prolog
    11 – Logic Paradigm and Prolog Logic: Programs are built by defining logical rules and goals. The runtime environment tries to achieve the goals by logically deduction. Examples: Prolog, ASP, Datalog, Florid, Logtalk There are other paradigms as well. This section focuses on the logic paradigm, sometimes called “declarative” programming. In this paradigm, programs are built by defining logical rules and goals, and the runtime environment tries to achieve the goals by logical deduction. By far the most common logic programming language is Prolog, although there are others (ASP, Datalog, Florid, Logtalk, for example). There are also many languages and systems that are derived from Prolog, such as the CLIPS expert system shell we use in CSc-180. You are probably already familiar with Boolean logic. In Boolean logic, names are given to things that are either TRUE or FALSE. The operations AND, OR, and NOT then allow us to build a rich set of rules of inference, such as DeMorgan’s rule, and Modus Ponens. Boolean logic is sufficiently powerful for building the digital circuitry used in a CPU. As a programming tool, however, Boolean logic has serious limitations. The only values available are TRUE and FALSE, which becomes problematic if we want to use other values, such as numbers or strings. It also is difficult in Boolean logic to express logical rules that can be applied generally depending on values that aren’t TRUE and FALSE. For example, if we want to create a rule that expresses that a person is eligible for social security if their age is over 62, it is difficult because there is no mechanism in Boolean logic for associating a number (such as age) with a person.
    [Show full text]
  • A Proposal of Hybrid Knowledge Engineering and Refinement
    A Proposal of Hybrid Knowledge Engineering and Refinement Approach Grzegorz J. Nalepa and Igor Wojnicki Institute of Automatics, AGH – University of Science and Technology, Al. Mickiewicza 30, 30-059 Kraków, Poland [email protected] [email protected] Abstract on several observations related to the Software and Knowl- edge Engineering concepts described below. The paper deals with some possible applications of Knowl- This paper presents a concept of a new software engineer- edge Engineering methods to the practical Software Engi- neering. Such an integration could provide a way to over- ing approach based on knowledge engineering methods. In come some constant problems present in the contemporary the paper some important features of both KE and SE ap- Software Engineering. This paper describes foundations of proaches are summarized. Furthermore, common design the HEKATE Project, which aims at incorporating well es- and evaluation problems encountered in SE are outlined. tablished Knowledge Engineering tools and paradigms into Most of these problems can be successfully approached, the Software Engineering domain. A new Hybrid Knowledge and possibly minimized in the field of KE and RBS design. Engineering (HEKATE) methodology is proposed, which This is why, selected concepts and tools developed for the would allow for faster development of highly reliable soft- MIRELLA Project are presented; they aim at supporting the ware. The HEKATE design process is introduced which of- design and evaluation of RBS. Finally, the main concept of fers important capabilities of formal verification, and gradual the hybrid knowledge engineering, on which the HEKATE refinement of software from the conceptual model stage to an executable prototype.
    [Show full text]
  • Enabling Logic Programming in Java Through Linguistic Symbiosis ?
    LogicObjects: Enabling Logic Programming in Java Through Linguistic Symbiosis ? Sergio Castro1, Kim Mens1, and Paulo Moura2 1 ICTEAM Institute, Université catholique de Louvain, Belgium {sergio.castro,kim.mens}@uclouvain.be 2 Center for Research in Advanced Computing Systems, INESC–TEC, Portugal [email protected] Abstract. While object-oriented programming languages are good at modelling real-world concepts and benefit from rich libraries and devel- oper tools, logic programming languages are well suited for declaratively solving computational problems that require knowledge reasoning. Non- trivial declarative applications could take advantage of the modelling fea- tures of object-oriented programming and of the rich software ecosystems surrounding them. Linguistic symbiosis is a common approach to enable complementary use of languages of different paradigms. However, the problem of concepts leaking from one paradigm to another often hinders the applicability of such approaches. This issue has mainly been reported for object-oriented languages participating in a symbiotic relation with a logic language. To address this issue, we present LogicObjects, a lin- guistic symbiosis framework for transparently and (semi-) automatically enabling logic programming in Java, that aims to solve most of the prob- lems of paradigm leaking reported in other works. Keywords: Linguistic Symbiosis, Object-Oriented Programming, Logic Programming, Multi-Paradigm Programming 1 Introduction Object-oriented languages like Java have demonstrated their usefulness for mod- elling real-world concepts. In addition, the availability of continuously growing software ecosystems around them, including advanced IDEs and extensive li- braries, has contributed to their success. Declarative languages like Prolog are more convenient for expressing problems of declarative nature, such as expert systems [6,16].
    [Show full text]
  • A Linguistic Symbiosis Approach to Bring the Declarative Power of Prolog to Java
    LogicObjects : A Linguistic Symbiosis Approach to Bring the Declarative Power of Prolog to Java Sergio Castro Kim Mens Paulo Moura RELEASeD lab RELEASeD lab Dept. of Computer Science ICTEAM Institute ICTEAM Institute University of Beira Interior Université catholique de Université catholique de & CRACS, INESC–TEC Louvain, Belgium Louvain, Belgium Portugal [email protected] [email protected] [email protected] ABSTRACT Although there exists some other work that focusses on Logic programming is well suited for declaratively solving facilitating the interaction from an object-oriented language computational problems that require knowledge representa- to a logic language, to the best of our knowledge this is the tion and reasoning. Object-oriented languages, on the other first approach that provides a truly transparent, automatic hand, are well suited for modeling real-world concepts and and customizable integration from the perspective of the profit from rich ecosystems developed around them, which object-oriented language. are often missing from logic languages. For applications that This paper is structured as follows: Section 2 presents a require both the declarative power of logic programming and problem of declarative nature and its implementation in a the rich modeling expressiveness and development environ- logic language. This will be referenced in the next sections. ments offered by object-oriented languages, there is a need Section 3 presents our framework and shows how it enables for reconciling both worlds. LogicObjects is our linguistic a transparent access from Java to our implementation in symbiosis framework for integrating Prolog within the Java logic. Section 4 discuss relevant related work and section 5 language.
    [Show full text]
  • The Logtalk Handbook Release V3.39.0
    The Logtalk Handbook Release v3.39.0 Paulo Moura Jun 17, 2020 CONTENTS: 1 User Manual 1 1.1 Declarative object-oriented programming.............................1 1.2 Main features.............................................2 1.2.1 Integration of logic and object-oriented programming..................2 1.2.2 Integration of event-driven and object-oriented programming.............2 1.2.3 Support for component-based programming.......................3 1.2.4 Support for both prototype and class-based systems...................3 1.2.5 Support for multiple object hierarchies..........................3 1.2.6 Separation between interface and implementation....................3 1.2.7 Private, protected and public inheritance.........................3 1.2.8 Private, protected and public object predicates......................4 1.2.9 Parametric objects.....................................4 1.2.10 High level multi-threading programming support....................4 1.2.11 Smooth learning curve...................................4 1.2.12 Compatibility with most Prolog systems and the ISO standard.............4 1.2.13 Performance.........................................4 1.2.14 Logtalk scope........................................5 1.3 Nomenclature............................................5 1.3.1 Smalltalk nomenclature..................................6 1.3.2 C++ nomenclature.....................................7 1.3.3 Java nomenclature.....................................8 1.3.4 Python nomenclature....................................9 1.4 Messages..............................................
    [Show full text]
  • From Plain Prolog to Logtalk Objects: Effective Code Encapsulation and Reuse
    From Plain Prolog to Logtalk Objects: Effective Code Encapsulation and Reuse Paulo Moura Dep. of Computer Science, Univ. of Beira Interior, Portugal Center for Research in Advanced Computing Systems INESC Porto, Portugal http://logtalk.org/ [email protected] 2011 Talk @ Uni Bonn Lecture „Advanced Logic Programming“ Chapter 8: Logtalk -- Objects in Prolog R O O T S Objects in Prolog?!? 2 Objects have identifiers and dynamic state! It seems Prolog modules were there first: Identifier! :- module(broadcast, [...]). Dynamic state! :- dynamic(listener/4). ... assert_listener(Templ, Listener, Module, TheGoal) :- asserta(listener(Templ, Listener, Module, TheGoal)). retract_listener(Templ, Listener, Module, TheGoal) :- retractall(listener(Templ, Listener, Module, TheGoal)). © 2011 Paulo Moura Advanced Logic Programming, Chapter 7. „Logtalk --Objects in Prolog“ Page 8-3 R O O T S Objects inherit lots of stuff I don’t need! Objects are not necessarily tied to hierarchies. But how about typical Prolog module code? Just import everything from :- module(aggregate, [...]). each module! :- use_module(library(ordsets)). :- use_module(library(pairs)). :- use_module(library(error)). :- use_module(library(lists)). :- use_module(library(apply)).... © 2011 Paulo Moura Advanced Logic Programming, Chapter 7. „Logtalk --Objects in Prolog“ Page 8-4 R O O T S Objects are dynamically created! Only if really necessary. Objects can be (and often are) static, simply loaded from source files... But, guess what, Prolog modules were there first: Dynamically creates module foo if it doesn’t exist! ?- foo:assertz(bar). yes © 2011 Paulo Moura Advanced Logic Programming, Chapter 7. „Logtalk --Objects in Prolog“ Page 8-5 R O O T S Why not stick to modules?!? Prolog modules fail to: enforce encapsulation in most implementations, you can call any module predicate using explicit qualification implement predicate namespaces due to the import semantics and current practice, module predicate names are often prefixed..
    [Show full text]
  • From Plain Prolog to Logtalk Objects: Effective Code Encapsulation and Reuse
    From Plain Prolog to Logtalk Objects: Effective Code Encapsulation and Reuse Paulo Moura Dep. of Computer Science, Univ. of Beira Interior, Portugal Center for Research in Advanced Computing Systems INESC Porto, Portugal http://logtalk.org/ [email protected] 2011 Talk @ Uni Bonn Lecture „Advanced Logic Programming“ Chapter 9b: Logtalk -- Objects in Prolog Logtalk – Objects in Prolog Modules as Objects??? 2 Objects are dynamically created! Module = Object? Modules are typically static, simply loaded from source files... But access to a non-existing module implicitly creates it at run-time: ?- p(X), X:assertz(something). yes Dynamically creates module if it doesn’t exist! © 2011 Paulo Moura Advanced Logic Programming, Chapter 9. „Logtalk --Objects in Prolog“ Page 9-3 Objects have identifiers and dynamic state! Module = Object? Identifier! :- module(broadcast, [...]). Dynamic state! :- dynamic(listener/4). ... assert_listener(Templ, Listener, Module, TheGoal) :- asserta(listener(Templ, Listener, Module, TheGoal)). retract_listener(Templ, Listener, Module, TheGoal) :- retractall(listener(Templ, Listener, Module, TheGoal)). © 2011 Paulo Moura Advanced Logic Programming, Chapter 9. „Logtalk --Objects in Prolog“ Page 9-4 Objects can inherit Module import = Inheriatance? :- module(aggregate, [...]). :- use_module(library(ordsets)). :- use_module(library(pairs)). :- use_module(library(error)). :- use_module(library(lists)). :- use_module(library(apply)).... © 2011 Paulo Moura Advanced Logic Programming, Chapter 9. „Logtalk --Objects in Prolog“
    [Show full text]