4.14.1 Managing (dynamic) predicates
- [ISO]abolish(:PredicateIndicator)
- Removes all clauses of a predicate with functor Functor and
arity
Arity from the database. All predicate attributes (dynamic,
multifile, index, etc.) are reset to their defaults. Abolishing an
imported predicate only removes the import link; the predicate will keep
its old definition in its definition module.
According to the ISO standard, abolish/1 can only be applied to dynamic procedures. This is odd, as for dealing with dynamic procedures there is already retract/1 and retractall/1. The abolish/1 predicate was introduced in DEC-10 Prolog precisely for dealing with static procedures. In SWI-Prolog, abolish/1 works on static procedures, unless the Prolog flag iso is set to
true
.It is advised to use retractall/1 for erasing all clauses of a dynamic predicate.
- abolish(+Name, +Arity)
- Same as
abolish(Name/Arity)
. The predicate abolish/2 conforms to the Edinburgh standard, while abolish/1 is ISO compliant. - copy_predicate_clauses(:From, :To)
- Copy all clauses of predicate From to To. The
predicate
To must be dynamic or undefined. If To is
undefined, it is created as a dynamic predicate holding a copy of the
clauses of
From. If To is a dynamic predicate, the clauses of
From are added (as in assertz/1)
to the clauses of To.
To and From must have the same arity. Acts as if
defined by the program below, but at a much better performance by
avoiding decompilation and compilation.
copy_predicate_clauses(From, To) :- head(From, MF:FromHead), head(To, MT:ToHead), FromHead =.. [_|Args], ToHead =.. [_|Args], forall(clause(MF:FromHead, Body), assertz(MT:ToHead, Body)). head(From, M:Head) :- strip_module(From, M, Name/Arity), functor(Head, Name, Arity).
- redefine_system_predicate(+Head)
- This directive may be used both in module
user
and in normal modules to redefine any system predicate. If the system definition is redefined in moduleuser
, the new definition is the default definition for all sub-modules. Otherwise the redefinition is local to the module. The system definition remains in the modulesystem
.Redefining system predicate facilitates the definition of compatibility packages. Use in other contexts is discouraged.
- [ISO,nondet]retract(+Term)
- When Term is an atom or a term it is unified with the first
unifying fact or clause in the database. The fact or clause is removed
from the database. The retract/1
predicate respects the logical update view. This implies that retract/1
succeeds for all clauses that match Term when the predicate
was called. The example below illustrates that the first call
to retract/1
succeeds on
bee
on backtracking despite the fact thatbee
is already retracted.73Example by Jan Burse.:- dynamic insect/1. insect(ant). insect(bee). ?- ( retract(insect(I)), writeln(I), retract(insect(bee)), fail ; true ). ant ; bee.
If multiple threads start a retract on the same predicate at the same time their notion of the entry generation is adjusted such that they do not retract the same first clause. This implies that, if multiple threads use
once(retract(Term))
, no two threads will retract the same clause. Note that on backtracking over retract/1, multiple threads may retract the same clause as both threads respect the logical update view. - [ISO,det]retractall(+Head)
- All facts or clauses in the database for which the head unifies with Head are removed. If Head refers to a predicate that is not defined, it is implicitly created as a dynamic predicate. See also dynamic/1.74The ISO standard only allows using dynamic/1 as a directive.
- [ISO]asserta(+Term)
- [ISO]assertz(+Term)
- [deprecated]assert(+Term)
- Assert a clause (fact or rule) into the database. The predicate
asserta/1
asserts the clause as first clause of the predicate while
assertz/1
assert the clause as last clause. The deprecated assert/1
is equivalent to assertz/1.
If the program space for the target module is limited (see set_module/1), asserta/1
can raise a
resource_error(program_space)
exception. The example below adds two facts and a rule. Note the double parentheses around the rule.?- assertz(parent('Bob', 'Jane')). ?- assertz(female('Jane')). ?- assertz((mother(Child, Mother) :- parent(Child, Mother), female(Mother))).
- asserta(+Term, -Reference)
- assertz(+Term, -Reference)
- [deprecated]assert(+Term, -Reference)
- Equivalent to asserta/1, assertz/1, assert/1, but in addition unifies Reference with a handle to the asserted clauses. The handle can be used to access this clause with clause/3 and erase/1.