Release 1.53.0

[SVN r82734]
Merged Boost.Parameter fixes from trunk to support accessing named paramter types tag::x::_.
2026-01-28 07:22:28 +00:00 · 2013-02-04 18:11:49 +00:00 · 2012-06-07 18:21:25 +00:00 · 2011-12-21 11:20:00 +00:00 · 2011-12-19 18:00:17 +00:00 · 2011-01-22 15:42:09 +00:00
64 changed files with 1392 additions and 798 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.5: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.6: 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="2006-09-21" />
+<meta name="date" content="2008-03-22" />
 <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" href="mailto:dalwan01&#64;student.umu.se">dalwan01&#64;student.umu.se</a></td></tr>
+<td><a class="first last reference external" 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" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
+<td><a class="first last reference external" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2006-09-21</td></tr>
+<td>2008-03-22</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" 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 external" 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" href="http://www.boost.org/LICENSE_1_0.txt">http
 <p>Makes it possible to bind Boost.Parameter-enabled
 functions, operators and constructors to Python.</p>
 </div>
-<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>
+<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>
 <ul class="simple">
-<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>
+<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>
 </ul>
 </div>
-<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
+<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
 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" 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>
+<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>
 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">
-<h1><a class="toc-backref" href="#id9" id="tutorial" name="tutorial">Tutorial</a></h1>
+<div class="section" id="tutorial">
+<h1><a class="toc-backref" href="#id8">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" href="index.html">macros</a> are required to understand this section.</p>
+Boost.Parameter <a class="reference external" 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,10 +121,11 @@ 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" 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 external" 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.</p>
+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>
 <pre class="literal-block">
 struct open_fwd
 {
@@ -150,7 +151,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" href="#special-keywords">special keywords</a>.</p>
+<a class="reference internal" href="#special-keywords">special keywords</a>.</p>
 </div>
 <p>Next we'll define the module and export the class:</p>
 <pre class="literal-block">
@@ -184,11 +185,13 @@ 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" href="../../../mpl/doc/refmanual/sequences.html">MPL
+forwarding overloads that we defined earlier. The second one is an <a class="reference external" 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" 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 <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
 pointer syntax means that the parameter is optional, so in this case
 ``width`` and ``height`` are optional parameters. The third parameter
@@ -239,8 +242,8 @@ users of broken compilers will have to give us function pointer
 types instead). -->
 </div>
 <hr class="docutils" />
-<div class="section">
-<h1><a class="toc-backref" href="#id10" id="concept-parameterspec" name="concept-parameterspec">concept <span class="concept">ParameterSpec</span></a></h1>
+<div class="section" id="concept-parameterspec">
+<h1><a class="toc-backref" href="#id9">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>
@@ -250,8 +253,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" 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
+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
 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; ]
@@ -260,12 +263,13 @@ 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">
-<h1><a class="toc-backref" href="#id11" id="special-keywords" name="special-keywords"><em>special</em> keywords</a></h1>
+<div class="section" id="special-keywords">
+<h1><a class="toc-backref" href="#id10"><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. 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>
+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: -->
 <pre class="literal-block">
 namespace core
 {
@@ -313,19 +317,21 @@ 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. 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. 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>
 </div>
 <hr class="docutils" />
-<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>
+<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>
 <p>Defines a named parameter enabled constructor.</p>
 <pre class="literal-block">
 template &lt;class ParameterSpecs&gt;
@@ -339,16 +345,16 @@ struct init : python::def_visitor&lt;init&lt;ParameterSpecs&gt; &gt;
 };
 </pre>
 <!-- @ignore() -->
-<div class="section">
-<h2><a id="init-requirements" name="init-requirements"><tt class="docutils literal"><span class="pre">init</span></tt> requirements</a></h2>
+<div class="section" id="init-requirements">
+<h2><tt class="docutils literal"><span class="pre">init</span></tt> requirements</h2>
 <ul>
