Checking that all definitions of a predicate succeed

[Victor NOEL]

Hello,

Before starting, I would like to warn that what I want to do is maybe the bad way to do it :)

I have the following problem :
Several categories implement the same protocol that states that they should declare a predicate with one or zero answer.
An object imports these categories, and want to call, for each one, the predicate and make sure that it succeeds.

I am looking for idea to implement this.

The reason behind this is that I have my Gorgias (see the Porting forum :) that is extended with categories, and I need them to implement a way to verify the consistency of set of terms.
Each category has its own way of checking, but all must succeed for the set to be consistent.

I tried to do his by making categories implement the negation of consistency check, and the object was verifying that none succeeded with findall, but it is problematic since I am committing some constraints in these predicates and want them to stay committed but they are not since the predicate must fail.

If someone has an idea, I will be happy :)

Thanks you,

Victor

[Paulo Moura]

I have the following problem :
Several categories implement the same protocol that states that they should declare a predicate with one or zero answer.
An object imports these categories, and want to call, for each one, the predicate and make sure that it succeeds.

I am looking for idea to implement this.

From your description, I assume you're defining aliases in the object in order to access the predicate definition in each category (since the definition in the first imported category will override the definitions in the remaining categories). Is my interpretation correct?

The reason behind this is that I have my Gorgias (see the Porting forum that is extended with categories, and I need them to implement a way to verify the consistency of set of terms.
Each category has its own way of checking, but all must succeed for the set to be consistent.

So, why not simple define an object predicate that calls all the aliases for the category consistency predicates? The object predicate could use the same name of the consistency predicate as defined in your protocol.

I tried to do his by making categories implement the negation of consistency check, and the object was verifying that none succeeded with findall, but it is problematic since I am committing some constraints in these predicates and want them to stay committed but they are not since the predicate must fail.

I don't understand why you need to use the negation of the consistency check. Maybe some sample code would help?

Cheers,

Paulo

[Victor NOEL]

From your description, I assume you're defining aliases in the object in order to access the predicate definition in each category (since the definition in the first imported category will override the definitions in the remaining categories). Is my interpretation correct?

Yes, exactly, I made a little example to show what I want to do, it is hard to explain with words.

Code: Select all

:- object(obj, imports(two, three)).
:-alias(two, pred/1, pred2/1).
:-alias(three, pred/1, pred3/1).
pred(A) :- pred2(A).
pred(A) :- pred3(A).

test(A) :- % should call pred to be sure that A is true for pred2 and pred3

:- end_object.

:-category(two).
pred(A) :- 0 is A mod 2.
:-end_category.

:-category(three).
pred(A) :- 0 is A mod 3.
:-end_category.

So, why not simple define an object predicate that calls all the aliases for the category consistency predicates? The object predicate could use the same name of the consistency predicate as defined in your protocol.

Yes, this can be a good idea. I didn't think about it, the only problem there could be (and maybe it is not a problem in fact) is that I generate the alias and the predicates that call them automatically with hooks.

But I don't see why I couldn't generate such a predicate calling all of them.

It is funny because while writing the example, it become clear that it was a good idea :]

I don't understand why you need to use the negation of the consistency check. Maybe some sample code would help?

It was an idea to do what I want.
I could call :
findall(test, the_contrary_predicate, []).
And be sure that none of them was true. But there was another problem, so I think what you proposed me is the way to go :]

Thanks you for your help

[Paulo Moura]

Yes, this can be a good idea. I didn't think about it, the only problem there could be (and maybe it is not a problem in fact) is that I generate the alias and the predicates that call them automatically with hooks.

So it seems that you just need to collect the predicate aliases and convert them into a conjunction that will be called by an object predicate with the same name as the original consistency check predicate.

Cheers,

Paulo

[Victor NOEL]

This is what I did an it worked well :]

Thanks you for the idea !

Victor