[ Control | Reference Manual | Alphabetic Index ]

+LookupModule : +Goal

Call the procedure visible in LookupModule rather than the context module

Goal: Callable term (atom or compound).
LookupModule: Atom.

Description

This predicate provides a means to invoke a procedure which is not visible. Normally, when a procedure is called, the system looks for a visible definition (local or imported) in the context module. This primitive on the other hand allows to specify a different lookup module.

One of two conditions must be satisfied for the lookup to succeed:

the predicate must be exported or reexported from the lookup module, or
the predicate is visible in the lookup module, and the LookupModule argument originates from a tool-call within LookupModule

The purpose of this is to allow calling procedures whose definition is not visible in the context module. The two main uses of this facility are:

If there are several definitions of a procedure with the same name in different modules, :/2 can be used to specify which one to call.
If a module wants to define a procedure, but needs to call another procedure of the same name (but from a different module), :/2 can be used to call that one instead of the locally defined one.

Note that :/2 does not affect the context module of the call. The following table summarises the different idioms:

	Call within module(m)         lookup module    context module

	..., twice(X), ...               m               m
	..., lm : twice(X), ...         lm               m
	..., twice(X) @ cm, ...          m              cm
	..., lm : twice(X) @ cm, ...    lm              cm
	..., call(twice(X)) @ cm, ...   cm              cm

Modules

This predicate is sensitive to its module context (tool predicate, see @/2).

Fail Conditions

Fails if Goal fails

Resatisfiable

Resatisfiable if Goal is resatisfiable

Exceptions

(4) instantiation fault: Goal is not instantiated.
(4) instantiation fault: Module is not instantiated.
(5) type error: Goal is neither an atom nor a compound term.
(5) type error: Module is not an atom.
(68) calling an undefined procedure: Goal is an undefined procedure in Module.

Examples

% two definitions are visible:

    :- lib(ria).    % exports #>= / 2
    :- lib(eplex).  % exports #>= / 2

	..., ria:(X #>= Y), ...
	..., eplex:(X #>= Y), ...


% the library predicate is hidden by the local definition:

    :- lib(lists).     % exports print_list/1

    print_list(List) :-
	writeln("This is the list:"),
	lists:print_list(List).