The Logtalk Handbook

Contents

• User Manual
  • Declarative object-oriented programming
  • Main features
    • Integration of logic and object-oriented programming
    • Integration of event-driven and object-oriented programming
    • Support for component-based programming
    • Support for both prototype and class-based systems
    • Support for multiple object hierarchies
    • Separation between interface and implementation
    • Private, protected and public inheritance
    • Private, protected and public object predicates
    • Parametric objects
    • High level multi-threading programming support
    • Smooth learning curve
    • Compatibility with most Prolog systems and the ISO standard
    • Performance
    • Logtalk scope
  • Nomenclature
    • Smalltalk nomenclature
    • C++ nomenclature
    • Java nomenclature
    • Python nomenclature
  • Messages
    • Operators used in message sending
    • Sending a message to an object
    • Delegating a message to an object
    • Sending a message to self
    • Broadcasting
    • Calling imported and inherited predicates
    • Message sending and event generation
    • Sending a message from a module
    • Message sending performance
  • Objects
    • Objects, prototypes, classes, and instances
    • Defining a new object
    • Parametric objects
    • Finding defined objects
    • Creating a new object in runtime
    • Abolishing an existing object
    • Object directives
    • Object relationships
    • Object properties
    • Built-in objects
  • Protocols
    • Defining a new protocol
    • Finding defined protocols
    • Creating a new protocol in runtime
    • Abolishing an existing protocol
    • Protocol directives
    • Protocol relationships
    • Protocol properties
    • Implementing protocols
    • Built-in protocols
  • Categories
    • Defining a new category
    • Hot patching
    • Finding defined categories
    • Creating a new category in runtime
    • Abolishing an existing category
    • Category directives
    • Category relationships
    • Category properties
    • Importing categories
    • Calling category predicates
    • Parametric categories
    • Built-in categories
  • Predicates
    • Reserved predicate names
    • Declaring predicates
    • Defining predicates
    • Definite clause grammar rules
    • Built-in methods
    • Predicate properties
    • Finding declared predicates
    • Calling Prolog predicates
    • Defining Prolog multifile predicates
    • Asserting and retracting Prolog predicates
  • Inheritance
    • Protocol inheritance
    • Implementation inheritance
    • Public, protected, and private inheritance
    • Multiple inheritance
    • Composition versus multiple inheritance
  • Event-driven programming
    • Definitions
    • Event generation
    • Communicating events to monitors
    • Performance concerns
    • Monitor semantics
    • Activation order of monitors
    • Event handling
  • Multi-threading programming
    • Enabling multi-threading support
    • Enabling objects to make multi-threading calls
    • Multi-threading built-in predicates
    • One-way asynchronous calls
    • Asynchronous calls and synchronized predicates
    • Synchronizing threads through notifications
    • Threaded engines
    • Multi-threading performance
  • Error handling
    • Raising Exceptions
    • Type-checking
    • Expected terms
    • Compiler warnings and errors
    • Runtime errors
  • Reflection
    • Structural reflection
    • Behavioral reflection
  • Writing and running applications
    • Starting Logtalk
    • Source files
    • Compiling and loading your applications
    • Loader files
    • Libraries of source files
    • Settings files
    • Compiler linter
    • Compiler flags
    • Reloading source files
    • Batch processing
    • Optimizing performance
    • Portable applications
    • Conditional compilation
    • Avoiding common errors
    • Coding style guidelines
  • Printing messages and asking questions
    • Printing messages
    • Message tokenization
    • Meta-messages
    • Intercepting messages
    • Asking questions
    • Intercepting questions
  • Term and goal expansion
    • Defining expansions
    • Expanding grammar rules
    • Bypassing expansions
    • Hook objects
    • Virtual source file terms and loading context
    • Default compiler expansion workflow
    • User defined expansion workflows
    • Using Prolog defined expansions
    • Debugging expansions
  • Documenting
    • Documenting directives
    • Processing and viewing documenting files
    • Inline formatting in comments text
    • Diagrams
  • Debugging
    • Compiling source files in debug mode
    • Procedure box model
    • Defining spy points
    • Tracing program execution
    • Debugging using spy points
    • Debugging commands
    • Context-switching calls
    • Debugging messages
    • Using the term-expansion mechanism for debugging
    • Ports profiling
    • Debug and trace events
  • Performance
    • Source code compilation modes
    • Local predicate calls
    • Calls to imported or inherited predicates
    • Calls to module predicates
    • Messages
    • Automatic expansion of built-in meta-predicates
    • Inlining
    • Generated code simplification and optimizations
    • Size of the generated code
    • Debug mode overhead
    • Other considerations
  • Installing Logtalk
    • Hardware and software requirements
    • Logtalk installers
    • Source distribution
    • Distribution overview
  • Prolog integration and migration
    • Source files with both Prolog code and Logtalk code
    • Encapsulating plain Prolog code in objects
    • Converting Prolog modules into objects
    • Compiling Prolog modules as objects
    • Dealing with proprietary Prolog directives and predicates
    • Calling Prolog module predicates