-<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
+<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
 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">
+<table border="1" class="docutils">
 <colgroup>
 <col width="30%" />
 <col width="17%" />
@@ -376,13 +382,13 @@ expressions:</p>
 </li>
 </ul>
 </div>
-<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>
+<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>
 <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">
-<h2><a id="id3" name="id3">Example</a></h2>
+<div class="section" id="example">
+<h2>Example</h2>
 <pre class="literal-block">
 #include &lt;boost/parameter/keyword.hpp&gt;
 #include &lt;boost/parameter/preprocessor.hpp&gt;
@@ -440,8 +446,8 @@ assert(args[y | 1] == 1);
 </div>
 </div>
 <hr class="docutils" />
-<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>
+<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>
 <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;
@@ -455,16 +461,16 @@ struct call : python::def_visitor&lt;call&lt;ParameterSpecs&gt; &gt;
 };
 </pre>
 <!-- @ignore() -->
-<div class="section">
-<h2><a id="call-requirements" name="call-requirements"><tt class="docutils literal"><span class="pre">call</span></tt> requirements</a></h2>
+<div class="section" id="call-requirements">
+<h2><tt class="docutils literal"><span class="pre">call</span></tt> requirements</h2>
 <ul>
-<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
+<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
 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">
+<table border="1" class="docutils">
 <colgroup>
 <col width="24%" />
 <col width="26%" />
@@ -493,13 +499,13 @@ instance of <tt class="docutils literal"><span class="pre">Class</span></tt>:</p
 </li>
 </ul>
 </div>
-<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>
+<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>
 <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">
-<h2><a id="id5" name="id5">Example</a></h2>
+<div class="section" id="id4">
+<h2>Example</h2>
 <pre class="literal-block">
 #include &lt;boost/parameter/keyword.hpp&gt;
 #include &lt;boost/parameter/preprocessor.hpp&gt;
@@ -567,8 +573,8 @@ return 0;
 </div>
 </div>
 <hr class="docutils" />
-<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>
+<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>
 <p>Defines a named parameter enabled member function.</p>
 <pre class="literal-block">
 template &lt;class Fwd, class ParameterSpecs&gt;
@@ -579,16 +585,16 @@ struct function : python::def_visitor&lt;function&lt;Fwd, ParameterSpecs&gt; &gt
 };
 </pre>
 <!-- @ignore() -->
-<div class="section">
-<h2><a id="function-requirements" name="function-requirements"><tt class="docutils literal"><span class="pre">function</span></tt> requirements</a></h2>
+<div class="section" id="function-requirements">
+<h2><tt class="docutils literal"><span class="pre">function</span></tt> requirements</h2>
 <ul>
-<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
+<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
 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">
+<table border="1" class="docutils">
 <colgroup>
 <col width="39%" />
 <col width="18%" />
@@ -619,8 +625,8 @@ are tagged arguments.</p>
 </li>
 </ul>
 </div>
-<div class="section">
-<h2><a id="id6" name="id6">Example</a></h2>
+<div class="section" id="id5">
+<h2>Example</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>
@@ -683,23 +689,23 @@ assert(y == 1);
 </div>
 </div>
 <hr class="docutils" />
-<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>
+<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>
 <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">
-<h2><a id="def-requirements" name="def-requirements"><tt class="docutils literal"><span class="pre">def</span></tt> requirements</a></h2>
+<div class="section" id="def-requirements">
+<h2><tt class="docutils literal"><span class="pre">def</span></tt> requirements</h2>
 <ul>
-<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
+<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
 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">
+<table border="1" class="docutils">
 <colgroup>
 <col width="39%" />
 <col width="21%" />
@@ -728,8 +734,8 @@ is the result type of <tt class="docutils literal"><span class="pre">f(…)</spa
 </li>
 </ul>
 </div>
