GNU Prolog - opérateur Univ? Explication de celui-ci

Question

l'opérateur univ. Je ne comprends pas exactement ça.

Par exemple ceci:

foo(PredList,[H|_]) :- bar(PredList,H).
foo(PredList,[_|T]) :- foo(PredList,T),!.

bar([H|_],Item) :- G =.. [H,Item],G.
bar([_|T],Item) :- bar(T,Item).

Qu'est-ce que ce fait? Cela semble voir si un autre prédicat est vrai. Je ne comprends pas ce que le « .. » ne.

Comment voulez-vous réécrire ce sans que l'opérateur univ?

Answer 1

pauses Univ (=..) jusqu'à un terme dans une liste de constituants, ou construit un terme de la liste à un tel. Essayez:

?- f(x,y) =.. L.
L = [f, x, y].

?- f(x,y,z) =.. [f|Args].
Args = [x, y, z].

?- Term =.. [g,x,y].
Term = g(x, y).

bar semble appeler chaque prédicat dans PredList sur Item, avec foo retours en arrière sur les Items. (En utilisant une variable comme un prédicat n'est pas portable;. Le prédicat call doit être préférée)

Modifier : Kaarel est droite, univ peut être remplacé par functor/3 et arg/3, comme suit:

bar([H|_],Item) :-
    functor(Goal,H,1),   % unifies Goal with H(_)
    arg(1,Goal,Item),    % unifies first argument of Goal with Item
    call(Goal).          % use this for portability

Answer 2

Le rewrite le plus approprié à mon avis serait:

 bar( [H|_], Item ) :- call(H, Item).

call/n ne sont pas encore partie de la norme de base ISO, mais ils pourraient devenir dans un proche avenir (*). Beaucoup de systèmes Prolog les soutiennent déjà.

Il y a une raison pour laquelle call/n doit être préféré (=..)/2 simple et solutions functor/3 + de arg/3. La solution de call/n est capable à la fermeture de la poignée (**).

Avec simple (=..)/2 et une solution functor/3 + de arg/3 peut invoquer bar/2 uniquement avec des atomes dans le premier argument de la liste. Par exemple:

 p1(1).
 p2(2).
 ?- bar( [p1, p2], 1 ).
 Yes
 ?- bar( [p1, p2], 2 ).
 Yes
 ?- bar( [p1, p2], 3 ).
 No

Avec la fermeture, nous ne sont pas limités aux atomes, et nous pourrions sauver un certain effort de codage. Par exemple, nous pouvons faire ce qui suit directement:

 ?- bar( [=(1), =(2)], 1 ).
 Yes
 ?- bar( [=(1), =(2)], 2 ).
 Yes
 ?- bar( [=(1), =(2)], 3 ).
 No

Cordialement

(*)
Projet de rectificatif technique 2
http://www.complang.tuwien.ac.at/ulrich / iso-Prolog / DTC2 # appel

(**)
Inventeur Il ?: call/n prédicats
http://www.complang.tuwien.ac.at/ulrich /Prolog-inedit/naish.html