• Reference Manual
  • Grammar
    • Entities
    • Object definition
    • Category definition
    • Protocol definition
    • Entity relations
    • Entity identifiers
    • Source file names
    • Terms
    • Directives
    • Clauses and goals
    • Lambda expressions
    • Entity properties
    • Predicate properties
    • Compiler flags
  • Control constructs
    • Message sending
    • Message delegation
    • Calling imported and inherited predicates
    • Calling external predicates
    • Context switching calls
  • Directives
    • Source file directives
    • Conditional compilation directives
    • Entity directives
    • Predicate directives
  • Built-in predicates
    • Enumerating objects, categories and protocols
    • Enumerating objects, categories and protocols properties
    • Creating new objects, categories and protocols
    • Abolishing objects, categories and protocols
    • Objects, categories, and protocols relations
    • Event handling
    • Multi-threading
    • Multi-threading engines
    • Compiling and loading source files
    • Flags
    • Linter
  • Built-in methods
    • Execution context
    • Reflection
    • Database
    • Meta-calls
    • Error handling
    • All solutions
    • Event handling
    • Message forwarding
    • Definite clause grammar rules
    • Term and goal expansion
    • Coinduction hooks
    • Message printing
    • Question asking
• Tutorial
  • List predicates
    • Defining a list object
    • Defining a list protocol
    • Summary
  • Dynamic object attributes
    • Defining a category
    • Importing the category
    • Summary
  • A reflective class-based system
    • Defining the base classes
    • Summary
  • Profiling programs
    • Messages as events
    • Profilers as monitors
    • Summary
• FAQ
  • General
    • Why are all versions of Logtalk numbered 2.x or 3.x?
    • Why do I need a Prolog compiler to use Logtalk?
    • Is the Logtalk implementation based on Prolog modules?
    • Does the Logtalk implementation use term-expansion?
  • Compatibility
    • What are the backend Prolog compiler requirements to run Logtalk?
    • Can I use constraint-based packages with Logtalk?
    • Can I use Logtalk objects and Prolog modules at the same time?
  • Installation
    • The integration scripts/shortcuts are not working!
    • I get errors when starting up Logtalk after upgrading to the latest version!
  • Portability
    • Are my Logtalk applications portable across Prolog compilers?
    • Are my Logtalk applications portable across operating systems?
  • Programming
    • Should I use prototypes or classes in my application?
    • Can I use both classes and prototypes in the same application?
    • Can I mix classes and prototypes in the same hierarchy?
    • Can I use a protocol or a category with both prototypes and classes?
    • What support is provided in Logtalk for defining and using components?
    • What support is provided in Logtalk for reflective programming?
  • Troubleshooting
    • Using compiler options on calls to the Logtalk compiling and loading predicates do not work!
    • Gecko-based browsers (e.g. Firefox) show non-rendered HTML entities when browsing XML documenting files!
    • Compiling a source file results in errors or warnings but the Logtalk compiler reports a successful compilation with zero errors and zero warnings!
  • Usability
    • Is there a shortcut for compiling and loading source files?
    • Is there an equivalent directive to the ensure_loaded/1 Prolog directive?
    • Are there shortcuts for the make functionality?
  • Deployment
    • Can I create standalone applications with Logtalk?
  • Performance
    • Is Logtalk implemented as a meta-interpreter?
    • What kind of code Logtalk generates when compiling objects? Dynamic code? Static code?
    • How about message-sending performance? Does Logtalk use static binding or dynamic binding?
    • Which Prolog-dependent factors are most crucial for good Logtalk performance?
    • How does Logtalk performance compare with plain Prolog and with Prolog modules?
  • Licensing
    • What’s the Logtalk distribution license?
    • Can Logtalk be used in commercial applications?
    • What’s the final license for a combination of Logtalk with a Prolog compiler?
  • Support
    • Are there professional consulting, training and supporting services?
