This commit was manufactured by cvs2svn to create tag

'Version_1_34_0_beta'. [SVN r37504]
2026-01-27 07:02:12 +00:00 · 2007-04-25 05:07:34 +00:00
64 changed files with 745 additions and 1311 deletions
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
--- a/doc/html/index.html
+++ b/doc/html/index.html
--- a/doc/html/python.html
+++ b/doc/html/python.html
@@ -3,11 +3,11 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.6: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.5: http://docutils.sourceforge.net/" />
 <title>The Boost Parameter Library Python Binding Documentation</title>
 <meta name="authors" content="Daniel Wallin" />
 <meta name="organization" content="Boost Consulting" />
-<meta name="date" content="2008-03-22" />
+<meta name="date" content="2006-09-21" />
 <meta name="copyright" content="Copyright David Abrahams, Daniel Wallin 2005. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)" />
 <link rel="stylesheet" href="rst.css" type="text/css" />
 </head>
@@ -21,16 +21,16 @@
 <tr><th class="docinfo-name">Authors:</th>
 <td>Daniel Wallin</td></tr>
 <tr><th class="docinfo-name">Contact:</th>
-<td><a class="first last reference external" href="mailto:dalwan01&#64;student.umu.se">dalwan01&#64;student.umu.se</a></td></tr>
+<td><a class="first last reference" href="mailto:dalwan01&#64;student.umu.se">dalwan01&#64;student.umu.se</a></td></tr>
 <tr><th class="docinfo-name">Organization:</th>
-<td><a class="first last reference external" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
+<td><a class="first last reference" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2008-03-22</td></tr>
+<td>2006-09-21</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
 <td>Copyright David Abrahams, Daniel Wallin
 2005. Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt
-or copy at <a class="reference external" href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</td></tr>
+or copy at <a class="reference" href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</td></tr>
 </tbody>
 </table>
 <div class="abstract topic">
@@ -38,24 +38,24 @@ or copy at <a class="reference external" href="http://www.boost.org/LICENSE_1_0.
 <p>Makes it possible to bind Boost.Parameter-enabled
 functions, operators and constructors to Python.</p>
 </div>
-<p><a class="reference external" href="../../../../index.htm"><img alt="Boost" src="../../../../boost.png" /></a></p>
-<div class="contents topic" id="contents">
-<p class="topic-title first">Contents</p>
+<p><a class="reference" href="../../../../index.htm"><img alt="Boost" src="../../../../boost.png" /></a></p>
+<div class="contents topic">
+<p class="topic-title first"><a id="contents" name="contents">Contents</a></p>
 <ul class="simple">
-<li><a class="reference internal" href="#introduction" id="id7">Introduction</a></li>
-<li><a class="reference internal" href="#tutorial" id="id8">Tutorial</a></li>
-<li><a class="reference internal" href="#concept-parameterspec" id="id9">concept <span class="concept">ParameterSpec</span></a></li>
-<li><a class="reference internal" href="#special-keywords" id="id10"><em>special</em> keywords</a></li>
-<li><a class="reference internal" href="#class-template-init" id="id11">class template <tt class="docutils literal"><span class="pre">init</span></tt></a></li>
-<li><a class="reference internal" href="#class-template-call" id="id12">class template <tt class="docutils literal"><span class="pre">call</span></tt></a></li>
-<li><a class="reference internal" href="#class-template-function" id="id13">class template <tt class="docutils literal"><span class="pre">function</span></tt></a></li>
-<li><a class="reference internal" href="#function-template-def" id="id14">function template <tt class="docutils literal"><span class="pre">def</span></tt></a></li>
-<li><a class="reference internal" href="#portability" id="id15">Portability</a></li>
+<li><a class="reference" href="#introduction" id="id8" name="id8">Introduction</a></li>
+<li><a class="reference" href="#tutorial" id="id9" name="id9">Tutorial</a></li>
+<li><a class="reference" href="#concept-parameterspec" id="id10" name="id10">concept <span class="concept">ParameterSpec</span></a></li>
+<li><a class="reference" href="#special-keywords" id="id11" name="id11"><em>special</em> keywords</a></li>
+<li><a class="reference" href="#class-template-init" id="id12" name="id12">class template <tt class="docutils literal"><span class="pre">init</span></tt></a></li>
+<li><a class="reference" href="#class-template-call" id="id13" name="id13">class template <tt class="docutils literal"><span class="pre">call</span></tt></a></li>
+<li><a class="reference" href="#class-template-function" id="id14" name="id14">class template <tt class="docutils literal"><span class="pre">function</span></tt></a></li>
+<li><a class="reference" href="#function-template-def" id="id15" name="id15">function template <tt class="docutils literal"><span class="pre">def</span></tt></a></li>
+<li><a class="reference" href="#portability" id="id16" name="id16">Portability</a></li>
 </ul>
 </div>
-<div class="section" id="introduction">
-<h1><a class="toc-backref" href="#id7">Introduction</a></h1>
-<p><tt class="docutils literal"><span class="pre">boost/parameter/python.hpp</span></tt> introduces a group of <a class="reference external" href="../../../python/doc/v2/def_visitor.html"><tt class="docutils literal"><span class="pre">def_visitors</span></tt></a> that can
+<div class="section">
+<h1><a class="toc-backref" href="#id8" id="introduction" name="introduction">Introduction</a></h1>
+<p><tt class="docutils literal"><span class="pre">boost/parameter/python.hpp</span></tt> introduces a group of <a class="reference" href="../../../python/doc/v2/def_visitor.html"><tt class="docutils literal"><span class="pre">def_visitors</span></tt></a> that can
 be used to easily expose Boost.Parameter-enabled member functions to Python with
 Boost.Python. It also provides a function template <tt class="docutils literal"><span class="pre">def()</span></tt> that can be used
 to expose Boost.Parameter-enabled free functions.</p>
@@ -70,8 +70,8 @@ types. Additionally, ``boost::parameter::python::function`` and
 ``boost::parameter::python::def`` requires a class with forwarding
 overloads. We will take a closer look at how this is done in the
 tutorial section below. -->
-<p>The keyword tags and associated argument types are specified as an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL
-Sequence</a>, using the function type syntax described in <a class="reference internal" href="#concept-parameterspec"><span class="concept">ParameterSpec</span></a>
+<p>The keyword tags and associated argument types are specified as an <a class="reference" href="../../../mpl/doc/refmanual/sequences.html">MPL
+Sequence</a>, using the function type syntax described in <a class="reference" href="#concept-parameterspec"><span class="concept">ParameterSpec</span></a>
 below. Additionally, <tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt> and
 <tt class="docutils literal"><span class="pre">boost::parameter::python::def</span></tt> requires a class with forwarding overloads.
 We will take a closer look at how this is done in the tutorial section below.</p>
@@ -80,11 +80,11 @@ We will take a closer look at how this is done in the tutorial section below.</p
 <!-- else are we going to do other than pass these sequences to -->
 <!-- function? -->
 </div>
-<div class="section" id="tutorial">
-<h1><a class="toc-backref" href="#id8">Tutorial</a></h1>
+<div class="section">
+<h1><a class="toc-backref" href="#id9" id="tutorial" name="tutorial">Tutorial</a></h1>
 <p>In this section we will outline the steps needed to bind a simple
 Boost.Parameter-enabled member function to Python. Knowledge of the
-Boost.Parameter <a class="reference external" href="index.html">macros</a> are required to understand this section.</p>
+Boost.Parameter <a class="reference" href="index.html">macros</a> are required to understand this section.</p>
 <p>The class and member function we are interested in binding looks
 like this:</p>
 <pre class="literal-block">
@@ -121,11 +121,10 @@ assert(width == 400);
 <p>It defines a set of overloaded member functions called <tt class="docutils literal"><span class="pre">open</span></tt> with one
 required parameter and two optional ones. To bind this member function to
 Python we use the binding utility <tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt>.
-<tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt> is a <a class="reference external" href="../../../python/doc/v2/def_visitor.html"><tt class="docutils literal"><span class="pre">def_visitor</span></tt></a> that we'll instantiate
+<tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt> is a <a class="reference" href="../../../python/doc/v2/def_visitor.html"><tt class="docutils literal"><span class="pre">def_visitor</span></tt></a> that we'll instantiate
 and pass to <tt class="docutils literal"><span class="pre">boost::python::class_::def()</span></tt>.</p>
 <p>To use <tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt> we first need to define
-a class with forwarding overloads. This is needed because <tt class="docutils literal"><span class="pre">window::open()</span></tt>
-is a function template, so we can't refer to it in any other way.</p>
+a class with forwarding overloads.</p>
 <pre class="literal-block">
 struct open_fwd
 {
@@ -151,7 +150,7 @@ needs to take three parameters as well.</p>
 <p class="last">We only need one overload in the forwarding class, despite the
 fact that there are two optional parameters. There are special
 circumstances when several overload are needed; see
-<a class="reference internal" href="#special-keywords">special keywords</a>.</p>
+<a class="reference" href="#special-keywords">special keywords</a>.</p>
 </div>
 <p>Next we'll define the module and export the class:</p>
 <pre class="literal-block">
@@ -185,13 +184,11 @@ BOOST_PYTHON_MODULE(my_module)
 ) -->
 <!-- @del jam_prefix[:] -->
 <p><tt class="docutils literal"><span class="pre">py::function</span></tt> is passed two parameters. The first one is the class with
-forwarding overloads that we defined earlier. The second one is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL
+forwarding overloads that we defined earlier. The second one is an <a class="reference" href="../../../mpl/doc/refmanual/sequences.html">MPL
 Sequence</a> with the keyword tag types and argument types for the function
 specified as function types. The pointer syntax used in <tt class="docutils literal"><span class="pre">tag::width*</span></tt> and
 <tt class="docutils literal"><span class="pre">tag::height*</span></tt> means that the parameter is optional. The first element of
-the <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL Sequence</a> is the return type of the function, in this case <tt class="docutils literal"><span class="pre">void</span></tt>,
-which is passed as the first argument to <tt class="docutils literal"><span class="pre">operator()</span></tt> in the forwarding
-class.</p>
+the <a class="reference" href="../../../mpl/doc/refmanual/sequences.html">MPL Sequence</a> is the return type of the function, in this case <tt class="docutils literal"><span class="pre">void</span></tt>.</p>
 <!-- The
 pointer syntax means that the parameter is optional, so in this case
 ``width`` and ``height`` are optional parameters. The third parameter
@@ -242,8 +239,8 @@ users of broken compilers will have to give us function pointer
 types instead). -->
 </div>
 <hr class="docutils" />
-<div class="section" id="concept-parameterspec">
-<h1><a class="toc-backref" href="#id9">concept <span class="concept">ParameterSpec</span></a></h1>
+<div class="section">
+<h1><a class="toc-backref" href="#id10" id="concept-parameterspec" name="concept-parameterspec">concept <span class="concept">ParameterSpec</span></a></h1>
 <p>A <span class="concept">ParameterSpec</span> is a function type <tt class="docutils literal"><span class="pre">K(T)</span></tt> that describes both the keyword tag,
 <tt class="docutils literal"><span class="pre">K</span></tt>, and the argument type, <tt class="docutils literal"><span class="pre">T</span></tt>, for a parameter.</p>
 <p><tt class="docutils literal"><span class="pre">K</span></tt> is either:</p>
