True when Name/Arity is a known functor. This 
means that at some point in time a term with name Name and Arity 
arguments was created. Functor objects are currently not subject to 
garbage collection. Due to timing, t/2 below with instantiated
Name and Arity can theoretically fail, i.e., a 
functor may be visible in instantiated mode while it is not yet visible 
in unbound mode. Considering that the only practical value of current_functor/2 
we are aware of is to analyse resource usage we accept this impure 
behaviour.
t(Name, Arity) :-
    (   current_functor(Name, Arity)
    ->  current_functor(N, A), N == Name, A == Arity
    ;   true
    ).
True if PredicateIndicator is a currently defined predicate. 
A predicate is considered defined if it exists in the specified module, 
is imported into the module or is defined in one of the modules from 
which the predicate will be imported if it is called (see
section 6.9). Note 
that current_predicate/1 
does not succeed for predicates that can be autoloaded. 
See also
current_predicate/2 
and predicate_property/2.
If PredicateIndicator is not fully specified, the 
predicate only generates values that are defined in or already imported 
into the target module. Generating all callable predicates therefore 
requires enumerating modules using current_module/1. 
Generating predicates callable in a given module requires enumerating 
the import modules using import_module/2 
and the autoloadable predicates using the
predicate_property/2 autoload.
Classical pre-ISO implementation of current_predicate/1, 
where the predicate is represented by the head term. The advantage is 
that this can be used for checking the existence of a predicate before 
calling it without the need for functor/3:
call_if_exists(G) :-
        current_predicate(_, G),
        call(G).
Because of this intended usage, current_predicate/2 
also succeeds if the predicate can be autoloaded. Unfortunately, 
checking the autoloader makes this predicate relatively slow, in 
particular because a failed lookup of the autoloader will cause the 
autoloader to verify that its index is up-to-date.
True when Head refers to a predicate that has property
Property. With sufficiently instantiated Head,
predicate_property/2 
tries to resolve the predicate the same way as calling it would do: if 
the predicate is not defined it scans the default modules (see default_module/2) 
and finally tries the autoloader. Unlike calling, failure to find the 
target predicate causes
predicate_property/2 
to fail silently. If Head is not sufficiently bound, only 
currently locally defined and already imported predicates are 
enumerated. See current_predicate/1 
for enumerating all predicates. A common issue concerns generating 
all built-in predicates. This can be achieved using the code below:
generate_built_in(Name/Arity) :-
    predicate_property(system:Head, built_in),
    functor(Head, Name, Arity),
    \+ sub_atom(Name, 0, _, _, $).   % discard reserved names
Property is one of:
- autoload(File)
- 
True if the predicate can be autoloaded from the file File. 
Like undefined, this property is not generated.
- built_in
- 
True if the predicate is locked as a built-in predicate. This implies it 
cannot be redefined in its definition module and it can normally not be 
seen in the tracer.
- defined
- 
True if the predicate is defined. This property is aware of sources 
being reloaded, in which case it claims the predicate defined 
only if it is defined in another source or it has seen a definition in 
the current source. See compile_aux_clauses/1.
- dynamic
- 
True if assert/1 
and retract/1 
may be used to modify the predicate. This property is set using dynamic/1.
- exported
- 
True if the predicate is in the public list of the context module.
- imported_from(Module)
- 
Is true if the predicate is imported into the context module from module Module.
- file(FileName)
- 
Unify FileName with the name of the source file in which the 
predicate is defined. See also source_file/2 
and the property
line_count. Note that this reports the file of the first 
clause of a predicate. A more robust interface can be achieved using nth_clause/3 
and clause_property/2.
- foreign
- 
True if the predicate is defined in the C language.
- implementation_module(-Module)
- 
True when Module is the module in which Head is or 
will be defined. Resolving this property goes through the same search 
mechanism as when the an undefined predicate is encountered, but does 
not perform any loading. It searches (1) the module inheritence 
hierarchy (see
default_module/2) 
and (2) the autoload index if the unknown 
flag is not set to failin the target module.
- indexed(Indexes)
- 
Indexes83This predicate 
property should be used for analysis and statistics only. The exact 
representation of Indexes may change between versions. 
is a list of additional (hash) indexes on the predicate. Each element of 
the list is a term
ArgSpec-Index. ArgSpec denotes the 
indexed argument(s) and is one of
- single(Argument)
- 
Hash on a single argument. Argument is the 1-based argument 
number.
- multi(ArgumentList)
- 
Hash on a combination of arguments.
- deep(Position)
- 
Index on a sub-argument. Position is a list holding first the argument 
of the predicate then the argument into the compound and recursively 
into deeper compound terms.
 Index is a term hash(Buckets, Speedup, Size, IsList). 
