File: funs.html

package info (click to toggle)
erlang-doc-html 1%3A11.b.2-1
links: PTS
area: main
in suites: etch, etch-m68k
size: 23,284 kB
ctags: 10,724
sloc: erlang: 505; ansic: 323; makefile: 62; perl: 61; sh: 45
file content (807 lines) | stat: -rw-r--r-- 21,722 bytes
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- This document was generated using DocBuilder 3.3.3 -->
<HTML>
<HEAD>
  <TITLE>Funs</TITLE>
  <SCRIPT type="text/javascript" src="../../doc/erlresolvelinks.js">
</SCRIPT>
</HEAD>
<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#FF00FF"
      ALINK="#FF0000">
<CENTER>
<A HREF="http://www.erlang.se"><IMG BORDER=0 ALT="[Ericsson AB]" SRC="min_head.gif"></A>
</CENTER>
<A NAME="2"><!-- Empty --></A>
<H2>2 Funs</H2>
<A NAME="2.1"><!-- Empty --></A>
<H3>2.1 Example 1 - map</H3>

<P>If we want to double every element in a list, we could write a
function named <CODE>double</CODE>:
<PRE>
double([H|T]) -&#62; [2*H|double(T)];
double([])    -&#62; [].
    
</PRE>

<P>This function obviously doubles the argument entered as input
as follows:
<PRE>
&#62; <STRONG>double([1,2,3,4]).</STRONG>
[2,4,6,8]
    
</PRE>

<P>We now add the function <CODE>add_one</CODE>, which adds one to every
element in a list:
<PRE>
add_one([H|T]) -&#62; [H+1|add_one(T)];
add_one([])    -&#62; [].
    
</PRE>

<P>These functions, <CODE>double</CODE> and <CODE>add_one</CODE>, have a very
similar structure. We can exploit this fact and write a function
<CODE>map</CODE> which expresses this similarity:
<PRE>
map(F, [H|T]) -&#62; [F(H)|map(F, T)];
map(F, [])    -&#62; [].

</PRE>

<P>We can now express the functions <CODE>double</CODE> and
<CODE>add_one</CODE> in terms of <CODE>map</CODE> as follows:
<PRE>
double(L)  -&#62; map(fun(X) -&#62; 2*X end, L).
add_one(L) -&#62; map(fun(X) -&#62; 1 + X end, L).
    
</PRE>

<P><CODE>map(F, List)</CODE> is a function which takes a function
<CODE>F</CODE> and a list <CODE>L</CODE> as arguments and returns the new
list which is obtained by applying <CODE>F</CODE> to each of
the elements in <CODE>L</CODE>.
<P>The process of abstracting out the common features of a number
of different programs is called procedural abstraction.
Procedural abstraction can be used in order to write several
different functions which have a similar structure, but differ
only in some minor detail. This is done as follows:
<P>
<OL>

<LI>
write one function which represents the common features of
        these functions
</LI>


<LI>
parameterize the difference in terms of functions which
        are passed as arguments to the common function.
</LI>


</OL>
<A NAME="2.2"><!-- Empty --></A>
<H3>2.2 Example 2 - foreach</H3>

<P>This example illustrates procedural abstraction. Initially, we
show the following two examples written as conventional
functions:
<P>
<OL>

<LI>
all elements of a list are printed onto a stream
</LI>


<LI>
a message is broadcast to a list of processes.
</LI>


</OL>

