/usr/lib/swi-prolog/doc/Manual/usemodules.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

<HTML>
<HEAD>
<TITLE>SWI-Prolog 5.7.3 Reference Manual: Section 5.6</TITLE><LINK REL=home HREF="index.html">
<LINK REL=contents HREF="Contents.html">
<LINK REL=index HREF="DocIndex.html">
<LINK REL=previous HREF="reexport.html">
<LINK REL=next HREF="metainmodule.html">
<STYLE type="text/css">
/* Style sheet for SWI-Prolog latex2html
*/

dd.defbody
{ margin-bottom: 1em;
}

dt.pubdef
{ background-color: #c5e1ff;
}

.bib dd
{ margin-bottom: 1em;
}

.bib dt
{ float: left;
margin-right: 1.3ex;
}

pre.code
{ margin-left: 1.5em;
margin-right: 1.5em;
border: 1px dotted;
padding-top: 5px;
padding-left: 5px;
padding-bottom: 5px;
background-color: #f8f8f8;
}

div.navigate
{ text-align: center;
background-color: #f0f0f0;
border: 1px dotted;
padding: 5px;
}

div.title
{ text-align: center;
padding-bottom: 1em;
font-size: 200%;
font-weight: bold;
}

div.author
{ text-align: center;
font-style: italic;
}

div.abstract
{ margin-top: 2em;
background-color: #f0f0f0;
border: 1px dotted;
padding: 5px;
margin-left: 10%; margin-right:10%;
}

div.abstract-title
{ text-align: center;
padding: 5px;
font-size: 120%;
font-weight: bold;
}

div.toc-h1
{ font-size: 200%;
font-weight: bold;
}

div.toc-h2
{ font-size: 120%;
font-weight: bold;
margin-left: 2em;
}

div.toc-h3
{ font-size: 100%;
font-weight: bold;
margin-left: 4em;
}

div.toc-h4
{ font-size: 100%;
margin-left: 6em;
}

span.sec-nr
{ 
}

span.sec-title
{ 
}

span.pred-ext
{ font-weight: bold;
}

span.pred-tag
{ float: right;
font-size: 80%;
font-style: italic;
color: #202020;
}

/* Footnotes */

sup.fn { color: blue; text-decoration: underline; }
span.fn-text { display: none; }
sup.fn span {display: none;}
sup:hover span 
{ display: block !important;
position: absolute; top: auto; left: auto; width: 80%;
color: #000; background: white;
border: 2px solid;
padding: 5px; margin: 10px; z-index: 100;
font-size: smaller;
}
</STYLE>
</HEAD>
<BODY BGCOLOR="white">
<DIV class="navigate"><A class="nav" href="index.html"><IMG SRC="home.gif" BORDER=0 ALT="Home"></A>
<A class="nav" href="Contents.html"><IMG SRC="index.gif" BORDER=0 ALT="Contents"></A>
<A class="nav" href="DocIndex.html"><IMG SRC="yellow_pages.gif" BORDER=0 ALT="Index"></A>
<A class="nav" href="reexport.html"><IMG SRC="prev.gif" BORDER=0 ALT="Previous"></A>
<A class="nav" href="metainmodule.html"><IMG SRC="next.gif" BORDER=0 ALT="Next"></A>
</DIV>

<H2><A NAME="sec:5.6"><SPAN class="sec-nr">5.6</SPAN> <SPAN class="sec-title">Using 
the Module System</SPAN></A></H2>

<A NAME="sec:usemodules"></A>

<P>The current structure of the module system has been designed with 
some specific organisations for large programs in mind. Many large 
programs define a basic library layer on top of which the actual program 
itself is defined. The module <CODE>user</CODE>, acting as the default 
module for all other modules of the program can be used to distribute 
these definitions over all program module without introducing the need 
to import this common layer each time explicitly. It can also be used to 
redefine built-in predicates if this is required to maintain 
compatibility to some other Prolog implementation. Typically, the 
loadfile of a large application looks like this:

<PRE class="code">
:- use_module(compatibility).   % load XYZ prolog compatibility

:- use_module(                  % load generic parts
        [ error                 % errors and warnings
        , goodies               % general goodies (library extensions)
        , debug                 % application specific debugging
        , virtual_machine       % virtual machine of application
        , ...                   % more generic stuff
        ]).

:- ensure_loaded(
        [ ...                   % the application itself
        ]).
</PRE>

<P>The `use_module' declarations will import the public predicates from 
the generic modules into the <CODE>user</CODE> module. The 
`ensure_loaded' directive loads the modules that constitute the actual 
application. It is assumed these modules import predicates from each 
other using
<A NAME="idx:usemodule12:1170"></A><A class="pred" href="import.html#use_module/1">use_module/[1,2]</A> 
as far as necessary.

<P>In combination with the object-oriented schema described below it is 
possible to define a neat modular architecture. The generic code defines 
general utilities and the message passing predicates (invoke/3 in the 
example below). The application modules define classes that communicate 
using the message passing predicates.

<H3><A NAME="sec:5.6.1"><SPAN class="sec-nr">5.6.1</SPAN> <SPAN class="sec-title">Object 
Oriented Programming</SPAN></A></H3>

<P>Another typical way to use the module system is for defining classes 
within an object oriented paradigm. The class structure and the methods 
of a class can be defined in a module and the explicit module-boundary 
overruling describes in <A class="sec" href="metainmodule.html">section 
5.7.2</A> can by used by the message passing code to invoke the 
behaviour. An outline of this mechanism is given below.

<PRE class="code">
%       Define class point

:- module(point, []).           % class point, no exports

%        name           type,           default access
%                                       value

variable(x,             integer,        0,      both).
variable(y,             integer,        0,      both).

%         method name   predicate name  arguments

behaviour(mirror,       mirror,         []).

mirror(P) :-
        fetch(P, x, X),
        fetch(P, y, Y),
        store(P, y, X),
        store(P, x, Y).
</PRE>

<P>The predicates fetch/3 and store/3 are predicates that change 
instance variables of instances. The figure below indicates how message 
passing can easily be implemented:

<PRE class="code">
%       invoke(+Instance, +Selector, ?ArgumentList)
%       send a message to an instance

invoke(I, S, Args) :-
        class_of_instance(I, Class),
        Class:behaviour(S, P, ArgCheck), !,
        convert_arguments(ArgCheck, Args, ConvArgs),
        Goal =.. [P|ConvArgs],
        Class:Goal.

</PRE>

<P>The construct &lt;<VAR>Module</VAR>&gt;:&lt;<VAR>Goal</VAR>&gt; 
explicitly calls <VAR>Goal</VAR> in module <VAR>Module</VAR>. It is 
discussed in more detail in
<A class="sec" href="metainmodule.html">section 5.7</A>.

<P></BODY></HTML>
swi-prolog-nox 5.10.4-3ubuntu1 / usr / lib / swi-prolog / doc / Manual / usemodules.html