• Developer Tools
  • Overview
    • Loading the developer tools
    • Tools documentation
  • asdf
  • assertions
    • API documentation
    • Loading
    • Adding assertions to your source code
    • Automatically adding file and line context information to assertions
    • Suppressing assertion calls from source code
    • Redirecting assertion failure messages
    • Converting assertion failures into errors
  • code_metrics
    • API documentation
    • Loading
    • Available metrics
    • Usage
    • Defining new metrics
    • Third-party tools
    • Applying metrics to Prolog modules
    • Applying metrics to plain Prolog code
  • dead_code_scanner
    • API documentation
    • Loading
    • Usage
    • Integration with the make tool
    • Caveats
    • Scanning Prolog modules
    • Scanning plain Prolog files
  • debug_messages
    • API documentation
    • Loading
    • Usage
  • debugger
    • API documentation
    • Loading
    • Usage
    • Alternative debugger tools
    • Known issues
  • diagrams
    • API documentation
    • Loading
    • Supported diagrams
    • Graph elements
    • Supported graph languages
    • Customization
    • Linking diagrams
    • Creating diagrams for Prolog module applications
    • Creating diagrams for plain Prolog files
    • Other notes
  • doclet
    • API documentation
    • Loading
    • Automating running doclets
    • Integration with the make tool
  • help
    • API documentation
    • Loading
    • Supported operating-systems
    • Known issues
  • lgtdoc
    • API documentation
    • Loading
    • Documenting source code
    • Generating documentation
  • lgtunit
    • Main files
    • API documentation
    • Loading
    • Writing and loading tests
    • Running unit tests
    • Parametric test objects
    • Test dialects
    • User-defined test dialects
    • QuickCheck
    • Skipping tests
    • Checking test goal results
    • Testing local predicates
    • Testing non-deterministic predicates
    • Testing generators
    • Testing input/output predicates
    • Suppressing tested predicates output
    • Tests with timeout limits
    • Setup and cleanup goals
    • Test annotations
    • Debugging failed tests
    • Code coverage
    • Automating running tests
    • Utility predicates
    • Exporting test results in xUnit XML format
    • Exporting test results in the TAP output format
    • Exporting code coverage results in XML format
    • Minimizing test results output
    • Known issues
  • linter
  • make
    • API documentation
  • ports_profiler
    • API documentation
    • Loading
    • Compiling source files for port profiling
    • Generating profiling data
    • Printing profiling data reports
    • Interpreting profiling data
    • Profiling Prolog modules
    • Profiling plain Prolog code
    • Known issues
  • profiler
    • Loading
    • Supported backend Prolog compilers
    • Compiling source code for profiling
  • tutor
    • API documentation
    • Loading
    • Usage
  • wrapper
    • API documentation
    • Loading
    • Workflows
    • Customization
    • Current limitations
• Libraries
  • Overview
    • Library documentation
    • Loading libraries
    • Testing libraries
    • Credits
    • Other notes
  • arbitrary
    • API documentation
    • Loading
    • Testing
    • Usage
    • Examples
    • Known issues
  • assignvars
    • API documentation
    • Loading
    • Testing
  • basic_types
    • API documentation
    • Loading
    • Testing
  • coroutining
    • API documentation
    • Loading
    • Testing
  • dates
    • API documentation
    • Loading
  • dependents
    • API documentation
    • Loading
  • dictionaries
    • API documentation
    • Loading
    • Testing
    • Usage
    • Credits
  • edcg
    • API documentation
    • Loading
    • Testing
    • Usage
    • Introduction
    • Syntax
    • Declaration of Predicates
    • Declaration of Accumulators
    • Declaration of Passed Arguments
    • Additional documentation
  • events
    • API documentation
    • Loading
  • expand_library_alias_paths
    • API documentation
    • Loading
    • Usage
  • expecteds
    • API documentation
    • Loading
    • Testing
    • Usage
    • See also
  • gensym
    • API documentation
    • Loading
    • Testing
  • git
    • API documentation
    • Loading
    • Testing
    • Usage
  • heaps
    • API documentation
    • Loading
    • Testing
    • Credits
  • hierarchies
    • API documentation
    • Loading
    • Testing
  • hook_flows
    • API documentation
    • Loading
    • Testing
    • Usage
  • hook_objects
    • API documentation
    • Loading
    • Testing
    • Usage
  • intervals
    • API documentation
    • Loading
    • Testing
  • java
    • API documentation
    • Loading
    • Testing
    • Usage
    • Known issues
  • logging
    • API documentation
    • Loading
  • loops
    • API documentation
    • Loading
    • Testing
    • Usage
  • meta
    • API documentation
    • Loading
    • Testing
    • Usage
  • meta_compiler
    • API documentation
    • Loading
    • Testing
    • Usage
  • optionals
    • API documentation
    • Loading
    • Testing
    • Usage
    • See also
  • os
    • API documentation
    • Loading
    • Testing
  • queues
    • API documentation
    • Loading
    • Testing
    • Usage
  • random
    • API documentation
    • Loading
    • Testing
    • Usage
  • reader
    • API documentation
    • Loading
    • Testing
  • redis
    • API documentation
    • Loading
    • Testing
    • Credits
    • Known issues
  • sets
    • API documentation
    • Loading
    • Testing
    • Usage
    • Credits
  • statistics
    • API documentation
    • Loading
    • Testing
  • timeout
    • API documentation
    • Loading
    • Testing
  • types
    • API documentation
    • Loading
    • Testing
  • unicode_data
    • Authors
    • License
    • Website
    • Description
    • Requirements
    • Usage
    • Known issues
    • Acknowledgements
    • Files and API Summary
  • zippers
    • API documentation
    • Loading
    • Testing
• Glossary
• Bibliography
• Index

• Search Page