The R13B03 release.OTP_R13B03

1 files changed, 1231 insertions, 0 deletions

diff --git a/system/doc/getting_started/seq_prog.xml b/system/doc/getting_started/seq_prog.xml
new file mode 100644
index 0000000000..bc1758d855
--- /dev/null
+++ b/system/doc/getting_started/seq_prog.xml
@@ -0,0 +1,1231 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE chapter SYSTEM "chapter.dtd">
+
+<chapter>
+  <header>
+    <copyright>
+      <year>2003</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      The contents of this file are subject to the Erlang Public License,
+      Version 1.1, (the "License"); you may not use this file except in
+      compliance with the License. You should have received a copy of the
+      Erlang Public License along with this software. If not, it can be
+      retrieved online at http://www.erlang.org/.
+    
+      Software distributed under the License is distributed on an "AS IS"
+      basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+      the License for the specific language governing rights and limitations
+      under the License.
+    
+    </legalnotice>
+
+    <title>Sequential Programming</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+    <file>seq_prog.xml</file>
+  </header>
+
+  <section>
+    <title>The Erlang Shell</title>
+    <p>Most operating systems have a command interpreter or shell, Unix
+      and Linux have many, Windows has the Command Prompt. Erlang has
+      its own shell where you can directly write bits of Erlang code
+      and evaluate (run) them to see what happens (see
+      <seealso marker="stdlib:shell">shell(3)</seealso>). Start
+      the Erlang shell (in Linux or UNIX) by starting a shell or
+      command interpreter in your operating system and typing
+      <c>erl</c>, you will see something like this.</p>
+    <pre>
+% <input>erl</input>
+Erlang (BEAM) emulator version 5.2 [source] [hipe]
+
+Eshell V5.2  (abort with ^G)
+1></pre>
+    <p>Now type in "2 + 5." as shown below.</p>
+    <pre>
+1> <input>2 + 5.</input>
+7
+2></pre>
+    <p>In Windows, the shell is started by double-clicking on the Erlang
+      shell icon.</p>
+    <p>You'll notice that the Erlang shell has numbered the lines that
+      can be entered, (as 1&gt; 2&gt;) and that it has correctly told you
+      that 2 + 5 is 7! Also notice that you have to tell it you are
+      done entering code by finishing with a full stop "." and a
+      carriage return. If you make mistakes writing things in the shell,
+      you can delete things by using the backspace key as in most
+      shells. There are many more editing commands in the shell
+      (See the chapter <seealso marker="erts:tty">"tty - A command line interface"</seealso> in ERTS User's Guide).</p>
+    <p>(Note: you will find a lot of line numbers given by the shell
+      out of sequence in this tutorial as it was written and the code
+      tested in several sessions).</p>
+    <p>Now let's try a more complex calculation.</p>
+    <pre>
+2> <input>(42 + 77) * 66 / 3.</input>
+2618.0</pre>
+    <p>Here you can see the use of brackets and the multiplication
+      operator "*" and division operator "/", just as in normal
+      arithmetic (see the chapter
+      <seealso marker="doc/reference_manual:expressions">"Arithmetic Expressions"</seealso> in the Erlang Reference Manual).</p>
+    <p>To shutdown the Erlang system and the Erlang shell type
+      Control-C. You will see the following output:</p>
+    <pre>
+BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded
+       (v)ersion (k)ill (D)b-tables (d)istribution
+<input>a</input>
+%</pre>
+    <p>Type "a" to leave the Erlang system.</p>
+    <p>Another way to shutdown the Erlang system is by entering
+      <c>halt()</c>:</p>
+    <pre>
+3> <input>halt().</input>
+% </pre>
+  </section>
+
+  <section>
+    <title>Modules and Functions</title>
+    <p>A programming language isn't much use if you can just run code
+      from the shell. So here is a small Erlang program. Enter it into
+      a file called <c>tut.erl</c> (the file name <c>tut.erl</c> is
+      important, also make sure that it is in the same directory as
+      the one where you started <c>erl</c>) using a suitable
+      text editor. If you are lucky your editor will have an Erlang
+      mode which will make it easier for you to enter and format your
+      code nicely (see the chapter
+      <seealso marker="tools:erlang_mode_chapter">"The Erlang mode for Emacs"</seealso> in Tools User's Guide), but you can manage
+      perfectly well without. Here's the code to enter:</p>
+    <code type="none">
+-module(tut).
+-export([double/1]).
+
+double(X) ->
+    2 * X.</code>
+    <p>It's not hard to guess that this "program" doubles the value of
+      numbers. I'll get back to the first two lines later. Let's compile
+      the program. This can be done in your Erlang shell as shown below:</p>
+    <pre>
+3> <input>c(tut).</input>
+{ok,tut}</pre>
+    <p>The <c>{ok,tut}</c> tells you that the compilation was OK. If it
+      said "error" instead, you have made some mistake in the text you
+      entered and there will also be error messages to give you some
+      idea as to what has gone wrong so you can change what you have
+      written and try again.</p>
+    <p>Now lets run the program.</p>
+    <pre>
+4> <input>tut:double(10).</input>
+20</pre>
+    <p>As expected double of 10 is 20.</p>
+    <p>Now let's get back to the first two lines. Erlang programs are
+      written in files. Each file contains what we call an Erlang
+      <em>module</em>. The first line of code in the module tells us
+      the name of the module (see the chapter
+      <seealso marker="doc/reference_manual:modules">"Modules"</seealso>
+      in the Erlang Reference Manual).</p>
+    <code type="none">
+-module(tut).</code>
+    <p>This tells us that the module is called <em>tut</em>. Note
+      the "." at the end of the line. The files which are used to store
+      the module must have the same name as the module but with
+      the extension ".erl". In our case the file name is <c>tut.erl</c>.
+      When we use a function in another module, we use the syntax,
+      <c>module_name:function_name(arguments)</c>. So</p>
+    <pre>
+4> <input>tut:double(10).</input></pre>
+    <p>means call function <c>double</c> in module <c>tut</c> with
+      argument "10".</p>
+    <p>The second line:</p>
+    <code type="none">
+-export([double/1]).</code>
+    <p>says that the module <c>tut</c> contains a function called
+      <c>double</c> which takes one argument (<c>X</c> in our example)
+      and that this function can be called from outside the module
+      <c>tut</c>. More about this later. Again note the "." at the end
+      of the line.</p>
+    <p>Now for a more complicated example, the factorial of a number
+      (e.g. factorial of 4 is 4 * 3 * 2 * 1). Enter the following code
+      in a file called <c>tut1.erl</c>.</p>
+    <code type="none">
+-module(tut1).
+-export([fac/1]).
+
+fac(1) ->
+    1;
+fac(N) ->
+    N * fac(N - 1).</code>
+    <p>Compile the file</p>
+    <pre>
+5> <input>c(tut1).</input>
+{ok,tut1}</pre>
+    <p>And now calculate the factorial of 4.</p>
+    <pre>
+6> <input>tut1:fac(4).</input>
+24</pre>
+    <p>The first part:</p>
+    <code type="none">
+fac(1) ->
+    1;</code>
+    <p>says that the factorial of 1 is 1. Note that we end this part
+      with a ";" which indicates that there is more of this function to
+      come. The second part:</p>
+    <code type="none">
+fac(N) ->
+    N * fac(N - 1).</code>
+    <p>says that the factorial of N is N multiplied by the factorial of
+      N - 1. Note that this part ends with a "." saying that there are
+      no more parts of this function.</p>
+    <p>A function can have many arguments. Let's expand the module
+      <c>tut1</c> with the rather stupid function to multiply two
+      numbers:</p>
+    <code type="none">
+-module(tut1).
+-export([fac/1, mult/2]).
+
+fac(1) ->
+    1;
+fac(N) ->
+    N * fac(N - 1).
+
+mult(X, Y) ->
+    X * Y.</code>
+    <p>Note that we have also had to expand the <c>-export</c> line
+      with the information that there is another function <c>mult</c>
+      with two arguments.</p>
+    <p>Compile:</p>
+    <pre>
+7> <input>c(tut1).</input>
+{ok,tut1}</pre>
+    <p>and try it out:</p>
+    <pre>
+8> <input>tut1:mult(3,4).</input>
+12</pre>
+    <p>In the example above the numbers are integers and the arguments
+      in the functions in the code, <c>N</c>, <c>X</c>, <c>Y</c> are
+      called variables. Variables must start with a capital letter
+      (see the chapter
+      <seealso marker="doc/reference_manual:expressions">"Variables"</seealso>
+      in the Erlang Reference Manual). Examples of variable could be
+      <c>Number</c>, <c>ShoeSize</c>, <c>Age</c> etc.</p>
+  </section>
+
+  <section>
+    <title>Atoms</title>
+    <p>Atoms are another data type in Erlang. Atoms start with a small
+      letter ((see the chapter
+      <seealso marker="doc/reference_manual:data_types">"Atom"</seealso>
+      in the Erlang Reference Manual)), for example: <c>charles</c>,
+      <c>centimeter</c>, <c>inch</c>. Atoms are simply names, nothing
+      else. They are not like variables which can have a value.</p>
+    <p>Enter the next program (file: <c>tut2.erl</c>) which could be
+      useful for converting from inches to centimeters and vice versa:</p>
+    <code type="none">
+-module(tut2).
+-export([convert/2]).
+
+convert(M, inch) ->
+    M / 2.54;
+
+convert(N, centimeter) ->
+    N * 2.54.</code>
+    <p>Compile and test:</p>
+    <pre>
+9> <input>c(tut2).</input>
+{ok,tut2}
+10> <input>tut2:convert(3, inch).</input>
+1.1811023622047243
+11> <input>tut2:convert(7, centimeter).</input>
+17.78</pre>
+    <p>Notice that I have introduced decimals (floating point numbers)
+      without any explanation, but I guess you can cope with that.</p>
+    <p>See what happens if I enter something other than centimeter or
+      inch in the convert function:</p>
+    <pre>
+12> <input>tut2:convert(3, miles).</input>
+** exception error: no function clause matching tut2:convert(3,miles)</pre>
+    <p>The two parts of the <c>convert</c> function are called its
+      clauses. Here we see that "miles" is not part of either of
+      the clauses. The Erlang system can't <em>match</em> either of
+      the clauses so we get an error message <c>function_clause</c>.
+      The shell formats the error message nicely, but the error tuple 
+      is saved in the shell's history list and can be output by the shell 
+      command <c>v/1</c>:</p>
+    <pre>
+13> <input>v(12).</input>
+{'EXIT',{function_clause,[{tut2,convert,[3,miles]},
+                          {erl_eval,do_apply,5},
+                          {shell,exprs,6},
+                          {shell,eval_exprs,6},
+                          {shell,eval_loop,3}]}}</pre>
+
+  </section>
+
+  <section>
+    <title>Tuples</title>
+    <p>Now the <c>tut2</c> program is hardly good programming style.
+      Consider:</p>
+    <code type="none">
+tut2:convert(3, inch).</code>
+    <p>Does this mean that 3 is in inches? or that 3 is in centimeters
+      and we want to convert it to inches? So Erlang has a way to group
+      things together to make things more understandable. We call these
+      <em>tuples</em>. Tuples are surrounded by "{" and "}".</p>
+    <p>So we can write <c>{inch,3}</c> to denote 3 inches and
+      <c>{centimeter,5}</c> to denote 5 centimeters. Now let's write a
+      new program which converts centimeters to inches and vice versa.
+      (file <c>tut3.erl</c>).</p>
+    <code type="none">
+-module(tut3).
+-export([convert_length/1]).
+
+convert_length({centimeter, X}) ->
+    {inch, X / 2.54};
+convert_length({inch, Y}) ->
+    {centimeter, Y * 2.54}.</code>
+    <p>Compile and test:</p>
+    <pre>
+14> <input>c(tut3).</input>
+{ok,tut3}
+15> <input>tut3:convert_length({inch, 5}).</input>
+{centimeter,12.7}
+16> <input>tut3:convert_length(tut3:convert_length({inch, 5})).</input>
+{inch,5.0}</pre>
+    <p>Note on line 16 we convert 5 inches to centimeters and back
+      again and reassuringly get back to the original value. I.e
+      the argument to a function can be the result of another function.
+      Pause for a moment and consider how line 16 (above) works.
+      The argument we have given the function <c>{inch,5}</c> is first
+      matched against the first head clause of <c>convert_length</c>
+      i.e. <c>convert_length({centimeter,X})</c> where it can be seen
+      that <c>{centimeter,X}</c> does not match <c>{inch,5}</c>
+      (the head is the bit before the "-&gt;"). This having failed, we try
+      the head of the next clause i.e. <c>convert_length({inch,Y})</c>,
+      this matches and <c>Y</c> get the value 5.</p>
+    <p>We have shown tuples with two parts above, but tuples can have
+      as many parts as we want and contain any valid Erlang
+      <em>term</em>. For example, to represent the temperature of
+      various cities of the world we could write</p>
+    <code type="none">
+{moscow, {c, -10}}
+{cape_town, {f, 70}}
+{paris, {f, 28}}</code>
+    <p>Tuples have a fixed number of things in them. We call each thing
+      in a tuple an element. So in the tuple <c>{moscow,{c,-10}}</c>,
+      element 1 is <c>moscow</c> and element 2 is <c>{c,-10}</c>. I
+      have chosen <c>c</c> meaning Centigrade (or Celsius) and <c>f</c>
+      meaning Fahrenheit.</p>
+  </section>
+
+  <section>
+    <title>Lists</title>
+    <p>Whereas tuples group things together, we also want to be able to
+      represent lists of things. Lists in Erlang are surrounded by "["
+      and "]". For example a list of the temperatures of various cities
+      in the world could be:</p>
+    <code type="none">
+[{moscow, {c, -10}}, {cape_town, {f, 70}}, {stockholm, {c, -4}},
+ {paris, {f, 28}}, {london, {f, 36}}]</code>
+    <p>Note that this list was so long that it didn't fit on one line.
+      This doesn't matter, Erlang allows line breaks at all "sensible
+      places" but not, for example, in the middle of atoms, integers
+      etc.</p>
+    <p>A very useful way of looking at parts of lists, is by using "|".
+      This is best explained by an example using the shell.</p>
+    <pre>
+17> <input>[First |TheRest] = [1,2,3,4,5].</input>
+[1,2,3,4,5]
+18> <input>First.</input>
+1
+19> <input>TheRest.</input>
+[2,3,4,5]</pre>
+    <p>We use | to separate the first elements of the list from
+      the rest of the list. (<c>First</c> has got value 1 and
+      <c>TheRest</c> value [2,3,4,5]).</p>
+    <p>Another example:</p>
+    <pre>
+20> <input>[E1, E2 | R] = [1,2,3,4,5,6,7].</input>
+[1,2,3,4,5,6,7]
+21> <input>E1.</input>
+1
+22> <input>E2.</input>
+2
+23> <input>R.</input>
+[3,4,5,6,7]</pre>
+    <p>Here we see the use of | to get the first two elements from
+      the list. Of course if we try to get more elements from the list
+      than there are elements in the list we will get an error. Note
+      also the special case of the list with no elements [].</p>
+    <pre>
+24> <input>[A, B | C] = [1, 2].</input>
+[1,2]
+25> <input>A.</input>
+1
+26> <input>B.</input>
+2
+27> <input>C.</input>
+[]</pre>
+    <p>In all the examples above, I have been using new variable names,
+      not reusing the old ones: <c>First</c>, <c>TheRest</c>, <c>E1</c>,
+      <c>E2</c>, <c>R</c>, <c>A</c>, <c>B</c>, <c>C</c>. The reason
+      for this is that a variable can only be given a value once in its
+      context (scope). I'll get back to this later, it isn't so
+      peculiar as it sounds!</p>
+    <p>The following example shows how we find the length of a list:</p>
+    <code type="none">
+-module(tut4).
+
+-export([list_length/1]).
+
+list_length([]) ->
+    0;    
+list_length([First | Rest]) ->
+    1 + list_length(Rest).</code>
+    <p>Compile (file <c>tut4.erl</c>) and test:</p>
+    <pre>
+28> <input>c(tut4).</input>
+{ok,tut4}
+29> <input>tut4:list_length([1,2,3,4,5,6,7]).</input>
+7</pre>
+    <p>Explanation:</p>
+    <code type="none">
+list_length([]) ->
+    0;</code>
+    <p>The length of an empty list is obviously 0.</p>
+    <code type="none">
+list_length([First | Rest]) ->
+    1 + list_length(Rest).</code>
+    <p>The length of a list with the first element <c>First</c> and
+      the remaining elements <c>Rest</c> is 1 + the length of
+      <c>Rest</c>.</p>
+    <p>(Advanced readers only: This is not tail recursive, there is a
+      better way to write this function).</p>
+    <p>In general we can say we use tuples where we would use "records"
+      or "structs" in other languages and we use lists when we want to
+      represent things which have varying sizes, (i.e. where we would
+      use linked lists in other languages).</p>
+    <p>Erlang does not have a string date type, instead strings can be
+      represented by lists of ASCII characters. So the list
+      <c>[97,98,99]</c> is equivalent to "abc". The Erlang shell is
+      "clever" and guesses the what sort of list we mean and outputs it
+      in what it thinks is the most appropriate form, for example:</p>
+    <pre>
+30> <input>[97,98,99].</input>
+"abc"</pre>
+  </section>
+
+  <section>
+    <title>Standard Modules and Manual Pages</title>
+    <p>Erlang has a lot of standard modules to help you do things. For
+      example, the module <c>io</c> contains a lot of functions to help
+      you do formatted input/output. To look up information about
+      standard modules, the command <c>erl -man</c> can be used at
+      the operating shell or command prompt (i.e. at the same place as
+      that where you started <c>erl</c>). Try the operating system
+      shell command:</p>
+    <pre>
+% <input>erl -man io</input>
+ERLANG MODULE DEFINITION                                    io(3)
+
+MODULE
+     io - Standard I/O Server Interface Functions
+
+DESCRIPTION
+     This module provides an  interface  to  standard  Erlang  IO
+     servers. The output functions all return ok if they are suc-
+     ...</pre>
+    <p>If this doesn't work on your system, the documentation is
+      included as HTML in the Erlang/OTP release, or you can read
+      the documentation as HTML or download it as PDF from either of
+      the sites www.erlang.se (commercial Erlang) or www.erlang.org
+      (open source), for example for release R9B:</p>
+    <code type="none">
+http://www.erlang.org/doc/r9b/doc/index.html</code>
+  </section>
+
+  <section>
+    <title>Writing Output to a Terminal</title>
+    <p>It's nice to be able to do formatted output in these example, so
+      the next example shows a simple way to use to use
+      the <c>io:format</c> function. Of course, just like all other
+      exported functions, you can test the <c>io:format</c> function in
+      the shell:</p>
+    <pre>
+31> <input>io:format("hello world~n", []).</input>
+hello world
+ok
+32> <input>io:format("this outputs one Erlang term: ~w~n", [hello]).</input>
+this outputs one Erlang term: hello
+ok
+33> <input>io:format("this outputs two Erlang terms: ~w~w~n", [hello, world]).</input>
+this outputs two Erlang terms: helloworld
+ok
+34> <input>io:format("this outputs two Erlang terms: ~w ~w~n", [hello, world]).</input>
+this outputs two Erlang terms: hello world
+ok</pre>
+    <p>The function <c>format/2</c> (i.e. <c>format</c> with two
+      arguments) takes two lists. The first one is nearly always a list
+      written between " ". This list is printed out as it stands,
+      except that each ~w is replaced by a term taken in order from
+      the second list. Each ~n is replaced by a new line.
+      The <c>io:format/2</c> function itself returns the atom <c>ok</c>
+      if everything goes as planned. Like other functions in Erlang, it
+      crashes if an error occurs. This is not a fault in Erlang, it is
+      a deliberate policy. Erlang has sophisticated mechanisms to
+      handle errors which we will show later. As an exercise, try to
+      make <c>io:format</c> crash, it shouldn't be difficult. But
+      notice that although <c>io:format</c> crashes, the Erlang shell
+      itself does not crash.</p>
+  </section>
+
+  <section>
+    <title>A Larger Example</title>
+    <p>Now for a larger example to consolidate what we have learnt so
+      far. Assume we have a list of temperature readings from a number
+      of cities in the world. Some of them are in Celsius (Centigrade)
+      and some in Fahrenheit (as in the previous list). First let's
+      convert them all to Celsius, then let's print out the data neatly.</p>
+    <code type="none">
+%% This module is in file tut5.erl
+
+-module(tut5).
+-export([format_temps/1]).
+
+%% Only this function is exported
+format_temps([])->                        % No output for an empty list
+    ok;
+format_temps([City | Rest]) ->
+    print_temp(convert_to_celsius(City)),
+    format_temps(Rest).
+
+convert_to_celsius({Name, {c, Temp}}) ->  % No conversion needed
+    {Name, {c, Temp}};
+convert_to_celsius({Name, {f, Temp}}) ->  % Do the conversion
+    {Name, {c, (Temp - 32) * 5 / 9}}.
+
+print_temp({Name, {c, Temp}}) ->
+    io:format("~-15w ~w c~n", [Name, Temp]).</code>
+    <pre>
+35> <input>c(tut5).</input>
+{ok,tut5}
+36> <input>tut5:format_temps([{moscow, {c, -10}}, {cape_town, {f, 70}},</input>
+<input>{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).</input>
+moscow          -10 c
+cape_town       21.11111111111111 c
+stockholm       -4 c
+paris           -2.2222222222222223 c
+london          2.2222222222222223 c
+ok</pre>
+    <p>Before we look at how this program works, notice that we have
+      added a few comments to the code. A comment starts with a %
+      character and goes on to the end of the line. Note as well that
+      the <c>-export([format_temps/1]).</c> line only includes
+      the function <c>format_temps/1</c>, the other functions are
+      <em>local</em> functions, i.e. they are not visible from outside
+      the module <c>tut5</c>.</p>
+    <p>Note as well that when testing the program from the shell, I had
+      to spread the input over two lines as the line was too long.</p>
+    <p>When we call <c>format_temps</c> the first time, <c>City</c>
+      gets the value <c>{moscow,{c,-10}}</c> and <c>Rest</c> is
+      the rest of the list. So we call the function
+      <c>print_temp(convert_to_celsius({moscow,{c,-10}}))</c>.</p>
+    <p>Here we see a function call as
+      <c>convert_to_celsius({moscow,{c,-10}})</c> as the argument to
+      the function <c>print_temp</c>. When we <em>nest</em> function
+      calls like this we execute (evaluate) them from the inside out.
+      I.e. we first evaluate <c>convert_to_celsius({moscow,{c,-10}})</c>
+      which gives the value <c>{moscow,{c,-10}}</c> as the temperature
+      is already in Celsius and then we evaluate
+      <c>print_temp({moscow,{c,-10}})</c>. The function
+      <c>convert_to_celsius</c> works in a similar way to
+      the <c>convert_length</c> function in the previous example.</p>
+    <p><c>print_temp</c> simply calls <c>io:format</c> in a similar way
+      to what has been described above. Note that ~-15w says to print
+      the "term" with a field length (width) of 15 and left justify it.
+      (<seealso marker="stdlib:io#fwrite/1">io(3)</seealso>).</p>
+    <p>Now we call <c>format_temps(Rest)</c> with the rest of the list
+      as an argument. This way of doing things is similar to the loop
+      constructs in other languages. (Yes, this is recursion, but don't
+      let that worry you). So the same <c>format_temps</c> function is
+      called again, this time <c>City</c> gets the value
+      <c>{cape_town,{f,70}}</c> and we repeat the same procedure as
+      before. We go on doing this until the list becomes empty, i.e. [],
+      which causes the first clause <c>format_temps([])</c> to match.
+      This simply returns (results in) the atom <c>ok</c>, so
+      the program ends.</p>
+  </section>
+
+  <section>
+    <title>Matching, Guards and Scope of Variables</title>
+    <p>It could be useful to find the maximum and minimum temperature
+      in lists like this. Before extending the program to do this,
+      let's look at functions for finding the maximum value of
+      the elements in a list:</p>
+    <code type="none">
+-module(tut6).
+-export([list_max/1]).
+
+list_max([Head|Rest]) ->
+   list_max(Rest, Head).
+
+list_max([], Res) ->
+    Res;
+list_max([Head|Rest], Result_so_far) when Head > Result_so_far ->
+    list_max(Rest, Head);
+list_max([Head|Rest], Result_so_far)  ->
+    list_max(Rest, Result_so_far).</code>
+    <pre>
+37> <input>c(tut6).</input>
+{ok,tut6}
+38> <input>tut6:list_max([1,2,3,4,5,7,4,3,2,1]).</input>
+7</pre>
+    <p>First note that we have two functions here with the same name
+      <c>list_max</c>. However each of these takes a different number
+      of arguments (parameters). In Erlang these are regarded as
+      completely different functions. Where we need to distinguish
+      between these functions we write <c>name/arity</c>, where
+      <c>name</c> is the name of the function and <c>arity</c> is
+      the number of arguments, in this case <c>list_max/1</c> and
+      <c>list_max/2</c>.</p>
+    <p>This is an example where we walk through a list "carrying" a
+      value with us, in this case <c>Result_so_far</c>.
+      <c>list_max/1</c> simply assumes that the max value of the list
+      is the head of the list and calls <c>list_max/2</c> with the rest
+      of the list and the value of the head of the list, in the above
+      this would be <c>list_max([2,3,4,5,7,4,3,2,1],1)</c>. If we tried
+      to use <c>list_max/1</c> with an empty list or tried to use it
+      with something which isn't a list at all, we would cause an error.
+      Note that the Erlang philosophy is not to handle errors of this
+      type in the function they occur, but to do so elsewhere. More
+      about this later.</p>
+    <p>In <c>list_max/2</c> we walk down the list and use <c>Head</c>
+      instead of <c>Result_so_far</c> when <c>Head</c> &gt;
+      <c>Result_so_far</c>. <c>when</c> is a special word we use before
+      the -&gt; in the function to say that we should only use this part
+      of the function if the test which follows is true. We call tests
+      of this type a <em>guard</em>. If the guard isn't true (we say
+      the guard fails), we try the next part of the function. In this
+      case if <c>Head</c> isn't greater than <c>Result_so_far</c> then
+      it must be smaller or equal to is, so we don't need a guard on
+      the next part of the function.</p>
+    <p>Some useful operators in guards are, &lt; less than, &gt;
+      greater than, == equal, &gt;= greater or equal, =&lt; less or
+      equal, /= not equal. (see the chapter
+      <seealso marker="doc/reference_manual:expressions">"Guard Sequences"</seealso> in the Erlang Reference Manual).</p>
+    <p>To change the above program to one which works out the minimum
+      value of the element in a list, all we would need to do is to
+      write &lt; instead of &gt;. (But it would be wise to change
+      the name of the function to <c>list_min</c> :-).</p>
+    <p>Remember that I mentioned earlier that a variable could only be
+      given a value once in its scope? In the above we see, for example,
+      that <c>Result_so_far</c> has been given several values. This is
+      OK since every time we call <c>list_max/2</c> we create a new
+      scope and one can regard the <c>Result_so_far</c> as a completely
+      different variable in each scope.</p>
+    <p>Another way of creating and giving a variable a value is by using
+      the match operator = . So if I write <c>M = 5</c>, a variable
+      called <c>M</c> will be created and given the value 5. If, in
+      the same scope I then write <c>M = 6</c>, I'll get an error. Try
+      this out in the shell:</p>
+    <pre>
+39> <input>M = 5.</input>
+5
+40> <input>M = 6.</input>
+** exception error: no match of right hand side value 6
+41> <input>M = M + 1.</input>
+** exception error: no match of right hand side value 6
+42> <input>N = M + 1.</input>
+6</pre>
+    <p>The use of the match operator is particularly useful for pulling
+      apart Erlang terms and creating new ones.</p>
+    <pre>
+43> <input>{X, Y} = {paris, {f, 28}}.</input>
+{paris,{f,28}}
+44> <input>X.</input>
+paris
+45> <input>Y.</input>
+{f,28}</pre>
+    <p>Here we see that <c>X</c> gets the value <c>paris</c> and
+      <c>Y</c><c>{f,28}</c>.</p>
+    <p>Of course if we try to do the same again with another city, we
+      get an error:</p>
+    <pre>
+46> <input>{X, Y} = {london, {f, 36}}.</input>
+** exception error: no match of right hand side value {london,{f,36}}</pre>
+    <p>Variables can also be used to improve the readability of
+      programs, for example, in the <c>list_max/2</c> function above,
+      we could write:</p>
+    <code type="none">
+list_max([Head|Rest], Result_so_far) when Head > Result_so_far ->
+    New_result_far = Head,
+    list_max(Rest, New_result_far);</code>
+    <p>which is possibly a little clearer.</p>
+  </section>
+
+  <section>
+    <title>More About Lists</title>
+    <p>Remember that the | operator can be used to get the head of a
+      list:</p>
+    <pre>
+47> <input>[M1|T1] = [paris, london, rome].</input>
+[paris,london,rome]
+48> <input>M1.</input>
+paris
+49> <input>T1.</input>
+[london,rome]</pre>
+    <p>The | operator can also be used to add a head to a list:</p>
+    <pre>
+50> <input>L1 = [madrid | T1].</input>
+[madrid,london,rome]
+51> <input>L1.</input>
+[madrid,london,rome]</pre>
+    <p>Now an example of this when working with lists - reversing
+      the order of a list:</p>
+    <code type="none">
+-module(tut8).
+
+-export([reverse/1]).
+
+reverse(List) ->
+    reverse(List, []).
+
+reverse([Head | Rest], Reversed_List) ->
+    reverse(Rest, [Head | Reversed_List]);
+reverse([], Reversed_List) ->
+    Reversed_List.</code>
+    <pre>
+52> <input>c(tut8).</input>
+{ok,tut8}
+53> <input>tut8:reverse([1,2,3]).</input>
+[3,2,1]</pre>
+    <p>Consider how <c>Reversed_List</c> is built. It starts as [], we
+      then successively take off the heads of the list to be reversed
+      and add them to the the <c>Reversed_List</c>, as shown in
+      the following:</p>
+    <code type="none">
+reverse([1|2,3], []) =>
+    reverse([2,3], [1|[]])
+
+reverse([2|3], [1]) =>
+    reverse([3], [2|[1])
+
+reverse([3|[]], [2,1]) =>
+    reverse([], [3|[2,1]])
+
+reverse([], [3,2,1]) =>
+    [3,2,1]</code>
+    <p>The module <c>lists</c> contains a lot of functions for
+      manipulating lists, for example for reversing them, so before you
+      write a list manipulating function it is a good idea to check
+      that one isn't already written for you. (see
+      <seealso marker="stdlib:lists">lists(3)</seealso>).</p>
+    <p>Now lets get back to the cities and temperatures, but take a more
+      structured approach this time. First let's convert the whole list
+      to Celsius as follows and test the function:</p>
+    <code type="none">
+-module(tut7).
+-export([format_temps/1]).
+
+format_temps(List_of_cities) ->
+    convert_list_to_c(List_of_cities).
+
+convert_list_to_c([{Name, {f, F}} | Rest]) ->
+    Converted_City = {Name, {c, (F -32)* 5 / 9}},
+    [Converted_City | convert_list_to_c(Rest)];
+
+convert_list_to_c([City | Rest]) ->
+    [City | convert_list_to_c(Rest)];
+
+convert_list_to_c([]) ->
+    [].</code>
+    <pre>
+54> <input>c(tut7).</input>
+{ok, tut7}.
+55> <input>tut7:format_temps([{moscow, {c, -10}}, {cape_town, {f, 70}},</input>
+<input>{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).</input>
+[{moscow,{c,-10}},
+ {cape_town,{c,21.11111111111111}},
+ {stockholm,{c,-4}},
+ {paris,{c,-2.2222222222222223}},
+ {london,{c,2.2222222222222223}}]</pre>
+    <p>Looking at this bit by bit:</p>
+    <code type="none">
+format_temps(List_of_cities) ->
+    convert_list_to_c(List_of_cities).</code>
+    <p>Here we see that <c>format_temps/1</c> calls
+      <c>convert_list_to_c/1</c>. <c>convert_list_to_c/1</c> takes off
+      the head of the <c>List_of_cities</c>, converts it to Celsius if
+      needed. The | operator is used to add the (maybe) converted
+      to the converted rest of the list:</p>
+    <code type="none">
+[Converted_City | convert_list_to_c(Rest)];</code>
+    <p>or</p>
+    <code type="none">
+[City | convert_list_to_c(Rest)];</code>
+    <p>We go on doing this until we get to the end of the list (i.e.
+      the list is empty:</p>
+    <code type="none">
+convert_list_to_c([]) ->
+    [].</code>
+    <p>Now we have converted the list, we add a function to print it:</p>
+    <code type="none">
+-module(tut7).
+-export([format_temps/1]).
+
+format_temps(List_of_cities) ->
+    Converted_List = convert_list_to_c(List_of_cities),
+    print_temp(Converted_List).
+
+convert_list_to_c([{Name, {f, F}} | Rest]) ->
+    Converted_City = {Name, {c, (F -32)* 5 / 9}},
+    [Converted_City | convert_list_to_c(Rest)];
+
+convert_list_to_c([City | Rest]) ->
+    [City | convert_list_to_c(Rest)];
+
+convert_list_to_c([]) ->
+    [].
+
+print_temp([{Name, {c, Temp}} | Rest]) ->
+    io:format("~-15w ~w c~n", [Name, Temp]),
+    print_temp(Rest);
+print_temp([]) ->
+    ok.</code>
+    <pre>
+56> <input>c(tut7).</input>
+{ok,tut7}
+57> <input>tut7:format_temps([{moscow, {c, -10}}, {cape_town, {f, 70}},</input>
+<input>{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).</input>
+moscow          -10 c
+cape_town       21.11111111111111 c
+stockholm       -4 c
+paris           -2.2222222222222223 c
+london          2.2222222222222223 c
+ok</pre>
+    <p>We now have to add a function to find the cities with
+      the maximum and minimum temperatures. The program below isn't
+      the most efficient way of doing this as we walk through the list
+      of cities four times. But it is better to first strive for
+      clarity and correctness and to make programs efficient only if
+      really needed.</p>
+    <code type="none"><![CDATA[
+-module(tut7).
+-export([format_temps/1]).
+
+format_temps(List_of_cities) ->
+    Converted_List = convert_list_to_c(List_of_cities),
+    print_temp(Converted_List),
+    {Max_city, Min_city} = find_max_and_min(Converted_List),
+    print_max_and_min(Max_city, Min_city).
+
+convert_list_to_c([{Name, {f, Temp}} | Rest]) ->
+    Converted_City = {Name, {c, (Temp -32)* 5 / 9}},
+    [Converted_City | convert_list_to_c(Rest)];
+
+convert_list_to_c([City | Rest]) ->
+    [City | convert_list_to_c(Rest)];
+
+convert_list_to_c([]) ->
+    [].
+
+print_temp([{Name, {c, Temp}} | Rest]) ->
+    io:format("~-15w ~w c~n", [Name, Temp]),
+    print_temp(Rest);
+print_temp([]) ->
+    ok.
+
+find_max_and_min([City | Rest]) ->
+    find_max_and_min(Rest, City, City).
+
+find_max_and_min([{Name, {c, Temp}} | Rest], 
+         {Max_Name, {c, Max_Temp}}, 
+         {Min_Name, {c, Min_Temp}}) ->
+    if 
+        Temp > Max_Temp ->
+            Max_City = {Name, {c, Temp}};           % Change
+        true -> 
+            Max_City = {Max_Name, {c, Max_Temp}} % Unchanged
+    end,
+    if
+         Temp < Min_Temp ->
+            Min_City = {Name, {c, Temp}};           % Change
+        true -> 
+            Min_City = {Min_Name, {c, Min_Temp}} % Unchanged
+    end,
+    find_max_and_min(Rest, Max_City, Min_City);
+
+find_max_and_min([], Max_City, Min_City) ->
+    {Max_City, Min_City}.
+
+print_max_and_min({Max_name, {c, Max_temp}}, {Min_name, {c, Min_temp}}) ->
+    io:format("Max temperature was ~w c in ~w~n", [Max_temp, Max_name]),
+    io:format("Min temperature was ~w c in ~w~n", [Min_temp, Min_name]).]]></code><pre>
+58> <input>c(tut7).</input>
+{ok, tut7}
+59> <input>tut7:format_temps([{moscow, {c, -10}}, {cape_town, {f, 70}},</input>
+<input>{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).</input>
+moscow          -10 c
+cape_town       21.11111111111111 c
+stockholm       -4 c
+paris           -2.2222222222222223 c
+london          2.2222222222222223 c
+Max temperature was 21.11111111111111 c in cape_town
+Min temperature was -10 c in moscow
+ok</pre>
+  </section>
+
+  <section>
+    <title>If and Case</title>
+    <p>The function <c>find_max_and_min</c> works out the maximum and
+      minimum temperature. We have introduced a new construct here
+      <c>if</c>. If works as follows:</p>
+    <code type="none">
+if
+    Condition 1 ->
+        Action 1;
+    Condition 2 ->
+        Action 2;
+    Condition 3 ->
+        Action 3;
+    Condition 4 ->
+        Action 4
+end</code>
+    <p>Note there is no ";" before <c>end</c>! Conditions are the same
+      as guards, tests which succeed or fail. Erlang starts at the top
+      until it finds a condition which succeeds and then it evaluates
+      (performs) the action following the condition and ignores all
+      other conditions and action before the <c>end</c>. If no
+      condition matches, there will be a run-time failure. A condition
+      which always is succeeds is the atom, <c>true</c> and this is
+      often used last in an <c>if</c> meaning do the action following
+      the <c>true</c> if all other conditions have failed.</p>
+    <p>The following is a short program to show the workings of
+      <c>if</c>.</p>
+    <code type="none">
+-module(tut9).
+-export([test_if/2]).
+
+test_if(A, B) ->
+    if 
+        A == 5 ->
+            io:format("A == 5~n", []),
+            a_equals_5;
+        B == 6 ->
+            io:format("B == 6~n", []),
+            b_equals_6;
+        A == 2, B == 3 ->                      %i.e. A equals 2 and B equals 3
+            io:format("A == 2, B == 3~n", []),
+            a_equals_2_b_equals_3;
+        A == 1 ; B == 7 ->                     %i.e. A equals 1 or B equals 7
+            io:format("A == 1 ; B == 7~n", []),
+            a_equals_1_or_b_equals_7
+    end.</code>
+    <p>Testing this program gives:</p>
+    <pre>
+60> <input>c(tut9).</input>
+{ok,tut9}
+61> <input>tut9:test_if(5,33).</input>
+A == 5
+a_equals_5
+62> <input>tut9:test_if(33,6).</input>
+B == 6
+b_equals_6
+63> <input>tut9:test_if(2, 3).</input>
+A == 2, B == 3
+a_equals_2_b_equals_3
+64> <input>tut9:test_if(1, 33).</input>
+A == 1 ; B == 7
+a_equals_1_or_b_equals_7
+65> <input>tut9:test_if(33, 7).</input>
+A == 1 ; B == 7
+a_equals_1_or_b_equals_7
+66> <input>tut9:test_if(33, 33).</input>
+** exception error: no true branch found when evaluating an if expression
+     in function  tut9:test_if/2</pre>
+    <p>Notice that <c>tut9:test_if(33,33)</c> did not cause any
+      condition to succeed so we got the run time error
+      <c>if_clause</c>, here nicely formatted by the shell. See the chapter
+      <seealso marker="doc/reference_manual:expressions">"Guard Sequences"</seealso> in the Erlang Reference Manual for details
+      of the many guard tests available. <c>case</c> is another
+      construct in Erlang. Recall that we wrote the
+      <c>convert_length</c> function as:</p>
+    <code type="none">
+convert_length({centimeter, X}) ->
+    {inch, X / 2.54};
+convert_length({inch, Y}) ->
+    {centimeter, Y * 2.54}.</code>
+    <p>We could also write the same program as:</p>
+    <code type="none">
+-module(tut10).
+-export([convert_length/1]).
+
+convert_length(Length) ->
+    case Length of
+        {centimeter, X} ->
+            {inch, X / 2.54};
+        {inch, Y} ->
+            {centimeter, Y * 2.54}
+    end.</code>
+    <pre>
+67> <input>c(tut10).</input>
+{ok,tut10}
+68> <input>tut10:convert_length({inch, 6}).</input>
+{centimeter,15.24}
+69> <input>tut10:convert_length({centimeter, 2.5}).</input>
+{inch,0.984251968503937}</pre>
+    <p>Notice that both <c>case</c> and <c>if</c> have <em>return values</em>, i.e. in the above example <c>case</c> returned
+      either <c>{inch,X/2.54}</c> or <c>{centimeter,Y*2.54}</c>.
+      The behaviour of <c>case</c> can also be modified by using guards.
+      An example should hopefully clarify this. The following example
+      tells us the length of a month, given the year. We need to know
+      the year of course, since February has 29 days in a leap year.</p>
+    <code type="none">
+-module(tut11).
+-export([month_length/2]).
+
+month_length(Year, Month) ->
+    %% All years divisible by 400 are leap
+    %% Years divisible by 100 are not leap (except the 400 rule above)
+    %% Years divisible by 4 are leap (except the 100 rule above)
+    Leap = if
+        trunc(Year / 400) * 400 == Year ->
+            leap;
+        trunc(Year / 100) * 100 == Year ->
+            not_leap;
+        trunc(Year / 4) * 4 == Year ->
+            leap;
+        true ->
+            not_leap
+    end,  
+    case Month of
+        sep -> 30;
+        apr -> 30;
+        jun -> 30;
+        nov -> 30;
+        feb when Leap == leap -> 29;
+        feb -> 28;
+        jan -> 31;
+        mar -> 31;
+        may -> 31;
+        jul -> 31;
+        aug -> 31;
+        oct -> 31;
+        dec -> 31
+    end.</code>
+    <pre>
+70> <input>c(tut11).</input>
+{ok,tut11}
+71> <input>tut11:month_length(2004, feb).</input>
+29
+72> <input>tut11:month_length(2003, feb).</input>
+28
+73> <input>tut11:month_length(1947, aug).</input>
+31</pre>
+  </section>
+
+  <section>
+    <title>Built In Functions (BIFs)</title>
+    <p>Built in functions BIFs are functions which for some reason is
+      built in to the Erlang virtual machine. BIFs often implement 
+      functionality that is impossible to implement in Erlang or is to
+      inefficient to implement in Erlang. Some BIFs can be called 
+      by use of the function name only but they are by default belonging
+      to the erlang module so for example the call to the BIF <c>trunc</c>
+      below is equivalent with a call to <c>erlang:trunc</c>.</p>
+    <p>As you can see, we first find out if a year is leap or not. If a
+      year is divisible by 400, it is a leap year. To find this out we
+      first divide the year by 400 and use the built in function
+      <c>trunc</c> (more later) to cut off any decimals. We then
+      multiply by 400 again and see if we get back the same value. For
+      example, year 2004:</p>
+    <code type="none">
+2004 / 400 = 5.01
+trunc(5.01) = 5
+5 * 400 = 2000</code>
+    <p>and we can see that we got back 2000 which is not the same as
+      2004, so 2004 isn't divisible by 400. Year 2000:</p>
+    <code type="none">
+2000 / 400 = 5.0
+trunc(5.0) = 5
+5 * 400 = 2000</code>
+    <p>so we have a leap year. The next two tests if the year is
+      divisible by 100 or 4 are done in the same way. The first
+      <c>if</c> returns <c>leap</c> or <c>not_leap</c> which lands up
+      in the variable <c>Leap</c>. We use this variable in the guard
+      for <c>feb</c> in the following <c>case</c> which tells us how
+      long the month is.</p>
+    <p>This example showed the use of <c>trunc</c>, an easier way would
+      be to use the Erlang operator <c>rem</c> which gives the remainder
+      after division. For example:</p>
+    <pre>
+74> <input>2004 rem 400.</input>
+4</pre>
+    <p>so instead of writing</p>
+    <code type="none">
+trunc(Year / 400) * 400 == Year ->
+    leap;</code>
+    <p>we could write</p>
+    <code type="none">
+Year rem 400 == 0 ->
+    leap;</code>
+    <p>There are many other built in functions (BIF) such as
+      <c>trunc</c>. Only a few built in functions can be used in guards,
+      and you cannot use functions you have defined yourself in guards.
+      (see the chapter
+      <seealso marker="doc/reference_manual:expressions">"Guard Sequences"</seealso> in the Erlang Reference Manual) (Aside for
+      advanced readers: This is to ensure that guards don't have side
+      effects). Let's play with a few of these functions in the shell:</p>
+    <pre>
+75> <input>trunc(5.6).</input>
+5
+76> <input>round(5.6).</input>
+6
+77> <input>length([a,b,c,d]).</input>
+4
+78> <input>float(5).</input>
+5.0
+79> <input>is_atom(hello).</input>
+true
+80> <input>is_atom("hello").</input>
+false
+81> <input>is_tuple({paris, {c, 30}}).</input>
+true
+82> <input>is_tuple([paris, {c, 30}]).</input>
+false</pre>
+    <p>All the above can be used in guards. Now for some which can't be
+      used in guards:</p>
+    <pre>
+83> <input>atom_to_list(hello).</input>
+"hello"
+84> <input>list_to_atom("goodbye").</input>
+goodbye
+85> <input>integer_to_list(22).</input>
+"22"</pre>
+    <p>The 3 BIFs above do conversions which would be difficult (or
+      impossible) to do in Erlang.</p>
+  </section>
+
+  <section>
+    <title>Higher Order Functions (Funs)</title>
+    <p>Erlang, like most modern functional programming languages, has
+      higher order functions. We start with an example using the shell:</p>
+    <pre>
+86> <input>Xf = fun(X) -> X * 2 end.</input>
+#Fun&lt;erl_eval.5.123085357&gt;
+87> <input>Xf(5).</input>
+10</pre>
+    <p>What we have done here is to define a function which doubles
+      the value of number and assign this function to a variable. Thus
+      <c>Xf(5)</c> returned the value 10. Two useful functions when
+      working with lists are <c>foreach</c> and <c>map</c>, which are
+      defined as follows:</p>
+    <code type="none">
+foreach(Fun, [First|Rest]) ->
+    Fun(First),
+    foreach(Fun, Rest);
+foreach(Fun, []) ->
+    ok.
+
+map(Fun, [First|Rest]) -> 
+    [Fun(First)|map(Fun,Rest)];
+map(Fun, []) -> 
+    [].</code>
+    <p>These two functions are provided in the standard module
+      <c>lists</c>. <c>foreach</c> takes a list and applies a fun to
+      every element in the list, <c>map</c> creates a new list by
+      applying a fun to every element in a list. Going back to
+      the shell, we start by using <c>map</c> and a fun to add 3 to
+      every element of a list:</p>
+    <pre>
+88> <input>Add_3 = fun(X) -> X + 3 end.</input>
+#Fun&lt;erl_eval.5.123085357&gt;
+89> <input>lists:map(Add_3, [1,2,3]).</input>
+[4,5,6]</pre>
+    <p>Now lets print out the temperatures in a list of cities (yet
+      again):</p>
+    <pre>
+90> <input>Print_City = fun({City, {X, Temp}}) -> io:format("~-15w ~w ~w~n",</input>
+<input>[City, X, Temp]) end.</input>
+#Fun&lt;erl_eval.5.123085357&gt;
+91> <input>lists:foreach(Print_City, [{moscow, {c, -10}}, {cape_town, {f, 70}},</input>
+<input>{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).</input>
+moscow          c -10
+cape_town       f 70
+stockholm       c -4
+paris           f 28
+london          f 36
+ok</pre>
+    <p>We will now define a fun which can be used to go through a list
+      of cities and temperatures and transform them all to Celsius.</p>
+    <code type="none">
+-module(tut13).
+
+-export([convert_list_to_c/1]).
+
+convert_to_c({Name, {f, Temp}}) ->
+    {Name, {c, trunc((Temp - 32) * 5 / 9)}};
+convert_to_c({Name, {c, Temp}}) ->
+    {Name, {c, Temp}}.
+
+convert_list_to_c(List) ->
+    lists:map(fun convert_to_c/1, List).</code>
+    <pre>
+92> <input>tut13:convert_list_to_c([{moscow, {c, -10}}, {cape_town, {f, 70}},</input>
+<input>{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).</input>
+[{moscow,{c,-10}},
+ {cape_town,{c,21}},
+ {stockholm,{c,-4}},
+ {paris,{c,-2}},
+ {london,{c,2}}]</pre>
+    <p>The <c>convert_to_c</c> function is the same as before, but we
+      use it as a fun:</p>
+    <code type="none">
+lists:map(fun convert_to_c/1, List)</code>
+    <p>When we use a function defined elsewhere as a fun we can refer
+      to it as <c>Function/Arity</c> (remember that <c>Arity</c> =
+      number of arguments). So in the <c>map</c> call we write
+      <c>lists:map(fun convert_to_c/1, List)</c>. As you can see
+      <c>convert_list_to_c</c> becomes much shorter and easier to
+      understand.</p>
+    <p>The standard module <c>lists</c> also contains a function
+      <c>sort(Fun, List)</c> where <c>Fun</c> is a fun with two
+      arguments. This fun should return <c>true</c> if the the first
+      argument is less than the second argument, or else <c>false</c>.
+      We add sorting to the <c>convert_list_to_c</c>:</p>
+    <code type="none"><![CDATA[
+-module(tut13).
+
+-export([convert_list_to_c/1]).
+
+convert_to_c({Name, {f, Temp}}) ->
+    {Name, {c, trunc((Temp - 32) * 5 / 9)}};
+convert_to_c({Name, {c, Temp}}) ->
+    {Name, {c, Temp}}.
+
+convert_list_to_c(List) ->
+    New_list = lists:map(fun convert_to_c/1, List),
+    lists:sort(fun({_, {c, Temp1}}, {_, {c, Temp2}}) ->
+                       Temp1 < Temp2 end, New_list).]]></code>
+    <pre>
+93> <input>c(tut13).</input>
+{ok,tut13}
+94> <input>tut13:convert_list_to_c([{moscow, {c, -10}}, {cape_town, {f, 70}},</input>
+<input>{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).</input>
+[{moscow,{c,-10}},
+ {stockholm,{c,-4}},
+ {paris,{c,-2}},
+ {london,{c,2}},
+ {cape_town,{c,21}}]</pre>
+    <p>In <c>sort</c> we use the fun:</p>
+    <code type="none"><![CDATA[
+fun({_, {c, Temp1}}, {_, {c, Temp2}}) -> Temp1 < Temp2 end,]]></code>
+    <p>Here we introduce the concept of an <em>anonymous variable</em>
+      "_". This is simply shorthand for a variable which is going to
+      get a value, but we will ignore the value. This can be used
+      anywhere suitable, not just in fun's. <c><![CDATA[Temp1 < Temp2]]></c>
+      returns <c>true</c> if <c>Temp1</c> is less than <c>Temp2</c>.</p>
+  </section>
+</chapter>
+