Logtalk documentation
Glossary
Contents > Glossary

# Glossary

ancestor
  A class or parent 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 an prototype are its parent(s) and the ancestors of its parent(s).
category
  A set of predicates directives and clauses that can be (virtually) imported by any object. Categories support composing objects using fine-grained units of code reuse and also hot patching of existing objects. A category should be functionally-cohesive, defining a single functionality.
  complementing category
    A category used for hot patching an existing object (or set of objects).
class
  An object that defines the common predicates of a set of objects (its instances).
  abstract class
    A class that cannot be instantiated. Usually used to store common predicates that are inherited by other classes.
  metaclass
    The class of a class, when we see it as an object. Metaclass instances are themselves classes. In a reflexive system any metaclass is also an object.
  subclass
    A class that is a specialization, direct or indirectly, of another class.
  superclass
    A class from which another class is a specialization (directly or indirectly via another class).
directive
  A Prolog/Logtalk term that affects the interpretation of Prolog/Logtalk code. Directives are represented using the `(:-)/1` prefix operator.
  entity directive
    A directive that affects how Logtalk entities (objects, protocols, or categories) are used or compiled.
  predicate directive
    A directive that affects how predicates are called or compiled.
  source file directive
    A directive that affects how a source file is compiled.
encapsulation
  The hiding of an object implementation. This promotes software reuse by isolating users from implementation details.
entity
  Generic name for Logtalk compilation units: objects, categories, and protocols.
event
  The sending of a message to an object. An event can be expressed as an ordered tuple: `(Event, Object, Message, Sender)`. Logtalk distinguish 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 on some language. This notation hides the arguments used to pass the lists of tokens being processed, thus simplifying the representation of grammars. Grammar rules are represented using the infix operator `(-->)/2` instead of the operator used on predicate clauses (`(:-)/2`).
  grammar rule non-terminal
    A syntactic category of words of phrases. A non-terminal is identified by its non-terminal indicator, i.e. by its name and number of arguments using the notation `Functor//Arity`.
  grammar rule terminal
    A word or a basic symbol of a language.
identity
  Property of an entity that distinguishes it from every other entity. Object and category identifiers can be an atoms or compound terms. Protocol identities must be atoms. All Logtalk entities (objects, protocols, and categories) share the same name space.
inheritance
  An object inherits predicate directives and clauses from other objects that it extends or specializes. If an object extends other object then we have a prototype-based inheritance. If an object specializes or instantiates another object we have a class-based inheritance.
  private inheritance
    All public and protected predicates are inherited as private predicates.
  protected inheritance
    All public predicates are inherited as protected. No change for protected or private predicates.
  public inheritance
    All inherited predicates maintain the declared scope.
instance
  The same as object. This term is used when we want to emphasize that an object characteristics are defined by another object (its class).
instantiation
  The process of creating a new class instance. In Logtalk, this does not necessarily implies dynamic creation of an object at runtime; an instance may also be defined as a static object in a source file.
library
  A directory containing source files. The directory name is used as the library name.
message
  A request for a service, sent to an object. In logical terms, a message can be seen as a request for proof construction using an object's predicates.
meta-interpreter
  A program capable of running other programs written in the same language.
method
  Set of predicate clauses used to answer a message sent to an object. Logtalk supports both static binding and dynamic binding to find which method to run to answer a message.
  abstract method
    A method implementing an algorithm whose step corresponds to calls to methods defined in the descendants of the object (or category) containing it.
  built-in method
    A pre-defined method that can be called from within any object or category. Built-in methods cannot be redefined.
  singleton method
    A method defined in an instance itself. Singleton methods are supported in Logtalk and can also be found in other object-oriented programming languages.
monitor
  Any object that is notified when a spied event occurs. The spied events can be set by the monitor itself or by any other object.
object
  An entity characterized by an identity and a set of predicate directives and clauses. Logtalk objects can be either static or dynamic. Logtalk objects can play the role of classes, instances, or prototypes.
  hook object
    An object, implementing the `expanding` built-in protocol, defining term- and goal-expansion clauses, used in the compilation of Logtalk source files. An hook object can be specified using the compiler flag `hook/1`.
  parametric object
    An object whose name is a compound term containing free variables that can be used to parameterize the object predicates.
  parametric object proxy
    A compound term (usually represented as a plain Prolog fact) with the same functor and with the same number of arguments as the identifier of a parametric object.
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 `Functor/Arity`.
  built-in predicate
    A pre-defined predicate that can be called from anywhere. Built-in predicates can be redefined within objects and categories.
  local predicate
    A predicate that is defined in an object (or in a category) but that is not listed in a scope directive. These predicates behave like private predicates but are invisible to the reflection built-in methods. Local predicates are usually auxiliary predicates, only relevant to the entity where they are defined.
  meta-predicate
    A predicate where one of its arguments will be called as a goal. For instance, `findall/3` and `call/1` are Prolog built-ins meta-predicates.
  predicate scope container
    The object that inherits a predicate declaration from an imported category or an implemented protocol.
  private predicate
    A predicate that can only be called from the object that contains the scope directive.
  protected predicate
    A predicate that can only be called from the object containing the scope directive or from an object that inherits the predicate.
  public predicate
    A predicate that can be called from any object.
  multifile predicate
    A predicate whose clauses can be defined in multiple entities. There must always be an object (or category) holding the multifile predicate primary declaration, which consists of both a `public/1` directive and a `multifile/1` directive.
  visible predicate
    A predicate that is declared for an object, a built-in method, a Logtalk built-in predicate, or a Prolog built-in predicate.
profiler
  A program that collects data about other program performance.
protocol
  An entity that can contain specifications (declarations) for predicates. A predicate is specified by a scope directive together, optionally, by other 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.
prototype
  A self-describing object that may extend or be extended by other objects.
self
  The original object that received the message under processing.
sender
  An object that sends a message to other object. When a message is sent from within a category, the sender is the object importing the category.
specialization
  A class is specialized by constructing a new class that inherit its predicates and possibly add new ones.
this
  The object that contains the predicate clause under execution. When the predicate clause is contained in a category, this is a reference to the object importing the category.