compile_term(+Clause)

+Clause

A valid Prolog clause, or list of clauses.

Description

If Clause is a list, the list elements are taken as static Prolog clauses and compiled as if they occurred in a file. Otherwise, if Clause is an atom or a compound term, it is itself compiled as a Prolog clause. This predicate works exactly as if all the clauses in the list were written into a file and this file was then compiled using compile/1. The difference between compile_term/1 and assert/1 is that the predicates for which clauses are compiled are not necessarily dynamic with compile_term/1, unless explicitly declared as such. Therefore clauses compiled with compile_term/1 usually replace the existing ones for the same predicate, moreover their source form is not available. On the other hand, compile_term/1 is faster than assert/1. Therefore, it can be used instead of assert/1 if the properties of dynamic procedures are not required.

Unlike compiling a file, when an event occurs which is not just a warning, the following clauses are not compiled, the compilation is aborted.

Fail Conditions

Resatisfiable

Exceptions

(4) instantiation fault

Clause is a partial list.

(5) type error

Clause is a list whose tail is neither nil nor a variable.

(66) trying to modify a system predicate

A system predicate is being redefined.

(130) syntax error: illegal head

The head of Clause is not an atom or a compound term.

(131) syntax error: illegal goal

A subgoal in the body of Clause is not an atom or a compound term.

(134) procedure clauses are not consecutive

Clause is a list of clauses where clauses of one procedure are not consecutive.

(135) trying to redefine a protected procedure

Trying to redefine a protected procedure.

(137) trying to redefine a procedure with another type

A procedure which was previously referenced as built-in or external is now defined as a regular one, or vice versa. Error 143 --- One of the clauses was a query and it failed.

(270) undefined variable attribute

Trying to compile delay clauses without switching on the coroutine state.

(275)

Trying to add delay clauses to a built-in or external procedure.

Examples

Success:
   compile_term([p(a), p(b), q(1), r("abc")]).
   compile_term([:- coroutine, delay p(X) if var(X)]).
   compile_term(p(X) :- q(X)).

   [eclipse]: compile_term([[a]]).                  (Error 66).
   warning: modifying a system predicate in '.' / 2

   yes.
   [eclipse]: [X].       % The system predicate was redefined.

   X = a
   yes.

   % Compile_term/1 can be used for conditional compilation:
   :- (exists('/usr/ucb') -> S = bsd; S = sysV),
      compile_term(os(S)).

   % Even a whole procedure can be conditionally compiled:
   :- os(bsd) ->
    compile_term([
        (pred1(X) :- pred2(X), pred3(X)),
        (pred1(Y) :- ...           )]).


Error:

   compile_term([p|X]).        (Error 4).
   compile_term([a|b]).        (Error 5).
   compile_term("a").          (Error 130).
   compile_term(["a" :- b]).   (Error 130).
   compile_term([p(X) :- 1]).  (Error 131).
   compile_term([a, b, a]).    (Error 134).
   compile_term(!).            (Error 135).
   compile_term([(p :- write(a)), write(b)]).      (Error 137).
   compile_term(:- var(a)).    (Error 143).
   compile_term(delay functor(A, _, _) if var(A)). (Error 275).

See Also