Dynamic rule assertion in SWI-prolog

Ich versuche eine Regel hinzufügen, die dynamisch auf die knowledge base verwenden SWI-prolog, wo der Körper der Regel ist im Voraus nicht bekannt.

Die gewünschte Regel wie folgt aussieht:

rule(a) :- fact(1), fact(2).

Normalerweise würde man einfach sagen,

assert((rule(a):-fact(1),fact(2))).

aber das problem ist, dass der Sachverhalt wird beschlossen, zur Laufzeit(die Anzahl der Fakten ist auch nicht bekannt, vor der Geltendmachung).

Deshalb würde ich gerne wissen, ob es eine Möglichkeit gibt zu behaupten, eine Regel, wo der Körper besteht aus einer Liste von Fakten, wie [Tat(1),Tatsache(2)]

InformationsquelleAutor Tom | 2010-10-31
  1. 5

    Werden wir eine Regel erstellen, die newrule(X) :- w,x,y,z(X).

    Der Körper einer Regel ist ein Tupel, ein Konstrukt in der form (w,x,y...).

    Für verschiedene aufbaulängen, beginnend mit keine Körper: 

    assert(goal).  
assert(goal:-cond).  
assert(goal:-(cond1,cond2)).

    Tupel-operator ist der Komma(`,'), wie in ','(a,b) == (a,b). 

    %%%%
%%%% Name: runtime.pl -- Runtime rule insertion.
%%%%
create_a_rule :- 
    Cond=[w,x,y,z(X)],
    Head=newrule(X),
    list_to_tuple(Cond,Body),
    dynamic(Head),
    assert(Head :- Body),
    listing(Head).

/*
This is a [l,i,s,t], and this is a (t,u,p,l,e).  
Convertng list to tuple:  
[]    -> undefined  
[x]   -> (x) == x  
[x,y] -> (x,y).  
[x,y,z..whatever] = (x,y,z..whatever)  
*/

list_to_tuple([],_) :- 
    ValidDomain='[x|xs]',
    Culprit='[]',
    Formal=domain_error(ValidDomain, Culprit),
    Context=context('list_to_tuple','Cannot create empty tuple!'),
    throw(error(Formal,Context)).

list_to_tuple([X],X).

list_to_tuple([H|T],(H,Rest_Tuple)) :-
    list_to_tuple(T,Rest_Tuple).

:- create_a_rule.
:- listing(newrule).

    --

    Gibt es zwei Auflistungen. Die erste Auflistung der Ergebnisse aus listing() aufgerufen wird, in create_a_rule(). Der 2. Eintrag ist von der listing() Befehl in der letzten Zeile.

    ?- [runtime].
:- dynamic newrule/1.

newrule(A) :-
    w,
    x,
    y,
    z(A).

:- dynamic newrule/1.

newrule(A) :-
    w,
    x,
    y,
    z(A).

% runtime compiled 0.01 sec, 1,448 bytes
true.
    • Vielen Dank für die perfekte und sehr feine Lösung!
    • wenn die Antwort "perfekt" ist, warum nimmst du nicht akzeptieren es?
    • assert Prädikat in dieser Antwort ist veraltet in SWI-Prolog.
    InformationsquelleAutor frayser
  2. 1

    Vorgeschlagene änderung frayser ' s Liste:

    list_to_tuple([X],X).

list_to_tuple([A,B],(A,B)).

list_to_tuple([A,B|T],(A,B,Rest_Tuple)) :-
    list_to_tuple(T,Rest_Tuple).

    Diese Klauseln vermeiden die Notwendigkeit für eine Ausnahme, wenn die erste variable wird eine leere Liste: es wird einfach fehlschlagen. Es bedeutet auch, werden Sie nie schlagen eine geltend machen, wenn backtracking.

    Allerdings, Sie möglicherweise trotzdem WOLLEN die Ausnahme-Klausel in den Ort, so könnte man noch setzen Sie auf zu fangen Fällen, in denen eine versuchte Einigung mit [] gemacht wurde. (Es wird nicht schlagen, wenn es backtracking, aber.)

    InformationsquelleAutor Kaitain
Schreibe einen Kommentar