-<div class="section">
-<h2><a id="id7" name="id7">Example</a></h2>
+<div class="section" id="id6">
+<h2>Example</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>
@@ -765,16 +771,16 @@ BOOST_PYTHON_MODULE(…)
 <!-- again, the undefined ``fwd`` identifier. -->
 </div>
 </div>
-<div class="section">
-<h1><a class="toc-backref" href="#id16" id="portability" name="portability">Portability</a></h1>
+<div class="section" id="portability">
+<h1><a class="toc-backref" href="#id15">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: 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.
+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.

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

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


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

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

-:Copyright:     Copyright David Abrahams, Daniel Wallin 2005. 
-                Distributed under the Boost Software License,
+:copyright:     Copyright David Abrahams, Daniel Wallin
+                2005-2009. 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)

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

-.. _concepts: ../../../more/generic_programming.html#concept
+.. _concepts: http://www.boost.org/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
@@ -351,8 +356,8 @@ shown in the table below.
 .. _`IncidenceGraph`: ../../../graph/doc/IncidenceGraph.html
 .. _`VertexListGraph`: ../../../graph/doc/VertexListGraph.html
 .. _`DFSVisitor`: ../../../graph/doc/DFSVisitor.html
-.. _`ReadWritePropertyMap`: ../../../property_map/ReadWritePropertyMap.html
-.. _`ReadablePropertyMap`: ../../../property_map/ReadablePropertyMap.html
+.. _`ReadWritePropertyMap`: ../../../property_map/doc/ReadWritePropertyMap.html
+.. _`ReadablePropertyMap`: ../../../property_map/doc/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
@@ -1067,8 +1072,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()
@@ -1081,7 +1086,7 @@ specify the parameter name explicitly, as follows:
 .. parsed-literal::

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

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

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

 .. @test('compile')

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

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

 .. @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
 ------------------------------
@@ -1333,10 +1371,10 @@ separately)::
  using boost::mpl::_;

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

  }}