@@ -253,8 +250,8 @@ types instead). -->
 <li><strong>or</strong>, a <em>special</em> keyword of the form <tt class="docutils literal"><span class="pre">Tag**</span></tt></li>
 </ul>
 <p>where <tt class="docutils literal"><span class="pre">Tag</span></tt> is a keyword tag type, as used in a specialization
-of <a class="reference external" href="../../../parameter/doc/html/reference.html#keyword"><tt class="docutils literal"><span class="pre">boost::parameter::keyword</span></tt></a>.</p>
-<p>The <strong>arity range</strong> for an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL Sequence</a> of <span class="concept">ParameterSpec</span>'s is
+of <a class="reference" href="../../../parameter/doc/html/reference.html#keyword"><tt class="docutils literal"><span class="pre">boost::parameter::keyword</span></tt></a>.</p>
+<p>The <strong>arity range</strong> for an <a class="reference" href="../../../mpl/doc/refmanual/sequences.html">MPL Sequence</a> of <span class="concept">ParameterSpec</span>'s is
 defined as the closed range:</p>
 <pre class="literal-block">
 [ mpl::size&lt;S&gt; - number of <em>special</em> keyword tags in <tt class="docutils literal"><span class="pre">S</span></tt>, mpl::size&lt;S&gt; ]
@@ -263,13 +260,12 @@ defined as the closed range:</p>
 the <strong>arity range</strong> of <tt class="docutils literal"><span class="pre">mpl::vector2&lt;x(int),y*(int)&gt;</span></tt> is <tt class="docutils literal"><span class="pre">[2,2]</span></tt> and the
 <strong>arity range</strong> of <tt class="docutils literal"><span class="pre">mpl::vector2&lt;x(int),y**(int)&gt;</span></tt> is <tt class="docutils literal"><span class="pre">[1,2]</span></tt>.</p>
 </div>
-<div class="section" id="special-keywords">
-<h1><a class="toc-backref" href="#id10"><em>special</em> keywords</a></h1>
+<div class="section">
+<h1><a class="toc-backref" href="#id11" id="special-keywords" name="special-keywords"><em>special</em> keywords</a></h1>
 <p>Sometimes it is desirable to have a default value for a parameter that differ
 in type from the parameter. This technique is useful for doing simple tag-dispatching