<PRE>
print_list(Stream, [H|T]) -&#62;
    io:format(Stream, &#34;~p~n&#34;, [H]),
    print_list(Stream, T);
print_list(Stream, []) -&#62;
    true.
    
</PRE>

<PRE>
broadcast(Msg, [Pid|Pids]) -&#62;
    Pid ! Msg,
    broadcast(Msg, Pids);
broadcast(_, []) -&#62;
    true.
    
</PRE>

<P>Both these functions have a very similar structure. They both
iterate over a list doing something to each element in the list.
The &#34;something&#34; has to be carried round as an extra argument to
the function which does this.
<P>The function <CODE>foreach</CODE> expresses this similarity:
<PRE>
foreach(F, [H|T]) -&#62;
    F(H),
    foreach(F, T);
foreach(F, []) -&#62;
    ok.

</PRE>

<P>Using <CODE>foreach</CODE>, <CODE>print_list</CODE> becomes:
<PRE>
foreach(fun(H) -&#62; io:format(S, &#34;~p~n&#34;,[H]) end, L)
    
</PRE>

<P><CODE>broadcast</CODE> becomes:
<PRE>
foreach(fun(Pid) -&#62; Pid ! M end, L)
    
</PRE>

<P><CODE>foreach</CODE> is evaluated for its side-effect and not its
value. <CODE>foreach(Fun ,L)</CODE> calls <CODE>Fun(X)</CODE> for each
element <CODE>X</CODE> in <CODE>L</CODE> and the processing occurs in
the order in which the elements were defined in <CODE>L</CODE>.
<CODE>map</CODE> does not define the order in which its elements are
processed.<A NAME="2.3"><!-- Empty --></A>
<H3>2.3 The Syntax of Funs</H3>

<P>Funs are written with the syntax:
<PRE>
F = fun (Arg1, Arg2, ... ArgN) -&#62;
        ...
    end
    
</PRE>

<P>This creates an anonymous function of <CODE>N</CODE> arguments and
binds it to the variable <CODE>F</CODE>.
<P>If we have already written a function in the same module and
wish to pass this function as an argument, we can use
the following syntax:
<PRE>
F = fun FunctionName/Arity
    
</PRE>

<P>With this form of function reference, the function which is
referred to does not need to be exported from the module.
<P>We can also refer to a function defined in a different module
with the following syntax:
<PRE>
F = {Module, FunctionName}
    
</PRE>

<P>In this case, the function must be exported from the module in
question.
<P>The follow program illustrates the different ways of creating
funs:
<PRE>
-module(fun_test).
-export([t1/0, t2/0, t3/0, t4/0, double/1]).
-import(lists, [map/2]).

t1() -&#62; map(fun(X) -&#62; 2 * X end, [1,2,3,4,5]).

t2() -&#62; map(fun double/1, [1,2,3,4,5]).

t3() -&#62; map({?MODULE, double}, [1,2,3,4,5]).

double(X) -&#62; X * 2.

</PRE>

<P>We can evaluate the fun <CODE>F</CODE> with the syntax:
<PRE>
F(Arg1, Arg2, ..., Argn)
    
</PRE>

<P>To check whether a term is a fun, use the test
<CODE>is_function/1</CODE> in a guard. Example:
<PRE>
f(F, Args) when is_function(F) -&#62;
   apply(F, Args);
f(N, _) when is_integer(N) -&#62;
   N.
    
</PRE>

<P>Funs are a distinct type. The BIFs erlang:fun_info/1,2 can
be used to retrieve information about a fun, and the BIF
erlang:fun_to_list/1 returns a textual representation of a fun.
The check_process_code/2 BIF returns true if the process
contains funs that depend on the old version of a module.
<P>
<TABLE CELLPADDING=4>
  <TR>
    <TD VALIGN=TOP><IMG ALT="Note!" SRC="note.gif"></TD>
    <TD>

<P>In OTP R5 and earlier releases, funs were represented using
        tuples.    </TD>
  </TR>
</TABLE>
<A NAME="2.4"><!-- Empty --></A>
<H3>2.4 Variable Bindings Within a Fun</H3>

<P>The scope rules for variables which occur in funs are as
follows:
<P>
<UL>

<LI>
All variables which occur in the head of a fun are assumed
        to be &#34;fresh&#34; variables.
</LI>


<LI>
Variables which are defined before the fun, and which
        occur in function calls or guard tests within the fun, have
        the values they had outside the fun.
</LI>


<LI>
No variables may be exported from a fun.
</LI>


</UL>

<P>The following examples illustrate these rules:

<PRE>
print_list(File, List) -&#62;
    {ok, Stream} = file:open(File, write),
    foreach(fun(X) -&#62; io:format(Stream,&#34;~p~n&#34;,[X]) end, List),
    file:close(Stream).
    
</PRE>

<P>In the above example, the variable <CODE>X</CODE> which is defined in
the head of the fun is a new variable. The value of the variable
<CODE>Stream</CODE> which is used within within the fun gets its value
from the <CODE>file:open</CODE> line.
<P>Since any variable which occurs in the head of a fun is
considered a new variable it would be equally valid to write:
<PRE>
print_list(File, List) -&#62;
    {ok, Stream} = file:open(File, write),
    foreach(fun(File) -&#62; 
                io:format(Stream,&#34;~p~n&#34;,[File]) 
            end, List),
    file:close(Stream).
    
</PRE>

<P>In this example, <CODE>File</CODE> is used as the new variable
instead of <CODE>X</CODE>. This is rather silly since code in the body
of the fun cannot refer to the variable <CODE>File</CODE> which is
defined outside the fun. Compiling this example will yield
the diagnostic:
<PRE>
./FileName.erl:Line: Warning: variable 'File' 
      shadowed in 'lambda head'
    
</PRE>

<P>This reminds us that the variable <CODE>File</CODE> which is defined
inside the fun collides with the variable <CODE>File</CODE> which is
defined outside the fun.
<P>The rules for importing variables into a fun has the consequence
that certain pattern matching operations have to be moved into
guard expressions and cannot be written in the head of the fun.
For example, we might write the following code if we intend
the first clause of <CODE>F</CODE> to be evaluated when the value of
its argument is <CODE>Y</CODE>:
<PRE>
f(...) -&#62;
    Y = ...
    map(fun(X) when X == Y -&#62;
             ;
           (_) -&#62;
             ...
        end, ...)
    ...
    
</PRE>

<P>instead of
<PRE>
f(...) -&#62;
    Y = ...
    map(fun(Y) -&#62;
             ;
           (_) -&#62;
             ...
        end, ...)
    ...
    
</PRE>
<A NAME="2.5"><!-- Empty --></A>
<H3>2.5 Funs and the Module Lists</H3>

<P>The following examples show a dialogue with the Erlang shell.
All the higher order functions discussed are exported from
the module <CODE>lists</CODE>.<A NAME="2.5.1"><!-- Empty --></A>
<H4>2.5.1 map</H4>

<PRE>
map(F, [H|T]) -&#62; [F(H)|map(F, T)];
map(F, [])    -&#62; [].

</PRE>

<P><CODE>map</CODE> takes a function of one argument and a list of
        terms. It returns the list obtained by applying the function
        to every argument in the list.
<PRE>
&#62; <STRONG>Double = fun(X) -&#62; 2 * X end.</STRONG>
#Fun&#60;erl_eval.6.72228031&#62;
&#62; <STRONG>lists:map(Double, [1,2,3,4,5]).</STRONG>
[2,4,6,8,10]
      
</PRE>

<P>When a new fun is defined in the shell, the value of the Fun
        is printed as <CODE>Fun#&#60;erl_eval&#62;</CODE>.<A NAME="2.5.2"><!-- Empty --></A>
<H4>2.5.2 any</H4>

<PRE>
any(Pred, [H|T]) -&#62;
    case Pred(H) of
        true  -&#62;  true;
        false -&#62;  any(Pred, T)
    end;
any(Pred, []) -&#62;
    false.

</PRE>

<P><CODE>any</CODE> takes a predicate <CODE>P</CODE> of one argument and a
        list of terms. A predicate is a function which returns
        <CODE>true</CODE> or <CODE>false</CODE>. <CODE>any</CODE> is true if there is a
        term <CODE>X</CODE> in the list such that <CODE>P(X)</CODE> is <CODE>true</CODE>.

<P>We define a predicate <CODE>Big(X)</CODE> which is <CODE>true</CODE> if
        its argument is greater that 10.
<PRE>
&#62; <STRONG>Big = fun(X) -&#62; if X &#62; 10 -&#62; true; true -&#62; false end end.</STRONG>
#Fun&#60;erl_eval.6.72228031&#62;
&#62; <STRONG>lists:any(Big, [1,2,3,4]).</STRONG>
false
&#62; <STRONG>lists:any(Big, [1,2,3,12,5]).</STRONG>
true
      
</PRE>
<A NAME="2.5.3"><!-- Empty --></A>
<H4>2.5.3 all</H4>

<PRE>
all(Pred, [H|T]) -&#62;
    case Pred(H) of
        true  -&#62;  all(Pred, T);
        false -&#62;  false
    end;
all(Pred, []) -&#62;
    true.

</PRE>

<P><CODE>all</CODE> has the same arguments as <CODE>any</CODE>. It is true
        if the predicate applied to all elements in the list is true.

<PRE>
&#62; <STRONG>lists:all(Big, [1,2,3,4,12,6]).</STRONG>   
false
&#62; <STRONG>lists:all(Big, [12,13,14,15]).</STRONG>       
true
      
</PRE>
<A NAME="2.5.4"><!-- Empty --></A>
<H4>2.5.4 foreach</H4>

<PRE>
foreach(F, [H|T]) -&#62;
    F(H),
    foreach(F, T);
foreach(F, []) -&#62;
    ok.

</PRE>

<P><CODE>foreach</CODE> takes a function of one argument and a list of
        terms. The function is applied to each argument in the list.
        <CODE>foreach</CODE> returns <CODE>ok</CODE>. It is used for its
        side-effect only.
<PRE>
&#62; <STRONG>lists:foreach(fun(X) -&#62; io:format(&#34;~w~n&#34;,[X]) end, [1,2,3,4]).</STRONG> 
1
2
3
4
ok
      
</PRE>
<A NAME="2.5.5"><!-- Empty --></A>
<H4>2.5.5 foldl</H4>

<PRE>
foldl(F, Accu, [Hd|Tail]) -&#62;
    foldl(F, F(Hd, Accu), Tail);
foldl(F, Accu, []) -&#62; Accu.

</PRE>

<P><CODE>foldl</CODE> takes a function of two arguments, an
        accumulator and a list. The function is called with two
        arguments. The first argument is the successive elements in
        the list, the second argument is the accumulator. The function
        must return a new accumulator which is used the next time
        the function is called.
<P>If we have a list of lists <CODE>L = [&#34;I&#34;,&#34;like&#34;,&#34;Erlang&#34;]</CODE>,
        then we can sum the lengths of all the strings in <CODE>L</CODE> as
        follows:
<PRE>
&#62; <STRONG>L = [&#34;I&#34;,&#34;like&#34;,&#34;Erlang&#34;].</STRONG>
[&#34;I&#34;,&#34;like&#34;,&#34;Erlang&#34;]
10&#62; <STRONG>lists:foldl(fun(X, Sum) -&#62; length(X) + Sum end, 0, L).</STRONG>                    
11
      
</PRE>

<P><CODE>foldl</CODE> works like a <CODE>while</CODE> loop in an imperative
        language:
<PRE>
L =  [&#34;I&#34;,&#34;like&#34;,&#34;Erlang&#34;],
Sum = 0,
while( L != []){
    Sum += length(head(L)),
    L = tail(L)
end
      
</PRE>
<A NAME="2.5.6"><!-- Empty --></A>
<H4>2.5.6 mapfoldl</H4>

<PRE>
mapfoldl(F, Accu0, [Hd|Tail]) -&#62;
    {R,Accu1} = F(Hd, Accu0),
    {Rs,Accu2} = mapfoldl(F, Accu1, Tail),
    {[R|Rs], Accu2};
mapfoldl(F, Accu, []) -&#62; {[], Accu}.

</PRE>

<P><CODE>mapfoldl</CODE> simultaneously maps and folds over a list.
        The following example shows how to change all letters in
        <CODE>L</CODE> to upper case and count them.
<P>First upcase:

<PRE>
&#62; <STRONG>Upcase = fun(X) when $a =&#60; X, X =&#60; $z -&#62; X + $A - $a;</STRONG>
                 <STRONG>(X) -&#62; X</STRONG> 
              <STRONG>end.</STRONG>
#Fun&#60;erl_eval.6.72228031&#62;
&#62; <STRONG>Upcase_word =</STRONG> 
      <STRONG>fun(X) -&#62;</STRONG> 
        <STRONG>lists:map(Upcase, X)</STRONG> 
      <STRONG>end.</STRONG>
#Fun&#60;erl_eval.6.72228031&#62;
&#62; <STRONG>Upcase_word(&#34;Erlang&#34;).</STRONG>
&#34;ERLANG&#34;
&#62; <STRONG>lists:map(Upcase_word, L).</STRONG>
[&#34;I&#34;,&#34;LIKE&#34;,&#34;ERLANG&#34;]
      
</PRE>

<P>Now we can do the fold and the map at the same time:
<PRE>
&#62; <STRONG>lists:mapfoldl(fun(Word, Sum) -&#62;</STRONG>
                    <STRONG>{Upcase_word(Word), Sum + length(Word)}</STRONG>
                 <STRONG>end, 0, L).</STRONG>
{[&#34;I&#34;,&#34;LIKE&#34;,&#34;ERLANG&#34;],11}
      
</PRE>
<A NAME="2.5.7"><!-- Empty --></A>
<H4>2.5.7 filter</H4>

<PRE>
filter(F, [H|T]) -&#62;
    case F(H) of
        true  -&#62; [H|filter(F, T)];
        false -&#62; filter(F, T)
    end;
filter(F, []) -&#62; [].

</PRE>

<P><CODE>filter</CODE> takes a predicate of one argument and a list
        and returns all element in the list which satisfy
        the predicate.
<PRE>
&#62; <STRONG>lists:filter(Big, [500,12,2,45,6,7]).</STRONG>
[500,12,45]
      
</PRE>

<P>When we combine maps and filters we can write very succinct
        code. For example, suppose we want to define a set difference
        function. We want to define <CODE>diff(L1, L2)</CODE> to be
        the difference between the lists <CODE>L1</CODE> and <CODE>L2</CODE>.
        This is the list of all elements in L1 which are not contained
        in L2. This code can be written as follows:
<PRE>
diff(L1, L2) -&#62; 
    filter(fun(X) -&#62; not member(X, L2) end, L1).
      
</PRE>

<P>The AND intersection of the list <CODE>L1</CODE> and <CODE>L2</CODE> is
        also easily defined:
<PRE>
intersection(L1,L2) -&#62; filter(fun(X) -&#62; member(X,L1) end, L2).
      
</PRE>
<A NAME="2.5.8"><!-- Empty --></A>
<H4>2.5.8 takewhile</H4>

<PRE>
takewhile(Pred, [H|T]) -&#62;
    case Pred(H) of
        true  -&#62; [H|takewhile(Pred, T)];
        false -&#62; []
    end;
takewhile(Pred, []) -&#62;
    [].

</PRE>

<P><CODE>takewhile(P, L)</CODE> takes elements <CODE>X</CODE> from a list
        <CODE>L</CODE> as long as the predicate <CODE>P(X)</CODE> is true.
<PRE>
&#62; <STRONG>lists:takewhile(Big, [200,500,45,5,3,45,6]).</STRONG>  
[200,500,45]
      
</PRE>
<A NAME="2.5.9"><!-- Empty --></A>
<H4>2.5.9 dropwhile</H4>

<PRE>
dropwhile(Pred, [H|T]) -&#62;
    case Pred(H) of
        true  -&#62; dropwhile(Pred, T);
        false -&#62; [H|T]
    end;
dropwhile(Pred, []) -&#62;
    [].

</PRE>

<P><CODE>dropwhile</CODE> is the complement of <CODE>takewhile</CODE>.

<PRE>
&#62; <STRONG>lists:dropwhile(Big, [200,500,45,5,3,45,6]).</STRONG>
[5,3,45,6]
      
</PRE>
<A NAME="2.5.10"><!-- Empty --></A>
<H4>2.5.10 splitwith</H4>

<PRE>
splitwith(Pred, L) -&#62;
    splitwith(Pred, L, []).

splitwith(Pred, [H|T], L) -&#62;
    case Pred(H) of 
        true  -&#62; splitwith(Pred, T, [H|L]);
        false -&#62; {reverse(L), [H|T]}
    end;
splitwith(Pred, [], L) -&#62;
    {reverse(L), []}.

</PRE>

<P><CODE>splitwith(P, L)</CODE> splits the list <CODE>L</CODE> into the two
        sub-lists <CODE>{L1, L2}</CODE>, where <CODE>L = takewhile(P, L)</CODE>
        and <CODE>L2 = dropwhile(P, L)</CODE>.
<PRE>
&#62; <STRONG>lists:splitwith(Big, [200,500,45,5,3,45,6]).</STRONG>
{[200,500,45],[5,3,45,6]}
      
</PRE>
<A NAME="2.6"><!-- Empty --></A>
<H3>2.6 Funs Which Return Funs</H3>

<P>So far, this section has only described functions which take
funs as arguments. It is also possible to write more powerful
functions which themselves return funs. The following examples
illustrate these type of functions.<A NAME="2.6.1"><!-- Empty --></A>
<H4>2.6.1 Simple Higher Order Functions</H4>

<P><CODE>Adder(X)</CODE> is a function which, given <CODE>X</CODE>, returns
        a new function <CODE>G</CODE> such that <CODE>G(K)</CODE> returns
        <CODE>K + X</CODE>.
<PRE>
&#62; <STRONG>Adder = fun(X) -&#62; fun(Y) -&#62; X + Y end end.</STRONG>
#Fun&#60;erl_eval.6.72228031&#62;
&#62; <STRONG>Add6 = Adder(6).</STRONG>
#Fun&#60;erl_eval.6.72228031&#62;
&#62; <STRONG>Add6(10).</STRONG>
16
      
</PRE>
<A NAME="2.6.2"><!-- Empty --></A>
<H4>2.6.2 Infinite Lists</H4>

<P>The idea is to write something like:
<PRE>
-module(lazy).
-export([ints_from/1]).
ints_from(N) -&#62;
    fun() -&#62;
            [N|ints_from(N+1)]
    end.
      
</PRE>

<P>Then we can proceed as follows:
<PRE>
&#62; <STRONG>XX = lazy:ints_from(1).</STRONG>
#Fun&#60;lazy.0.29874839&#62;
&#62; <STRONG>XX().</STRONG>
[1|#Fun&#60;lazy.0.29874839&#62;]
&#62; <STRONG>hd(XX()).</STRONG>
1
&#62; <STRONG>Y = tl(XX()).</STRONG>
#Fun&#60;lazy.0.29874839&#62;
&#62; <STRONG>hd(Y()).</STRONG>
2
      
</PRE>

<P>etc. - this is an example of &#34;lazy embedding&#34;.<A NAME="2.6.3"><!-- Empty --></A>
<H4>2.6.3 Parsing</H4>

<P>The following examples show parsers of the following type:
<PRE>
Parser(Toks) -&#62; {ok, Tree, Toks1} | fail
      
</PRE>

<P><CODE>Toks</CODE> is the list of tokens to be parsed. A successful
        parse returns <CODE>{ok, Tree, Toks1}</CODE>, where <CODE>Tree</CODE> is a
        parse tree and <CODE>Toks1</CODE> is a tail of <CODE>Tree</CODE> which
        contains symbols encountered after the structure which was
        correctly parsed. Otherwise <CODE>fail</CODE> is returned.
<P>The example which follows illustrates a simple, functional
        parser which parses the grammar:
<PRE>
(a | b) &#38; (c | d)
      
</PRE>

<P>The following code defines a function <CODE>pconst(X)</CODE> in
        the module <CODE>funparse</CODE>, which returns a fun which parses a
        list of tokens.
<PRE>
pconst(X) -&#62;
    fun (T) -&#62;
       case T of
           [X|T1] -&#62; {ok, {const, X}, T1};
           _      -&#62; fail
       end
    end.

</PRE>

<P>This function can be used as follows:
<PRE>
&#62; <STRONG>P1 = funparse:pconst(a).</STRONG>
#Fun&#60;funparse.0.22674075&#62;
&#62; <STRONG>P1([a,b,c]).</STRONG>
{ok,{const,a},[b,c]}
&#62; <STRONG>P1([x,y,z]).</STRONG>     
fail
      
</PRE>

<P>Next, we define the two higher order functions <CODE>pand</CODE>
        and <CODE>por</CODE> which combine primitive parsers to produce more
        complex parsers. Firstly <CODE>pand</CODE>:
<PRE>
pand(P1, P2) -&#62;
    fun (T) -&#62;
        case P1(T) of
            {ok, R1, T1} -&#62;
                case P2(T1) of
                    {ok, R2, T2} -&#62;
                        {ok, {'and', R1, R2}};
                    fail -&#62;
                        fail
                end;
            fail -&#62;
                fail
        end
    end.

</PRE>

<P>Given a parser <CODE>P1</CODE> for grammar <CODE>G1</CODE>, and a parser
        <CODE>P2</CODE> for grammar <CODE>G2</CODE>, <CODE>pand(P1, P2)</CODE> returns a
        parser for the grammar which consists of sequences of tokens
        which satisfy <CODE>G1</CODE> followed by sequences of tokens which
        satisfy <CODE>G2</CODE>.
<P><CODE>por(P1, P2)</CODE> returns a parser for the language
        described by the grammar <CODE>G1</CODE> or <CODE>G2</CODE>.
<PRE>
por(P1, P2) -&#62;
    fun (T) -&#62;
        case P1(T) of
            {ok, R, T1} -&#62; 
                {ok, {'or',1,R}, T1};
            fail -&#62; 
                case P2(T) of
                    {ok, R1, T1} -&#62;
                        {ok, {'or',2,R1}, T1};
                    fail -&#62;
                        fail
                end
        end
    end.

</PRE>

<P>The original problem was to parse the grammar
        <CODE>(a | b) &#38; (c | d)</CODE>. The following code addresses this
        problem:
<PRE>
grammar() -&#62;
    pand(
         por(pconst(a), pconst(b)),
         por(pconst(c), pconst(d))).

</PRE>

<P>The following code adds a parser interface to the grammar:
<PRE>
parse(List) -&#62;
    (grammar())(List).

</PRE>

<P>We can test this parser as follows:
<PRE>
&#62; <STRONG>funparse:parse([a,c]).</STRONG>
{ok,{'and',{'or',1,{const,a}},{'or',1,{const,c}}}}
&#62; <STRONG>funparse:parse([a,d]).</STRONG> 
{ok,{'and',{'or',1,{const,a}},{'or',2,{const,d}}}}
&#62; <STRONG>funparse:parse([b,c]).</STRONG>   
{ok,{'and',{'or',2,{const,b}},{'or',1,{const,c}}}}
&#62; <STRONG>funparse:parse([b,d]).</STRONG> 
{ok,{'and',{'or',2,{const,b}},{'or',2,{const,d}}}}
&#62; <STRONG>funparse:parse([a,b]).</STRONG>   
fail
      
</PRE>
<CENTER>
<HR>
<SMALL>
Copyright &copy; 1991-2006
<A HREF="http://www.erlang.se">Ericsson AB</A><BR>
</SMALL>
</CENTER>
</BODY>
</HTML>