[ 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:

1. 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.
2. 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).

## See Also

call / 1, @ / 2, export / 1