jupyter: jupytext: text_representation: extension: .md format_name: markdown format_version: '1.3' jupytext_version: 1.16.7 kernelspec: display_name: Logtalk language: logtalk name: logtalk_kernel ---

<!--

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. -->

dynpred

This folder contains examples of using the built-in database handling methods with object and categories. Two object hierarchies are provided, one prototype-based, and the other class-based, in order to illustrate the differences between asserting predicates in a class and in a prototype:

The following objects are defined:

[114, 111, 111, 116]

root of the prototype hierarchy; declares and defines a public, dynamic predicate

[100, 101, 115, 99, 101, 110, 100, 97, 110, 116]

simple prototype extending the root prototype

[99, 108, 97, 115, 115]

root of the class hierarchy; declares and defines a public predicate

[109, 101, 116, 97, 99, 108, 97, 115, 115]

class metaclass

[105, 110, 115, 116, 97, 110, 99, 101]

simple instance of class class

[112, 114, 111, 116, 111, 116, 121, 112, 101]

simple prototype used to illustrate how the scope of asserted predicates depends on the target object (this, self, or an explicit object)

In addition, the file categories.lgt illustrates how to define category predicates that handle dynamic predicates in the context of this and in the context of self.

Print Logtalk, Prolog backend, and kernel versions (if running as a notebook):

%versions

Start by loading the example:

logtalk_load(dynpred(loader)).

Sending to descendant the message p/1, returns the definition in root:

descendant::p(Value).

Asserting a local definition for p/1 in descendant overrides the inherited definition:

descendant::(assertz(p(descendant)), p(Value)).

If we retract the local definition, again the definition inherited from root will be used:

descendant::(retractall(p(_)), p(Value)).

The object class does not understand the message p1/1 (the predicate is declared only for the class descendant instances):

catch(class::p1(X), Error, true).

The same message is valid for the class instances:

instance::p1(X).

If we assert a clause for a new predicate, p2/1, in class (a side-effect being a dynamic declaration of the predicate):

class::assertz(p2(class)).

The new predicate, like p1/1, is not available for class:

catch(class::p2(Value), Error, true).

But is available for the class instances, the same way as p1/1:

instance::p2(X).

If we change our mind and abolish the new predicate:

class::abolish(p2/1).

Then instance will no longer accept the p2/1 message:

catch(instance::p2(_), Error, true).

Using a prototype, assert three new predicates (the method object_assert/0 asserts the predicate public_predicate/0 from outside the prototype; the method self_assert/0 asserts the predicate protected_predicate/0 in self; the method this_assert/0 asserts the predicate private_predicate/0 in this):

prototype::(object_assert, self_assert, this_assert).

Check the resulting scope of each predicate:

prototype::dynamic_predicates.