..
   This file is part of Logtalk <https://logtalk.org/>  
   SPDX-FileCopyrightText: 1998-2025 Paulo Moura <pmoura@logtalk.org>
   SPDX-License-Identifier: Apache-2.0

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.


Glossary
========

.. _glossary:

.. glossary::
   :sorted:

   ancestor
      A :term:`class` or a parent :term:`prototype` that contributes (via
      inheritance) to the definition of an object. For class-based hierarchies,
      the ancestors of an instance are its class(es) and all the superclasses
      of its class(es). For prototype-based hierarchies, the ancestors of
      a prototype are its parent(s) and the ancestors of its parent(s).

   category
      A set of :term:`predicates directives <predicate directive>` and
      clauses that can be (virtually) imported by any object. Categories
      support composing objects using fine-grained units of code reuse
      and also :term:`hot patching` of existing objects. A category
      should be functionally-cohesive, defining a single functionality.

   complementing category
      A category used for :term:`hot patching` an existing object (or a
      set of objects).

   parametric category
      See :term:`parametric entity`.

   class
      An :term:`object` that specializes another object, interpreted as its
      superclass. A class defines the common predicates of a set of objects
      that instantiate it. An object can also be interpreted as a class
      when it instantiates itself.

   abstract class
      A :term:`class` that cannot be instantiated by sending it a message.
      Usually used to contain common predicates that are inherited by other 
      classes.

   metaclass
      The :term:`class` of a class, when interpreted as an :term:`instance`.
      Metaclass instances are themselves classes. Metaclasses are optional,
      except for the root class, and can be shared by several classes.

   subclass
      A :term:`class` that is a specialization, direct or indirectly, of
      another class. A class may have multiple subclasses.

   superclass
      A :term:`class` from which another class is a specialization
      (directly or indirectly via another class). A class may have
      multiple superclasses.

   closed-world assumption
      The assumption that what cannot be proved true is false. Therefore,
      sending a :term:`message` corresponding to a *declared* but not *defined*
      predicate, or calling a declared predicate with no clauses, fails.
      But messages or calls to undeclared predicates generate an error.

   directive
      A source file term that affects the interpretation of source code.
      Directives use the ``(:-)/1`` prefix operator as functor.

   entity directive
      A directive that affects how Logtalk :term:`entities <entity>` are
      used or compiled.

   predicate directive
      A directive that specifies a predicate property that affects how
      predicates are called or compiled.

   source file directive
      A :term:`directive` that affects how a :term:`source file` is compiled.

   encapsulation
      The hiding of an object implementation. This promotes software reuse
      by isolating the object clients from its implementation details.
      Encapsulation is enforced in Logtalk by using
      :term:`predicate scope directives <predicate scope directive>`.

   entity
      Generic name for Logtalk compilation units: :term:`objects <object>`,
      :term:`categories <category>`, and :term:`protocols <protocol>`.
      Entities share a single namespace (i.e., entity
      :term:`identifiers <identity>` must be unique) and can be static (the
      default) or dynamic. Static entities are defined in source files.
      Dynamic entities can also be defined in source files but are usually
      created and abolished at runtime using the language built-in predicates.

   parametric entity
      An :term:`object` or :term:`category` whose :term:`identifier <identity>`
      is a compound term possibly containing free variables that can be used
      to parameterize the entity predicates. Parameters are *logical variables*
      implicitly shared by all the entity clauses. Note that the identifier
      of a parametric entity is its functor, irrespective of the possible
      values of its arguments (e.g., ``foo(bar)`` and ``foo(baz)`` are
      different parameterizations of the same parametric entity, ``foo/1``).

   entity alias
      An alternative name for an entity. Entity aliases can be defined using
      the :ref:`directives_uses_1` and :ref:`directives_use_module_1` directives.
      Entity aliases can be used to improve code clarity by using alternative
      names that are more meaningful in the calling context, to bind parametric
      entity parameters, and to simplify experimenting with alternative entities
      implementing the same protocol.

   static entity
      See :term:`entity`.

   dynamic entity
      See :term:`entity`.

   event
      The sending of a :term:`message` to an object. An event can be
      expressed as an ordered tuple: ``(Event, Object, Message, Sender)``.
      Logtalk distinguishes between the sending of a message — ``before``
      event — and the return of control to the sender — ``after`` event.

   grammar rule
      An alternative notation for predicates used to parse or generate
      sentences in some language. This notation hides the arguments used to
      pass the sequences of tokens being processed, thus simplifying the
      representation of grammars. Grammar rules are represented using as
      functor the infix operator ``(-->)/2`` instead of the ``(:-)/2``
      operator used with predicate clauses.

   grammar rule non-terminal
      A syntactic category of words or phrases. A non-terminal is
      identified by its *non-terminal indicator*, i.e. by its name and
      number of arguments using the notation ``Name//Arity``.

   grammar rule terminal
      A word or basic symbol of a language.

   identity
      Property of an :term:`entity` that distinguishes it from every other entity.
      The identifier of an entity is its functor (i.e., its name and arity),
      which must be unique. Object and :term:`category` identifiers can be
      atoms or compound terms. Protocol identities must be atoms. All Logtalk
      entities (objects, protocols, and categories) share the same namespace.

   inheritance
      An :term:`entity` inherits :term:`predicates directives <predicate directive>`
      and clauses from related entities. In the particular case of objects,
      when an object extends other object, we have prototype-based inheritance.
      When an object specializes or instantiates another object, we have
      class-based inheritance. See also :term:`public inheritance`,
      :term:`protected inheritance`, and :term:`private inheritance`.

   private inheritance
      All public and protected predicates are inherited as private
      predicates. See also :term:`public inheritance` and
      :term:`protected inheritance`.

   protected inheritance
      All public predicates are inherited as protected. No scope change
      for protected or private predicates. See also :term:`public inheritance`
      and :term:`private inheritance`.

   public inheritance
      All inherited predicates maintain their declared scope. See also
      :term:`protected inheritance` and :term:`private inheritance`.

   instance
      An :term:`object` that instantiates another object, interpreted as
      its :term:`class`. An object may instantiate multiple objects (also
      known as multiple instantiation).

   instantiation
      The process of creating a new :term:`class` :term:`instance`. In Logtalk,
      this does not necessarily imply dynamic creation of an object at runtime;
      an instance may also be defined as a static object in a source file.

   polymorphism
      Different objects (and categories) can provide different implementations
      of the same predicate. The predicate declaration can be inherited from a
      common ancestor, also known as *subtype polymorphism*. Logtalk implements
      *single dispatch* on the receiver of a message, which can be described as
      *single-argument polymorphism*. As :term:`message lookup` only uses the
      predicate functor, multiple predicate implementations for different types
      of arguments are possible, also known as *ad hoc polymorphism*.
      :term:`Parametric objects and categories <parametric entity>` enable
      implementation of *parametric polymorphism* by using one or more
      parameters to pass object identifiers that can be used to parameterize
      generic predicate definitions.

   library
      A directory containing source files. See also :term:`library alias`
      and :term:`library notation`.

   library alias
      An atom that can be used as an alias for a :term:`library` full
      path. Library aliases and their corresponding paths can be defined
      using the :ref:`predicates_logtalk_library_path_2` predicate. See
      also :term:`library notation`.

   library notation
      A compound term where the name is a :term:`library alias` and the
      single argument is a :term:`source file` relative path. Use of
      library notation simplifies compiling and loading source files and
      can make an application easily relocatable by defining an alias for
      the root directory of the application files.

   module
      A Prolog entity characterized by an identity and a set of
      :term:`predicates directives <predicate directive>` and clauses.
      Prolog modules are usually static although some Prolog systems
      allow the creation of dynamic modules at runtime. Prolog modules
      can be interpreted as prototypes.

   message
      A query sent to an object. In logical terms, a message can be
      interpreted as a request for proof construction using an object
      database and the databases of related entities.

   message lookup
      Sending a message to an object requires a lookup for the
      :term:`predicate declaration`, to check if the message is within the
      scope of the sender, and a lookup for the :term:`predicate definition`
      that is going to be called to answer the message. Message lookup can
      occur at :term:`compile <static binding>` time or at :term:`runtime
      <dynamic binding>`.

   message to self
      A message sent to the object that received the original message under
      processing. Messages to self require :term:`dynamic binding` as the
      value of self is only know at runtime.

   meta-interpreter
      A program capable of running other programs written in the same
      language.

   method
      The :term:`predicate definition` used to answer a :term:`message` sent
      to an object. Logtalk supports both :term:`static binding` and
      :term:`dynamic binding` to find which method to run to answer a message.
      See also :term:`built-in method`.

   abstract method
      A :term:`method` implementing an algorithm whose step corresponds
      to calls to methods defined in the descendants of the object (or
      :term:`category`) containing it.

   built-in method
      A predefined :term:`method` that can be called from within any object
      or :term:`category`. I.e. built-in methods are built-in object and
      category predicates. Built-in methods cannot be redefined.

   singleton method
      A :term:`method` defined in an :term:`instance` itself. Singleton
      methods are supported in Logtalk and can also be found in other
      object-oriented programming languages.

   template method
      See :term:`abstract method`.

   monitor
      Any object, implementing the :ref:`monitoring <apis:monitoring/0>`
      built-in protocol, that is notified by the runtime when a spied event
      occurs. The spied :term:`events <event>` can be set by the monitor
      itself or by any other object.

   object
      An entity characterized by an :term:`identity` and a set of
      :term:`predicates directives <predicate directive>` and clauses.
      Logtalk objects can be either static or dynamic. Logtalk objects
      can play the *role* of classes, instances, or prototypes. The
      role or roles an object plays are a function of its relations
      with other objects.

   object database
      The set of predicates locally defined inside an object.

   doclet object
      An object specifying the steps necessary to (re)generate the API
      documentation for a project. See the :doc:`devtools/doclet`
      and :doc:`devtools/lgtdoc/` tools for details.

   hook object
      An object, implementing the :ref:`expanding <apis:expanding/0>` built-in
      protocol, defining term- and goal-expansion predicates, used in the
      compilation of Logtalk or Prolog source files. A hook object can be
      specified using the :ref:`hook <flag_hook>` flag. It can also
      be specified using a :ref:`directives_set_logtalk_flag_2` directive in
      the source files to be expanded.

   expansion workflow
      A sequence of term-expansion or goal-expansion steps where each step is
      usually defined using a :term:`hook object` or a combination of hook
      objects.

   parametric object
      See :term:`parametric entity`.

   parametric object proxy
      A compound term (usually represented as a plain Prolog fact) with
      the same name and number of arguments as the identifier of a parametric
      object.

   parameter
      An argument of a parametric object or a parametric category identifier.
      Parameters are *logical variables* implicitly shared by all the entity
      predicate clauses.

   parameter variable
      A variable used as parameter in a parametric object or a parametric
      category using the syntax ``_ParameterName_`` (i.e., a variable whose
      name stars and ends with an underscore). Parameter variables are
      *logical variables* shared by all entity terms. Occurrences of parameter
      variables in :term:`entity directives <entity directive>` and clauses
      are implicitly unified with the corresponding entity parameters.

   parent
      A prototype that is extended by another prototype.

   predicate
      Predicates describe what is true about the application domain. A
      predicate is identified by its *predicate indicator*, i.e. by its
      name and number of arguments using the notation ``Name/Arity``.
      See also :term:`built-in predicate` and :term:`method`.

   predicate declaration
      A predicate declaration is composed by a set of
      :term:`predicates directives <predicate directive>`, which must
      include ar least a :term:`scope directive <predicate scope directive>`.

   predicate definition
      The set of clauses for a predicate, contained in an object or category.
      Predicate definitions can be overridden or specialized in descendant
      entities.

   predicate alias
      An alternative functor (``Name/Arity``) for a predicate. Predicate
      aliases can be defined for any inherited predicate using the
      :ref:`directives_alias_2` directive and for predicates listed in
      :ref:`directives_uses_2` and :ref:`directives_use_module_2` directives.
      Predicate aliases can be used to solve inheritance conflicts, to
      improve code clarity by using alternative names that are more
      meaningful in the calling context, and to use a different order of the
      predicate arguments.

   predicate shorthand
      A :term:`predicate alias` that defines a call template, possibly using
      a different name, with a reduced number of arguments by hard-coding
      the value of the omitted arguments in the original call template.
      Predicate shorthands can be defined using :ref:`directives_uses_2`
      and :ref:`directives_use_module_2` directives. They can be used to
      simplify predicate calls and to ensure consistent call patterns
      when some of the arguments always use the same fixed values in the
      calling context.

   built-in predicate
      A predefined predicate that can be called from anywhere. Built-in
      predicates can be redefined within :term:`objects <object>` and
      :term:`categories <category>`.

   coinductive predicate
      A predicate whose calls are proved using greatest fixed point
      semantics. Coinductive predicates allows reasoning about
      infinite rational entities such as cyclic terms and ω-automata.

   local predicate
      A predicate that is defined in an object (or in a :term:`category`)
      but that is not listed in a
      :term:`scope directive <predicate scope directive>`. These predicates
      behave like private predicates but are invisible to the reflection
      :term:`built-in methods <built-in method>`. Local predicates are
      usually auxiliary predicates and only relevant to the entity where
      they are defined.

   meta-argument
      A predicate argument that is called as a goal, used as a :term:`closure`
      to construct a goal that will be called, or that is handled in a
      way that requires awareness of the predicate calling context.

   meta-predicate
      A predicate with one or more :term:`meta-arguments <meta-argument>`.
      For example, :ref:`methods_call_N` and :ref:`methods_findall_3` are
      built-in meta-predicates.

   closure
      A callable term (i.e., an atom or a compound term) passed to a
      :term:`meta-predicate` call where it is extended with additional
      arguments to form a goal called by the meta-predicate.

   predicate scope directive
      A directive that declares a predicate by specifying its visibility
      as *public*, *protected*, or *private*.

   predicate scope container
      The object that inherits a :term:`predicate declaration` from an
      imported :term:`category` or an implemented :term:`protocol`.

   private predicate
      A predicate that can only be called from the object that contains
      its :term:`scope directive <predicate scope directive>`.

   protected predicate
      A predicate that can only be called from the object containing its
      :term:`scope directive <predicate scope directive>` or from an object
      that inherits the predicate.

   public predicate
      A predicate that can be called from any object.

   primary predicate declaration
      See :term:`multifile predicate`.

   predicate calling context
      The object or category from within a predicate is called (either
      directly or using a control construct such as a message-sending
      control construct).

   predicate definition context
      The object or category that contains the definition (i.e., clauses)
      for a predicate.

   predicate execution context
      The implicit arguments (including :term:`sender`, :term:`self`,
      and :term:`this`) required for the correct execution of a
      predicate call.

   dynamic predicate
      A predicate whose clauses can be dynamically added or retracted at
      runtime.

   discontiguous predicate
      A predicate whose clauses are not contiguous in a :term:`source file`.
      I.e. a predicate whose clauses are mixed with clauses for other
      predicates.

   multifile predicate
      A predicate whose clauses can be defined in multiple
      :term:`entities <entity>` and :term:`source files <source file>`.
      The object or category holding the directive without an entity
      prefix qualifying the predicate holds the multifile predicate
      *primary declaration*, which consists of both a
      :term:`scope directive <predicate scope directive>` and a
      :ref:`directives_multifile_1` directive for the predicate.

   synchronized predicate
      A synchronized predicate is protected by a mutex ensuring that, in
      a multi-threaded application, it can only be called by a single
      thread at a time.

   visible predicate
      A predicate that is within scope, a locally defined predicate, a
      :term:`built-in method`, a Logtalk built-in predicate, or a Prolog
      built-in predicate.

   hook predicate
      A predicate, usually declared :term:`multifile <multifile predicate>`,
      that allows the user to customize another predicate or provide
      alternative definitions for a default predicate definition.

   profiler
      A program that collects data about other program performance.

   protocol
      An entity that contains
      :term:`predicate declarations <predicate declaration>`. A predicate
      is declared using a :term:`scope directive <predicate scope directive>`.
      It may be further specified by additional predicate directives.
      Protocols support the separation between interface and implementation,
      can be implemented by both objects and categories, and can be extended
      by other protocols. A protocol should be functionally-cohesive,
      specifying a single functionality. Also known as *interface*.

   interface
      See :term:`protocol`.

   prototype
      A self-describing object that may extend or be extended by other
      objects. An object with no instantiation or specialization relations
      with other objects is always interpreted as a prototype.

   self
      The object that received the :term:`message` under processing.

   sender
      An object that sends a :term:`message` to other object. When a message
      is sent from within a :term:`category`, the *sender* is the object
      importing the category on which behalf the message was sent.

   super call
      Call of an inherited (or imported) :term:`predicate definition`. Mainly
      used when redefining an inherited (or imported) predicate to call the
      overridden definition while making additional calls. Super calls preserve
      :term:`self` and may require :term:`dynamic binding` if the predicate is
      dynamic.

   specialization
      A :term:`class` is specialized by defining a new class that inherits its
      predicates and possibly adds new ones.

   source file
      A text file defining Logtalk and/or Prolog code. Multiple Logtalk
      entities may be defined in a single source file. Plain Prolog code
      may be intermixed with Logtalk entity definitions. Depending on the
      used :term:`backend Prolog compiler`, the text encoding may be
      specified using an :ref:`directives_encoding_1` directive as the
      first term in the first line in the file.

   adapter file
      A Prolog source file defining a minimal abstraction layer between the
      Logtalk compiler/runtime and a specific :term:`backend Prolog compiler`.

   doclet file
      A :term:`source file` whose main purpose is to generate documentation
      for a :term:`library` or an application.

   loader file
      A :term:`source file` whose main purpose is to load a set of
      source files (possibly with specific compiler flags) and any
      library dependencies.

   settings file
      A :term:`source file`, compiled and loaded automatically by default at
      Logtalk startup, mainly defining default values for compiler flags that
      override the defaults found on the backend Prolog compiler
      :term:`adapter files <adapter file>`.

   tester file
      A :term:`source file` whose main purpose is to load and a run a set of
      unit tests.

   component
      A unique atom or compound term template identifying a library, tool,
      application, or application sub-system. Component names are notably
      used by the message printing and question asking mechanisms. Compound
      terms are used instead of atoms when parameterization is required.

   scratch directory
      The directory used to save the intermediate Prolog files generated by
      the compiler when compiling :term:`source files <source file>`.

   this
      The object that contains the predicate clause under execution. When
      the predicate clause is contained in a :term:`category`, *this* is a
      reference to the object importing the category on which behalf the
      predicate clause is being used to prove the current goal.

   dynamic binding
      Runtime lookup of a :term:`predicate declaration` and
      :term:`predicate definition` to verify the validity of a
      :term:`message` (or a :term:`super call`) and find the
      predicate definition that will be used to answer the message (or the
      super call). Also known as *late binding*. See also :term:`static binding`.

   late binding
      See :term:`dynamic binding`.

   static binding
      Compile time lookup of a :term:`predicate declaration` and
      :term:`predicate definition` when compiling a :term:`message` sending
      call (or a :term:`super call`). Dynamic binding is used whenever static
      binding is not possible (e.g., due to the predicate being dynamic or due
      to lack of enough information at compilation time). Also known as *early
      binding*. See also :term:`dynamic binding`.

   early binding
      See :term:`static binding`.

   lambda expression
      A compound term that can be used in place of a goal or :term:`closure`
      meta-argument and that abstracts a :term:`predicate definition` by
      listing its variables and a callable term that implements the
      definition. Lambda expressions help avoid the need of naming and
      defining auxiliary predicates.

   lambda parameter
      A term (usually a variable or a non-ground compound term) that is
      local to a :term:`lambda expression`. All lambda parameters must
      be explicitly enumerated in a lambda expression for well-defined
      semantics.

   lambda free variable
      A variable that is global to a :term:`lambda expression`. All
      used global variables must be explicitly listed in a lambda
      expression for well-defined semantics.

   hot patching
      The act of fixing :term:`entity directives <entity directive>` and
      predicates or adding new entity directives and predicates to loaded
      :term:`entities <entity>` in a running application without requiring
      access to the entities source code or restarting the application.
      Achieved using :term:`complementing categories <complementing category>`.

   threaded engine
      A computing thread running a goal whose solutions can be lazily and
      concurrently computed and retrieved. A threaded engine also supports
      a term queue that allows passing arbitrary terms to the engine. This
      queue can be used to pass e.g. data and new goals to the engine.

   backend Prolog compiler
      The Prolog compiler that is used to host and run Logtalk and that is
      called for compiling the intermediate Prolog code generated by the
      Logtalk compiler when compiling source files.

   steadfastness
      A predicate definition is *steadfast* when it still generates only
      correct answers when called with unexpected arguments (notably,
      bound output arguments). Typically, a predicate may not be steadfast
      when output argument unifications can occur before a cut in a predicate
      clause body.

   top-level interpreter shorthand
      Aliases for frequently used built-in predicates such as
      :ref:`predicates_logtalk_load_1` and :ref:`predicates_logtalk_make_1`.
      These shorthands are **not** part of the Logtalk language and must
      only be used at the top-level interpreter.

   meta-variable
      A variable in a :term:`meta-argument` position that is expected to be
      unified with a goal or a closure at runtime.

   naked meta-variable
      A :term:`meta-variable` used as the body of a predicate clause or
      grammar rule or used in a cut-transparent argument of a control
      construct. The "naked" designation highlights that the meta-variable
      is not wrapped by ``call/1`` or ``phrase//1`` goals.

   homoiconic
      A property of programming languages where *code* and *data* use the
      same representation. Logtalk (and Prolog) are examples of homoiconic
      programming languages. A Logtalk program is a set of terms (clauses
      and directives) that can be handled as *data* by e.g. the term-expansion
      mechanism.

   clause reference
      An opaque term that uniquely identifies a clause. Provided by
      some backends via alternative database built-in predicates.