-based on the presence of a parameter. For example:</p>
-<!-- An example_ of this is given in the Boost.Parameter
-docs. The example uses a different technique, but could also have been written like this: -->
+based on the presence of a parameter. An <a class="reference" href="index.html#dispatching-based-on-the-presence-of-a-default">example</a> of this is given in the Boost.Parameter
+docs. The example uses a different technique, but could also have been written like this:</p>
 <pre class="literal-block">
 namespace core
 {
@@ -317,21 +313,19 @@ int main()
    depth_first_search(params()(color = 0));
 }''') -->
 <!-- @build() -->
-<!-- .. _example: index.html#dispatching-based-on-the-presence-of-a-default -->
 <p>In the above example the type of the default for <tt class="docutils literal"><span class="pre">color</span></tt> is <tt class="docutils literal"><span class="pre">mpl::false_</span></tt>, a
 type that is distinct from any color map that the user might supply.</p>
 <p>When binding the case outlined above, the default type for <tt class="docutils literal"><span class="pre">color</span></tt> will not
 be convertible to the parameter type. Therefore we need to tag the <tt class="docutils literal"><span class="pre">color</span></tt>
-keyword as a <em>special</em> keyword. This is done by specifying the tag as
-<tt class="docutils literal"><span class="pre">tag::color**</span></tt> when binding the function (see <a class="reference internal" href="#concept-parameterspec">concept ParameterSpec</a> for
-more details on the tagging). By doing this we tell the binding functions that
-it needs to generate two overloads, one with the <tt class="docutils literal"><span class="pre">color</span></tt> parameter present
-and one without. Had there been two <em>special</em> keywords, four overloads would
-need to be generated. The number of generated overloads is equal to 2<sup>N</sup>, where <tt class="docutils literal"><span class="pre">N</span></tt> is the number of <em>special</em> keywords.</p>
+keyword as a <em>special</em> keyword. By doing this we tell the binding functions
+that it needs to generate two overloads, one with the <tt class="docutils literal"><span class="pre">color</span></tt> parameter
+present and one without. Had there been two <em>special</em> keywords, four
+overloads would need to be generated. The number of generated overloads is
+equal to 2<sup>N</sup>, where <tt class="docutils literal"><span class="pre">N</span></tt> is the number of <em>special</em> keywords.</p>
 </div>
 <hr class="docutils" />
-<div class="section" id="class-template-init">
-<h1><a class="toc-backref" href="#id11">class template <tt class="docutils literal"><span class="pre">init</span></tt></a></h1>
+<div class="section">
+<h1><a class="toc-backref" href="#id12" id="class-template-init" name="class-template-init">class template <tt class="docutils literal"><span class="pre">init</span></tt></a></h1>
 <p>Defines a named parameter enabled constructor.</p>
 <pre class="literal-block">
 template &lt;class ParameterSpecs&gt;
@@ -345,16 +339,16 @@ struct init : python::def_visitor&lt;init&lt;ParameterSpecs&gt; &gt;
 };
 </pre>
 <!-- @ignore() -->
-<div class="section" id="init-requirements">
-<h2><tt class="docutils literal"><span class="pre">init</span></tt> requirements</h2>
+<div class="section">
+<h2><a id="init-requirements" name="init-requirements"><tt class="docutils literal"><span class="pre">init</span></tt> requirements</a></h2>
 <ul>
-<li><p class="first"><tt class="docutils literal"><span class="pre">ParameterSpecs</span></tt> is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element is a
+<li><p class="first"><tt class="docutils literal"><span class="pre">ParameterSpecs</span></tt> is an <a class="reference" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element is a
 model of <span class="concept">ParameterSpec</span>.</p>
 </li>
 <li><p class="first">For every <tt class="docutils literal"><span class="pre">N</span></tt> in <tt class="docutils literal"><span class="pre">[U,V]</span></tt>, where <tt class="docutils literal"><span class="pre">[U,V]</span></tt> is the <strong>arity
 range</strong> of <tt class="docutils literal"><span class="pre">ParameterSpecs</span></tt>, <tt class="docutils literal"><span class="pre">Class</span></tt> must support these
 expressions:</p>
-<table border="1" class="docutils">
+<table border="1" class="docutils table">
 <colgroup>
 <col width="30%" />
 <col width="17%" />
@@ -382,13 +376,13 @@ expressions:</p>
 </li>
 </ul>
 </div>
-<div class="section" id="template-class-callpolicies-operator-callpolicies-const">
-<h2><tt class="docutils literal"><span class="pre">template</span> <span class="pre">&lt;class</span> <span class="pre">CallPolicies&gt;</span> <span class="pre">operator[](CallPolicies</span> <span class="pre">const&amp;)</span></tt></h2>
+<div class="section">
+<h2><a id="template-class-callpolicies-operator-callpolicies-const" name="template-class-callpolicies-operator-callpolicies-const"><tt class="docutils literal"><span class="pre">template</span> <span class="pre">&lt;class</span> <span class="pre">CallPolicies&gt;</span> <span class="pre">operator[](CallPolicies</span> <span class="pre">const&amp;)</span></tt></a></h2>
 <p>Returns a <tt class="docutils literal"><span class="pre">def_visitor</span></tt> equivalent to <tt class="docutils literal"><span class="pre">*this</span></tt>, except that it
 uses CallPolicies when creating the binding.</p>
 </div>
-<div class="section" id="example">
-<h2>Example</h2>
+<div class="section">
+<h2><a id="id3" name="id3">Example</a></h2>
 <pre class="literal-block">
 #include &lt;boost/parameter/keyword.hpp&gt;
 #include &lt;boost/parameter/preprocessor.hpp&gt;
@@ -446,8 +440,8 @@ assert(args[y | 1] == 1);
 </div>
 </div>
 <hr class="docutils" />
-<div class="section" id="class-template-call">
-<h1><a class="toc-backref" href="#id12">class template <tt class="docutils literal"><span class="pre">call</span></tt></a></h1>
+<div class="section">
+<h1><a class="toc-backref" href="#id13" id="class-template-call" name="class-template-call">class template <tt class="docutils literal"><span class="pre">call</span></tt></a></h1>
 <p>Defines a <tt class="docutils literal"><span class="pre">__call__</span></tt> operator, mapped to <tt class="docutils literal"><span class="pre">operator()</span></tt> in C++.</p>
 <pre class="literal-block">
 template &lt;class ParameterSpecs&gt;
@@ -461,16 +455,16 @@ struct call : python::def_visitor&lt;call&lt;ParameterSpecs&gt; &gt;
 };
 </pre>
 <!-- @ignore() -->
-<div class="section" id="call-requirements">
-<h2><tt class="docutils literal"><span class="pre">call</span></tt> requirements</h2>
+<div class="section">
+<h2><a id="call-requirements" name="call-requirements"><tt class="docutils literal"><span class="pre">call</span></tt> requirements</a></h2>
 <ul>
-<li><p class="first"><tt class="docutils literal"><span class="pre">ParameterSpecs</span></tt> is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element
+<li><p class="first"><tt class="docutils literal"><span class="pre">ParameterSpecs</span></tt> is an <a class="reference" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element
 except the first models <span class="concept">ParameterSpec</span>. The first element
 is the result type of <tt class="docutils literal"><span class="pre">c(…)</span></tt>.</p>
 </li>
 <li><p class="first"><tt class="docutils literal"><span class="pre">Class</span></tt> must support these expressions, where <tt class="docutils literal"><span class="pre">c</span></tt> is an
 instance of <tt class="docutils literal"><span class="pre">Class</span></tt>:</p>
-<table border="1" class="docutils">
+<table border="1" class="docutils table">
 <colgroup>
 <col width="24%" />
 <col width="26%" />
@@ -499,13 +493,13 @@ instance of <tt class="docutils literal"><span class="pre">Class</span></tt>:</p
 </li>
 </ul>
 </div>
-<div class="section" id="id3">
-<h2><tt class="docutils literal"><span class="pre">template</span> <span class="pre">&lt;class</span> <span class="pre">CallPolicies&gt;</span> <span class="pre">operator[](CallPolicies</span> <span class="pre">const&amp;)</span></tt></h2>
+<div class="section">
+<h2><a id="id4" name="id4"><tt class="docutils literal"><span class="pre">template</span> <span class="pre">&lt;class</span> <span class="pre">CallPolicies&gt;</span> <span class="pre">operator[](CallPolicies</span> <span class="pre">const&amp;)</span></tt></a></h2>
 <p>Returns a <tt class="docutils literal"><span class="pre">def_visitor</span></tt> equivalent to <tt class="docutils literal"><span class="pre">*this</span></tt>, except that it
 uses CallPolicies when creating the binding.</p>
 </div>
-<div class="section" id="id4">
-<h2>Example</h2>
+<div class="section">
+<h2><a id="id5" name="id5">Example</a></h2>
 <pre class="literal-block">
 #include &lt;boost/parameter/keyword.hpp&gt;
 #include &lt;boost/parameter/preprocessor.hpp&gt;
@@ -573,8 +567,8 @@ return 0;
 </div>
 </div>
 <hr class="docutils" />
-<div class="section" id="class-template-function">
-<h1><a class="toc-backref" href="#id13">class template <tt class="docutils literal"><span class="pre">function</span></tt></a></h1>
+<div class="section">
+<h1><a class="toc-backref" href="#id14" id="class-template-function" name="class-template-function">class template <tt class="docutils literal"><span class="pre">function</span></tt></a></h1>
 <p>Defines a named parameter enabled member function.</p>
 <pre class="literal-block">
 template &lt;class Fwd, class ParameterSpecs&gt;
@@ -585,16 +579,16 @@ struct function : python::def_visitor&lt;function&lt;Fwd, ParameterSpecs&gt; &gt
 };
 </pre>
 <!-- @ignore() -->
-<div class="section" id="function-requirements">
-<h2><tt class="docutils literal"><span class="pre">function</span></tt> requirements</h2>
+<div class="section">
+<h2><a id="function-requirements" name="function-requirements"><tt class="docutils literal"><span class="pre">function</span></tt> requirements</a></h2>
 <ul>
-<li><p class="first"><tt class="docutils literal"><span class="pre">ParameterSpecs</span></tt> is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element
+<li><p class="first"><tt class="docutils literal"><span class="pre">ParameterSpecs</span></tt> is an <a class="reference" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element
 except the first models <span class="concept">ParameterSpec</span>. The first element
 is the result type of <tt class="docutils literal"><span class="pre">c.f(…)</span></tt>, where <tt class="docutils literal"><span class="pre">f</span></tt> is the member
 function.</p>
 </li>
 <li><p class="first">An instance of <tt class="docutils literal"><span class="pre">Fwd</span></tt> must support this expression:</p>
-<table border="1" class="docutils">
+<table border="1" class="docutils table">
 <colgroup>
 <col width="39%" />
 <col width="18%" />
@@ -625,8 +619,8 @@ are tagged arguments.</p>
 </li>
 </ul>
 </div>
-<div class="section" id="id5">
-<h2>Example</h2>
+<div class="section">
+<h2><a id="id6" name="id6">Example</a></h2>
 <p>This example exports a member function <tt class="docutils literal"><span class="pre">f(int</span> <span class="pre">x,</span> <span class="pre">int</span> <span class="pre">y</span> <span class="pre">=</span> <span class="pre">…)</span></tt> to Python. The
 sequence of <span class="concept">ParameterSpec</span>'s <tt class="docutils literal"><span class="pre">mpl::vector2&lt;tag::x(int),</span> <span class="pre">tag::y*(int)&gt;</span></tt> has
 an <strong>arity range</strong> of [2,2], so we only need one forwarding overload.</p>
@@ -689,23 +683,23 @@ assert(y == 1);
 </div>
 </div>
 <hr class="docutils" />
-<div class="section" id="function-template-def">
-<h1><a class="toc-backref" href="#id14">function template <tt class="docutils literal"><span class="pre">def</span></tt></a></h1>
+<div class="section">
+<h1><a class="toc-backref" href="#id15" id="function-template-def" name="function-template-def">function template <tt class="docutils literal"><span class="pre">def</span></tt></a></h1>
 <p>Defines a named parameter enabled free function in the current Python scope.</p>
 <pre class="literal-block">
 template &lt;class Fwd, class ParameterSpecs&gt;
 void def(char const* name);
 </pre>
 <!-- @ignore() -->
-<div class="section" id="def-requirements">
-<h2><tt class="docutils literal"><span class="pre">def</span></tt> requirements</h2>
+<div class="section">
+<h2><a id="def-requirements" name="def-requirements"><tt class="docutils literal"><span class="pre">def</span></tt> requirements</a></h2>
 <ul>
-<li><p class="first"><tt class="docutils literal"><span class="pre">ParameterSpecs</span></tt> is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element
+<li><p class="first"><tt class="docutils literal"><span class="pre">ParameterSpecs</span></tt> is an <a class="reference" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element
 except the first models <span class="concept">ParameterSpec</span>. The first element
 is the result type of <tt class="docutils literal"><span class="pre">f(…)</span></tt>, where <tt class="docutils literal"><span class="pre">f</span></tt> is the function.</p>
 </li>
 <li><p class="first">An instance of <tt class="docutils literal"><span class="pre">Fwd</span></tt> must support this expression:</p>
-<table border="1" class="docutils">
+<table border="1" class="docutils table">
 <colgroup>
 <col width="39%" />
 <col width="21%" />
@@ -734,8 +728,8 @@ is the result type of <tt class="docutils literal"><span class="pre">f(…)</spa
 </li>
 </ul>
 </div>
-<div class="section" id="id6">
-<h2>Example</h2>
+<div class="section">
+<h2><a id="id7" name="id7">Example</a></h2>
 <p>This example exports a function <tt class="docutils literal"><span class="pre">f(int</span> <span class="pre">x,</span> <span class="pre">int</span> <span class="pre">y</span> <span class="pre">=</span> <span class="pre">…)</span></tt> to Python. The
 sequence of <span class="concept">ParameterSpec</span>'s <tt class="docutils literal"><span class="pre">mpl::vector2&lt;tag::x(int),</span> <span class="pre">tag::y*(int)&gt;</span></tt> has
 an <strong>arity range</strong> of [2,2], so we only need one forwarding overload.</p>
@@ -771,16 +765,16 @@ BOOST_PYTHON_MODULE(…)
 <!-- again, the undefined ``fwd`` identifier. -->
 </div>
 </div>
-<div class="section" id="portability">
-<h1><a class="toc-backref" href="#id15">Portability</a></h1>
+<div class="section">
+<h1><a class="toc-backref" href="#id16" id="portability" name="portability">Portability</a></h1>
 <p>The Boost.Parameter Python binding library requires <em>partial template
 specialization</em>.</p>
 </div>
 </div>
 <div class="footer">
 <hr class="footer" />
-Generated on: 2008-06-26 21:51 UTC.
-Generated by <a class="reference external" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference external" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+Generated on: 2007-01-03 17:02 UTC.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.

 </div>
 </body>
--- a/doc/html/reference.html
+++ b/doc/html/reference.html
--- a/doc/html/rst.css
+++ b/doc/html/rst.css
@@ -19,12 +19,8 @@ img {
 }

 span.vellipsis {
-  display: block;
-  width: 5px;
-  height: 22px;
-  background: url("vellipsis.gif");
-  margin-left: 3em;
-  text-indent: -1000px;
+  line-height: 30% ;
+  font-size: 200% ;
 }


--- a/doc/html/vellipsis.gif
+++ b/doc/html/vellipsis.gif
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -71,27 +71,22 @@ __ ../../../../index.htm
 -------------------------------------

 :Authors:       David Abrahams, Daniel Wallin
-:Contact:       dave@boost-consulting.com, daniel@boostpro.com
-:organization:  `BoostPro Computing`_
-:date:          $Date: 2005/07/17 19:53:01 $
+:Contact:       dave@boost-consulting.com, dalwan01@student.umu.se
+:Organization:  `Boost Consulting`_
+:Date:          $Date: 2005/07/18 20:34:31 $

-:copyright:     Copyright David Abrahams, Daniel Wallin
-                2005-2009. Distributed under the Boost Software License,
+:Copyright:     Copyright David Abrahams, Daniel Wallin 2005. 
+                Distributed under the Boost Software License,
                Version 1.0. (See accompanying file LICENSE_1_0.txt
                or copy at http://www.boost.org/LICENSE_1_0.txt)

-.. _`BoostPro Computing`: http://www.boostpro.com
+.. _`Boost Consulting`: http://www.boost-consulting.com

-.. _concepts: http://www.boost.org/more/generic_programming.html#concept
+.. _concepts: ../../../more/generic_programming.html#concept

 -------------------------------------

-[Note: this tutorial does not cover all details of the library.  Please see also the `reference documentation`__\ ]
-
-__ reference.html
-
 .. contents:: **Table of Contents**
-   :depth: 2

 .. role:: concept
   :class: concept
@@ -356,8 +351,8 @@ shown in the table below.
 .. _`IncidenceGraph`: ../../../graph/doc/IncidenceGraph.html
 .. _`VertexListGraph`: ../../../graph/doc/VertexListGraph.html
 .. _`DFSVisitor`: ../../../graph/doc/DFSVisitor.html
-.. _`ReadWritePropertyMap`: ../../../property_map/doc/ReadWritePropertyMap.html
-.. _`ReadablePropertyMap`: ../../../property_map/doc/ReadablePropertyMap.html
+.. _`ReadWritePropertyMap`: ../../../property_map/ReadWritePropertyMap.html
+.. _`ReadablePropertyMap`: ../../../property_map/ReadablePropertyMap.html

 Don't be intimidated by the information in the second and third
 columns above.  For the purposes of this exercise, you don't need
@@ -1072,8 +1067,8 @@ With the declaration above, the following two calls are equivalent:

 .. parsed-literal::

-  def("f", &f, **some_policies**, **"Documentation for f"**);
-  def("f", &f, **"Documentation for f"**, **some_policies**);
+  def("f", f, **some_policies**, **"Documentation for f"**);
+  def("f", f, **"Documentation for f"**, **some_policies**);

 .. @example.prepend('''
   int main()
@@ -1086,7 +1081,7 @@ specify the parameter name explicitly, as follows:
 .. parsed-literal::

  def(
-      "f", &f
+      "f", f
     , **_policies = some_policies**, "Documentation for f");

 .. @example.append('}')
@@ -1112,17 +1107,14 @@ be used within the body of a class::
  struct callable2
  {
      BOOST_PARAMETER_CONST_MEMBER_FUNCTION(
-          (void), call, tag, (required (arg1,(int))(arg2,(int))))
+          (void), operator(), tag, (required (arg1,(int))(arg2,(int))))
      {
          std::cout << arg1 << ", " << arg2 << std::endl;
      }
  };

 .. @example.prepend('''
-   #include <boost/parameter.hpp>
-   #include <iostream>
-   using namespace boost::parameter;
-   ''')
+   #include <boost/parameter.hpp>''')

 .. @test('compile')

@@ -1133,7 +1125,7 @@ arguments on to a separate implementation function::
  struct callable2
  {
      BOOST_PARAMETER_CONST_MEMBER_FUNCTION(
-          (void), call, tag, (required (arg1,(int))(arg2,(int))))
+          (void), operator(), tag, (required (arg1,(int))(arg2,(int))))
      {
          call_impl(arg1,arg2);
      }
@@ -1145,40 +1137,10 @@ arguments on to a separate implementation function::
   #include <boost/parameter.hpp>

   BOOST_PARAMETER_NAME(arg1)