Here
Buckets is the number of buckets in the hash and Speedup 
is the expected speedup relative to trying all clauses linearly, Size 
is the size of the index in memory in bytes and finally, IsList 
indicates that a list is created for all clauses with the same key. This 
is used to create deep indexes for the arguments of compound 
terms.
 
- interpreted
- 
True if the predicate is defined in Prolog. We return true on this 
because, although the code is actually compiled, it is completely 
transparent, just like interpreted code.
- iso
- 
True if the predicate is covered by the ISO standard (ISO/IEC 13211-1).
- line_count(LineNumber)
- 
Unify LineNumber with the line number of the first clause of 
the predicate. Fails if the predicate is not associated with a file. See 
also source_file/2. 
See also the fileproperty above, notably the reference to clause_property/2.
- multifile
- 
True if there may be multiple (or no) files providing clauses for the 
predicate. This property is set using multifile/1.
- meta_predicate(Head)
- 
If the predicate is declared as a meta-predicate using meta_predicate/1, 
unify Head with the head-pattern. The head-pattern is a 
compound term with the same name and arity as the predicate where each 
argument of the term is a meta-predicate specifier. See meta_predicate/1 
for details.
- nodebug
- 
Details of the predicate are not shown by the debugger. This is the 
default for built-in predicates. User predicates can be compiled this 
way using the Prolog flag generate_debug_info.
- non_terminal(T)
- 
rue if the predicate implements a grammar rule. See
non_terminal/1.
- notrace
- 
Do not show ports of this predicate in the debugger.
- number_of_clauses(ClauseCount)
- 
Unify ClauseCount to the number of clauses associated with 
the predicate. Fails for foreign predicates.
- number_of_rules(RuleCount)
- 
Unify RuleCount to the number of clauses associated with the 
predicate. A rule is defined as a clauses that has a body that 
is not just true(i.e., a fact). Fails for foreign 
predicates. This property is used to avoid analysing predicates with 
only facts inlibrary(prolog_codewalk).
- last_modified_generation(Generation)
- 
Database generation at which the predicate was modified for the last 
time. Intended to quickly assesses the validity of caches.
- public
- 
Predicate is declared public using public/1. 
Note that without further definition, public predicates are considered 
undefined and this property is not reported.
- quasi_quotation_syntax
- 
The predicate (with arity 4) is declared to provide quasi quotation 
syntax with quasi_quotation_syntax/1.
- static
- 
The definition can not be modified using assertz/1 
and friends. This property is the opposite from dynamic, 
i.e., for each defined predicate, eitherstaticordynamicis true but never both.
- thread_local
- 
If true (only possible on the multithreaded version) each thread has its 
own clauses for the predicate. This property is set using
thread_local/1.
- transparent
- 
True if the predicate is declared transparent using the
module_transparent/1 
or meta_predicate/1 
declaration. In the latter case the property meta_predicate(Head)is also provided. See chapter 6 
for details.
- undefined
- 
True if a procedure definition block for the predicate exists, but there 
are no clauses for it and it is not declared dynamic or multifile. This 
is true if the predicate occurs in the body of a loaded predicate, an 
attempt to call it has been made via one of the meta-call predicates, 
the predicate has been declared as e.g., a meta-predicate or the 
predicate had a definition in the past. Originally used to find missing 
predicate definitions. The current implementation of list_undefined/0 
used cross-referencing. Deprecated.
- visible
- 
True when predicate can be called without raising a predicate existence 
error. This means that the predicate is (1) defined, (2) can be 
inherited from one of the default modules (see default_module/2) 
or (3) can be autoloaded. The behaviour is logically consistent iff the 
property
visibleis provided explicitly. If the property is left 
unbound, only defined predicates are enumerated.
- volatile
- 
If true, the clauses are not saved into a saved state by qsave_program/[1,2]. 
This property is set using volatile/1.
Provides access to the clauses of a predicate using their index number. 
Counting starts at 1. If Reference is specified it unifies Pred 
with the most general term with the same name/arity as the predicate and
Index with the index number of the clause. Otherwise the name 
and arity of Pred are used to determine the predicate. If Index 
is provided, Reference will be unified with the clause 
reference. If Index is unbound, backtracking will yield both 
the indexes and the references of all clauses of the predicate. The 
following example finds the 2nd clause of append/3:
?- use_module(library(lists)).
...
?- nth_clause(append(_,_,_), 2, Ref), clause(Head, Body, Ref).
Ref = <clause>(0x994290),
Head = lists:append([_G23|_G24], _G21, [_G23|_G27]),
Body = append(_G24, _G21, _G27).