Reflection of defined predicates on un-instantiated classes?

[EllenOrange]

Consider the following sample code and REPL statements

:- object(thing,
	instantiates(thing)).
:- end_object.

:- object(hat,
	specializes(thing)
	).
	:- public( color/1).
	color(red).
:- end_object.	

:- object(hat1,
	instantiates(hat)).
	color(black).
:- end_object.

2 ?- hat1::color(X).
X = black.

3 ?- hat::color(X).
!     Existence error: predicate_declaration color/1 does not exist
!       in goal: hat::color(A)
!       with execution context:
!         entity:            user
!         sender:            user
!         this:              user
!         self:              B
!         meta-call context: []
!         coinduction stack: []
!
4 ?- object_property(hat,declares(color/1,_)).
true .

5 ?- object_property(hat,defines(color/1,_)).
true .

This all makes sense; in 3) color/1 doesn't exist because the class hat doesn't instantiate itself. I could make 3) work by adding instantiates(hat) to its definition, but at that point one might as well use a hierarchy of prototypes based on extends().

My question is: Is there a way of finding what predicate of color/1 is defined by hat, without instantiating hat?

The context for this question is that I'm writing the type and cardinality verification code I asked about yesterday, and I ran into this question along the way. My verification code can create/destroy temp instantiation as needed, but it seems hacky, and I figure there might be something I'm missing about the Reflection API.

[pmoura]

I assume you mean finding the clause for the color/1 predicate in hat? The reflection API doesn't provide that information. But if you use a prototype hierarchy that becomes easy: you just send a message to the prototype.

[pmoura]

Some Logtalk developer tools do use a runtime dynamically created object to extract information from a category or an object playing the role of a class. An alternative is to gather that information using the term-expansion mechanism at compile time.

[pmoura]

Wondering... how about adding a predicate to access that information to the classes metaclasses?

[EllenOrange]

dynamically created object , term-expansion at compile time

Thanks!

Ah yes, term-expansion to stash the information at compile time; I hadn't thought of that option. :)

If I wind up using a class structure, either of these options would work.

[pmoura]

P.S. You can use:

```logtalk
...
```

for Logtalk syntax highlighting.

[pmoura]

Several classes can instantiate the same metaclass. As the predicates that would make the changes will be called by sending messages to the classes, the definition of those predicates can always make the changes local to the class that received the messages.

[EllenOrange]

As the predicates that would make the changes will be called by sending messages to the classes, the definition of those predicates can always make the changes local to the class that received the messages.

I don't get that; there must be something fundamental here that I'm still not understanding. Could you elaborate?

For example, here is how I interpret your suggestion into code, based loosely on your inheritance.lgt example:

:- object(metaclass,
	instantiates(metaclass)).

	:- public(class_assert/1).
	class_assert(Clause) :-
		self(Self),
		Self::assertz(Clause).	
:- end_object.

:- object(superclass,
	instantiates(metaclass)).

	:- public(foo/1).
	foo(1).
:- end_object.

:- object(subclass,
	specializes(superclass),
	instantiates(metaclass)).

	:- dynamic.
	:- public(bar/2).
	bar(1,2).
:- end_object.

:- object(instance,
	instantiates(subclass)).

	foo(2).
:- end_object.

:- object(empty_instance,
	instantiates(subclass)).
:- end_object.

I get the result I expect, which doesn't work. :)

?-  superclass::class_assert(foo(2)). 
!     Permission error: create predicate_declaration foo/1
!       in goal: assertz(foo(2))
!       with execution context:
!         entity:            metaclass
!         sender:            user
!         this:              metaclass
!         self:              superclass
!         meta-call context: []
!         coinduction stack: []

So what am I misunderstanding about your suggestion?

[pmoura]

Note that, be default, the dynamic_declarations flag is set to deny, hence the permission error. You need to set it to allow for those classes.

[pmoura]

You also need to declare the foo/1 predicate dynamic:

:- object(superclass,
	instantiates(metaclass)).

	:- public(foo/1).
	:- dynamic(foo/1).
	foo(1).

:- end_object.

After that change and after adding the following directive to the beginning of the file containing your code:

:- set_logtalk_flag(dynamic_declarations, allow).

We get:

$ swilgt -q
?- {eo}.
*     Suspicious call: A::assertz(B) instead of ::assertz(B)
*       while compiling object metaclass
*       in file /Users/pmoura/Desktop/lgtemp/eo.lgt between lines 7-9
*     
true.

?- superclass::class_assert(foo(2)).
!     Permission error: create predicate_declaration foo/1
!       in goal: assertz(foo(2))
!       with execution context:
!         entity:            metaclass
!         sender:            user
!         this:              metaclass
!         self:              superclass
!         meta-call context: []
!         coinduction stack: []
!     
?- ^D
✔ ~/Desktop/lgtemp 
19:06 $ swilgt -q
?- {eo}.
*     Suspicious call: A::assertz(B) instead of ::assertz(B)
*       while compiling object metaclass
*       in file /Users/pmoura/Desktop/lgtemp/eo.lgt between lines 7-9
*     
true.

?- superclass::class_assert(foo(2)).
true.

?- instance::foo(X).
X = 2.

?- empty_instance::foo(X).
X = 1 ;
X = 2.

[EllenOrange]

Great, thanks for the clarification and working example!

[pmoura]

Btw, if you load the tutor tool, you'll get explanations for most compiler warnings and errors. For example, for you original code:

$ swilgt -q
?- {tutor(loader)}.
true.

?- {eo}.
*     Suspicious call: A::assertz(B) instead of ::assertz(B)
*       while compiling object metaclass
*       in file /Users/pmoura/Desktop/lgtemp/eo.lgt between lines 7-9
*     Only use an explicit message sending instead of a message to "self" when
*     you need to generate an event for the message. Otherwise, simply send
*     a message to "self".
*     
true.

?- superclass::class_assert(foo(2)).
!     Permission error: create predicate_declaration foo/1
!       in goal: assertz(foo(2))
!       with execution context:
!         entity:            metaclass
!         sender:            user
!         this:              metaclass
!         self:              superclass
!         meta-call context: []
!         coinduction stack: []
!     The object does not allow dynamic declaration of new predicates.
!     Set its "dynamic_declarations" flag to "allow" to fix this error.
!     
?- 

You can load this (and other tools) automatically at startup by using a settings file.

[EllenOrange]

A good point. I'll turn that on by default.

[pmoura]

P.S. Just pushed improved documentation for the asserta/1 and assertz/1 built-in methods, clarifying semantics that you may find useful:

https://logtalk3.readthedocs.io/en/latest/refman/methods/asserta_1.html
https://logtalk3.readthedocs.io/en/latest/refman/methods/assertz_1.html