-   BOOST_PARAMETER_NAME(arg2)
-   using namespace boost::parameter;
-   ''')
+   BOOST_PARAMETER_NAME(arg2)''')

 .. @test('compile')

-Static Member Functions
-=======================
-
-To expose a static member function, simply insert the keyword
-“``static``” before the function name:
-
-.. parsed-literal::
-
-  BOOST_PARAMETER_NAME(arg1)
-
-  struct somebody
-  {
-      BOOST_PARAMETER_MEMBER_FUNCTION(
-          (void), **static** f, tag, (optional (arg1,(int),0)))
-      {
-          std::cout << arg1 << std::endl;
-      }
-  };
-
-.. @example.prepend('''
-   #include <boost/parameter.hpp>
-   #include <iostream>
-   using namespace boost::parameter;
-   ''')
-
-.. @test('compile')
-
-
 ------------------------------
 Parameter-Enabled Constructors
 ------------------------------
@@ -1371,10 +1333,10 @@ separately)::
  using boost::mpl::_;

  typedef parameter::parameters<
-      required<tag::class_type, boost::is_class<_> >
-    , parameter::optional<tag::base_list, mpl::is_sequence<_> >
-    , parameter::optional<tag::held_type>
-    , parameter::optional<tag::copyable>
+      required<tag::class_type, is_class<_> >
+    , optional<tag::base_list, mpl::is_sequence<_> >
+    , optional<tag::held_type>
+    , optional<tag::copyable>
  > class_signature;

  }}
@@ -1383,7 +1345,6 @@ separately)::
   #include <boost/parameter.hpp>
   #include <boost/mpl/is_sequence.hpp>
   #include <boost/noncopyable.hpp>
-   #include <boost/type_traits/is_class.hpp>
   #include <memory>

   using namespace boost::parameter;
@@ -1410,13 +1371,12 @@ separately)::
 Argument Packs and Parameter Extraction
 ---------------------------------------

