Concaténation de terme Prolog

Question

J'essaie de formater un résultat à partir d'un programme, mais j'ai du mal à le faire.

Je voulais donner quelque chose comme ceci comme résultat:

Res = do(paint(x) do(clean(a), do(repair(b) , initialState))) 

essentiellement, je veux concaténer termes successifs à initialState atome mais, il ne fonctionne pas avec atom_concat puisque les autres termes de concaténer ne sont pas atomes et aussi je voulais ajouter le) chaque fois que je passe par la fonction "faire". Donc, ce serait quelque chose comme: Res = initialState.

Lorsque la fonction a été appelée faire, je l'aurais fonction comme

concatenateTerm(Pred, Res, Res). 

Pred beeing réparation (b) par exemple, et obtenir le résultat: res = do(repair(b), initialState).

Est-ce possible?

Merci

Answer 1

Si je vous comprends bien, vous devez faire quelque chose comme:

Res0 = initialState, 
do(repair(b), Res0, Res1), 
do(clean(a), Res1, Res2), 
do(paint(x), Res2, Res3), 

où vous résultat final est en Res3. Rappelez-vous que les procédures prolog ne "retournent" rien et que les valeurs d'entrée et de sortie doivent être passées par des arguments. Pourquoi voulez-vous concaténer des termes successifs à l'atome initialState? Ce n'est pas la façon prologue. Il serait beaucoup plus naturel en prologue de construire une structure qui est modifiée à chaque fois.

Answer 2

@ d0pe, il n'y a aucun résultat en Prolog (ils existent dans Mercure et Erlang, je suppose) il n'y a que des valeurs nommées qui spécifiaient/unifié dans la tête et probablement plus tard dans le corps unifiés. L'exécution de Temp = Res, concatenateTerm (Pred,Temp, Res) échouera dans la plupart des cas car Temp = Res, Res = do(Pred, Temp) produira un terme infiniment récursif do(Pred, do(Pred, do(Pred, ...))) (lorsque l'extension appropriée est disponible). Je suppose que ce n'est pas ce que tu veux.
Mais maintenant, je comprends que vous voulez modifierRes - c'est une mauvaise compréhension de Prolog. Il n'y a pas de variables, vous devez utiliser la prochaine approche Res0 = initialState, Res1 = do(repair(b), Res0), Res2 = do(clean(a), Res1), Res3 = do(paint(x), Res2).

Probablement votre règle ressemblera (voir des exemples de singe + bananna en Prolog):

solve(FinalState, finish, FinalState). % our initial state is our goal 

solve(InitState, do(Action, Future), FinalState):- 
    action(InitState, Action, NewState), 
    solve(NewState, Future, FinalState). 

Answer 3

Je suis d'accord avec @rvirding dans que vous aurez juste besoin de construire un terme comme résultat PROLOG , au lieu d'essayer de construire un atome . Même si vous essayez ce dernier (ce qui est en effet possible), vous pouvez généralement convertir des atomes en termes et revenir en utilisant des fonctions utilitaires (telles que atom_to_term/3 ou term_to_atom/2 dans SWI-PROLOG), si besoin est.

Quoi qu'il en soit, un simple prédicat de prendre toute une liste de termes « d'État » et la production d'un tel terme que vous avez décrit précédemment pourrait ressembler à ceci:

build_do_term([X,Y], do(X,Y)) :- !. 
build_do_term([X|Xs], do(X,Rem)) :- 
    build_do_term(Xs, Rem). 

Appeler ce prédicat sur les termes de l'État (dont il doit y avoir au moins deux):

?- build_do_term([paint(x), clean(a), repair(b), initialState], Rem). 
Rem = do(paint(x), do(clean(a), do(repair(b), initialState))). 

... qui reflète le comportement que vous avez décrit comme après. Si vous ne souhaitez pas créer le terme en une seule fois à partir d'une liste, vous pouvez toujours utiliser la méthode de construction de terme do/2 utilisée dans build_do_term/2 ci-dessus dans votre propre code pour construire le terme approprié do/2 si nécessaire.