@@ -1345,6 +1383,7 @@ 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;
@@ -1371,12 +1410,13 @@ 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 ``binding<
-… >`` metafunction to extract “logical parameters”.  Note that
-defaults are specified by supplying an optional third argument to
-``binding< … >``::
+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::

  namespace boost { namespace python {

@@ -1394,16 +1434,16 @@ defaults are specified by supplying an optional third argument to
      args;

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

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

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

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

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

  > class_signature;

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

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

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

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

  int z1 = print_name_and_index( 
     **spec(**\ _index=12, _name="sam"\ **)** 
@@ -1720,6 +1764,11 @@ 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
 ==========================

@@ -1764,13 +1813,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 ``binding< … >`` metafunction introduced
+case we can use the ``value_type< … >`` metafunction introduced
 `earlier`__::

   BOOST_PARAMETER_NAME(index)

   template <class ArgumentPack>
-   typename parameter::binding<ArgumentPack, tag::index, int>::type
+   typename parameter::value_type<ArgumentPack, tag::index, int>::type
   twice_index(ArgumentPack const& args)
   {
       return 2 * args[_index|42];
@@ -1778,13 +1827,13 @@ case we can use the ``binding< … >`` 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()
@@ -1792,7 +1841,11 @@ case we can use the ``binding< … >`` metafunction introduced
       assert(six == 6);
   }''')

-.. @test('run')
+.. @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.

 __ binding_intro_

@@ -1837,21 +1890,29 @@ 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 combining the logical-or (“``||``”) operator
-with a function object built by the Boost Lambda_ library: [#bind]_
+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]_

 .. parsed-literal::

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

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

   namespace parameter = boost::parameter;

@@ -1876,7 +1937,7 @@ with a function object built by the Boost Lambda_ library: [#bind]_

 .. @test('run')

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

 .. sidebar:: Mnemonics

@@ -1886,10 +1947,15 @@ with a function object built by the Boost Lambda_ library: [#bind]_
   Similarly, in ``color_map[param||f]``, ``f`` is only invoked if
   no ``color_map`` argument was supplied.

-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 ``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.

 ================ 
 Best Practices
@@ -2251,17 +2317,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:       Daniel Wallin
-:Contact:       dalwan01@student.umu.se
-:organization:  `Boost Consulting`_
+:Authors:       David Abrahams, Daniel Wallin
+:Contact:       dave@boost-consulting.com, daniel@boostpro.com
+:organization:  `BoostPro Computing`_
 :date:          $Date$

 :copyright:     Copyright David Abrahams, Daniel Wallin
-                2005. Distributed under the Boost Software License,
+                2005-2009. 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

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


 .. role:: class
@@ -132,7 +132,8 @@ 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.
+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. 

 ::

@@ -204,7 +205,9 @@ 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``.
+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
    pointer syntax means that the parameter is optional, so in this case
@@ -295,8 +298,10 @@ 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. 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. 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:

 .. parsed-literal::

@@ -351,18 +356,20 @@ docs. The example uses a different technique, but could also have been written l

 .. @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. 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. 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.

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

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

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

 :copyright:     Copyright David Abrahams, Daniel Wallin
-                2005. Distributed under the Boost Software License,
+                2005-2009. 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

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


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

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

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

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

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

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


@@ -403,13 +402,22 @@ __ ../../../../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 
-     |      ``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
+     |     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|.


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

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

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

@@ -443,11 +451,10 @@ __ ../../../../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:
@@ -488,6 +495,23 @@ 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
@@ -546,6 +570,37 @@ __ ../../../../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
@@ -554,6 +609,7 @@ 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)``
 -----------------------------------------------------------------

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

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

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

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

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

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

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

    template <class A0, …, class A\ **m**>
    *result type* **name**\ (
@@ -661,9 +716,149 @@ 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
@@ -694,11 +889,10 @@ 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**
@@ -713,6 +907,11 @@ 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.
@@ -771,7 +970,7 @@ already ``#defined``.

 __ ../../../../boost/parameter/config.hpp

-:Default Value: ``5``
+:Default Value: ``8``

 Tutorial
 ========
--- a/include/boost/parameter.hpp
+++ b/include/boost/parameter.hpp
@@ -3,6 +3,8 @@
 // (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,6 +11,7 @@
 #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>
@@ -21,11 +22,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;
@@ -45,7 +46,7 @@ struct lambda_tag;
 // declarations to build member function overload sets that can
 // match against keywords.
 //
-  
+
 // MPL sequence support
 struct arg_list_tag;

@@ -82,14 +83,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
@@ -158,15 +159,6 @@ 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
 {
@@ -214,9 +206,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 arg, Next const& tail)
+    arg_list(TaggedArg head, Next const& tail)
      : Next(tail)
-      , arg(arg)
+      , arg(head)
    {}

    // A metafunction class that, given a keyword and a default
@@ -244,8 +236,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(
@@ -260,7 +252,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
@@ -340,7 +332,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>
@@ -348,7 +340,7 @@ struct arg_list : Next
    {
        return arg.value;
    }
-    
+
 #else

    reference operator[](keyword<key_type> const&) const
@@ -403,7 +395,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);
@@ -417,7 +409,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>
@@ -427,7 +419,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,6 +5,8 @@
 #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>
@@ -38,11 +40,11 @@ struct use_default_tag {};
 //   X(something, *(predicate))
 //   X(something, (int))

-template <class T>
+template <class T, class Args>
 struct cast;

-template <>
-struct cast<void*>
+template <class Args>
+struct cast<void*, Args>
 {
    static use_default_tag execute(use_default_tag)
    {
@@ -71,27 +73,39 @@ struct cast<void*>

 typedef void* voidstar;

-template <class T>
-struct cast<voidstar(T)>
-  : cast<void*>
+template <class T, class Args>
+struct cast<voidstar(T), Args>
+  : cast<void*, Args>
 {
 };

 #else

-template <class T>
-struct cast<void*(T)>
-  : cast<void*>
+template <class T, class Args>
+struct cast<void*(T), Args>
+  : cast<void*, Args>
 {
 };

 #endif

-template <class T>
-struct cast<void(T)>
+// This is a hack used in cast<> to turn the user supplied type,
+// which may or may not be a placeholder expression into one, so
+// that it will be properly evaluated by mpl::apply.
+template <class T, class Dummy = mpl::_1>
+struct as_placeholder_expr
 {
+    typedef T type;
+};
+
+template <class T, class Args>
+struct cast<void(T), Args>
+{
+    typedef typename mpl::apply2<
+        as_placeholder_expr<T>, Args, Args>::type type0;
+
    typedef typename boost::add_reference<
-        typename boost::remove_const<T>::type 
+        typename boost::remove_const<type0>::type 
    >::type reference;

    static use_default_tag execute(use_default_tag)
@@ -104,7 +118,7 @@ struct cast<void(T)>
        return use_default_tag();
    }

-    static T execute(T value)
+    static type0 execute(type0 value)
    {
        return value;
    }
@@ -116,9 +130,9 @@ struct cast<void(T)>
    }
 };

-#  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) \
-    boost::parameter::aux::cast<void predicate>::remove_const( \
-        boost::parameter::aux::cast<void predicate>::execute(value) \
+#  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate, args) \
+    boost::parameter::aux::cast<void predicate, args>::remove_const( \
+        boost::parameter::aux::cast<void predicate, args>::execute(value) \
    )

 # endif
--- a/include/boost/parameter/aux_/default.hpp
+++ b/include/boost/parameter/aux_/default.hpp
@@ -4,7 +4,9 @@
 // http://www.boost.org/LICENSE_1_0.txt)

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

 namespace boost { namespace parameter { namespace aux {

@@ -27,7 +29,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.
@@ -48,8 +50,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
 {
@@ -58,8 +60,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
@@ -0,0 +1,26 @@
+// 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,21 +2,41 @@
 // 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_MAYBE_060211_HPP
-# define BOOST_PARAMETER_MAYBE_060211_HPP
+//
+// 2009.10.21 TDS remove depenency on boost::python::detail::referent_storage
+//
+#ifndef BOOST_PARAMETER_MAYBE_091021_HPP
+# define BOOST_PARAMETER_MAYBE_091021_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/python/detail/referent_storage.hpp>
+# include <boost/aligned_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 {

-struct maybe_base {};
+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;
+};

 template <class T>
 struct maybe : maybe_base
@@ -24,17 +44,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)
    {}

@@ -48,28 +68,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.bytes) non_cv_value(value);
+        new (m_storage.address()) non_cv_value(value_);
        constructed = true;
-        return *(non_cv_value*)m_storage.bytes;
+        return *(non_cv_value*)m_storage.address();
    }

    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.bytes)->~non_cv_value();
+        ((non_cv_value*)m_storage.address())->~non_cv_value();
    }

    typedef reference(maybe<T>::*safe_bool)() const;
@@ -87,7 +107,9 @@ struct maybe : maybe_base
 private:
    boost::optional<T> value;
    mutable bool constructed;
-    mutable typename boost::python::detail::referent_storage<
+
+
+    mutable typename 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,6 +8,7 @@
 # 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,6 +5,8 @@
 #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,6 +14,7 @@
 # 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
@@ -7,7 +7,7 @@
 #define BOOST_PARAMETER_CONFIG_050403_HPP

 #ifndef BOOST_PARAMETER_MAX_ARITY
-# define BOOST_PARAMETER_MAX_ARITY 5
+# define BOOST_PARAMETER_MAX_ARITY 8
 #endif

 #endif // BOOST_PARAMETER_CONFIG_050403_HPP
--- a/include/boost/parameter/keyword.hpp
+++ b/include/boost/parameter/keyword.hpp
@@ -91,14 +91,18 @@ 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()
    {
-        static keyword<Tag> result;
-        return result;
+        return const_cast<keyword<Tag>&>(instance);
    }
 };

+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
@@ -107,19 +111,19 @@ struct keyword

 #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>& name   \
-       = ::boost::parameter::keyword<tag_namespace::name>::get();
+# 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;

 #else

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

 #endif
--- a/include/boost/parameter/macros.hpp
+++ b/include/boost/parameter/macros.hpp
@@ -15,13 +15,14 @@
 #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)

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

 # 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,7 +16,8 @@
 # include <boost/mpl/placeholders.hpp>

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

 #  include <boost/utility/enable_if.hpp>
 #  include <boost/mpl/lambda.hpp>
@@ -26,7 +27,7 @@ namespace boost { namespace parameter { namespace aux {
 // Tag type passed to MPL lambda.
 struct lambda_tag;

-struct name_tag_base 
+struct name_tag_base
 {};

 template <class Tag>
@@ -45,7 +46,7 @@ namespace boost { namespace mpl {
 template <class T>
 struct lambda<
    T
-  , typename enable_if<
+  , typename boost::enable_if<
        parameter::aux::is_name_tag<T>, parameter::aux::lambda_tag
    >::type
 >
@@ -76,14 +77,14 @@ struct lambda<

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

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


-#ifndef BOOST_NO_SFINAE
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
    // 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
-# ifndef BOOST_NO_SFINAE
+# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
      : 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 it's constructor
+    // we need to pass the arguments to its constructor
    // reversed.
    //
    aux::empty_arg_list operator()() const
--- a/include/boost/parameter/preprocessor.hpp
+++ b/include/boost/parameter/preprocessor.hpp
@@ -14,7 +14,9 @@
 # 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>
@@ -23,9 +25,12 @@
 # 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>

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

 namespace boost { namespace parameter { namespace aux {

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

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

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

-# ifndef BOOST_NO_SFINAE
+# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
 #  define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) \
    , typename boost::parameter::aux::match< \
          parameters, BOOST_PP_ENUM_PARAMS(n, ParameterArgumentType) \
-      >::type boost_parameter_enabler_argument = parameters()
+      >::type = parameters()
 # else
 #  define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n)
 # endif
@@ -685,7 +691,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) \
-    >::get() | boost::parameter::aux::use_default_tag()
+    >::instance | boost::parameter::aux::use_default_tag()

 # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG(arg, tag_ns) \
    BOOST_PARAMETER_FUNCTION_CAST( \
@@ -695,6 +701,7 @@ struct funptr_predicate<void**>
            ) \
        ] \
      , BOOST_PARAMETER_FN_ARG_PRED(arg) \
+      , Args \
    )

 # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY(name, n, split_args, tag_namespace) \
@@ -722,6 +729,7 @@ struct funptr_predicate<void**>
    BOOST_PARAMETER_FUNCTION_CAST( \
        boost::parameter::aux::as_lvalue(BOOST_PARAMETER_FN_ARG_DEFAULT(arg), 0L) \
      , BOOST_PARAMETER_FN_ARG_PRED(arg) \
+      , Args \
    )

 # define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY(name, n, split_args, tag_ns, const_) \
@@ -834,9 +842,10 @@ 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)>::get() \
+              boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::instance \
          ] \
        , BOOST_PARAMETER_FN_ARG_PRED(arg) \
+        , Args \
      )

 // Generates the function template that recives a ArgumentPack, and then
--- 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 0;
+   return boost::report_errors();
 }

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

 namespace test {

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

-#ifndef BOOST_NO_SFINAE
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
    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>

-#ifndef BOOST_NO_SFINAE
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
 # 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));
  }

-#ifndef BOOST_NO_SFINAE
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
  // 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");

-#ifndef BOOST_NO_SFINAE
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
    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
Author	SHA1	Message	Date
Marshall Clow	706f83be06	Release 1.53.0 [SVN r82734]	2013-02-04 18:11:49 +00:00
Lorenzo Caminiti	b74489d477	Merged Boost.Parameter fixes from trunk to support accessing named paramter types tag::x::_. [SVN r78851]	2012-06-07 18:21:25 +00:00
Tim Blechmann	475001a591	parameter: merge fix from trunk (required for boost.heap) [SVN r76090]	2011-12-21 11:20:00 +00:00
Tim Blechmann	f9e0d1c5c3	parameter: merge enable_if fix from trunk [SVN r76069]	2011-12-19 18:00:17 +00:00
Marshall Clow	bdcbf442bf	Merge fix to release branch, fixes #4983 [SVN r68366]	2011-01-22 15:42:09 +00:00
Andrey Semashev	c9cf0ab0f5	Merged changes from trunk. [SVN r62272]	2010-05-27 17:58:58 +00:00
Douglas Gregor	20301b3da4	Add some missing includes for the parameter library [SVN r62231]	2010-05-26 07:47:05 +00:00
Andrey Semashev	59e172adb3	Added missing include. [SVN r60776]	2010-03-22 20:18:30 +00:00
Troy D. Straszheim	9f4334c1c1	rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release. [SVN r56941]	2009-10-17 01:10:45 +00:00
Daniel James	7ff5c4b996	Merge some missing link/libraries changes. Fixes #2279,#3454. Merged revisions 52231,53476 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r52231 \| jewillco \| 2009-04-07 17:46:32 +0100 (Tue, 07 Apr 2009) \| 1 line Updating maintainer info for BGL, fixes #2279 ........ r53476 \| jewillco \| 2009-05-31 02:40:59 +0100 (Sun, 31 May 2009) \| 1 line Fixed more links to property_map ........ [SVN r56226]	2009-09-15 21:16:58 +00:00
Troy D. Straszheim	1b1499b94c	Add basic copyright/license to keep cmake out of the inspection report [SVN r55095]	2009-07-22 21:51:01 +00:00
Troy D. Straszheim	3cf03f73ca	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
Dave Abrahams	04cea6497d	Merging all parameter changes from trunk. These all look like they fix bugs, although the one that lets you use the argument pack to compute a return type was never tested (still isn't). [SVN r47446]	2008-07-15 16:02:00 +00:00
Daniel James	e6eda9a776	Merged revisions 43206,43208-43213 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r43206 \| danieljames \| 2008-02-10 09:55:03 +0000 (Sun, 10 Feb 2008) \| 1 line Fix some broken links. ........ r43209 \| danieljames \| 2008-02-10 14:56:22 +0000 (Sun, 10 Feb 2008) \| 1 line Link to people pages on the website, as they've been removed from the download. ........ r43210 \| danieljames \| 2008-02-10 15:02:17 +0000 (Sun, 10 Feb 2008) \| 1 line Point links to the pages that used to be in 'more' to the site. ........ r43212 \| danieljames \| 2008-02-10 16:10:16 +0000 (Sun, 10 Feb 2008) \| 1 line Fix links on the home page as well. ........ r43213 \| danieljames \| 2008-02-10 16:21:22 +0000 (Sun, 10 Feb 2008) \| 1 line Generated documentation which is no longer generated. ........ [SVN r43214]	2008-02-10 16:39:38 +00:00
Beman Dawes	8a404e2d67	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41370]	2007-11-25 18:38:02 +00:00
Beman Dawes	31f9f620fe	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41369]	2007-11-25 18:07:19 +00:00
Beman Dawes	56ddeddfaf	Starting point for releases [SVN r39706]	2007-10-05 14:25:06 +00:00
nobody	fe43dad724	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Daniel Wallin	ce2d43c1b5	Merged HEAD to RC_1_34_0 [SVN r37582]	2007-05-03 14:39:42 +00:00
nobody	86d7201a99	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r37579]	2007-05-03 14:11:06 +00:00