-Next, within the body of ``class_`` , we use the |ParameterSpec|\ 's
-nested ``::bind< … >`` template to bundle the actual arguments into an
-|ArgumentPack|_ type, and then use the library's ``value_type< … >``
-metafunction to extract “logical parameters”.  ``value_type< … >`` is
-a lot like ``binding< … >``, but no reference is added to the actual
-argument type.  Note that defaults are specified by passing it an
-optional third argument::
+Next, within the body of ``class_`` , we use the |ParameterSpec|\
+'s nested ``::bind< … >`` template to bundle the actual arguments
+into an |ArgumentPack|_ type, and then use the library's ``binding<
+… >`` metafunction to extract “logical parameters”.  Note that
+defaults are specified by supplying an optional third argument to
+``binding< … >``::

  namespace boost { namespace python {

@@ -1434,16 +1394,16 @@ optional third argument::
      args;

      // Extract first logical parameter.
-      typedef typename parameter::value_type<
+      typedef typename parameter::binding<
        args, tag::class_type>::type class_type;
      
-      typedef typename parameter::value_type<
+      typedef typename parameter::binding<
        args, tag::base_list, bases<> >::type base_list;
      
-      typedef typename parameter::value_type<
+      typedef typename parameter::binding<
        args, tag::held_type, class_type>::type held_type;
      
-      typedef typename parameter::value_type<
+      typedef typename parameter::binding<
        args, tag::copyable, void>::type copyable;
  };

@@ -1545,12 +1505,12 @@ parameters deducible::
  typedef parameter::parameters<
      required<tag::class_type, is_class<_> >

-    , parameter::optional<
+    , optional<
          deduced<tag::base_list>
        , is_base_and_derived<detail::bases_base,_>
      >

-    , parameter::optional<
+    , optional<
          deduced<tag::held_type>
        , mpl::not_<
              mpl::or_<
@@ -1560,12 +1520,11 @@ parameters deducible::
          >
      >

-    , parameter::optional<deduced<tag::copyable>, is_same<noncopyable,_> >
+    , optional<deduced<tag::copyable>, is_same<noncopyable,_> >

  > class_signature;

 .. @example.prepend('''
-   #include <boost/type_traits/is_class.hpp>
   namespace boost { namespace python {''')

 .. @example.append('''
@@ -1583,16 +1542,16 @@ parameters deducible::
       args;
 
       // Extract first logical parameter.
-       typedef typename parameter::value_type<
+       typedef typename parameter::binding<
         args, tag::class_type>::type class_type;
      
-       typedef typename parameter::value_type<
+       typedef typename parameter::binding<
         args, tag::base_list, bases<> >::type base_list;
      
-       typedef typename parameter::value_type<
+       typedef typename parameter::binding<
         args, tag::held_type, class_type>::type held_type;
      
-       typedef typename parameter::value_type<
+       typedef typename parameter::binding<
         args, tag::copyable, void>::type copyable;
   };

@@ -1742,10 +1701,7 @@ its function call operator:
    , optional<tag::\ index, is_convertible<_,int> >
  > spec;

-  char const sam[] = "sam";
-  int twelve = 12;
-
-  int z0 = print_name_and_index( **spec(**\ sam, twelve\ **)** );
+  int z0 = print_name_and_index( **spec(**\ "sam", 12\ **)** );

  int z1 = print_name_and_index( 
     **spec(**\ _index=12, _name="sam"\ **)** 
@@ -1764,11 +1720,6 @@ its function call operator:

 .. @test('run', howmany='all')

-Note that because of the `forwarding problem`_, ``parameter::parameters::operator()``
-can't accept non-const rvalues.
-
-.. _`forwarding problem`: http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm
-
 Extracting Parameter Types
 ==========================

@@ -1813,13 +1764,13 @@ function template and allow *it* to do type deduction::
 Occasionally one needs to deduce argument types without an extra
 layer of function call.  For example, suppose we wanted to return
 twice the value of the ``index`` parameter?  In that
-case we can use the ``value_type< … >`` metafunction introduced
+case we can use the ``binding< … >`` metafunction introduced
 `earlier`__::

   BOOST_PARAMETER_NAME(index)

   template <class ArgumentPack>
-   typename parameter::value_type<ArgumentPack, tag::index, int>::type
+   typename parameter::binding<ArgumentPack, tag::index, int>::type
   twice_index(ArgumentPack const& args)
   {
       return 2 * args[_index|42];
@@ -1827,13 +1778,13 @@ case we can use the ``value_type< … >`` metafunction introduced

   int six = twice_index(_index = 3);

+.. TODO: binding<> returns a reference. We should use value_type<> here.
+
 .. @example.prepend('''
   #include <boost/parameter.hpp>
-   #include <boost/type_traits/remove_reference.hpp>
   #include <cassert>

-   namespace parameter = boost::parameter;
-   ''')
+   namespace parameter = boost::parameter;''')

 .. @example.append('''
   int main()
@@ -1841,11 +1792,7 @@ case we can use the ``value_type< … >`` metafunction introduced
       assert(six == 6);
   }''')

-.. @test('run', howmany='all')
-
-Note that if we had used ``binding< … >`` rather than ``value_type< …
->``, we would end up returning a reference to the temporary created in
-the ``2 * …`` expression.
+.. @test('run')

 __ binding_intro_

@@ -1890,29 +1837,21 @@ when using |ArgumentPack|\ s explicitly, we need a tool other than
 In the example above, the string ``"hello, world"`` is constructed
 despite the fact that the user passed us a value for ``s3``.  To
 remedy that, we can compute the default value *lazily* (that is,
-only on demand), by using ``boost::bind()`` to create a function
-object.
-
-.. danielw: I'm leaving the text below in the source, because we might
-.. want to change back to it after 1.34, and if I remove it now we
-.. might forget about it.
-
-.. by combining the logical-or (“``||``”) operator
-.. with a function object built by the Boost Lambda_ library: [#bind]_
+only on demand), by combining the logical-or (“``||``”) operator
+with a function object built by the Boost Lambda_ library: [#bind]_

 .. parsed-literal::

+   namespace lambda = boost::lambda;
+
   typename parameter::binding<
       ArgumentPack, tag::s3, std::string
-   >::type s3 = args[_s3
-       **|| boost::bind(std::plus<std::string>(), boost::ref(s1), boost::ref(s2))** ];
+   >::type s3 = args[_s3 **|| (lambda::var(s1)+lambda::var(s2))** ];

 .. @example.prepend('''
-   #include <boost/bind.hpp>
-   #include <boost/ref.hpp>
+   #include <boost/lambda/lambda.hpp>
   #include <boost/parameter.hpp>
   #include <string>
-   #include <functional>

   namespace parameter = boost::parameter;

@@ -1937,7 +1876,7 @@ object.

 .. @test('run')

-.. .. _Lambda: ../../../lambda/index.html
+.. _Lambda: ../../../lambda/index.html

 .. sidebar:: Mnemonics

@@ -1947,15 +1886,10 @@ object.
   Similarly, in ``color_map[param||f]``, ``f`` is only invoked if
   no ``color_map`` argument was supplied.

-The expression ``bind(std::plus<std::string>(), ref(s1), ref(s2))`` yields
-a *function object* that, when invoked, adds the two strings together.
-That function will only be invoked if no ``s3`` argument is supplied by 
-the caller.
-
-.. The expression ``lambda::var(s1)+lambda::var(s2)`` yields a
-.. *function object* that, when invoked, adds the two strings
-.. together.  That function will only be invoked if no ``s3`` argument
-.. is supplied by the caller.
+The expression ``lambda::var(s1)+lambda::var(s2)`` yields a
+*function object* that, when invoked, adds the two strings
+together.  That function will only be invoked if no ``s3`` argument
+is supplied by the caller.

 ================ 
 Best Practices
@@ -2317,17 +2251,17 @@ __ ../../../graph/doc/bgl_named_params.html

 .. _`ConceptC++`: http://www.generic-programming.org/software/ConceptGCC/

-.. .. [#bind] The Lambda library is known not to work on `some
-..   less-conformant compilers`__.  When using one of those you could
-..   use `Boost.Bind`_ to generate the function object::
+.. [#bind] The Lambda library is known not to work on `some
+   less-conformant compilers`__.  When using one of those you could
+   use `Boost.Bind`_ to generate the function object::

-..      boost::bind(std::plus<std::string>(),s1,s2)
+      boost::bind(std::plus<std::string>(),s1,s2)

 .. [#is_keyword_expression] Here we're assuming there's a predicate
   metafunction ``is_keyword_expression`` that can be used to
   identify models of Boost.Python's KeywordExpression concept.

-.. .. __ http://www.boost.org/regression/release/user/lambda.html
+__ http://www.boost.org/regression/release/user/lambda.html
 .. _Boost.Bind: ../../../bind/index.html


--- a/doc/python.rst
+++ b/doc/python.rst
@@ -2,13 +2,13 @@
 The Boost Parameter Library Python Binding Documentation 
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

-:Authors:       David Abrahams, Daniel Wallin
-:Contact:       dave@boost-consulting.com, daniel@boostpro.com
-:organization:  `BoostPro Computing`_
+:Authors:       Daniel Wallin
+:Contact:       dalwan01@student.umu.se
+:organization:  `Boost Consulting`_
 :date:          $Date$

 :copyright:     Copyright David Abrahams, Daniel Wallin
-                2005-2009. Distributed under the Boost Software License,
+                2005. Distributed under the Boost Software License,
                Version 1.0. (See accompanying file LICENSE_1_0.txt
                or copy at http://www.boost.org/LICENSE_1_0.txt)

@@ -22,7 +22,7 @@

 __ ../../../../index.htm

-.. _`BoostPro Computing`: http://www.boostpro.com
+.. _`Boost Consulting`: http://www.boost-consulting.com


 .. role:: class
@@ -132,8 +132,7 @@ Python we use the binding utility ``boost::parameter::python::function``.
 and pass to ``boost::python::class_::def()``.

 To use ``boost::parameter::python::function`` we first need to define
-a class with forwarding overloads. This is needed because ``window::open()``
-is a function template, so we can't refer to it in any other way. 
+a class with forwarding overloads.

 ::

@@ -205,9 +204,7 @@ forwarding overloads that we defined earlier. The second one is an `MPL
 Sequence`_ with the keyword tag types and argument types for the function
 specified as function types. The pointer syntax used in ``tag::width*`` and
 ``tag::height*`` means that the parameter is optional. The first element of
-the `MPL Sequence`_ is the return type of the function, in this case ``void``,
-which is passed as the first argument to ``operator()`` in the forwarding
-class.
+the `MPL Sequence`_ is the return type of the function, in this case ``void``.

 ..  The
    pointer syntax means that the parameter is optional, so in this case
@@ -298,10 +295,8 @@ the **arity range** of ``mpl::vector2<x(int),y*(int)>`` is ``[2,2]`` and the

 Sometimes it is desirable to have a default value for a parameter that differ
 in type from the parameter. This technique is useful for doing simple tag-dispatching
-based on the presence of a parameter. For example:
-
-.. An example_ of this is given in the Boost.Parameter
-   docs. The example uses a different technique, but could also have been written like this:
+based on the presence of a parameter. An example_ of this is given in the Boost.Parameter
+docs. The example uses a different technique, but could also have been written like this:

 .. parsed-literal::

@@ -356,20 +351,18 @@ based on the presence of a parameter. For example:

 .. @build()

-.. .. _example: index.html#dispatching-based-on-the-presence-of-a-default
+.. _example: index.html#dispatching-based-on-the-presence-of-a-default

 In the above example the type of the default for ``color`` is ``mpl::false_``, a
 type that is distinct from any color map that the user might supply.

 When binding the case outlined above, the default type for ``color`` will not
 be convertible to the parameter type. Therefore we need to tag the ``color``
-keyword as a *special* keyword. This is done by specifying the tag as
-``tag::color**`` when binding the function (see `concept ParameterSpec`_ for
-more details on the tagging). By doing this we tell the binding functions that
-it needs to generate two overloads, one with the ``color`` parameter present
-and one without. Had there been two *special* keywords, four overloads would
-need to be generated. The number of generated overloads is equal to 2\
-:sup:`N`, where ``N`` is the number of *special* keywords.
+keyword as a *special* keyword. By doing this we tell the binding functions
+that it needs to generate two overloads, one with the ``color`` parameter
+present and one without. Had there been two *special* keywords, four
+overloads would need to be generated. The number of generated overloads is
+equal to 2\ :sup:`N`, where ``N`` is the number of *special* keywords.

 ------------------------------------------------------------------------------

--- a/doc/reference.rst
+++ b/doc/reference.rst
@@ -3,12 +3,12 @@
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 :Authors:       David Abrahams, Daniel Wallin
-:Contact:       dave@boost-consulting.com, daniel@boostpro.com
-:organization:  `BoostPro Computing`_
+:Contact:       dave@boost-consulting.com, dalwan01@student.umu.se
+:organization:  `Boost Consulting`_
 :date:          $Date: 2005/07/17 19:53:01 $

 :copyright:     Copyright David Abrahams, Daniel Wallin
-                2005-2009. Distributed under the Boost Software License,
+                2005. Distributed under the Boost Software License,
                Version 1.0. (See accompanying file LICENSE_1_0.txt
                or copy at http://www.boost.org/LICENSE_1_0.txt)

@@ -19,7 +19,7 @@

 __ ../../../../index.htm

-.. _`BoostPro Computing`: http://www.boostpro.com
+.. _`Boost Consulting`: http://www.boost-consulting.com


 //////////////////////////////////////////////////////////////////////////////
@@ -174,7 +174,7 @@ Concepts

 This section describes the generic type concepts_ used by the Parameter library. 

-.. _concepts: http://www.boost.org/more/generic_programming.html#concept
+.. _concepts: ../../../../more/generic_programming.html#concept

 |ArgumentPack|
 --------------
@@ -253,7 +253,7 @@ argument type. In each row,
   +----------------------+--------------+--------------------------------+
   |Type                  |``A`` required|Condition ``A`` must satisfy    |
   +======================+==============+================================+
-   |``K``                 |no            |*n/a*                           |
+   ||keyword|_\ ``<K>``   |no            |*n/a*                           |
   +----------------------+--------------+--------------------------------+
   ||optional|_\ ``<K,F>``|no            |``mpl::apply<F,A>::type::value``|
   |                      |              |is ``true``.                    |
@@ -381,15 +381,16 @@ __ ../../../../boost/parameter/parameters.hpp
        };

        template <class A0>
-        |ArgumentPack|_ `operator()`_\(A0& a0) const;
+        |ArgumentPack|_ `operator()`_\(A0 const& a0) const;

        template <class A0, class A1>
-        |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1) const; 
-
-        :vellipsis:`⋮`
-
+        |ArgumentPack|_ `operator()`_\(A0 const& a0, A1 const& a1) const; :vellipsis:`\ 
+       .
+       .
+       .
+     `
        template <class A0, class A1, …class A\ β>
-        |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1, …A\ β& a\ β) const;
+        |ArgumentPack|_ `operator()`_\(A0 const& a0, A1 const& a1, …A\ β const& a\ β) const;
    };


@@ -402,22 +403,13 @@ __ ../../../../boost/parameter/parameters.hpp
  follows, for any argument type ``A``\ *i*:


-     | let ``D0`` the set [d0, …, d\ *j*] of all **deduced** *parameter specs* in [``P0``, …, ``P``\ β]
     | ``R``\ *i* is ``A``\ *i*\ 's |intended argument type|
     |
-     | if ``A``\ *i* is a result type of ``keyword<T>::``\ |operator=|_
-     | then 
-     |     ``K``\ *i* is ``T``
-     | else
-     |     if some ``A``\ *j* where *j*\ ≤\ *i* is a result type of ``keyword<T>::``\ |operator=|_
-     |     *or* some ``P``\ *j* in *j*\ ≤\ *i* is **deduced**
-     |     then
-     |         if some *parameter spec* ``d``\ *j* in ``D``\ *i* matches ``A``\ *i*
-     |         then
-     |             ``K``\ *i* is ``d``\ *j*\ 's |keyword tag type|.
-     |             ``D``\ :sub:`i+1` is ``D``\ *i* - [``d``\ *j*]
-     |     else
-     |         ``K``\ *i* is ``P``\ *i*\ 's |keyword tag type|.
+     |  if ``A``\ *i* is a result type of ``keyword<T>::``\ |operator=|_
+     |  then 
+     |      ``K``\ *i* is ``T``
+     |  else 
+     |      ``K``\ *i* is ``P``\ *i*\ 's |keyword tag type|.


 .. _match:
@@ -433,7 +425,7 @@ __ ../../../../boost/parameter/parameters.hpp
  every *j* in 0…β, either:

  * ``P``\ *j* is the *unspecified* default
-  * **or**, ``P``\ *j* is a *keyword tag type*
+  * **or**, ``P``\ *j* is a specialization of |keyword|_,

  * **or**, ``P``\ *j* is |optional|_ ``<X,F>`` and either

@@ -451,10 +443,11 @@ __ ../../../../boost/parameter/parameters.hpp
 ``operator()``
  .. parsed-literal::

-      template <class A0> |ArgumentPack|_ operator()(A0 const& a0) const; 
-
-      :vellipsis:`⋮`
-
+      template <class A0> |ArgumentPack|_ operator()(A0 const& a0) const; :vellipsis:`\ 
+        .
+        .
+        .
+       `
      template <class A0, …class A\ β> |ArgumentPack|_ `operator()`_\(A0 const& a0, …A\ β const& a\ β) const;

  :Returns:
@@ -495,23 +488,6 @@ The default value of ``Predicate`` is an unspecified |Metafunction|_ that return
 .. |Metafunction| replace:: :concept:`Metafunction`
 .. _Metafunction: ../../../mpl/doc/refmanual/metafunction.html

-
-``deduced``
-----------
-
-This template is used to wrap the *keyword tag* argument to
-``optional`` or ``required``.
-
-:Defined in: `boost/parameter/parameters.hpp`__
-
-__ ../../../../boost/parameter/parameters.hpp
-
-.. parsed-literal::
-
-    template <class Tag>
-    struct deduced;
-
-
 //////////////////////////////////////////////////////////////////////////////

 Metafunctions
@@ -570,37 +546,6 @@ __ ../../../../boost/parameter/binding.hpp
  reference| exists, returns ``boost::``\ |result_of|_\ ``<F()>::type``. [#no_result_of]_


-``value_type``
--------------
-
-Returns the result type of indexing an argument pack with a
-|keyword tag type| or with a |tagged default|.
-
-:Defined n: `boost/parameter/value_type.hpp`__
-
-__ ../../../../boost/parameter/value_type.hpp
-
-.. parsed-literal::
-
-    template <class A, class K, class D = void>
-    struct value_type
-    {
-        typedef … type;
-    };
-
-:Requires: ``A`` is a model of |ArgumentPack|_.
-
-:Returns: the type of the |tagged reference| in ``A``
-  having |keyword tag type| ``K``, if any.  If no such |tagged
-  reference| exists, returns ``D``. Equivalent to::
-
-    typename remove_reference<
-      typename binding<A, K, D>::type
-    >::type
-
-  … when ``D`` is not a reference type.
-
-
 //////////////////////////////////////////////////////////////////////////////

 Code Generation Macros
@@ -609,7 +554,6 @@ Code Generation Macros
 Macros in this section can be used to ease the writing of code
 using the Parameter libray by eliminating repetitive boilerplate.

-
 ``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)``
 -----------------------------------------------------------------

@@ -627,20 +571,17 @@ __ ../../../../boost/parameter/preprocessor.hpp
 :Argument specifiers syntax:
  .. parsed-literal::

-    argument-specifiers ::= *specifier-group* {*specifier-group*}
+    argument-specifiers ::= specifier-group {specifier-group}

-    specifier-group0 ::= *specifier-group1* |
-                         ( '**(**' '**deduced**' *specifier-group1* {*specifier-group1*} '**)**' )
+    specifier-group ::= ( '(' 'optional' optional-specifier {optional-specifier} ')' ) |
+                        ( '(' 'required' required-specifier {required-specifier} ')' )

-    specifier-group1 ::= ( '**(**' '**optional**' *optional-specifier* {*optional-specifier*} '**)**' ) |
-                         ( '**(**' '**required**' *required-specifier* {*required-specifier*} '**)**' )
+    optional-specifier ::= '(' name ',' restriction ',' default-value ')'
+    required-specifier ::= '(' name ',' restriction ')'

-    optional-specifier ::= '**(**' *name* '**,**' *restriction* '**,**' *default-value* ')'
-    required-specifier ::= '**(**' *name* '**,**' *restriction* ')'
-
-    restriction ::= ('*****' '**(**' *lambda-expression* '**)**' ) |
-                    ( '**(**' *typename* '**)**' ) |
-                    '*****'
+    restriction ::= ('*' '(' lambda-expression ')' ) |
+                    ( '(' typename ')' ) |
+                    '*'

  ``name`` is any valid C++ identifier. ``default-value`` is any valid
  C++ expression. ``typename`` is the name of a type.
@@ -690,7 +631,11 @@ Approximate expansion:
        *… forward to implementation …*
    }

-    :vellipsis:`⋮`
+    :vellipsis:`\
+      .
+      .
+      .
+     `

    template <class A0, …, class A\ **m**>
    *result type* **name**\ (
@@ -716,149 +661,9 @@ Approximate expansion:
      , *argument name*\ **m** ## _type& *argument name*\ **m**
    )

-
-
-``BOOST_PARAMETER_MEMBER_FUNCTION(result,name,tag_namespace,arguments)``
------------------------------------------------------------------------
-
-:Defined in: `boost/parameter/preprocessor.hpp`__
-
-__ ../../../../boost/parameter/preprocessor.hpp
-
-See ``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)``
-
-
-
-``BOOST_PARAMETER_CONSTRUCTOR(cls, impl, tag_namespace, arguments)``
--------------------------------------------------------------------
-
-:Defined in: `boost/parameter/preprocessor.hpp`__
-
-__ ../../../../boost/parameter/preprocessor.hpp
-
-:Requires: ``cls`` is the name of this class. ``impl`` is the 
-  parenthesized implementation base class for ``cls``.
-  ``tag_namespace`` is the namespace in which the keywords 
-  used by the function resides. ``arguments`` is
-  a list of *argument specifiers*, as defined in 
-  ``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)``.
-
-:Generated names in enclosing scope:
-  * ``boost_param_params_ ## __LINE__ ## ctor``
-  * ``constructor_parameters ## __LINE__``
-
-Approximate expansion:
-  **Where**:
-
-  * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
-  * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
-
-  .. parsed-literal::
-
-    struct boost_param_params\_ ## __LINE__ ## ctor
-      : boost::parameter::parameters<
-            *list of parameter specifications, based on arguments*
-        >
-    {};
-
-    typedef boost_param_params\_ ## __LINE__ ## **name** 
-      constructor_parameters ## __LINE__;
-
-    template <class A0, …, class A\ **n**>
-    *cls*\ (A0 const& a0, …, A\ **n** const& a\ **n**)
-      : *impl*\ (constructor_parameters ## __LINE__(a0, …, a\ **n**))
-    {}
-
-    :vellipsis:`⋮`
-
-    template <class A0, …, class A\ **m**>
-    *cls*\ (A0 const& a0, …, A\ **n** const& a\ **m**)
-      : *impl*\ (constructor_parameters ## __LINE__(a0, …, a\ **m**))
-    {}
-
-
-``BOOST_PARAMETER_NAME(name)``
------------------------------
-
-Declares a tag-type and keyword object.
-
-Expands to:
-
-**If** *name* is of the form:
-
-.. parsed-literal::
-
-  (*tag-name*, *namespace-name*) *object-name*
-
-**then**
-
-.. parsed-literal::
-
-  namespace *namespace-name* 
-  {
-    struct *tag-name*
-    {
-        static char const* keyword_name()
-        {
-            return ##\ *tag-name*;
-        }
-
-        typedef *unspecified* _;
-        typedef *unspecified* _1;
-    };
-  }
-
-  ::boost::parameter::keyword<*tag-namespace*\ ::\ *tag-name*\ > const& *object-name*
-      = ::boost::parameter::keyword<*tag-namespace*\ ::\ *tag-name*\ >::instance;
-
-**Else**
-
-.. parsed-literal::
-
-  namespace tag
-  {
-    struct *name*
-    {
-        static char const* keyword_name()
-        {
-            return ##\ *name*;
-        }
-
-        typedef *unspecified* _;
-        typedef *unspecified* _1;
-    };
-  }
-
-  ::boost::parameter::keyword<tag::\ *name*\ > const& _\ *name*
-      = ::boost::parameter::keyword<tag::\ *name*\ >::instance;
-
-
-``BOOST_PARAMETER_TEMPLATE_KEYWORD(name)``
------------------------------------------
-
-Expands to:
-
-.. parsed-literal::
-
-  namespace tag
-  {
-    struct *name*;
-  }
-
-  template <class T>
-  struct *name* 
-    : ::boost::parameter::template_keyword<tag::\ *name*, T>
-  {};
-
-
 ``BOOST_PARAMETER_FUN(r,n,l,h,p)``
 ----------------------------------

-.. admonition:: Deprecated
-
-  This macro has been deprecated in favor of
-  ``BOOST_PARAMETER_FUNCTION``.
-
 Generates a sequence of `forwarding function`_ templates named
 ``n``, with arities ranging from ``l`` to ``h`` , returning ``r``,
 and using ``p`` to control overload resolution and assign tags to
@@ -889,10 +694,11 @@ Generates
      , typename **p**::match<A1,A2,…A\ **l**,A\ ##\ BOOST_PP_INC_\ (**l**)>::type p = **p**\ ())
    {
       return **name**\ _with_named_params(**p**\ (x1,x2,…x\ **l**,x\ ##\ BOOST_PP_INC_\ (**l**)));
-    }
-
-    :vellipsis:`⋮`
-
+    } :vellipsis:`\ 
+      .
+      .
+      .
+     `
    template <class A1, class A2, …class A\ **h**>
    r name(
        A1 const& a1, A2 const& a2, …A\ **h** const& x\ **h**
@@ -907,11 +713,6 @@ Generates
 ``BOOST_PARAMETER_KEYWORD(n,k)``
 --------------------------------

-.. admonition:: Deprecated
-
-  This macro has been deprecated in favor of
-  ``BOOST_PARAMETER_NAME``.
-
 Generates the declaration of a |keyword tag type| named ``k`` in
 namespace ``n``, and a corresponding |keyword object| definition in
 the enclosing namespace.
--- a/include/boost/parameter.hpp
+++ b/include/boost/parameter.hpp
@@ -3,8 +3,6 @@
 // (See accompanying file LICENSE_1_0.txt or copy at 
 // http://www.boost.org/LICENSE_1_0.txt)

-//  See www.boost.org/libs/parameter for documentation.
-
 #ifndef BOOST_PARAMETER_050401_HPP
 #define BOOST_PARAMETER_050401_HPP

--- a/include/boost/parameter/aux_/arg_list.hpp
+++ b/include/boost/parameter/aux_/arg_list.hpp
@@ -11,7 +11,6 @@
 #include <boost/parameter/aux_/default.hpp>
 #include <boost/parameter/aux_/parameter_requirements.hpp>
 #include <boost/parameter/aux_/yesno.hpp>
-#include <boost/parameter/aux_/is_maybe.hpp>
 #include <boost/parameter/config.hpp>

 #include <boost/mpl/apply.hpp>
@@ -22,11 +21,11 @@

 #include <boost/type_traits/add_reference.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/facilities/intercept.hpp>

-namespace boost { namespace parameter {
+namespace boost { namespace parameter { 

 // Forward declaration for aux::arg_list, below.
 template<class T> struct keyword;
@@ -46,7 +45,7 @@ struct lambda_tag;
 // declarations to build member function overload sets that can
 // match against keywords.
 //
-
+  
 // MPL sequence support
 struct arg_list_tag;

@@ -83,14 +82,14 @@ struct empty_arg_list
    template <class KW>
    static no_tag has_key(KW*);
 #endif
-
+    
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
    || (BOOST_WORKAROUND(__GNUC__, < 3)) \
    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
+    
    // The overload set technique doesn't work with these older
    // compilers, so they need some explicit handholding.
-
+      
    // A metafunction class that, given a keyword, returns the type
    // of the base sublist whose get() function can produce the
    // value for that key
@@ -159,6 +158,15 @@ no_tag operator*(empty_arg_list, KW*);
 template <class KW, class T>
 struct tagged_argument;

+// Forward declaration for arg_list::operator[], with
+// IS_XXX helper
+struct maybe_base;
+
+template <class T>
+struct is_maybe
+  : is_base_and_derived<maybe_base, T>
+{};
+
 template <class T>
 struct get_reference
 {
@@ -206,9 +214,9 @@ struct arg_list : Next
    // Create a new list by prepending arg to a copy of tail.  Used
    // when incrementally building this structure with the comma
    // operator.
-    arg_list(TaggedArg head, Next const& tail)
+    arg_list(TaggedArg arg, Next const& tail)
      : Next(tail)
-      , arg(head)
+      , arg(arg)
    {}

    // A metafunction class that, given a keyword and a default
@@ -236,8 +244,8 @@ struct arg_list : Next
    // same keyword is used again
    static yes_tag has_key(key_type*);
    using Next::has_key;
-
-#  define BOOST_PARAMETER_CALL_HAS_KEY(next, key) next::has_key((key*)0)
+    
+#  define BOOST_PARAMETER_CALL_HAS_KEY(next, key) next::has_key((key*)0)  
 # endif

    BOOST_MPL_ASSERT_MSG(
@@ -252,7 +260,7 @@ struct arg_list : Next
    // specific arguments by name
    //

-    // Helpers that handle the case when TaggedArg is
+    // Helpers that handle the case when TaggedArg is 
    // empty<T>.
    template <class D>
    reference get_default(D const&, mpl::false_) const
@@ -332,7 +340,7 @@ struct arg_list : Next
    template <class Default>
    reference get(default_<key_type,Default> const& d) const
    {
-        return get_default(d, holds_maybe());
+        return get_default(d, holds_maybe());        
    }

    template <class Default>
@@ -340,7 +348,7 @@ struct arg_list : Next
    {
        return arg.value;
    }
-
+    
 #else

    reference operator[](keyword<key_type> const&) const
@@ -395,7 +403,7 @@ struct arg_list : Next
    // Comma operator to compose argument list without using parameters<>.
    // Useful for argument lists with undetermined length.
    template <class KW, class T2>
-    arg_list<tagged_argument<KW, T2>, self>
+    arg_list<tagged_argument<KW, T2>, self> 
    operator,(tagged_argument<KW,T2> x) const
    {
        return arg_list<tagged_argument<KW,T2>, self>(x, *this);
@@ -409,7 +417,7 @@ struct arg_list : Next

 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)  // ETI workaround
 template <> struct arg_list<int,int> {};
-#endif
+#endif 

 // MPL sequence support
 template <class ArgumentPack>
@@ -419,7 +427,7 @@ struct arg_list_iterator

    // The incremented iterator
    typedef arg_list_iterator<typename ArgumentPack::tail_type> next;
-
+    
    // dereferencing yields the key type
    typedef typename ArgumentPack::key_type type;
 };
--- a/include/boost/parameter/aux_/cast.hpp
+++ b/include/boost/parameter/aux_/cast.hpp
@@ -5,8 +5,6 @@
 #ifndef BOOST_PARAMETER_CAST_060902_HPP
 # define BOOST_PARAMETER_CAST_060902_HPP

-# include <boost/detail/workaround.hpp>
-
 # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
  && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #  include <boost/type_traits/add_reference.hpp>
--- a/include/boost/parameter/aux_/default.hpp
+++ b/include/boost/parameter/aux_/default.hpp
@@ -4,9 +4,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)

 #ifndef DEFAULT_050329_HPP
-# define DEFAULT_050329_HPP
-
-# include <boost/detail/workaround.hpp>
+#define DEFAULT_050329_HPP

 namespace boost { namespace parameter { namespace aux {

@@ -29,7 +27,7 @@ struct default_
 //    the user when resolving the value of the parameter with the
 //    given keyword
 //
-# if BOOST_WORKAROUND(__EDG_VERSION__, <= 300)
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 300)
 // These compilers need a little extra help with overload
 // resolution; we have empty_arg_list's operator[] accept a base
 // class to make that overload less preferable.
@@ -50,8 +48,8 @@ struct lazy_default
        : lazy_default_base<KW,DefaultComputer>(x)
      {}
  };
-#  define BOOST_PARAMETER_lazy_default_fallback lazy_default_base
-# else 
+# define BOOST_PARAMETER_lazy_default_fallback lazy_default_base
+#else 
 template <class KW, class DefaultComputer>
 struct lazy_default
 {
@@ -60,8 +58,8 @@ struct lazy_default
    {}
    DefaultComputer const& compute_default;
 };
-#  define BOOST_PARAMETER_lazy_default_fallback lazy_default
-# endif 
+# define BOOST_PARAMETER_lazy_default_fallback lazy_default
+#endif 

 }}} // namespace boost::parameter::aux

--- a/include/boost/parameter/aux_/is_maybe.hpp
+++ b/include/boost/parameter/aux_/is_maybe.hpp
@@ -1,26 +0,0 @@
-// Copyright Daniel Wallin, David Abrahams 2010. Use, modification and
-// distribution is subject to the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PARAMETER_IS_MAYBE_050329_HPP
-#define BOOST_PARAMETER_IS_MAYBE_050329_HPP
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-namespace boost {
-namespace parameter {
-namespace aux {
-
-struct maybe_base {};
-
-template <class T>
-struct is_maybe
-  : is_base_and_derived<maybe_base, T>
-{};
-
-} // namespace aux
-} // namespace parameter
-} // namespace boost
-
-#endif // BOOST_PARAMETER_IS_MAYBE_050329_HPP
--- a/include/boost/parameter/aux_/maybe.hpp
+++ b/include/boost/parameter/aux_/maybe.hpp
@@ -2,41 +2,21 @@
 // subject to the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-//
-// 2009.10.21 TDS remove depenency on boost::python::detail::referent_storage
-//
-#ifndef BOOST_PARAMETER_MAYBE_091021_HPP
-# define BOOST_PARAMETER_MAYBE_091021_HPP
+#ifndef BOOST_PARAMETER_MAYBE_060211_HPP
+# define BOOST_PARAMETER_MAYBE_060211_HPP

 # include <boost/mpl/if.hpp>
 # include <boost/mpl/identity.hpp>
 # include <boost/type_traits/is_reference.hpp>
 # include <boost/type_traits/add_reference.hpp>
 # include <boost/optional.hpp>
-# include <boost/aligned_storage.hpp>
+# include <boost/python/detail/referent_storage.hpp>
 # include <boost/type_traits/remove_cv.hpp>
 # include <boost/type_traits/add_const.hpp>
-# include <boost/parameter/aux_/is_maybe.hpp>

 namespace boost { namespace parameter { namespace aux {

-template <class T> struct referent_size;
-
-template <class T>
-struct referent_size<T&>
-{
-  BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(T));
-};
-
-// A metafunction returning a POD type which can store U, where T ==
-// U&. If T is not a reference type, returns a POD which can store T.
-template <class T>
-struct referent_storage
-{
-  typedef typename boost::aligned_storage<
-    referent_size<T>::value
-    >::type type;
-};
+struct maybe_base {};

 template <class T>
 struct maybe : maybe_base
@@ -44,17 +24,17 @@ struct maybe : maybe_base
    typedef typename add_reference<
 # if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
        T const
-# else
+# else 
        typename add_const<T>::type
-# endif
+# endif 
    >::type reference;
-
+    
    typedef typename remove_cv<
        BOOST_DEDUCED_TYPENAME remove_reference<reference>::type
    >::type non_cv_value;
-
-    explicit maybe(T value_)
-      : value(value_)
+        
+    explicit maybe(T value)
+      : value(value)
      , constructed(false)
    {}

@@ -68,28 +48,28 @@ struct maybe : maybe_base
            this->destroy();
    }

-    reference construct(reference value_) const
+    reference construct(reference value) const
    {
-        return value_;
+        return value;
    }

    template <class U>
-    reference construct2(U const& value_) const
+    reference construct2(U const& value) const
    {
-        new (m_storage.address()) non_cv_value(value_);
+        new (m_storage.bytes) non_cv_value(value);
        constructed = true;
-        return *(non_cv_value*)m_storage.address();
+        return *(non_cv_value*)m_storage.bytes;
    }

    template <class U>
-    reference construct(U const& value_) const
+    reference construct(U const& value) const
    {
-        return this->construct2(value_);
+        return this->construct2(value);
    }

    void destroy()
    {
-        ((non_cv_value*)m_storage.address())->~non_cv_value();
+        ((non_cv_value*)m_storage.bytes)->~non_cv_value();
    }

    typedef reference(maybe<T>::*safe_bool)() const;
@@ -107,9 +87,7 @@ struct maybe : maybe_base
 private:
    boost::optional<T> value;
    mutable bool constructed;
-
-
-    mutable typename referent_storage<
+    mutable typename boost::python::detail::referent_storage<
        reference
    >::type m_storage;
 };
--- a/include/boost/parameter/aux_/overloads.hpp
+++ b/include/boost/parameter/aux_/overloads.hpp
--- a/include/boost/parameter/aux_/parameter_requirements.hpp
+++ b/include/boost/parameter/aux_/parameter_requirements.hpp
--- a/include/boost/parameter/aux_/parenthesized_type.hpp
+++ b/include/boost/parameter/aux_/parenthesized_type.hpp
--- a/include/boost/parameter/aux_/preprocessor/flatten.hpp
+++ b/include/boost/parameter/aux_/preprocessor/flatten.hpp
--- a/include/boost/parameter/aux_/preprocessor/for_each.hpp
+++ b/include/boost/parameter/aux_/preprocessor/for_each.hpp
--- a/include/boost/parameter/aux_/python/invoker.hpp
+++ b/include/boost/parameter/aux_/python/invoker.hpp
@@ -8,7 +8,6 @@
 # include <boost/mpl/begin.hpp>
 # include <boost/mpl/next.hpp>
 # include <boost/mpl/deref.hpp>
-# include <boost/mpl/size.hpp>
 # include <boost/parameter/keyword.hpp>
 # include <boost/preprocessor/iteration/iterate.hpp>

--- a/include/boost/parameter/aux_/python/invoker_iterate.hpp
+++ b/include/boost/parameter/aux_/python/invoker_iterate.hpp
--- a/include/boost/parameter/aux_/result_of0.hpp
+++ b/include/boost/parameter/aux_/result_of0.hpp
--- a/include/boost/parameter/aux_/set.hpp
+++ b/include/boost/parameter/aux_/set.hpp
@@ -5,8 +5,6 @@
 #ifndef BOOST_PARAMETER_SET_060912_HPP
 # define BOOST_PARAMETER_SET_060912_HPP

-# include <boost/detail/workaround.hpp>
-
 # if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
  && !BOOST_WORKAROUND(__GNUC__, < 3)
 #  include <boost/mpl/insert.hpp>
--- a/include/boost/parameter/aux_/tag.hpp
+++ b/include/boost/parameter/aux_/tag.hpp
--- a/include/boost/parameter/aux_/tagged_argument.hpp
+++ b/include/boost/parameter/aux_/tagged_argument.hpp
@@ -14,7 +14,6 @@
 # include <boost/mpl/and.hpp>
 # include <boost/mpl/not.hpp>
 # include <boost/type_traits/is_same.hpp>
-# include <boost/type_traits/is_convertible.hpp>
 # include <boost/type_traits/is_reference.hpp>

 namespace boost { namespace parameter { namespace aux {
--- a/include/boost/parameter/aux_/template_keyword.hpp
+++ b/include/boost/parameter/aux_/template_keyword.hpp
--- a/include/boost/parameter/aux_/unwrap_cv_reference.hpp
+++ b/include/boost/parameter/aux_/unwrap_cv_reference.hpp
--- a/include/boost/parameter/aux_/void.hpp
+++ b/include/boost/parameter/aux_/void.hpp
--- a/include/boost/parameter/aux_/yesno.hpp
+++ b/include/boost/parameter/aux_/yesno.hpp
--- a/include/boost/parameter/binding.hpp
+++ b/include/boost/parameter/binding.hpp
--- a/include/boost/parameter/config.hpp
+++ b/include/boost/parameter/config.hpp
--- a/include/boost/parameter/keyword.hpp
+++ b/include/boost/parameter/keyword.hpp
@@ -91,18 +91,14 @@ struct keyword
    // every instantiation of a function template is the same object.
    // We provide a reference to a common instance of each keyword
    // object and prevent construction by users.
-    static keyword<Tag> const instance;
-
-    // This interface is deprecated
+    
    static keyword<Tag>& get()
    {
-        return const_cast<keyword<Tag>&>(instance);
+        static keyword<Tag> result;
+        return result;
    }
 };

-template <class Tag>
-keyword<Tag> const keyword<Tag>::instance = {};
-
 // Reduces boilerplate required to declare and initialize keywords
 // without violating ODR.  Declares a keyword tag type with the given
 // name in namespace tag_namespace, and declares and initializes a
@@ -111,19 +107,19 @@ keyword<Tag> const keyword<Tag>::instance = {};

 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)

-# define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                    \
-    namespace tag_namespace                                             \
-    {                                                                   \
-      struct name                                                       \
-      {                                                                 \
-          static char const* keyword_name()                             \
-          {                                                             \
-              return #name;                                             \
-          }                                                             \
-      };                                                                \
-    }                                                                   \
-    static ::boost::parameter::keyword<tag_namespace::name> const& name \
-       = ::boost::parameter::keyword<tag_namespace::name>::instance;
+# define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                \
+    namespace tag_namespace                                         \
+    {                                                               \
+      struct name                                                   \
+      {                                                             \
+          static char const* keyword_name()                         \
+          {                                                         \
+              return #name;                                         \
+          }                                                         \
+      };                                                            \
+    }                                                               \
+    static ::boost::parameter::keyword<tag_namespace::name>& name   \
+       = ::boost::parameter::keyword<tag_namespace::name>::get();

 #else

@@ -140,8 +136,8 @@ keyword<Tag> const keyword<Tag>::instance = {};
    }                                                               \
    namespace                                                       \
    {                                                               \
-       ::boost::parameter::keyword<tag_namespace::name> const& name \
-       = ::boost::parameter::keyword<tag_namespace::name>::instance;\
+       ::boost::parameter::keyword<tag_namespace::name>& name       \
+       = ::boost::parameter::keyword<tag_namespace::name>::get();   \
    }

 #endif
--- a/include/boost/parameter/macros.hpp
+++ b/include/boost/parameter/macros.hpp
@@ -15,14 +15,13 @@
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/cat.hpp>
-#include <boost/detail/workaround.hpp>

 #define BOOST_PARAMETER_FUN_TEMPLATE_HEAD1(n) \
    template<BOOST_PP_ENUM_PARAMS(n, class T)>

 #define BOOST_PARAMETER_FUN_TEMPLATE_HEAD0(n)

-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) 
+#ifndef BOOST_NO_SFINAE

 # define BOOST_PARAMETER_MATCH_TYPE(n, param)           \
            BOOST_PP_EXPR_IF(n, typename) param::match  \
--- a/include/boost/parameter/match.hpp
+++ b/include/boost/parameter/match.hpp
--- a/include/boost/parameter/name.hpp
+++ b/include/boost/parameter/name.hpp
@@ -16,8 +16,7 @@
 # include <boost/mpl/placeholders.hpp>

 # if !defined(BOOST_NO_SFINAE) \
-  && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
-  && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+  && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

 #  include <boost/utility/enable_if.hpp>
 #  include <boost/mpl/lambda.hpp>
@@ -77,14 +76,14 @@ struct lambda<

 # if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 #  define BOOST_PARAMETER_NAME_OBJECT(tag, name)                    \
-    static ::boost::parameter::keyword<tag> const& name             \
-       = ::boost::parameter::keyword<tag>::instance;
+    static ::boost::parameter::keyword<tag>& name                   \
+       = ::boost::parameter::keyword<tag>::get();
 # else
 #  define BOOST_PARAMETER_NAME_OBJECT(tag, name)                    \
    namespace                                                       \
    {                                                               \
-       ::boost::parameter::keyword<tag> const& name                 \
-       = ::boost::parameter::keyword<tag>::instance;                \
+       ::boost::parameter::keyword<tag>& name                       \
+       = ::boost::parameter::keyword<tag>::get();                   \
    }
 # endif

--- a/include/boost/parameter/parameters.hpp
+++ b/include/boost/parameter/parameters.hpp
@@ -725,7 +725,7 @@ struct parameters
    // ::type).


-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+#ifndef BOOST_NO_SFINAE
    // If NamedList satisfies the PS0, PS1, ..., this is a
    // metafunction returning parameters.  Otherwise it 
    // has no nested ::type.
@@ -775,7 +775,7 @@ struct parameters
 #endif
    >
    struct match
-# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+# ifndef BOOST_NO_SFINAE
      : match_base<
            typename aux::make_arg_list<
                typename BOOST_PARAMETER_build_arg_list(
@@ -835,7 +835,7 @@ struct parameters
    // !!!NOTE!!!
    //
    // The make_arg_list<> produces a reversed arg_list, so
-    // we need to pass the arguments to its constructor
+    // we need to pass the arguments to it's constructor
    // reversed.
    //
    aux::empty_arg_list operator()() const
--- a/include/boost/parameter/preprocessor.hpp
+++ b/include/boost/parameter/preprocessor.hpp
@@ -14,9 +14,7 @@
 # include <boost/parameter/aux_/preprocessor/flatten.hpp>

 # include <boost/preprocessor/repetition/repeat_from_to.hpp>
-# include <boost/preprocessor/comparison/equal.hpp>
 # include <boost/preprocessor/control/if.hpp>
-# include <boost/preprocessor/control/iif.hpp>
 # include <boost/preprocessor/control/expr_if.hpp>
 # include <boost/preprocessor/repetition/enum_params.hpp>
 # include <boost/preprocessor/repetition/enum_binary_params.hpp>
@@ -25,12 +23,9 @@
 # include <boost/preprocessor/seq/for_each_product.hpp>
 # include <boost/preprocessor/seq/for_each_i.hpp> 
 # include <boost/preprocessor/tuple/elem.hpp> 
-# include <boost/preprocessor/tuple/eat.hpp>
 # include <boost/preprocessor/seq/fold_left.hpp>
-# include <boost/preprocessor/seq/push_back.hpp>
 # include <boost/preprocessor/seq/size.hpp>
 # include <boost/preprocessor/seq/enum.hpp>
-# include <boost/preprocessor/seq/push_back.hpp>

 # include <boost/preprocessor/detail/is_nullary.hpp>

@@ -43,7 +38,7 @@

 namespace boost { namespace parameter { namespace aux {

-#  if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+#  ifndef BOOST_NO_SFINAE

 // Given Match, which is "void x" where x is an argument matching
 // criterion, extract a corresponding MPL predicate.
@@ -154,8 +149,7 @@ struct argument_pack
      , typename Parameters::deduced_list
      , tag_keyword_arg
      , mpl::false_
-    >::type result;
-    typedef typename mpl::first<result>::type type;
+    >::type type;
 };

 # if 1 //BOOST_WORKAROUND(BOOST_MSVC, < 1300)
@@ -359,11 +353,11 @@ struct funptr_predicate<void**>
    template<BOOST_PP_ENUM_PARAMS_Z(z, n, class ParameterArgumentType)>
 /**/

-# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+# ifndef BOOST_NO_SFINAE
 #  define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) \
    , typename boost::parameter::aux::match< \
          parameters, BOOST_PP_ENUM_PARAMS(n, ParameterArgumentType) \
-      >::type = parameters()
+      >::type boost_parameter_enabler_argument = parameters()
 # else
 #  define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n)
 # endif
@@ -691,7 +685,7 @@ struct funptr_predicate<void**>
 # define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT(arg, tag_namespace) \
    boost::parameter::keyword< \
        tag_namespace::BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \
-    >::instance | boost::parameter::aux::use_default_tag()
+    >::get() | boost::parameter::aux::use_default_tag()

 # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG(arg, tag_ns) \
    BOOST_PARAMETER_FUNCTION_CAST( \
@@ -840,7 +834,7 @@ struct funptr_predicate<void**>
 # define BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG(r, tag_ns, arg) \
    , BOOST_PARAMETER_FUNCTION_CAST( \
          args[ \
-              boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::instance \
+              boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::get() \
          ] \
        , BOOST_PARAMETER_FN_ARG_PRED(arg) \
      )
--- a/include/boost/parameter/python.hpp
+++ b/include/boost/parameter/python.hpp
--- a/include/boost/parameter/value_type.hpp
+++ b/include/boost/parameter/value_type.hpp
--- a/index.html
+++ b/index.html
--- a/test/basics.cpp
+++ b/test/basics.cpp
@@ -107,6 +107,6 @@ int main()
   
   //f(index = 56, name = 55); // won't compile

-   return boost::report_errors();
+   return 0;
 }

--- a/test/basics.hpp
+++ b/test/basics.hpp
@@ -12,7 +12,6 @@
 #include <boost/assert.hpp>
 #include <boost/mpl/assert.hpp>
 #include <cstring>
-#include <boost/detail/lightweight_test.hpp>

 namespace test {

@@ -80,9 +79,9 @@ struct values_t
        BOOST_MPL_ASSERT((boost::is_same<Value,Value_>));
        BOOST_MPL_ASSERT((boost::is_same<Name,Name_>));
 #endif
-        BOOST_TEST(equal(n, n_));
-        BOOST_TEST(equal(v, v_));
-        BOOST_TEST(equal(i, i_));
+        BOOST_ASSERT(equal(n, n_));
+        BOOST_ASSERT(equal(v, v_));
+        BOOST_ASSERT(equal(i, i_));
    }

    Name const& n;
--- a/test/deduced.cpp
+++ b/test/deduced.cpp
--- a/test/deduced.hpp
+++ b/test/deduced.hpp
--- a/test/deduced_dependent_predicate.cpp
+++ b/test/deduced_dependent_predicate.cpp
--- a/test/deduced_unmatched_arg.cpp
+++ b/test/deduced_unmatched_arg.cpp
--- a/test/duplicates.cpp
+++ b/test/duplicates.cpp
--- a/test/earwicker.cpp
+++ b/test/earwicker.cpp
--- a/test/efficiency.cpp
+++ b/test/efficiency.cpp
--- a/test/macros.cpp
+++ b/test/macros.cpp
--- a/test/maybe.cpp
+++ b/test/maybe.cpp
--- a/test/mpl.cpp
+++ b/test/mpl.cpp
--- a/test/normalized_argument_types.cpp
+++ b/test/normalized_argument_types.cpp
--- a/test/ntp.cpp
+++ b/test/ntp.cpp
--- a/test/optional_deduced_sfinae.cpp
+++ b/test/optional_deduced_sfinae.cpp
--- a/test/preprocessor.cpp
+++ b/test/preprocessor.cpp
@@ -453,7 +453,7 @@ int main()
      , name = S("foo")
    );

-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+#ifndef BOOST_NO_SFINAE
    assert(sfinae("foo") == 1);
    assert(sfinae(1) == 0);

--- a/test/preprocessor_deduced.cpp
+++ b/test/preprocessor_deduced.cpp
--- a/test/python_test.cpp
+++ b/test/python_test.cpp
--- a/test/sfinae.cpp
+++ b/test/sfinae.cpp
@@ -9,7 +9,7 @@
 #include <string>
 #include <boost/type_traits/is_convertible.hpp>

-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+#ifndef BOOST_NO_SFINAE
 # include <boost/utility/enable_if.hpp>
 # include <boost/type_traits/is_same.hpp>
 #endif 
@@ -70,7 +70,7 @@ namespace test
      f_impl(args(a0, a1));
  }

-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+#ifndef BOOST_NO_SFINAE
  // On compilers that actually support SFINAE, add another overload
  // that is an equally good match and can only be in the overload set
  // when the others are not.  This tests that the SFINAE is actually
@@ -96,7 +96,7 @@ int main()
    f("foo", 3.f);
    f(value = 3.f, name = "foo");

-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+#ifndef BOOST_NO_SFINAE
    BOOST_TEST(f(3, 4) == 0);
 #endif
    return boost::report_errors();
--- a/test/singular.cpp
+++ b/test/singular.cpp
--- a/test/timings.txt
+++ b/test/timings.txt
--- a/test/tutorial.cpp
+++ b/test/tutorial.cpp
--- a/test/unwrap_cv_reference.cpp
+++ b/test/unwrap_cv_reference.cpp