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

proxies

A parametric object may be used to represent objects whose "state" is static and set when the object is defined. However, there can be only one parametric object with a given functor and arity. For example, if we define the following parametric object:

%%highlight
:- object(circle(_Radius, _Color)).
        ...
:- end_object.

then the following terms may be interpreted as references to the object above:

%%highlight
circle(1, blue)
circle(2, yellow)

In the context of parametric objects, the above terms are known as "parametric object proxies". Proxies represent different instantiations of a parametric object parameters. Proxy terms may be stored on the database as Prolog facts or as Prolog rules (parameter instantiation can be deduced instead of being fixed). This results in a very compact representation, which can be an advantage when dealing with a large number of objects with immutable state. In addition, all the predicates managing these compact representation are encapsulated in a parametric object. This can be, however, a fragile solution as changes on the parametric object ancestors may imply changes to the number and meaning of the parametric object parameters which, in turn, may imply changes to all the Prolog facts used to represent the individual objects.

Note that parametric objects can co-exist with "normal" objects. For example, when using a class-based design, we may use "normal" instances together with a parametric instance of the same class.

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

%versions

Start by loading the example:

logtalk_load(proxies(loader)).

Print the area and the perimeter for all circle proxies:

forall(circle(Id, R, C), circle(Id, R, C)::print).

Logtalk provides a convenient notation for accessing proxies represented as Prolog facts when sending a message:

{circle(_, _, _)}::print, fail; true.

Print the area and the perimeter for the circle #2:

{circle('#2', R, C)}::print.

Construct a list with the areas of all circles:

findall(Area, {circle(_, _, _)}::area(Area), Areas).

Some example queries for backend Prolog compilers implementing the time/1 timing predicate (e.g., SWI-Prolog or YAP; the adapter files for these two systems ensure that a (::)/2 goal in the argument of the time/1 predicate is compiled prior to calling it so that we benchmark the code instead of the compiler).

Recompile the example in optimal mode:

logtalk_make(optimal).

Confirm that the time/1 predicate is available:

time(true).

Benchmark some queries:

time(circle(one, 7, red)::id(Id)).

time(circle(one, 7, red)::radius(Radius)).

time(circle(one, 7, red)::color(Color)).

Id0 = one, time(circle(Id0, 7, red)::id(Id)).

Radius0 = 7, time(circle(one, Radius0, red)::radius(Radius)).

Color0 = red, time(circle(one, 7, Color0)::color(Color)).

time({circle('#2', Radius, Color)}::id(Id)).