Quickbook: Merge from trunk to quickbook-dev.

[SVN r76255]
2026-01-20 16:52:13 +00:00 · 2012-01-01 13:35:27 +00:00 · 2011-12-07 09:40:30 +00:00 · 2011-11-30 01:35:25 +00:00 · 2011-03-27 10:17:05 +00:00
55 changed files with 2975 additions and 281 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,136 +0,0 @@
-# Copyright 2016 Edward Diener
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
-
-    - os: linux
-      compiler: g++-4.4
-      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.6
-      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-libc++
-      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - git submodule update --init libs/parameter_python
-  - cp -r $TRAVIS_BUILD_DIR/* libs/parameter
-  - python tools/boostdep/depinst/depinst.py parameter
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 --verbose-test libs/config/test//config_info toolset=$TOOLSET cxxstd=$CXXSTD || true
-  - ./b2 -j3 libs/parameter/test toolset=$TOOLSET cxxstd=$CXXSTD
-
-notifications:
-  email:
-    on_success: always
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,37 +0,0 @@
-# Copyright 2017 Edward Diener
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0,msvc-14.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-
-install:
-  - cd ..
-  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - git submodule update --init libs/parameter_python
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\parameter
-  - python tools/boostdep/depinst/depinst.py parameter
-  - bootstrap
-  - b2 headers
-
-build: off
-
-test_script:
-  - b2 libs/parameter/test toolset=%TOOLSET%
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -1,12 +1,12 @@
 # Copyright David Abrahams 2006. 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)
-
 import docutils ;

-sources = [ glob *.rst ] ;
+import path ;
+sources = [ path.glob . : *.rst ] ;
 bases = $(sources:S=) ;
-
+  
 # This is a path relative to the html/ subdirectory where the
 # generated output will eventually be moved.
 stylesheet = "--stylesheet=rst.css" ;
@@ -22,9 +22,3 @@ for local b in $(bases)

 alias htmls : $(bases) ;
 stage html : $(bases) ;
-
-###############################################################################
-alias boostdoc ;
-explicit boostdoc ;
-alias boostrelease : html ;
-explicit boostrelease ;
--- a/doc/html/index.html
+++ b/doc/html/index.html
@@ -37,7 +37,7 @@ can be deduced from their types.</p>
 </tbody>
 </table>
 <!-- @jam_prefix.append('''
-project test : requirements <include>. <implicit-dependency>/boost//headers ;''') -->
+project test : requirements <include>. <source>/boost//headers ;''') -->
 <!-- @example.prepend('''
 #include <boost/parameter.hpp>

@@ -727,7 +727,7 @@ worse—think of the kinds of errors you get from your STL
 implementation when you make a mistake).<a class="footnote-reference" href="#conceptcpp" id="id7"><sup>4</sup></a></li>
 <li>The problems with exposing such permissive function template
 signatures have been the subject of much discussion, especially
-in the presence of <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">unqualified calls</a>.  If all we want is to
+in the presence of <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#225">unqualified calls</a>.  If all we want is to
 avoid unintentional argument-dependent lookup (ADL), we can
 isolate <tt class="docutils literal">depth_first_search</tt> in a namespace containing no
 types<a class="footnote-reference" href="#using" id="id8"><sup>6</sup></a>, but suppose we <em>want</em> it to found via ADL?</li>
@@ -1632,7 +1632,7 @@ using boost::mpl::_;''') -->
 int main()
 {}''') -->
 <!-- @test('run', howmany='all') -->
-<p>Note that because of the <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">forwarding problem</a>, <tt class="docutils literal"><span class="pre">parameter::parameters::operator()</span></tt>
+<p>Note that because of the <a class="reference external" href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">forwarding problem</a>, <tt class="docutils literal"><span class="pre">parameter::parameters::operator()</span></tt>
 can't accept non-const rvalues.</p>
 </div>
 <div class="section" id="extracting-parameter-types">
--- a/doc/html/python.html
+++ b/doc/html/python.html
@@ -0,0 +1,788 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.7: http://docutils.sourceforge.net/" />
+<title>The Boost Parameter Library Python Binding Documentation</title>
+<meta name="authors" content="David Abrahams  Daniel Wallin" />
+<meta name="organization" content="BoostPro Computing" />
+<meta name="date" content="2009-01-29" />
+<meta name="copyright" content="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)" />
+<link rel="stylesheet" href="rst.css" type="text/css" />
+</head>
+<body>
+<div class="document" id="the-boost-parameter-library-python-binding-documentation">
+<h1 class="title">The Boost Parameter Library Python Binding Documentation</h1>
+<table class="docinfo" frame="void" rules="none">
+<col class="docinfo-name" />
+<col class="docinfo-content" />
+<tbody valign="top">
+<tr><th class="docinfo-name">Authors:</th>
+<td>David Abrahams
+<br />Daniel Wallin</td></tr>
+<tr><th class="docinfo-name">Contact:</th>
+<td><a class="first reference external" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a>, <a class="last reference external" href="mailto:daniel&#64;boostpro.com">daniel&#64;boostpro.com</a></td></tr>
+<tr><th class="docinfo-name">Organization:</th>
+<td><a class="first last reference external" href="http://www.boostpro.com">BoostPro Computing</a></td></tr>
+<tr><th class="docinfo-name">Date:</th>
+<td>2009-01-29</td></tr>
+<tr><th class="docinfo-name">Copyright:</th>
+<td>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 <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">
+<p class="topic-title first">Abstract</p>
+<p>Makes it possible to bind Boost.Parameter-enabled
+functions, operators and constructors to Python.</p>
+</div>
+<p><a class="reference external" href="../../../../index.htm"><img alt="Boost" src="../../../../boost.png" /></a></p>
+<div class="contents topic" id="contents">
+<p class="topic-title first">Contents</p>
+<ul class="simple">
+<li><a class="reference internal" href="#introduction" id="id7">Introduction</a></li>
+<li><a class="reference internal" href="#tutorial" id="id8">Tutorial</a></li>
+<li><a class="reference internal" href="#concept-parameterspec" id="id9">concept <span class="concept">ParameterSpec</span></a></li>
+<li><a class="reference internal" href="#special-keywords" id="id10"><em>special</em> keywords</a></li>
+<li><a class="reference internal" href="#class-template-init" id="id11">class template <tt class="docutils literal">init</tt></a></li>
+<li><a class="reference internal" href="#class-template-call" id="id12">class template <tt class="docutils literal">call</tt></a></li>
+<li><a class="reference internal" href="#class-template-function" id="id13">class template <tt class="docutils literal">function</tt></a></li>
+<li><a class="reference internal" href="#function-template-def" id="id14">function template <tt class="docutils literal">def</tt></a></li>
+<li><a class="reference internal" href="#portability" id="id15">Portability</a></li>
+</ul>
+</div>
+<div class="section" id="introduction">
+<h1><a class="toc-backref" href="#id7">Introduction</a></h1>
+<p><tt class="docutils literal">boost/parameter/python.hpp</tt> introduces a group of <a class="reference external" href="../../../python/doc/v2/def_visitor.html"><tt class="docutils literal">def_visitors</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">def()</tt> that can be used
+to expose Boost.Parameter-enabled free functions.</p>
+<p>When binding a Boost.Parameter enabled function, the keyword tags
+must be specified.  Additionally, because Boost.Parameter enabled
+functions are templates, the desired function signature must be
+specified.</p>
+<!-- The keyword tags are specified as an `MPL Sequence`_, using the
+pointer qualifications described in |ParameterSpec|_ below.  The
+signature is also specifid as an `MPL sequence`_ of parameter
+types. Additionally, ``boost::parameter::python::function`` and
+``boost::parameter::python::def`` requires a class with forwarding
+overloads. We will take a closer look at how this is done in the
+tutorial section below. -->
+<p>The keyword tags and associated argument types are specified as an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL
+Sequence</a>, using the function type syntax described in <a class="reference internal" href="#concept-parameterspec"><span class="concept">ParameterSpec</span></a>
+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>
+<!-- The last two sentences are terribly vague.  Which namespace is -->
+<!-- ``function`` in?  Isn't the return type always needed?  What -->
+<!-- else are we going to do other than pass these sequences to -->
+<!-- function? -->
+</div>
+<div class="section" id="tutorial">
+<h1><a class="toc-backref" href="#id8">Tutorial</a></h1>
+<p>In this section we will outline the steps needed to bind a simple
+Boost.Parameter-enabled member function to Python. Knowledge of the
+Boost.Parameter <a class="reference external" href="index.html">macros</a> are required to understand this section.</p>
+<p>The class and member function we are interested in binding looks
+like this:</p>
+<pre class="literal-block">
+#include &lt;boost/parameter/keyword.hpp&gt;
+#include &lt;boost/parameter/preprocessor.hpp&gt;
+#include &lt;boost/parameter/python.hpp&gt;
+#include &lt;boost/python.hpp&gt;
+
+// First the keywords
+BOOST_PARAMETER_KEYWORD(tag, title)
+BOOST_PARAMETER_KEYWORD(tag, width)
+BOOST_PARAMETER_KEYWORD(tag, height)
+
+class window
+{
+public:
+    BOOST_PARAMETER_MEMBER_FUNCTION(
+      (void), open, tag,
+      (required (title, (std::string)))
+      (optional (width, (unsigned), 400)
+                (height, (unsigned), 400))
+    )
+    {
+        <em>… function implementation …</em>
+    }
+};
+</pre>
+<!-- @example.prepend('#include <cassert>') -->
+<!-- @example.replace_emphasis('''
+assert(title == "foo");
+assert(height == 20);
+assert(width == 400);
+''') -->
+<p>It defines a set of overloaded member functions called <tt class="docutils literal">open</tt> with one
+required parameter and two optional ones. To bind this member function to
+Python we use the binding utility <tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt>.
+<tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt> is a <a class="reference external" href="../../../python/doc/v2/def_visitor.html"><tt class="docutils literal">def_visitor</tt></a> that we'll instantiate
+and pass to <tt class="docutils literal"><span class="pre">boost::python::class_::def()</span></tt>.</p>
+<p>To use <tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt> we first need to define
+a class with forwarding overloads. This is needed because <tt class="docutils literal"><span class="pre">window::open()</span></tt>
+is a function template, so we can't refer to it in any other way.</p>
+<pre class="literal-block">
+struct open_fwd
+{
+    template &lt;class A0, class A1, class A2&gt;
+    void operator()(
+        boost::type&lt;void&gt;, window&amp; self
+      , A0 const&amp; a0, A1 const&amp; a1, A2 const&amp; a2
+    )
+    {
+        self.open(a0, a1, a2);
+    }
+};
+</pre>
+<p>The first parameter, <tt class="docutils literal"><span class="pre">boost::type&lt;void&gt;</span></tt>, tells the forwarding overload
+what the return type should be. In this case we know that it's always void
+but in some cases, when we are exporting several specializations of a
+Boost.Parameter-enabled template, we need to use that parameter to
+deduce the return type.</p>
+<p><tt class="docutils literal"><span class="pre">window::open()</span></tt> takes a total of 3 parameters, so the forwarding function
+needs to take three parameters as well.</p>
+<div class="note">
+<p class="first admonition-title">Note</p>
+<p class="last">We only need one overload in the forwarding class, despite the
+fact that there are two optional parameters. There are special
+circumstances when several overload are needed; see
+<a class="reference internal" href="#special-keywords">special keywords</a>.</p>
+</div>
+<p>Next we'll define the module and export the class:</p>
+<pre class="literal-block">
+BOOST_PYTHON_MODULE(my_module)
+{
+    using namespace boost::python;
+    namespace py = boost::parameter::python;
+    namespace mpl = boost::mpl;
+
+    class_&lt;window&gt;(&quot;window&quot;)
+        .def(
+            &quot;open&quot;, py::function&lt;
+                open_fwd
+              , mpl::vector&lt;
+                    void
+                  , tag::title(std::string)
+                  , tag::width*(unsigned)
+                  , tag::height*(unsigned)
+                &gt;
+            &gt;()
+        );
+}
+</pre>
+<!-- @jam_prefix.append('import python ;') -->
+<!-- @jam_prefix.append('stage . : my_module /boost/python//boost_python ;') -->
+<!-- @my_module = build(
+    output = 'my_module'
+  , target_rule = 'python-extension'
+  , input = '/boost/python//boost_python'
+  , howmany = 'all'
+) -->
+<!-- @del jam_prefix[:] -->
+<p><tt class="docutils literal"><span class="pre">py::function</span></tt> is passed two parameters. The first one is the class with
+forwarding overloads that we defined earlier. The second one is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL
+Sequence</a> with the keyword tag types and argument types for the function
+specified as function types. The pointer syntax used in <tt class="docutils literal"><span class="pre">tag::width*</span></tt> and
+<tt class="docutils literal"><span class="pre">tag::height*</span></tt> means that the parameter is optional. The first element of
+the <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL Sequence</a> is the return type of the function, in this case <tt class="docutils literal">void</tt>,
+which is passed as the first argument to <tt class="docutils literal">operator()</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
+is an `MPL Sequence`_ with the desired function signature. The return type comes first, and
+then the parameter types:
+
+.. parsed-literal::
+
+    mpl::vector<void,        std::string, unsigned, unsigned>
+                *return type*  *title*        *width*     *height*
+
+.. @ignore() -->
+<p>That's it! This class can now be used in Python with the expected syntax:</p>
+<pre class="literal-block">
+&gt;&gt;&gt; w = my_module.window()
+&gt;&gt;&gt; w.open(title = &quot;foo&quot;, height = 20)
+</pre>
+<!-- @example.prepend('import my_module') -->
+<!-- @run_python(module_path = my_module) -->
+<!-- Sorry to say this at such a late date, but this syntax really -->
+<!-- strikes me as cumbersome.  Couldn't we do something like:
+
+ class_<window>("window")
+       .def(
+           "open",
+           (void (*)(
+               tag::title(std::string),
+               tag::width*(unsigned),
+               tag::height*(unsigned))
+           )0
+       );
+
+or at least:
+
+   class_<window>("window")
+       .def(
+           "open",
+           mpl::vector<
+               void,
+               tag::title(std::string),
+               tag::width*(unsigned),
+               tag::height*(unsigned)
+           >()
+       );
+
+assuming, that is, that we will have to repeat the tags (yes,
+users of broken compilers will have to give us function pointer
+types instead). -->
+</div>
+<hr class="docutils" />
+<div class="section" id="concept-parameterspec">
+<h1><a class="toc-backref" href="#id9">concept <span class="concept">ParameterSpec</span></a></h1>
+<p>A <span class="concept">ParameterSpec</span> is a function type <tt class="docutils literal">K(T)</tt> that describes both the keyword tag,
+<tt class="docutils literal">K</tt>, and the argument type, <tt class="docutils literal">T</tt>, for a parameter.</p>
+<p><tt class="docutils literal">K</tt> is either:</p>
+<ul class="simple">
+<li>A <em>required</em> keyword of the form <tt class="docutils literal">Tag</tt></li>
+<li><strong>or</strong>, an <em>optional</em> keyword of the form <tt class="docutils literal">Tag*</tt></li>
+<li><strong>or</strong>, a <em>special</em> keyword of the form <tt class="docutils literal">Tag**</tt></li>
+</ul>
+<p>where <tt class="docutils literal">Tag</tt> is a keyword tag type, as used in a specialization
+of <a class="reference external" href="../../../parameter/doc/html/reference.html#keyword"><tt class="docutils literal"><span class="pre">boost::parameter::keyword</span></tt></a>.</p>
+<p>The <strong>arity range</strong> for an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL Sequence</a> of <span class="concept">ParameterSpec</span>'s is
+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">S</tt>, mpl::size&lt;S&gt; ]
+</pre>
+<p>For example, 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">[2,2]</tt>,
+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">[2,2]</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">[1,2]</tt>.</p>
+</div>
+<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. 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
+{
+  template &lt;class ArgumentPack&gt;
+  void dfs_dispatch(ArgumentPack const&amp; args, mpl::false_)
+  {
+      <em>…compute and use default color map…</em>
+  }
+
+  template &lt;class ArgumentPack, class ColorMap&gt;
+  void dfs_dispatch(ArgumentPack const&amp; args, ColorMap colormap)
+  {
+      <em>…use colormap…</em>
+  }
+}
+
+template &lt;class ArgumentPack&gt;
+void depth_first_search(ArgumentPack const&amp; args)
+{
+    core::dfs_dispatch(args, args[color | mpl::false_()]);
+}
+</pre>
+<!-- @example.prepend('''
+#include <boost/parameter/keyword.hpp>
+#include <boost/parameter/parameters.hpp>
+#include <boost/mpl/bool.hpp>
+#include <cassert>
+
+BOOST_PARAMETER_KEYWORD(tag, color);
+
+typedef boost::parameter::parameters<tag::color> params;
+
+namespace mpl = boost::mpl;
+''') -->
+<!-- @example.replace_emphasis('''
+assert(args[color | 1] == 1);
+''') -->
+<!-- @example.replace_emphasis('''
+assert(args[color | 1] == 0);
+''') -->
+<!-- @example.append('''
+int main()
+{
+    depth_first_search(params()());
+    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">color</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">color</tt> will not
+be convertible to the parameter type. Therefore we need to tag the <tt class="docutils literal">color</tt>
+keyword as a <em>special</em> keyword. This is done by specifying the tag as
+<tt class="docutils literal"><span class="pre">tag::color**</span></tt> when binding the function (see <a class="reference internal" href="#concept-parameterspec">concept ParameterSpec</a> for
+more details on the tagging). By doing this we tell the binding functions that
+it needs to generate two overloads, one with the <tt class="docutils literal">color</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">N</tt> is the number of <em>special</em> keywords.</p>
+</div>
+<hr class="docutils" />
+<div class="section" id="class-template-init">
+<h1><a class="toc-backref" href="#id11">class template <tt class="docutils literal">init</tt></a></h1>
+<p>Defines a named parameter enabled constructor.</p>
+<pre class="literal-block">
+template &lt;class ParameterSpecs&gt;
+struct init : python::def_visitor&lt;init&lt;ParameterSpecs&gt; &gt;
+{
+    template &lt;class Class&gt;
+    void def(Class&amp; class_);
+
+    template &lt;class CallPolicies&gt;
+    <em>def_visitor</em> operator[](CallPolicies const&amp; policies) const;
+};
+</pre>
+<!-- @ignore() -->
+<div class="section" id="init-requirements">
+<h2><tt class="docutils literal">init</tt> requirements</h2>
+<ul>
+<li><p class="first"><tt class="docutils literal">ParameterSpecs</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">N</tt> in <tt class="docutils literal">[U,V]</tt>, where <tt class="docutils literal">[U,V]</tt> is the <strong>arity
+range</strong> of <tt class="docutils literal">ParameterSpecs</tt>, <tt class="docutils literal">Class</tt> must support these
+expressions:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="30%" />
+<col width="17%" />
+<col width="53%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th class="head"><p class="first last">Expression</p>
+</th>
+<th class="head"><p class="first last">Return type</p>
+</th>
+<th class="head"><p class="first last">Requirements</p>
+</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><p class="first last"><tt class="docutils literal">Class(a0, …, aN)</tt></p>
+</td>
+<td><p class="first last">-</p>
+</td>
+<td><p class="first last"><tt class="docutils literal">a0</tt>…<tt class="docutils literal">aN</tt> are tagged arguments.</p>
+</td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+</div>
+<div class="section" id="template-class-callpolicies-operator-callpolicies-const">
+<h2><tt class="docutils literal">template &lt;class CallPolicies&gt; <span class="pre">operator[](CallPolicies</span> const&amp;)</tt></h2>
+<p>Returns a <tt class="docutils literal">def_visitor</tt> equivalent to <tt class="docutils literal">*this</tt>, except that it
+uses CallPolicies when creating the binding.</p>
+</div>
+<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;
+#include &lt;boost/parameter/python.hpp&gt;
+#include &lt;boost/python.hpp&gt;
+#include &lt;boost/mpl/vector.hpp&gt;
+
+BOOST_PARAMETER_KEYWORD(tag, x)
+BOOST_PARAMETER_KEYWORD(tag, y)
+
+struct base
+{
+    template &lt;class ArgumentPack&gt;
+    base(ArgumentPack const&amp; args)
+    {
+        <em>… use args …</em>
+    }
+};
+
+class X : base
+{
+public:
+    BOOST_PARAMETER_CONSTRUCTOR(X, (base), tag,
+        (required (x, *))
+        (optional (y, *))
+    )
+};
+
+BOOST_PYTHON_MODULE(<em>module name</em>)
+{
+    using namespace boost::python;
+    namespace py = boost::parameter::python;
+    namespace mpl = boost::mpl;
+
+    class_&lt;X&gt;(&quot;X&quot;, no_init)
+        .def(
+            py::init&lt;
+                mpl::vector&lt;tag::x(int), tag::y*(int)&gt;
+            &gt;()
+        );
+}
+</pre>
+<!-- @example.replace_emphasis('''
+assert(args[x] == 0);
+assert(args[y | 1] == 1);
+''') -->
+<!-- @example.replace_emphasis('my_module') -->
+<!-- @jam_prefix.append('import python ;') -->
+<!-- @jam_prefix.append('stage . : my_module /boost/python//boost_python ;') -->
+<!-- @my_module = build(
+    output = 'my_module'
+  , target_rule = 'python-extension'
+  , input = '/boost/python//boost_python'
+) -->
+</div>
+</div>
+<hr class="docutils" />
+<div class="section" id="class-template-call">
+<h1><a class="toc-backref" href="#id12">class template <tt class="docutils literal">call</tt></a></h1>
+<p>Defines a <tt class="docutils literal">__call__</tt> operator, mapped to <tt class="docutils literal">operator()</tt> in C++.</p>
+<pre class="literal-block">
+template &lt;class ParameterSpecs&gt;
+struct call : python::def_visitor&lt;call&lt;ParameterSpecs&gt; &gt;
+{
+    template &lt;class Class&gt;
+    void def(Class&amp; class_);
+
+    template &lt;class CallPolicies&gt;
+    <em>def_visitor</em> operator[](CallPolicies const&amp; policies) const;
+};
+</pre>
+<!-- @ignore() -->
+<div class="section" id="call-requirements">
+<h2><tt class="docutils literal">call</tt> requirements</h2>
+<ul>
+<li><p class="first"><tt class="docutils literal">ParameterSpecs</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">Class</tt> must support these expressions, where <tt class="docutils literal">c</tt> is an
+instance of <tt class="docutils literal">Class</tt>:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="24%" />
+<col width="26%" />
+<col width="50%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th class="head"><p class="first last">Expression</p>
+</th>
+<th class="head"><p class="first last">Return type</p>
+</th>
+<th class="head"><p class="first last">Requirements</p>
+</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><p class="first last"><tt class="docutils literal">c(a0, …, aN)</tt></p>
+</td>
+<td><p class="first last">Convertible to <tt class="docutils literal">R</tt></p>
+</td>
+<td><p class="first last"><tt class="docutils literal">a0</tt>…<tt class="docutils literal">aN</tt> are tagged arguments.</p>
+</td>
+</tr>
+</tbody>
+</table>
+<p>For every <tt class="docutils literal">N</tt> in <tt class="docutils literal">[U,V]</tt>, where <tt class="docutils literal">[U,V]</tt> is the <strong>arity range</strong> of <tt class="docutils literal">ParameterSpecs</tt>.</p>
+</li>
+</ul>
+</div>
+<div class="section" id="id3">
+<h2><tt class="docutils literal">template &lt;class CallPolicies&gt; <span class="pre">operator[](CallPolicies</span> const&amp;)</tt></h2>
+<p>Returns a <tt class="docutils literal">def_visitor</tt> equivalent to <tt class="docutils literal">*this</tt>, except that it
+uses CallPolicies when creating the binding.</p>
+</div>
+<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;
+#include &lt;boost/parameter/python.hpp&gt;
+#include &lt;boost/python.hpp&gt;
+#include &lt;boost/mpl/vector.hpp&gt;
+
+BOOST_PARAMETER_KEYWORD(tag, x)
+BOOST_PARAMETER_KEYWORD(tag, y)
+
+namespace parameter = boost::parameter;
+
+typedef parameter::parameters&lt;
+    parameter::required&lt;tag::x&gt;
+  , parameter::optional&lt;tag::y&gt;
+&gt; call_parameters;
+
+class X
+{
+public:
+    template &lt;class ArgumentPack&gt;
+    int call_impl(ArgumentPack const&amp; args)
+    {
+        <em>… use args …</em>
+    }
+
+    template &lt;class A0&gt;
+    int operator()(A0 const&amp; a0)
+    {
+        return call_impl(call_parameters()(a0));
+    }
+
+    template &lt;class A0, class A1&gt;
+    int operator()(A0 const&amp; a0, A1 const&amp; a1)
+    {
+        return call_impl(call_parameters()(a0,a1));
+    }
+};
+
+BOOST_PYTHON_MODULE(<em>module name</em>)
+{
+    using namespace boost::python;
+    namespace py = parameter::python;
+    namespace mpl = boost::mpl;
+
+    class_&lt;X&gt;(&quot;X&quot;)
+        .def(
+            py::call&lt;
+                mpl::vector&lt;int, tag::x(int), tag::y*(int)&gt;
+            &gt;()
+        );
+}
+</pre>
+<!-- @example.replace_emphasis('''
+assert(args[x] == 0);
+assert(args[y | 1] == 1);
+return 0;
+''') -->
+<!-- @example.replace_emphasis('my_module') -->
+<!-- @my_module = build(
+    output = 'my_module'
+  , target_rule = 'python-extension'
+  , input = '/boost/python//boost_python'
+) -->
+</div>
+</div>
+<hr class="docutils" />
+<div class="section" id="class-template-function">
+<h1><a class="toc-backref" href="#id13">class template <tt class="docutils literal">function</tt></a></h1>
+<p>Defines a named parameter enabled member function.</p>
+<pre class="literal-block">
+template &lt;class Fwd, class ParameterSpecs&gt;
+struct function : python::def_visitor&lt;function&lt;Fwd, ParameterSpecs&gt; &gt;
+{
+    template &lt;class Class, class Options&gt;
+    void def(Class&amp; class_, char const* name, Options const&amp; options);
+};
+</pre>
+<!-- @ignore() -->
+<div class="section" id="function-requirements">
+<h2><tt class="docutils literal">function</tt> requirements</h2>
+<ul>
+<li><p class="first"><tt class="docutils literal">ParameterSpecs</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">f</tt> is the member
+function.</p>
+</li>
+<li><p class="first">An instance of <tt class="docutils literal">Fwd</tt> must support this expression:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="39%" />
+<col width="18%" />
+<col width="43%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th class="head"><p class="first last">Expression</p>
+</th>
+<th class="head"><p class="first last">Return type</p>
+</th>
+<th class="head"><p class="first last">Requirements</p>
+</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><p class="first last"><tt class="docutils literal"><span class="pre">fwd(boost::type&lt;R&gt;(),</span> self, a0, …, aN)</tt></p>
+</td>
+<td><p class="first last">Convertible to <tt class="docutils literal">R</tt></p>
+</td>
+<td><p class="first last"><tt class="docutils literal">self</tt> is a reference to the object on which
+the function should be invoked. <tt class="docutils literal">a0</tt>…<tt class="docutils literal">aN</tt>
+are tagged arguments.</p>
+</td>
+</tr>
+</tbody>
+</table>
+<p>For every <tt class="docutils literal">N</tt> in <tt class="docutils literal">[U,V]</tt>, where <tt class="docutils literal">[U,V]</tt> is the <strong>arity range</strong> of <tt class="docutils literal">ParameterSpecs</tt>.</p>
+</li>
+</ul>
+</div>
+<div class="section" id="id5">
+<h2>Example</h2>
+<p>This example exports a member function <tt class="docutils literal">f(int x, int y = …)</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>
+<pre class="literal-block">
+#include &lt;boost/parameter/keyword.hpp&gt;
+#include &lt;boost/parameter/preprocessor.hpp&gt;
+#include &lt;boost/parameter/python.hpp&gt;
+#include &lt;boost/python.hpp&gt;
+#include &lt;boost/mpl/vector.hpp&gt;
+
+BOOST_PARAMETER_KEYWORD(tag, x)
+BOOST_PARAMETER_KEYWORD(tag, y)
+
+class X
+{
+public:
+    BOOST_PARAMETER_MEMBER_FUNCTION((void), f, tag,
+        (required (x, *))
+        (optional (y, *, 1))
+    )
+    {
+        <em>…</em>
+    }
+};
+
+struct f_fwd
+{
+    template &lt;class A0, class A1&gt;
+    void operator()(boost::type&lt;void&gt;, X&amp; self, A0 const&amp; a0, A1 const&amp; a1)
+    {
+        self.f(a0, a1);
+    }
+};
+
+BOOST_PYTHON_MODULE(<em>module name</em>)
+{
+    using namespace boost::python;
+    namespace py = boost::parameter::python;
+    namespace mpl = boost::mpl;
+
+    class_&lt;X&gt;(&quot;X&quot;)
+        .def(&quot;f&quot;,
+            py::function&lt;
+                f_fwd
+              , mpl::vector&lt;void, tag::x(int), tag::y*(int)&gt;
+            &gt;()
+        );
+}
+</pre>
+<!-- @example.replace_emphasis('''
+assert(x == 0);
+assert(y == 1);
+''') -->
+<!-- @example.replace_emphasis('my_module') -->
+<!-- @my_module = build(
+    output = 'my_module'
+  , target_rule = 'python-extension'
+  , input = '/boost/python//boost_python'
+) -->
+</div>
+</div>
+<hr class="docutils" />
+<div class="section" id="function-template-def">
+<h1><a class="toc-backref" href="#id14">function template <tt class="docutils literal">def</tt></a></h1>
+<p>Defines a named parameter enabled free function in the current Python scope.</p>
+<pre class="literal-block">
+template &lt;class Fwd, class ParameterSpecs&gt;
+void def(char const* name);
+</pre>
+<!-- @ignore() -->
+<div class="section" id="def-requirements">
+<h2><tt class="docutils literal">def</tt> requirements</h2>
+<ul>
+<li><p class="first"><tt class="docutils literal">ParameterSpecs</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">f</tt> is the function.</p>
+</li>
+<li><p class="first">An instance of <tt class="docutils literal">Fwd</tt> must support this expression:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="39%" />
+<col width="21%" />
+<col width="40%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th class="head"><p class="first last">Expression</p>
+</th>
+<th class="head"><p class="first last">Return type</p>
+</th>
+<th class="head"><p class="first last">Requirements</p>
+</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><p class="first last"><tt class="docutils literal"><span class="pre">fwd(boost::type&lt;R&gt;(),</span> a0, …, aN)</tt></p>
+</td>
+<td><p class="first last">Convertible to <tt class="docutils literal">R</tt></p>
+</td>
+<td><p class="first last"><tt class="docutils literal">a0</tt>…<tt class="docutils literal">aN</tt> are tagged arguments.</p>
+</td>
+</tr>
+</tbody>
+</table>
+<p>For every <tt class="docutils literal">N</tt> in <tt class="docutils literal">[U,V]</tt>, where <tt class="docutils literal">[U,V]</tt> is the <strong>arity range</strong> of <tt class="docutils literal">ParameterSpecs</tt>.</p>
+</li>
+</ul>
+</div>
+<div class="section" id="id6">
+<h2>Example</h2>
+<p>This example exports a function <tt class="docutils literal">f(int x, int y = …)</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>
+<pre class="literal-block">
+BOOST_PARAMETER_FUNCTION((void), f, tag,
+    (required (x, *))
+    (optional (y, *, 1))
+)
+{
+    <em>…</em>
+}
+
+struct f_fwd
+{
+    template &lt;class A0, class A1&gt;
+    void operator()(boost::type&lt;void&gt;, A0 const&amp; a0, A1 const&amp; a1)
+    {
+        f(a0, a1);
+    }
+};
+
+BOOST_PYTHON_MODULE(…)
+{
+    def&lt;
+        f_fwd
+      , mpl::vector&lt;
+            void, tag::x(int), tag::y*(int)
+        &gt;
+    &gt;(&quot;f&quot;);
+}
+</pre>
+<!-- @ignore() -->
+<!-- again, the undefined ``fwd`` identifier. -->
+</div>
+</div>
+<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: 2011-11-08 21:40 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>
+</html>
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -30,7 +30,7 @@ __ ../../../../index.htm
  can be deduced from their types.

 .. @jam_prefix.append('''
-        project test : requirements <include>. <implicit-dependency>/boost//headers ;''')
+        project test : requirements <include>. <source>/boost//headers ;''')

 .. @example.prepend('''
   #include <boost/parameter.hpp>
@@ -783,7 +783,7 @@ signatures.
   isolate ``depth_first_search`` in a namespace containing no
   types [#using]_, but suppose we *want* it to found via ADL?

-__ http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225
+__ http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#225

 It's usually a good idea to prevent functions from being considered
 for overload resolution when the passed argument types aren't
@@ -1800,7 +1800,7 @@ its function call operator:
 Note that because of the `forwarding problem`_, ``parameter::parameters::operator()``
 can't accept non-const rvalues.

-.. _`forwarding problem`: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm
+.. _`forwarding problem`: http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm

 Extracting Parameter Types
 ==========================
@@ -2285,7 +2285,7 @@ enclosing namespace without qualification::
 Follow `this link`__ for documentation on how to expose
 Boost.Parameter-enabled functions to Python with `Boost.Python`_.

-__ ../../../parameter_python/doc/html/index.html
+__ python.html

 ===========
 Reference
--- a/doc/python.rst
+++ b/doc/python.rst
@@ -0,0 +1,778 @@
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ The Boost Parameter Library Python Binding Documentation 
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+: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-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)
+
+:abstract:      Makes it possible to bind Boost.Parameter-enabled
+                functions, operators and constructors to Python.
+
+|(logo)|__
+
+.. |(logo)| image:: ../../../../boost.png
+   :alt: Boost
+
+__ ../../../../index.htm
+
+.. _`BoostPro Computing`: http://www.boostpro.com
+
+
+.. role:: class
+    :class: class
+
+.. role:: concept
+    :class: concept
+
+.. role:: function
+    :class: function
+
+.. |ParameterSpec| replace:: :concept:`ParameterSpec`
+
+.. contents::
+    :depth: 1
+
+Introduction
+------------
+
+``boost/parameter/python.hpp`` introduces a group of |def_visitors|_ that can
+be used to easily expose Boost.Parameter-enabled member functions to Python with 
+Boost.Python. It also provides a function template ``def()`` that can be used
+to expose Boost.Parameter-enabled free functions.
+
+.. |def_visitor| replace:: ``def_visitor``
+.. |def_visitors| replace:: ``def_visitors``
+
+.. _def_visitor: def_visitors_
+.. _def_visitors: ../../../python/doc/v2/def_visitor.html
+
+When binding a Boost.Parameter enabled function, the keyword tags
+must be specified.  Additionally, because Boost.Parameter enabled
+functions are templates, the desired function signature must be
+specified.
+
+..  The keyword tags are specified as an `MPL Sequence`_, using the
+    pointer qualifications described in |ParameterSpec|_ below.  The
+    signature is also specifid as an `MPL sequence`_ of parameter
+    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.
+
+The keyword tags and associated argument types are specified as an `MPL
+Sequence`_, using the function type syntax described in |ParameterSpec|_
+below. 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.
+
+.. The last two sentences are terribly vague.  Which namespace is
+.. ``function`` in?  Isn't the return type always needed?  What
+.. else are we going to do other than pass these sequences to
+.. function?
+
+.. _`MPL Sequence`: ../../../mpl/doc/refmanual/sequences.html
+.. _parameterspec: `concept ParameterSpec`_
+
+Tutorial
+--------
+
+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 macros_ are required to understand this section.
+
+.. _macros: index.html
+
+The class and member function we are interested in binding looks
+like this:
+
+.. parsed-literal::
+
+  #include <boost/parameter/keyword.hpp>
+  #include <boost/parameter/preprocessor.hpp>
+  #include <boost/parameter/python.hpp>
+  #include <boost/python.hpp>
+
+  // First the keywords
+  BOOST_PARAMETER_KEYWORD(tag, title)
+  BOOST_PARAMETER_KEYWORD(tag, width)
+  BOOST_PARAMETER_KEYWORD(tag, height)
+
+  class window
+  {
+  public:
+      BOOST_PARAMETER_MEMBER_FUNCTION(
+        (void), open, tag,
+        (required (title, (std::string)))
+        (optional (width, (unsigned), 400)
+                  (height, (unsigned), 400))
+      )
+      {
+          *… function implementation …*
+      }
+  };
+
+.. @example.prepend('#include <cassert>')
+.. @example.replace_emphasis('''
+   assert(title == "foo");
+   assert(height == 20);
+   assert(width == 400);
+   ''')
+
+It defines a set of overloaded member functions called ``open`` with one
+required parameter and two optional ones. To bind this member function to
+Python we use the binding utility ``boost::parameter::python::function``.
+``boost::parameter::python::function`` is a |def_visitor|_ that we'll instantiate
+and pass to ``boost::python::class_::def()``.
+
+To use ``boost::parameter::python::function`` we first need to define
+a class with forwarding overloads. This is needed because ``window::open()``
+is a function template, so we can't refer to it in any other way. 
+
+::
+
+  struct open_fwd
+  {
+      template <class A0, class A1, class A2>
+      void operator()(
+          boost::type<void>, window& self
+        , A0 const& a0, A1 const& a1, A2 const& a2
+      )
+      {
+          self.open(a0, a1, a2);
+      }
+  };
+
+The first parameter, ``boost::type<void>``, tells the forwarding overload
+what the return type should be. In this case we know that it's always void
+but in some cases, when we are exporting several specializations of a
+Boost.Parameter-enabled template, we need to use that parameter to
+deduce the return type.
+
+``window::open()`` takes a total of 3 parameters, so the forwarding function
+needs to take three parameters as well.
+
+.. Note::
+
+    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 
+    `special keywords`_.
+
+Next we'll define the module and export the class:
+
+::
+
+  BOOST_PYTHON_MODULE(my_module)
+  {
+      using namespace boost::python;
+      namespace py = boost::parameter::python;
+      namespace mpl = boost::mpl;
+
+      class_<window>("window")
+          .def(
+              "open", py::function<
+                  open_fwd
+                , mpl::vector<
+                      void
+                    , tag::title(std::string)
+                    , tag::width*(unsigned)
+                    , tag::height*(unsigned)
+                  >
+              >()
+          );
+  }
+
+.. @jam_prefix.append('import python ;')
+.. @jam_prefix.append('stage . : my_module /boost/python//boost_python ;')
+.. @my_module = build(
+        output = 'my_module'
+      , target_rule = 'python-extension'
+      , input = '/boost/python//boost_python'
+      , howmany = 'all'
+    )
+
+.. @del jam_prefix[:]
+
+``py::function`` is passed two parameters. The first one is the class with
+forwarding overloads that we defined earlier. The second one is an `MPL
+Sequence`_ with the keyword tag types and argument types for the function
+specified as function types. The pointer syntax used in ``tag::width*`` and
+``tag::height*`` means that the parameter is optional. The first element of
+the `MPL Sequence`_ is the return type of the function, in this case ``void``,
+which is passed as the first argument to ``operator()`` in the forwarding
+class.
+
+..  The
+    pointer syntax means that the parameter is optional, so in this case
+    ``width`` and ``height`` are optional parameters. The third parameter
+    is an `MPL Sequence`_ with the desired function signature. The return type comes first, and
+    then the parameter types:
+
+    .. parsed-literal::
+
+        mpl::vector<void,        std::string, unsigned, unsigned>
+                    *return type*  *title*        *width*     *height*
+
+    .. @ignore()
+
+That's it! This class can now be used in Python with the expected syntax::
+
+    >>> w = my_module.window()
+    >>> w.open(title = "foo", height = 20)
+
+.. @example.prepend('import my_module')
+.. @run_python(module_path = my_module)
+
+.. Sorry to say this at such a late date, but this syntax really
+.. strikes me as cumbersome.  Couldn't we do something like:
+
+    class_<window>("window")
+          .def(
+              "open", 
+              (void (*)( 
+                  tag::title(std::string), 
+                  tag::width*(unsigned), 
+                  tag::height*(unsigned)) 
+              )0
+          );
+
+   or at least:
+
+      class_<window>("window")
+          .def(
+              "open", 
+              mpl::vector<
+                  void, 
+                  tag::title(std::string), 
+                  tag::width*(unsigned), 
+                  tag::height*(unsigned)
+              >()
+          );
+
+   assuming, that is, that we will have to repeat the tags (yes,
+   users of broken compilers will have to give us function pointer
+   types instead).
+
+------------------------------------------------------------------------------
+
+concept |ParameterSpec|
+-----------------------
+
+A |ParameterSpec| is a function type ``K(T)`` that describes both the keyword tag,
+``K``, and the argument type, ``T``, for a parameter.
+
+``K`` is either:
+
+* A *required* keyword of the form ``Tag``
+* **or**, an *optional* keyword of the form ``Tag*``
+* **or**, a *special* keyword of the form ``Tag**``
+
+where ``Tag`` is a keyword tag type, as used in a specialization
+of |keyword|__.
+
+.. |keyword| replace:: ``boost::parameter::keyword``
+__ ../../../parameter/doc/html/reference.html#keyword
+
+The **arity range** for an `MPL Sequence`_ of |ParameterSpec|'s is
+defined as the closed range:
+
+.. parsed-literal::
+
+  [ mpl::size<S> - number of *special* keyword tags in ``S``, mpl::size<S> ]
+
+For example, the **arity range** of ``mpl::vector2<x(int),y(int)>`` is ``[2,2]``,
+the **arity range** of ``mpl::vector2<x(int),y*(int)>`` is ``[2,2]`` and the
+**arity range** of ``mpl::vector2<x(int),y**(int)>`` is ``[1,2]``.
+
+
+
+*special* keywords
+---------------------------------
+
+Sometimes it is desirable to have a default value for a parameter that differ
+in type from the parameter. This technique is useful for doing simple tag-dispatching
+based on the presence of a parameter. For example:
+
+.. An example_ of this is given in the Boost.Parameter
+   docs. The example uses a different technique, but could also have been written like this:
+
+.. parsed-literal::
+
+  namespace core
+  {
+    template <class ArgumentPack>
+    void dfs_dispatch(ArgumentPack const& args, mpl::false\_)
+    {
+        *…compute and use default color map…*
+    }
+
+    template <class ArgumentPack, class ColorMap>
+    void dfs_dispatch(ArgumentPack const& args, ColorMap colormap)
+    {
+        *…use colormap…*
+    }
+  }
+
+  template <class ArgumentPack>
+  void depth_first_search(ArgumentPack const& args)
+  {
+      core::dfs_dispatch(args, args[color | mpl::false_()]);
+  }
+
+.. @example.prepend('''
+   #include <boost/parameter/keyword.hpp>
+   #include <boost/parameter/parameters.hpp>
+   #include <boost/mpl/bool.hpp>
+   #include <cassert>
+
+   BOOST_PARAMETER_KEYWORD(tag, color);
+
+   typedef boost::parameter::parameters<tag::color> params;
+
+   namespace mpl = boost::mpl;
+   ''')
+
+.. @example.replace_emphasis('''
+   assert(args[color | 1] == 1);
+   ''')
+
+.. @example.replace_emphasis('''
+   assert(args[color | 1] == 0);
+   ''')
+
+.. @example.append('''
+   int main()
+   {
+       depth_first_search(params()());
+       depth_first_search(params()(color = 0));
+   }''')
+
+.. @build()
+
+.. .. _example: index.html#dispatching-based-on-the-presence-of-a-default
+
+In the above example the type of the default for ``color`` is ``mpl::false_``, a
+type that is distinct from any color map that the user might supply.
+
+When binding the case outlined above, the default type for ``color`` will not
+be convertible to the parameter type. Therefore we need to tag the ``color``
+keyword as a *special* keyword. This is done by specifying the tag as
+``tag::color**`` when binding the function (see `concept ParameterSpec`_ for
+more details on the tagging). By doing this we tell the binding functions that
+it needs to generate two overloads, one with the ``color`` parameter present
+and one without. Had there been two *special* keywords, four overloads would
+need to be generated. The number of generated overloads is equal to 2\
+:sup:`N`, where ``N`` is the number of *special* keywords.
+
+------------------------------------------------------------------------------
+
+class template ``init``
+-----------------------
+
+Defines a named parameter enabled constructor.
+
+.. parsed-literal::
+
+    template <class ParameterSpecs>
+    struct init : python::def_visitor<init<ParameterSpecs> >
+    {
+        template <class Class> 
+        void def(Class& class\_);
+
+        template <class CallPolicies>
+        *def\_visitor* operator[](CallPolicies const& policies) const;
+    };
+
+.. @ignore()
+
+``init`` requirements 
+~~~~~~~~~~~~~~~~~~~~~
+
+* ``ParameterSpecs`` is an `MPL sequence`_ where each element is a
+  model of |ParameterSpec|. 
+* For every ``N`` in ``[U,V]``, where ``[U,V]`` is the **arity
+  range** of ``ParameterSpecs``, ``Class`` must support these
+  expressions: 
+
+  ======================= ============= =========================================
+  Expression              Return type   Requirements
+  ======================= ============= =========================================
+  ``Class(a0, …, aN)``    \-            ``a0``\ …\ ``aN`` are tagged arguments.
+  ======================= ============= =========================================
+
+
+
+``template <class CallPolicies> operator[](CallPolicies const&)``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Returns a ``def_visitor`` equivalent to ``*this``, except that it
+uses CallPolicies when creating the binding.
+
+
+Example
+~~~~~~~
+
+.. parsed-literal::
+
+    #include <boost/parameter/keyword.hpp>
+    #include <boost/parameter/preprocessor.hpp>
+    #include <boost/parameter/python.hpp>
+    #include <boost/python.hpp>
+    #include <boost/mpl/vector.hpp>
+
+    BOOST_PARAMETER_KEYWORD(tag, x)
+    BOOST_PARAMETER_KEYWORD(tag, y)
+
+    struct base 
+    { 
+        template <class ArgumentPack>
+        base(ArgumentPack const& args)
+        {
+            *… use args …*
+        }
+    };
+
+    class X : base
+    {
+    public:
+        BOOST_PARAMETER_CONSTRUCTOR(X, (base), tag,
+            (required (x, \*))
+            (optional (y, \*))
+        )
+    };
+
+    BOOST_PYTHON_MODULE(*module name*)
+    {
+        using namespace boost::python;
+        namespace py = boost::parameter::python;
+        namespace mpl = boost::mpl;
+
+        class_<X>("X", no_init)
+            .def(
+                py::init<
+                    mpl::vector<tag::x(int), tag::y\*(int)>
+                >()
+            );
+    }
+
+.. @example.replace_emphasis('''
+   assert(args[x] == 0);
+   assert(args[y | 1] == 1);
+   ''')
+
+.. @example.replace_emphasis('my_module')
+
+.. @jam_prefix.append('import python ;')
+.. @jam_prefix.append('stage . : my_module /boost/python//boost_python ;')
+.. @my_module = build(
+        output = 'my_module'
+      , target_rule = 'python-extension'
+      , input = '/boost/python//boost_python'
+    )
+
+------------------------------------------------------------------------------
+
+class template ``call``
+-----------------------
+
+Defines a ``__call__`` operator, mapped to ``operator()`` in C++.
+
+.. parsed-literal::
+
+    template <class ParameterSpecs>
+    struct call : python::def_visitor<call<ParameterSpecs> >
+    {
+        template <class Class> 
+        void def(Class& class\_);
+
+        template <class CallPolicies>
+        *def\_visitor* operator[](CallPolicies const& policies) const;
+    };
+
+.. @ignore()
+
+``call`` requirements 
+~~~~~~~~~~~~~~~~~~~~~
+
+* ``ParameterSpecs`` is an `MPL sequence`_ where each element
+  except the first models |ParameterSpec|. The first element
+  is the result type of ``c(…)``.
+* ``Class`` must support these expressions, where ``c`` is an 
+  instance of ``Class``:
+
+  =================== ==================== =======================================
+  Expression          Return type          Requirements
+  =================== ==================== =======================================
+  ``c(a0, …, aN)``    Convertible to ``R`` ``a0``\ …\ ``aN`` are tagged arguments.
+  =================== ==================== =======================================
+
+  For every ``N`` in ``[U,V]``, where ``[U,V]`` is the **arity range** of ``ParameterSpecs``.
+
+
+``template <class CallPolicies> operator[](CallPolicies const&)``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Returns a ``def_visitor`` equivalent to ``*this``, except that it
+uses CallPolicies when creating the binding.
+
+
+Example
+~~~~~~~
+
+.. parsed-literal::
+
+    #include <boost/parameter/keyword.hpp>
+    #include <boost/parameter/preprocessor.hpp>
+    #include <boost/parameter/python.hpp>
+    #include <boost/python.hpp>
+    #include <boost/mpl/vector.hpp>
+
+    BOOST_PARAMETER_KEYWORD(tag, x)
+    BOOST_PARAMETER_KEYWORD(tag, y)
+
+    namespace parameter = boost::parameter;
+
+    typedef parameter::parameters<
+        parameter::required<tag::x>
+      , parameter::optional<tag::y>
+    > call_parameters;
+
+    class X
+    {
+    public:
+        template <class ArgumentPack>
+        int call_impl(ArgumentPack const& args)
+        {
+            *… use args …*
+        }
+
+        template <class A0>
+        int operator()(A0 const& a0)
+        {
+            return call_impl(call_parameters()(a0));
+        }
+
+        template <class A0, class A1>
+        int operator()(A0 const& a0, A1 const& a1)
+        {
+            return call_impl(call_parameters()(a0,a1));
+        }
+    };
+
+    BOOST_PYTHON_MODULE(*module name*)
+    {
+        using namespace boost::python;
+        namespace py = parameter::python;
+        namespace mpl = boost::mpl;
+
+        class_<X>("X")
+            .def(
+                py::call<
+                    mpl::vector<int, tag::x(int), tag::y\*(int)>
+                >()
+            );
+    }    
+
+.. @example.replace_emphasis('''
+   assert(args[x] == 0);
+   assert(args[y | 1] == 1);
+   return 0;
+   ''')
+
+.. @example.replace_emphasis('my_module')
+
+.. @my_module = build(
+        output = 'my_module'
+      , target_rule = 'python-extension'
+      , input = '/boost/python//boost_python'
+    )
+
+------------------------------------------------------------------------------
+
+class template ``function``
+---------------------------
+
+Defines a named parameter enabled member function.
+
+.. parsed-literal::
+
+    template <class Fwd, class ParameterSpecs>
+    struct function : python::def_visitor<function<Fwd, ParameterSpecs> >
+    {
+        template <class Class, class Options> 
+        void def(Class& class\_, char const* name, Options const& options);
+    };
+
+.. @ignore()
+
+``function`` requirements 
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+* ``ParameterSpecs`` is an `MPL sequence`_ where each element
+  except the first models |ParameterSpec|. The first element
+  is the result type of ``c.f(…)``, where ``f`` is the member
+  function.
+* An instance of ``Fwd`` must support this expression:
+
+  ============================================ ==================== =================================================
+  Expression                                   Return type          Requirements
+  ============================================ ==================== =================================================
+  ``fwd(boost::type<R>(), self, a0, …, aN)``   Convertible to ``R`` ``self`` is a reference to the object on which
+                                                                    the function should be invoked. ``a0``\ …\ ``aN``
+                                                                    are tagged arguments.
+  ============================================ ==================== =================================================
+
+  For every ``N`` in ``[U,V]``, where ``[U,V]`` is the **arity range** of ``ParameterSpecs``.
+
+
+Example
+~~~~~~~
+
+This example exports a member function ``f(int x, int y = …)`` to Python. The
+sequence of |ParameterSpec|'s ``mpl::vector2<tag::x(int), tag::y*(int)>`` has
+an **arity range** of [2,2], so we only need one forwarding overload.
+
+.. parsed-literal::
+
+    #include <boost/parameter/keyword.hpp>
+    #include <boost/parameter/preprocessor.hpp>
+    #include <boost/parameter/python.hpp>
+    #include <boost/python.hpp>
+    #include <boost/mpl/vector.hpp>
+
+    BOOST_PARAMETER_KEYWORD(tag, x)
+    BOOST_PARAMETER_KEYWORD(tag, y)
+
+    class X
+    {
+    public:
+        BOOST_PARAMETER_MEMBER_FUNCTION((void), f, tag,
+            (required (x, \*))
+            (optional (y, \*, 1))
+        )
+        {
+            *…*
+        }
+    };
+
+    struct f_fwd
+    {
+        template <class A0, class A1>
+        void operator()(boost::type<void>, X& self, A0 const& a0, A1 const& a1)
+        {
+            self.f(a0, a1);
+        }
+    };
+
+    BOOST_PYTHON_MODULE(*module name*)
+    {
+        using namespace boost::python;
+        namespace py = boost::parameter::python;
+        namespace mpl = boost::mpl;
+
+        class_<X>("X")
+            .def("f",
+                py::function<
+                    f_fwd
+                  , mpl::vector<void, tag::x(int), tag::y\*(int)>
+                >()
+            );
+    }
+
+.. @example.replace_emphasis('''
+   assert(x == 0);
+   assert(y == 1);
+   ''')
+
+.. @example.replace_emphasis('my_module')
+
+.. @my_module = build(
+        output = 'my_module'
+      , target_rule = 'python-extension'
+      , input = '/boost/python//boost_python'
+    )
+
+------------------------------------------------------------------------------
+
+function template ``def``
+-------------------------
+
+Defines a named parameter enabled free function in the current Python scope.
+
+.. parsed-literal::
+
+    template <class Fwd, class ParameterSpecs>
+    void def(char const* name);
+
+.. @ignore()
+
+``def`` requirements 
+~~~~~~~~~~~~~~~~~~~~
+
+* ``ParameterSpecs`` is an `MPL sequence`_ where each element
+  except the first models |ParameterSpec|. The first element
+  is the result type of ``f(…)``, where ``f`` is the function.
+* An instance of ``Fwd`` must support this expression:
+
+  ====================================== ==================== =======================================
+  Expression                             Return type          Requirements
+  ====================================== ==================== =======================================
+  ``fwd(boost::type<R>(), a0, …, aN)``   Convertible to ``R`` ``a0``\ …\ ``aN`` are tagged arguments.
+  ====================================== ==================== =======================================
+
+  For every ``N`` in ``[U,V]``, where ``[U,V]`` is the **arity range** of ``ParameterSpecs``.
+
+
+Example
+~~~~~~~
+
+This example exports a function ``f(int x, int y = …)`` to Python. The
+sequence of |ParameterSpec|'s ``mpl::vector2<tag::x(int), tag::y*(int)>`` has
+an **arity range** of [2,2], so we only need one forwarding overload.
+
+.. parsed-literal::
+
+    BOOST_PARAMETER_FUNCTION((void), f, tag,
+        (required (x, \*))
+        (optional (y, \*, 1))
+    )
+    {
+        *…*
+    }
+
+    struct f_fwd
+    {
+        template <class A0, class A1>
+        void operator()(boost::type<void>, A0 const& a0, A1 const& a1)
+        {
+            f(a0, a1);
+        }
+    };
+
+    BOOST_PYTHON_MODULE(…)
+    {
+        def<
+            f_fwd
+          , mpl::vector<
+                void, tag::\ x(int), tag::\ y\*(int)
+            >
+        >("f");
+    }
+
+.. @ignore()
+
+.. again, the undefined ``fwd`` identifier.
+
+Portability
+-----------
+
+The Boost.Parameter Python binding library requires *partial template
+specialization*.
+
--- a/include/boost/parameter/aux_/arg_list.hpp
+++ b/include/boost/parameter/aux_/arg_list.hpp
@@ -78,11 +78,15 @@ struct empty_arg_list
        };
    };

+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
    // Terminator for has_key, indicating that the keyword is unique
    template <class KW>
    static no_tag has_key(KW*);
+#endif

-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#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.
@@ -146,6 +150,11 @@ struct empty_arg_list
    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
 };

+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+template<class KW>
+no_tag operator*(empty_arg_list, KW*);
+#endif
+
 // Forward declaration for arg_list::operator,
 template <class KW, class T>
 struct tagged_argument;
@@ -218,17 +227,25 @@ struct arg_list : Next
        };
    };

-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && !BOOST_WORKAROUND(__GNUC__, == 2)
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    friend yes_tag operator*(arg_list, key_type*);
+#  define BOOST_PARAMETER_CALL_HAS_KEY(next, key) (*(next*)0 * (key*)0)
+# else
    // Overload for key_type, so the assert below will fire if the
    // 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)
+# endif
+
    BOOST_MPL_ASSERT_MSG(
-        sizeof(Next::has_key((key_type*)0)) == sizeof(no_tag)
+        sizeof(BOOST_PARAMETER_CALL_HAS_KEY(Next,key_type)) == sizeof(no_tag)
      , duplicate_keyword, (key_type)
    );

+# undef BOOST_PARAMETER_CALL_HAS_KEY
 #endif
    //
    // Begin implementation of indexing operators for looking up
@@ -249,7 +266,9 @@ struct arg_list : Next
        return arg.value ? arg.value.get() : arg.value.construct(d.value);
    }

-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+    || BOOST_WORKAROUND(__GNUC__, < 3) \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
    // These older compilers don't support the overload set creation
    // idiom well, so we need to do all the return type calculation
    // for the compiler and dispatch through an outer function template
@@ -339,7 +358,6 @@ struct arg_list : Next
    template <class Default>
    reference operator[](lazy_default<key_type, Default>) const
    {
-        BOOST_MPL_ASSERT_NOT((holds_maybe));
        return arg.value;
    }

@@ -389,6 +407,10 @@ struct arg_list : Next
    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
 };

+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)  // ETI workaround
+template <> struct arg_list<int,int> {};
+#endif
+
 // MPL sequence support
 template <class ArgumentPack>
 struct arg_list_iterator
--- a/include/boost/parameter/aux_/cast.hpp
+++ b/include/boost/parameter/aux_/cast.hpp
@@ -7,7 +7,8 @@

 # include <boost/detail/workaround.hpp>

-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+  && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #  include <boost/type_traits/add_reference.hpp>
 #  include <boost/type_traits/remove_const.hpp>
 # endif
@@ -16,7 +17,8 @@ namespace boost { namespace parameter { namespace aux {

 struct use_default_tag {};

-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

 #  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) value

--- a/include/boost/parameter/aux_/parenthesized_type.hpp
+++ b/include/boost/parameter/aux_/parenthesized_type.hpp
@@ -18,12 +18,96 @@ namespace boost { namespace parameter { namespace aux {
 template <class UnaryFunctionPointer>
 struct unaryfunptr_arg_type;

+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
 template <class Arg>
 struct unaryfunptr_arg_type<void(*)(Arg)>
 {
    typedef Arg type;
 };

+# else
+
+// Use the "native typeof" bugfeatures of older versions of MSVC to
+// accomplish what we'd normally do with partial specialization.  This
+// capability was discovered by Igor Chesnokov.
+
+#  if BOOST_WORKAROUND(BOOST_MSVC, != 1300)
+
+// This version applies to VC6.5 and VC7.1 (except that we can just
+// use partial specialization for the latter in this case).
+
+// This gets used as a base class.  
+template<typename Address>
+struct msvc_type_memory
+{
+    // A nullary metafunction that will yield the Value type "stored"
+    // at this Address.
+    struct storage;
+};
+
+template<typename Value, typename Address>
+struct msvc_store_type : msvc_type_memory<Address>
+{
+    // VC++ somehow lets us define the base's nested storage
+    // metafunction here, where we have the Value type we'd like to
+    // "store" in it.  Later we can come back to the base class and
+    // extract the "stored type."
+    typedef msvc_type_memory<Address> location;
+    struct location::storage 
+    {
+        typedef Value type;
+    };
+};
+
+#  else
+
+// This slightly more complicated version of the same thing is
+// required for msvc-7.0
+template<typename Address>
+struct msvc_type_memory
+{
+    template<bool>
+    struct storage_impl;
+
+    typedef storage_impl<true> storage;
+};
+
+template<typename Value, typename Address>
+struct msvc_store_type : msvc_type_memory<Address>
+{
+    // Rather than supplying a definition for the base class' nested
+    // class, we specialize the base class' nested template
+    template<>
+    struct storage_impl<true>  
+    {
+        typedef Value type;
+    };
+};
+
+#  endif
+
+// Function template argument deduction does many of the same things
+// as type matching during partial specialization, so we call a
+// function template to "store" T into the type memory addressed by
+// void(*)(T).
+template <class T>
+msvc_store_type<T,void(*)(T)>
+msvc_store_argument_type(void(*)(T));
+
+template <class FunctionPointer>
+struct unaryfunptr_arg_type
+{
+    // We don't want the function to be evaluated, just instantiated,
+    // so protect it inside of sizeof.
+    enum { dummy = sizeof(msvc_store_argument_type((FunctionPointer)0)) };
+
+    // Now pull the type out of the instantiated base class
+    typedef typename msvc_type_memory<FunctionPointer>::storage::type type;
+};
+
+# endif
+
 template <>
 struct unaryfunptr_arg_type<void(*)(void)>
 {
--- a/include/boost/parameter/aux_/python/invoker.hpp
+++ b/include/boost/parameter/aux_/python/invoker.hpp
@@ -0,0 +1,132 @@
+// Copyright Daniel Wallin 2005. 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_INVOKER_051210_HPP
+# define BOOST_PARAMETER_INVOKER_051210_HPP
+
+# 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>
+
+namespace boost { namespace parameter { namespace python { namespace aux {
+
+template <long Arity, class M, class R, class Args>
+struct invoker;
+
+template <class M, class R>
+struct make_invoker
+{
+    template <class Args>
+    struct apply
+    {
+        typedef invoker<
+            mpl::size<Args>::value, M, R, Args
+        > type;
+    };
+};
+
+template <long Arity, class M, class R, class T, class Args>
+struct member_invoker;
+
+template <class M, class R, class T>
+struct make_member_invoker
+{
+    template <class Args>
+    struct apply
+    {
+        typedef member_invoker<
+            mpl::size<Args>::value, M, R, T, Args
+        > type;
+    };
+};
+
+template <long Arity, class T, class R, class Args>
+struct call_invoker;
+
+template <class T, class R>
+struct make_call_invoker
+{
+    template <class Args>
+    struct apply
+    {
+        typedef call_invoker<
+            mpl::size<Args>::value, T, R, Args
+        > type;
+    };
+};
+
+template <long Arity, class T, class Args>
+struct init_invoker;
+
+template <class T>
+struct make_init_invoker
+{
+    template <class Args>
+    struct apply
+    {
+        typedef init_invoker<
+            mpl::size<Args>::value, T, Args
+        > type;
+    };
+};
+
+template <class M, class R, class Args>
+struct invoker<0, M, R, Args>
+{
+    static R execute()
+    {
+        return M()(boost::type<R>());
+    }
+};
+
+template <class M, class R, class T, class Args>
+struct member_invoker<0, M, R, T, Args>
+{
+    static R execute(T& self)
+    {
+        return M()(boost::type<R>(), self);
+    }
+};
+
+template <class T, class R, class Args>
+struct call_invoker<0, T, R, Args>
+{
+    static R execute(T& self)
+    {
+        return self();
+    }
+};
+
+template <class T, class Args>
+struct init_invoker<0, T, Args>
+{
+    static T* execute(T& self)
+    {
+        return new T;
+    }
+};
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 1))
+# include BOOST_PP_ITERATE()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 2))
+# include BOOST_PP_ITERATE()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 3))
+# include BOOST_PP_ITERATE()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 4))
+# include BOOST_PP_ITERATE()
+
+}}}} // namespace boost::parameter::python::aux
+
+#endif // BOOST_PARAMETER_INVOKER_051210_HPP
+
--- a/include/boost/parameter/aux_/python/invoker_iterate.hpp
+++ b/include/boost/parameter/aux_/python/invoker_iterate.hpp
@@ -0,0 +1,93 @@
+// Copyright Daniel Wallin 2005. 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)
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/dec.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+#define N BOOST_PP_ITERATION()
+
+#define BOOST_PARAMETER_PY_ARG_TYPES(z, n, _) \
+    typedef typename mpl::next< \
+        BOOST_PP_CAT(iter,BOOST_PP_DEC(n)) \
+    >::type BOOST_PP_CAT(iter,n); \
+    \
+    typedef typename mpl::deref<BOOST_PP_CAT(iter,n)>::type BOOST_PP_CAT(spec,n); \
+    typedef typename mpl::if_< \
+        mpl::and_< \
+            mpl::not_<typename BOOST_PP_CAT(spec,n)::required> \
+          , typename BOOST_PP_CAT(spec,n)::optimized_default \
+        > \
+      , parameter::aux::maybe<typename BOOST_PP_CAT(spec,n)::type> \
+      , typename BOOST_PP_CAT(spec,n)::type \
+    >::type BOOST_PP_CAT(arg,n); \
+    typedef typename BOOST_PP_CAT(spec,n)::keyword BOOST_PP_CAT(kw,n);
+
+#if BOOST_PP_ITERATION_FLAGS() == 1
+template <class M, class R, class Args>
+struct invoker<N, M, R, Args>
+#elif BOOST_PP_ITERATION_FLAGS() == 2
+template <class T, class R, class Args>
+struct call_invoker<N, T, R, Args>
+#elif BOOST_PP_ITERATION_FLAGS() == 3
+template <class T, class Args>
+struct init_invoker<N, T, Args>
+#elif BOOST_PP_ITERATION_FLAGS() == 4
+template <class M, class R, class T, class Args>
+struct member_invoker<N, M, R, T, Args>
+#endif
+{
+    typedef typename mpl::begin<Args>::type iter0;
+    typedef typename mpl::deref<iter0>::type spec0;
+    typedef typename mpl::if_<
+        mpl::and_<
+            mpl::not_<typename spec0::required>
+          , typename spec0::optimized_default
+        >
+      , parameter::aux::maybe<typename spec0::type>
+      , typename spec0::type
+    >::type arg0;
+    typedef typename spec0::keyword kw0;
+
+    BOOST_PP_REPEAT_FROM_TO(1, N, BOOST_PARAMETER_PY_ARG_TYPES, ~)
+
+    static
+#if BOOST_PP_ITERATION_FLAGS() == 3
+    T*
+#else
+    R
+#endif 
+    execute(
+#if BOOST_PP_ITERATION_FLAGS() == 2 || BOOST_PP_ITERATION_FLAGS() == 4
+        T& self
+      ,
+#endif
+        BOOST_PP_ENUM_BINARY_PARAMS(N, arg, a)
+    )
+    {
+        return
+#if BOOST_PP_ITERATION_FLAGS() == 1 || BOOST_PP_ITERATION_FLAGS() == 4
+         M()(
+              boost::type<R>()
+# if BOOST_PP_ITERATION_FLAGS() == 4
+            , self
+# endif
+            , BOOST_PP_ENUM_BINARY_PARAMS(N, parameter::keyword<kw, >::get() = a)
+         );
+#elif BOOST_PP_ITERATION_FLAGS() == 2
+         self(
+            BOOST_PP_ENUM_BINARY_PARAMS(N, parameter::keyword<kw, >::get() = a)
+         );
+#elif BOOST_PP_ITERATION_FLAGS() == 3
+         new T(
+             BOOST_PP_ENUM_BINARY_PARAMS(N, parameter::keyword<kw, >::get() = a)
+         );
+#endif
+    }
+};
+
+#undef BOOST_PARAMETER_PY_ARG_TYPES
+#undef N
+
--- a/include/boost/parameter/aux_/set.hpp
+++ b/include/boost/parameter/aux_/set.hpp
@@ -7,7 +7,8 @@

 # include <boost/detail/workaround.hpp>

-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
+  && !BOOST_WORKAROUND(__GNUC__, < 3)
 #  include <boost/mpl/insert.hpp>
 #  include <boost/mpl/set/set0.hpp>
 #  include <boost/mpl/has_key.hpp>
--- a/include/boost/parameter/aux_/tagged_argument.hpp
+++ b/include/boost/parameter/aux_/tagged_argument.hpp
@@ -120,13 +120,13 @@ struct tagged_argument : tagged_argument_base
    }
 # else
    template <class Default>
-    reference operator[](default_<key_type,Default> const& ) const
+    reference operator[](default_<key_type,Default> const& x) const
    {
        return value;
    }

    template <class F>
-    reference operator[](lazy_default<key_type,F> const& ) const
+    reference operator[](lazy_default<key_type,F> const& x) const
    {
        return value;
    }
--- a/include/boost/parameter/aux_/unwrap_cv_reference.hpp
+++ b/include/boost/parameter/aux_/unwrap_cv_reference.hpp
@@ -44,6 +44,12 @@ struct is_cv_reference_wrapper
    value> type;
 };

+#if BOOST_WORKAROUND(MSVC, == 1200)
+template <>
+struct is_cv_reference_wrapper<int>
+  : mpl::false_ {};
+#endif
+
 // Needed for unwrap_cv_reference below. T might be const, so
 // eval_if might fail because of deriving from T const on EDG.
 template <class T>
--- a/include/boost/parameter/binding.hpp
+++ b/include/boost/parameter/binding.hpp
@@ -11,13 +11,18 @@
 # include <boost/parameter/aux_/void.hpp>
 # include <boost/type_traits/is_same.hpp>

+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  include <boost/mpl/eval_if.hpp>
+# endif
+
 namespace boost { namespace parameter { 

 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword.  If no such
 // parameter has been specified, returns Default

-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 template <class Parameters, class Keyword, class Default>
 struct binding0
 {
@@ -35,9 +40,14 @@ struct binding0
 # endif

 template <class Parameters, class Keyword, class Default = void_>
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 struct binding
+# else
+struct binding_eti
+# endif
 {
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
    typedef typename mpl::eval_if<
        mpl::is_placeholder<Parameters>
      , mpl::identity<int>
@@ -56,8 +66,24 @@ struct binding
    ));
 # endif

+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default))
+# endif
+};
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+template <class Parameters, class Keyword, class Default = void_>
+struct binding
+{
+    typedef typename mpl::eval_if<
+        is_same<Parameters, int>
+      , mpl::identity<int>
+      , binding_eti<Parameters, Keyword, Default>
+    >::type type;
+
    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default))
 };
+# endif

 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword.  If no such
--- a/include/boost/parameter/keyword.hpp
+++ b/include/boost/parameter/keyword.hpp
@@ -52,6 +52,7 @@ struct keyword
        return aux::lazy_default<Tag, Default>(default_);
    }

+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)  // avoid partial ordering bugs
    template <class T>
    typename aux::tag<Tag, T const>::type const
    operator=(T const& x) const
@@ -59,10 +60,15 @@ struct keyword
        typedef typename aux::tag<Tag, T const>::type result;
        return result(x);
    }
+#endif 

+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)  // avoid partial ordering bugs
    template <class Default>
    aux::default_<Tag, const Default>
    operator|(const Default& default_) const
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+        volatile
+#endif 
    {
        return aux::default_<Tag, const Default>(default_);
    }
@@ -70,9 +76,13 @@ struct keyword
    template <class Default>
    aux::lazy_default<Tag, Default>
    operator||(Default const& default_) const
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+        volatile
+#endif 
    {
        return aux::lazy_default<Tag, Default>(default_);
    }
+#endif

 public: // Insurance against ODR violations
    
@@ -99,6 +109,24 @@ keyword<Tag> const keyword<Tag>::instance = {};
 // reference in an anonymous namespace to a singleton instance of that
 // type.

+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+# define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                    \
+    namespace tag_namespace                                             \
+    {                                                                   \
+      struct name                                                       \
+      {                                                                 \
+          static char const* keyword_name()                             \
+          {                                                             \
+              return #name;                                             \
+          }                                                             \
+      };                                                                \
+    }                                                                   \
+    static ::boost::parameter::keyword<tag_namespace::name> const& name \
+       = ::boost::parameter::keyword<tag_namespace::name>::instance;
+
+#else
+
 #define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                 \
    namespace tag_namespace                                         \
    {                                                               \
@@ -116,6 +144,8 @@ keyword<Tag> const keyword<Tag>::instance = {};
       = ::boost::parameter::keyword<tag_namespace::name>::instance;\
    }

+#endif
+
 }} // namespace boost::parameter

 #endif // KEYWORD_050328_HPP
--- a/include/boost/parameter/name.hpp
+++ b/include/boost/parameter/name.hpp
@@ -16,6 +16,7 @@
 # include <boost/mpl/placeholders.hpp>

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

 #  include <boost/utility/enable_if.hpp>
@@ -74,6 +75,19 @@ struct lambda<
 #  define BOOST_PARAMETER_IS_BINARY(x) BOOST_PP_IS_BINARY(x)
 # endif

+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  define BOOST_PARAMETER_NAME_OBJECT(tag, name)                    \
+    static ::boost::parameter::keyword<tag> const& name             \
+       = ::boost::parameter::keyword<tag>::instance;
+# else
+#  define BOOST_PARAMETER_NAME_OBJECT(tag, name)                    \
+    namespace                                                       \
+    {                                                               \
+       ::boost::parameter::keyword<tag> const& name                 \
+       = ::boost::parameter::keyword<tag>::instance;                \
+    }
+# endif
+
 # define BOOST_PARAMETER_BASIC_NAME(tag_namespace, tag, name)       \
    namespace tag_namespace                                         \
    {                                                               \
@@ -93,11 +107,7 @@ struct lambda<
          > _1;                                                     \
      };                                                            \
    }                                                               \
-    namespace                                                       \
-    {                                                               \
-       ::boost::parameter::keyword<tag_namespace::tag> const& name  \
-       = ::boost::parameter::keyword<tag_namespace::tag>::instance; \
-    }
+    BOOST_PARAMETER_NAME_OBJECT(tag_namespace::tag, name)

 # define BOOST_PARAMETER_COMPLEX_NAME_TUPLE1(tag,namespace)         \
    (tag, namespace), ~
--- a/include/boost/parameter/preprocessor.hpp
+++ b/include/boost/parameter/preprocessor.hpp
@@ -37,6 +37,10 @@
 # include <boost/mpl/always.hpp>
 # include <boost/mpl/apply_wrap.hpp>

+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#  include <boost/type.hpp>
+# endif
+
 namespace boost { namespace parameter { namespace aux {

 #  if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
@@ -98,6 +102,41 @@ struct match
 {};
 # endif 

+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+
+// Function template argument deduction does many of the same things
+// as type matching during partial specialization, so we call a
+// function template to "store" T into the type memory addressed by
+// void(*)(T).
+template <class T>
+msvc_store_type<T,void*(*)(void**(T))>
+msvc_store_predicate_type(void*(*)(void**(T)));
+
+template <class T>
+msvc_store_type<boost::is_convertible<mpl::_,T>,void*(*)(void*(T))>
+msvc_store_predicate_type(void*(*)(void*(T)));
+
+template <class FunctionType>
+struct unwrap_predicate
+{
+    static FunctionType f;
+
+    // We don't want the function to be evaluated, just instantiated,
+    // so protect it inside of sizeof.
+    enum { dummy = sizeof(msvc_store_predicate_type(f)) };
+
+    // Now pull the type out of the instantiated base class
+    typedef typename msvc_type_memory<FunctionType>::storage::type type;
+};
+
+template <>
+struct unwrap_predicate<void*(*)(void**)>
+{
+    typedef mpl::always<mpl::true_> type;
+};
+
+# endif
+
 # undef false_

 template <
@@ -119,6 +158,7 @@ struct argument_pack
    typedef typename mpl::first<result>::type type;
 };

+# if 1 //BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 // Works around VC6 problem where it won't accept rvalues.
 template <class T>
 T& as_lvalue(T& value, long)
@@ -131,9 +171,11 @@ T const& as_lvalue(T const& value, int)
 {
    return value;
 }
+# endif


-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

 template <class Predicate, class T, class Args>
 struct apply_predicate
@@ -460,7 +502,13 @@ struct funptr_predicate<void**>
 #  define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_required(tag) \
    required<boost::parameter::deduced<tag>

-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+#  if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+#   define BOOST_PARAMETER_PREDICATE_TYPE(p) void*(*) (void* p)
+#  else
+#   define BOOST_PARAMETER_PREDICATE_TYPE(p) void p
+#  endif

 #  define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
    BOOST_PP_COMMA_IF(i) \
@@ -473,9 +521,24 @@ struct funptr_predicate<void**>
        ) \
    ) \
      , typename boost::parameter::aux::unwrap_predicate< \
-            void BOOST_PARAMETER_FN_ARG_PRED(elem) \
+            BOOST_PARAMETER_PREDICATE_TYPE(BOOST_PARAMETER_FN_ARG_PRED(elem)) \
        >::type \
    >
+# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
+    BOOST_PP_COMMA_IF(i) \
+    boost::parameter::BOOST_PP_CAT( \
+        BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \
+      , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \
+    )( \
+        tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \
+            BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \
+        ) \
+    ) \
+      , boost::parameter::aux::funptr_predicate< \
+            void* BOOST_PARAMETER_FN_ARG_PRED(elem) \
+        > \
+    >
 # elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #  define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
    BOOST_PP_COMMA_IF(i) \
@@ -520,6 +583,21 @@ struct funptr_predicate<void**>
        typedef typename BOOST_PARAMETER_PARENTHESIZED_TYPE(result) type;                       \
    };

+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+#  define BOOST_PARAMETER_FUNCTION_RESULT(result, name, args)  \
+    BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args)        \
+    template <>                                                 \
+    struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<int>      \
+    { typedef int type; };
+
+# else
+
+#  define BOOST_PARAMETER_FUNCTION_RESULT(result, name, args)  \
+    BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args)
+
+# endif
+
 // Defines implementation function
 # define BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name)           \
    template <class Args>                                   \
@@ -818,7 +896,7 @@ struct funptr_predicate<void**>
    BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
    ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
        ResultType(*)() \
-      , Args const& \
+      , Args const& args \
      , int \
        BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
            BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \
@@ -837,7 +915,7 @@ struct funptr_predicate<void**>

 // Defines the result metafunction and the parameters specialization.
 # define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args)   \
-      BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args)                   \
+      BOOST_PARAMETER_FUNCTION_RESULT(result, name, args)                   \
                                                                            \
          BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, name, args)    \
          BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(name);                   \
@@ -943,6 +1021,18 @@ struct funptr_predicate<void**>
    BOOST_PP_COMMA_IF(i) elem& BOOST_PP_CAT(a, i)
 /**/

+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+// Older MSVC can't do what's necessary to handle commas in base names; just
+// use a typedef instead if you have a base name that contains commas.
+#  define BOOST_PARAMETER_PARENTHESIZED_BASE(x) BOOST_PP_SEQ_HEAD(x)
+
+# else
+
+#  define BOOST_PARAMETER_PARENTHESIZED_BASE(x) BOOST_PARAMETER_PARENTHESIZED_TYPE(x)
+
+# endif
+
 # define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00(z, n, r, data, elem) \
    BOOST_PP_IF( \
        n \
@@ -967,7 +1057,7 @@ struct funptr_predicate<void**>
          , n \
        ) \
    ) \
-      : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \
+      : BOOST_PARAMETER_PARENTHESIZED_BASE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \
            BOOST_PP_CAT(constructor_parameters, __LINE__)()( \
                BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
            ) \
@@ -1058,7 +1148,18 @@ struct funptr_predicate<void**>
      , (const ParameterArgumentType ## i)(ParameterArgumentType ## i) \
      , (const ParameterArgumentType ## i) \
    ))
+// MSVC6.5 lets us bind rvalues to T&.
+# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \
+    (BOOST_PP_IF( \
+        BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \
+            BOOST_PARAMETER_FN_ARG_NAME(elem) \
+        ) \
+      , (ParameterArgumentType ## i) \
+      , (const ParameterArgumentType ## i) \
+    ))
 // No partial ordering. This feature doesn't work.
+// This is exactly the same as for VC6.5, but we might change it later.
 # else
 #  define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \
    (BOOST_PP_IF( \
--- a/include/boost/parameter/python.hpp
+++ b/include/boost/parameter/python.hpp
@@ -0,0 +1,735 @@
+// Copyright Daniel Wallin 2006. 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_PYTHON_060209_HPP
+# define BOOST_PARAMETER_PYTHON_060209_HPP
+
+# include <boost/mpl/vector.hpp>
+# include <boost/mpl/fold.hpp>
+# include <boost/mpl/prior.hpp>
+# include <boost/mpl/shift_right.hpp>
+# include <boost/mpl/shift_left.hpp>
+# include <boost/mpl/bitand.hpp>
+# include <boost/mpl/pair.hpp>
+# include <boost/mpl/size.hpp>
+# include <boost/mpl/push_back.hpp>
+# include <boost/mpl/or.hpp>
+# include <boost/mpl/count_if.hpp>
+# include <boost/mpl/transform.hpp>
+# include <boost/mpl/front.hpp>
+# include <boost/mpl/iterator_range.hpp>
+# include <boost/mpl/next.hpp>
+# include <boost/mpl/begin_end.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/mpl/empty.hpp>
+# include <boost/python/def.hpp>
+# include <boost/python/make_constructor.hpp>
+# include <boost/python/init.hpp>
+# include <boost/python/to_python_converter.hpp>
+# include <boost/parameter/aux_/maybe.hpp>
+# include <boost/parameter/aux_/python/invoker.hpp>
+
+namespace boost { namespace parameter { namespace python 
+{
+  namespace python_ = boost::python;
+}}}
+
+namespace boost { namespace parameter { namespace python { namespace aux 
+{
+
+  inline PyObject* unspecified_type()
+  {
+      static PyTypeObject unspecified = {
+          PyObject_HEAD_INIT(NULL)
+          0,                                /* ob_size        */
+          "Boost.Parameter.Unspecified",    /* tp_name        */
+          PyType_Type.tp_basicsize,         /* tp_basicsize   */
+          0,                                /* tp_itemsize    */
+          0,                                /* tp_dealloc     */
+          0,                                /* tp_print       */
+          0,                                /* tp_getattr     */
+          0,                                /* tp_setattr     */
+          0,                                /* tp_compare     */
+          0,                                /* tp_repr        */
+          0,                                /* tp_as_number   */
+          0,                                /* tp_as_sequence */
+          0,                                /* tp_as_mapping  */
+          0,                                /* tp_hash        */
+          0,                                /* tp_call        */
+          0,                                /* tp_str         */
+          0,                                /* tp_getattro    */
+          0,                                /* tp_setattro    */
+          0,                                /* tp_as_buffer   */
+          Py_TPFLAGS_DEFAULT,               /* tp_flags       */
+          0,                                /* tp_doc         */
+      };
+
+      if (unspecified.ob_type == 0)
+      {
+          unspecified.ob_type = &PyType_Type;
+          PyType_Ready(&unspecified);
+      }
+
+      return (PyObject*)&unspecified;
+  }
+
+  struct empty_tag {};
+
+  struct empty_tag_to_python
+  {
+      static PyObject* convert(empty_tag)
+      {
+          return python_::xincref(unspecified_type());
+      }
+  };
+
+}}}} // namespace boost::parameter::python::aux
+
+namespace boost { namespace python 
+{
+
+  // Converts a Python value to a maybe<T>
+  template <class T>
+  struct arg_from_python<parameter::aux::maybe<T> >
+    : arg_from_python<T>
+  {
+      arg_from_python(PyObject* p)
+        : arg_from_python<T>(p)
+        , empty(parameter::python::aux::unspecified_type() == p)
+      {}
+
+      bool convertible() const
+      {
+          return empty || arg_from_python<T>::convertible();
+      }
+
+      parameter::aux::maybe<T> operator()()
+      {
+          if (empty)
+          {
+              return parameter::aux::maybe<T>();
+          }
+          else
+          {
+              return parameter::aux::maybe<T>(
+                  arg_from_python<T>::operator()()
+              );
+          }
+      }
+
+      bool empty;
+  };
+
+}} // namespace boost::python
+
+namespace boost { namespace parameter { namespace python {
+
+namespace aux
+{
+
+  template <class K>
+  struct is_optional
+    : mpl::not_<
+          mpl::or_<typename K::required, typename K::optimized_default>
+      >
+  {};
+
+  template <class K, class Required, class Optimized, class T>
+  struct arg_spec
+  {
+      typedef K keyword;
+      typedef Required required;
+      typedef T type;
+      typedef Optimized optimized_default;
+  };
+  
+  template <class K, class T, class Optimized = mpl::false_>
+  struct make_arg_spec_impl
+  {
+      typedef arg_spec<
+          typename K::first, typename K::second, Optimized, T
+      > type;
+  };
+
+  template <class K, class T>
+  struct make_arg_spec_impl<K, T, typename K::third>
+  {
+      typedef arg_spec<
+          typename K::first, typename K::second, typename K::third, T
+      > type;
+  };
+
+  template <class K, class T>
+  struct make_arg_spec
+    : make_arg_spec_impl<K, T>
+  {
+  };
+
+  template <class Spec, class State>
+  struct combinations_op
+  {
+      typedef typename State::second bits;
+      typedef typename State::first result0;
+
+      typedef typename mpl::if_<
+          mpl::or_<
+              typename Spec::required
+            , typename Spec::optimized_default
+            , mpl::bitand_<bits, mpl::long_<1> >
+          >
+        , typename mpl::push_back<result0, Spec>::type
+        , result0
+      >::type result;
+
+      typedef typename mpl::if_<
+          mpl::or_<
+              typename Spec::required
+            , typename Spec::optimized_default
+          >
+        , bits
+        , typename mpl::shift_right<bits, mpl::long_<1> >::type
+      >::type next_bits;
+
+      typedef mpl::pair<
+          result
+        , next_bits
+      > type;
+  };
+
+  // Used as start value in the recursive arg() composition below.
+  struct no_keywords
+  {
+      template <class T>
+      T const& operator,(T const& x) const
+      {
+          return x;
+      }
+  };
+
+  template <class Def, class F, class Iter, class End, class Keywords>
+  void def_combination_aux0(
+      Def def, F f, Iter, End, Keywords const& keywords, mpl::false_)
+  {
+      typedef typename mpl::deref<Iter>::type spec;
+      typedef typename spec::keyword kw;
+
+      def_combination_aux(
+          def, f, typename mpl::next<Iter>::type(), End()
+        , (
+              keywords, boost::python::arg(kw::keyword_name())
+          )
+      );
+  }
+
+  template <class Def, class F, class Iter, class End, class Keywords>
+  void def_combination_aux0(
+      Def def, F f, Iter, End, Keywords const& keywords, mpl::true_)
+  {
+      typedef typename mpl::deref<Iter>::type spec;
+      typedef typename spec::keyword kw;
+
+      def_combination_aux(
+          def, f, typename mpl::next<Iter>::type(), End()
+        , (
+              keywords, boost::python::arg(kw::keyword_name()) = empty_tag()
+          )
+      );
+  }
+
+  inline void initialize_converter()
+  {
+      static python_::to_python_converter<empty_tag, empty_tag_to_python> x;
+  }
+
+  template <class Def, class F, class Iter, class End, class Keywords>
+  void def_combination_aux(
+      Def def, F f, Iter, End, Keywords const& keywords)
+  {
+      typedef typename mpl::deref<Iter>::type spec;
+
+      typedef typename mpl::and_<
+          typename spec::optimized_default
+        , mpl::not_<typename spec::required>
+      >::type optimized_default;
+      
+      def_combination_aux0(
+          def, f, Iter(), End(), keywords, optimized_default()
+      );
+  }
+
+  template <class Def, class F, class End, class Keywords>
+  void def_combination_aux(
+      Def def, F f, End, End, Keywords const& keywords)
+  {
+      def(f, keywords);
+  } 
+
+  template <class Def, class F, class End>
+  void def_combination_aux(
+      Def def, F f, End, End, no_keywords const&)
+  {
+      def(f);
+  }
+
+  template <
+      class Def, class Specs, class Bits, class Invoker
+  >
+  void def_combination(
+      Def def, Specs*, Bits, Invoker*)
+  {
+      typedef typename mpl::fold<
+          Specs
+        , mpl::pair<mpl::vector0<>, Bits>
+        , combinations_op<mpl::_2, mpl::_1>
+      >::type combination0;
+
+      typedef typename combination0::first combination;
+
+      typedef typename mpl::apply_wrap1<
+          Invoker, combination
+      >::type invoker;
+
+      def_combination_aux(
+          def
+        , &invoker::execute
+        , typename mpl::begin<combination>::type()
+        , typename mpl::end<combination>::type()
+        , no_keywords()
+      );
+  }
+
+  template <
+      class Def, class Specs, class Bits, class End, class Invoker
+  >
+  void def_combinations(
+      Def def, Specs*, Bits, End, Invoker*)
+  {
+      initialize_converter();
+
+      def_combination(def, (Specs*)0, Bits(), (Invoker*)0);
+
+      def_combinations(
+          def
+        , (Specs*)0
+        , mpl::long_<Bits::value + 1>()
+        , End()
+        , (Invoker*)0
+      );
+  }
+
+  template <
+      class Def, class Specs, class End, class Invoker
+  >
+  void def_combinations(
+      Def, Specs*, End, End, Invoker*)
+  {}
+
+  struct not_specified {};
+
+  template <class CallPolicies>
+  struct call_policies_as_options
+  {
+      call_policies_as_options(CallPolicies const& call_policies)
+        : call_policies(call_policies)
+      {}
+
+      CallPolicies const& policies() const
+      {
+          return call_policies;
+      }
+
+      char const* doc() const
+      {
+          return 0;
+      }
+
+      CallPolicies call_policies;
+  };
+
+  template <class Class, class Options = not_specified>
+  struct def_class
+  {
+      def_class(Class& cl, char const* name, Options options = Options())
+        : cl(cl)
+        , name(name)
+        , options(options)
+      {}
+
+      template <class F>
+      void def(F f, not_specified const*) const
+      {
+          cl.def(name, f);
+      }
+
+      template <class F>
+      void def(F f, void const*) const
+      {
+          cl.def(name, f, options.doc(), options.policies());
+      }
+      
+      template <class F>
+      void operator()(F f) const
+      {
+          this->def(f, &options);
+      }
+
+      template <class F, class Keywords>
+      void def(F f, Keywords const& keywords, not_specified const*) const
+      {
+          cl.def(name, f, keywords);
+      }
+
+      template <class F, class Keywords>
+      void def(F f, Keywords const& keywords, void const*) const
+      {
+          cl.def(name, f, keywords, options.doc(), options.policies());
+      }
+
+      template <class F, class Keywords>
+      void operator()(F f, Keywords const& keywords) const
+      {
+          this->def(f, keywords, &options);
+      }
+
+      Class& cl;
+      char const* name;
+      Options options;
+  };
+
+  template <class Class, class CallPolicies = boost::python::default_call_policies>
+  struct def_init
+  {
+      def_init(Class& cl, CallPolicies call_policies = CallPolicies())
+        : cl(cl)
+        , call_policies(call_policies)
+      {}
+
+      template <class F>
+      void operator()(F f) const
+      {
+          cl.def(
+              "__init__"
+            , boost::python::make_constructor(f, call_policies)
+          );
+      }
+
+      template <class F, class Keywords>
+      void operator()(F f, Keywords const& keywords) const
+      {
+          cl.def(
+              "__init__"
+            , boost::python::make_constructor(f, call_policies, keywords)
+          );
+      }
+
+      Class& cl;
+      CallPolicies call_policies;
+  };
+
+  struct def_function
+  {
+      def_function(char const* name)
+        : name(name)
+      {}
+      
+      template <class F>
+      void operator()(F f) const
+      {
+          boost::python::def(name, f);
+      }
+
+      template <class F, class Keywords>
+      void operator()(F f, Keywords const& keywords) const
+      {
+          boost::python::def(name, f, keywords);
+      }
+
+      char const* name;
+  };
+
+} // namespace aux
+
+template <class M, class Signature>
+void def(char const* name, Signature)
+{
+    typedef mpl::iterator_range<
+        typename mpl::next<
+            typename mpl::begin<Signature>::type
+        >::type
+      , typename mpl::end<Signature>::type
+    > arg_types;
+
+    typedef typename mpl::transform<
+        typename M::keywords
+      , arg_types
+      , aux::make_arg_spec<mpl::_1, mpl::_2>
+      , mpl::back_inserter<mpl::vector0<> >
+    >::type arg_specs;
+
+    typedef typename mpl::count_if<
+        arg_specs
+      , aux::is_optional<mpl::_1>
+    >::type optional_arity;
+    
+    typedef typename mpl::front<Signature>::type result_type;
+    typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+    aux::def_combinations(
+        aux::def_function(name)
+      , (arg_specs*)0
+      , mpl::long_<0>()
+      , mpl::long_<upper::value>()
+      , (aux::make_invoker<M, result_type>*)0
+    );
+}
+
+template <class M, class Class, class Signature>
+void def(Class& cl, char const* name, Signature)
+{
+    typedef mpl::iterator_range<
+        typename mpl::next<
+            typename mpl::begin<Signature>::type
+        >::type
+      , typename mpl::end<Signature>::type
+    > arg_types;
+
+    typedef typename mpl::transform<
+        typename M::keywords
+      , arg_types
+      , aux::make_arg_spec<mpl::_1, mpl::_2>
+      , mpl::back_inserter<mpl::vector0<> >
+    >::type arg_specs;
+
+    typedef typename mpl::count_if<
+        arg_specs
+      , aux::is_optional<mpl::_1>
+    >::type optional_arity;
+    
+    typedef typename mpl::front<Signature>::type result_type;
+    typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+    aux::def_combinations(
+        aux::def_class<Class>(cl, name)
+      , (arg_specs*)0
+      , mpl::long_<0>()
+      , mpl::long_<upper::value>()
+      , (aux::make_invoker<M, result_type>*)0
+    );
+}
+
+namespace aux
+{
+
+  template <class K>
+  struct keyword
+  {
+      typedef K type;
+  };
+
+  template <class K>
+  struct keyword<K*>
+  {
+      typedef K type;
+  };
+
+  template <class K>
+  struct keyword<K**>
+  {
+      typedef K type;
+  };
+
+  template <class K>
+  struct required
+  {
+      typedef mpl::true_ type;
+  };
+
+  template <class K>
+  struct required<K*>
+  {
+      typedef mpl::false_ type;
+  };
+
+  template <class K>
+  struct optimized
+  {
+      typedef mpl::true_ type;
+  };
+
+  template <class K>
+  struct optimized<K**>
+  {
+      typedef mpl::false_ type;
+  };
+
+  template <class T>
+  struct make_kw_spec;
+
+  template <class K, class T>
+  struct make_kw_spec<K(T)>
+  {
+      typedef arg_spec<
+          typename keyword<K>::type
+        , typename required<K>::type
+        , typename optimized<K>::type
+        , T
+      > type;
+  };
+
+} // namespace aux
+
+template <class ParameterSpecs, class CallPolicies = boost::python::default_call_policies>
+struct init 
+  : boost::python::def_visitor<init<ParameterSpecs, CallPolicies> >
+{
+    init(CallPolicies call_policies = CallPolicies())
+      : call_policies(call_policies)
+    {}
+
+    template <class CallPolicies1>
+    init<ParameterSpecs, CallPolicies1> 
+    operator[](CallPolicies1 const& call_policies) const
+    {
+        return init<ParameterSpecs, CallPolicies1>(call_policies);
+    }
+
+    template <class Class>
+    void visit_aux(Class& cl, mpl::true_) const
+    {
+        cl.def(boost::python::init<>()[call_policies]);
+    }
+
+    template <class Class>
+    void visit_aux(Class& cl, mpl::false_) const
+    {
+        typedef typename mpl::transform<
+            ParameterSpecs
+          , aux::make_kw_spec<mpl::_>
+          , mpl::back_inserter<mpl::vector0<> >
+        >::type arg_specs;
+
+        typedef typename mpl::count_if<
+            arg_specs
+          , aux::is_optional<mpl::_>
+        >::type optional_arity;
+
+        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+        aux::def_combinations(
+            aux::def_init<Class, CallPolicies>(cl, call_policies)
+          , (arg_specs*)0
+          , mpl::long_<0>()
+          , mpl::long_<upper::value>()
+          , (aux::make_init_invoker<typename Class::wrapped_type>*)0
+        );
+    }
+
+    template <class Class>
+    void visit(Class& cl) const
+    {
+        visit_aux(cl, mpl::empty<ParameterSpecs>());
+    }
+
+    CallPolicies call_policies;
+};
+
+template <class ParameterSpecs, class CallPolicies = boost::python::default_call_policies>
+struct call 
+  : boost::python::def_visitor<call<ParameterSpecs, CallPolicies> >
+{
+    call(CallPolicies const& call_policies = CallPolicies())
+      : call_policies(call_policies)
+    {}
+
+    template <class CallPolicies1>
+    call<ParameterSpecs, CallPolicies1>
+    operator[](CallPolicies1 const& call_policies) const
+    {
+        return call<ParameterSpecs, CallPolicies1>(call_policies);
+    }
+
+    template <class Class>
+    void visit(Class& cl) const
+    {
+        typedef mpl::iterator_range<
+            typename mpl::next<
+                typename mpl::begin<ParameterSpecs>::type
+            >::type
+          , typename mpl::end<ParameterSpecs>::type
+        > arg_types;
+
+        typedef typename mpl::front<ParameterSpecs>::type result_type;
+
+        typedef typename mpl::transform<
+            arg_types
+          , aux::make_kw_spec<mpl::_>
+          , mpl::back_inserter<mpl::vector0<> >
+        >::type arg_specs;
+
+        typedef typename mpl::count_if<
+            arg_specs
+          , aux::is_optional<mpl::_>
+        >::type optional_arity;
+
+        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+        typedef aux::call_policies_as_options<CallPolicies> options;
+
+        aux::def_combinations(
+            aux::def_class<Class, options>(cl, "__call__", options(call_policies))
+          , (arg_specs*)0
+          , mpl::long_<0>()
+          , mpl::long_<upper::value>()
+          , (aux::make_call_invoker<typename Class::wrapped_type, result_type>*)0
+        );
+    }
+
+    CallPolicies call_policies;
+};
+
+template <class Fwd, class ParameterSpecs>
+struct function 
+  : boost::python::def_visitor<function<Fwd, ParameterSpecs> >
+{
+    template <class Class, class Options>
+    void visit(Class& cl, char const* name, Options const& options) const
+    {
+        typedef mpl::iterator_range<
+            typename mpl::next<
+                typename mpl::begin<ParameterSpecs>::type
+            >::type
+          , typename mpl::end<ParameterSpecs>::type
+        > arg_types;
+
+        typedef typename mpl::front<ParameterSpecs>::type result_type;
+
+        typedef typename mpl::transform<
+            arg_types
+          , aux::make_kw_spec<mpl::_>
+          , mpl::back_inserter<mpl::vector0<> >
+        >::type arg_specs;
+
+        typedef typename mpl::count_if<
+            arg_specs
+          , aux::is_optional<mpl::_>
+        >::type optional_arity;
+
+        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+        aux::def_combinations(
+            aux::def_class<Class, Options>(cl, name, options)
+          , (arg_specs*)0
+          , mpl::long_<0>()
+          , mpl::long_<upper::value>()
+          , (aux::make_member_invoker<
+                Fwd, result_type, typename Class::wrapped_type
+            >*)0
+        );
+    }
+};
+
+}}} // namespace boost::parameter::python
+
+#endif // BOOST_PARAMETER_PYTHON_060209_HPP
+
--- a/include/boost/parameter/value_type.hpp
+++ b/include/boost/parameter/value_type.hpp
@@ -12,13 +12,18 @@
 # include <boost/parameter/aux_/void.hpp>
 # include <boost/type_traits/is_same.hpp>

+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  include <boost/mpl/eval_if.hpp>
+# endif
+
 namespace boost { namespace parameter { 

 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword.  If no such
 // parameter has been specified, returns Default

-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 template <class Parameters, class Keyword, class Default>
 struct value_type0
 {
@@ -36,9 +41,14 @@ struct value_type0
 # endif

 template <class Parameters, class Keyword, class Default = void_>
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 struct value_type
+# else
+struct value_type_eti
+# endif
 {
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
    typedef typename mpl::eval_if<
        mpl::is_placeholder<Parameters>
      , mpl::identity<int>
@@ -57,8 +67,24 @@ struct value_type
    ));
 # endif

+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
+# endif
+};
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+template <class Parameters, class Keyword, class Default = void_>
+struct value_type
+{
+    typedef typename mpl::eval_if<
+        is_same<Parameters, int>
+      , mpl::identity<int>
+      , value_type_eti<Parameters, Keyword, Default>
+    >::type type;
+
    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
 };
+# endif

 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword.  If no such
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -1,17 +0,0 @@
-{
-    "key": "parameter",
-    "name": "Parameter",
-    "authors": [
-        "David Abrahams",
-        "Daniel Wallin"
-    ],
-    "description": "Boost.Parameter Library - Write functions that accept arguments by name.",
-    "category": [
-        "Emulation",
-        "Programming"
-    ],
-    "maintainers": [
-        "David Abrahams <dave -at- boost-consulting.com>",
-        "Daniel Wallin <daniel -at- boostpro.com>"
-    ]
-}
--- a/test/literate/building-argumentpacks0.cpp
+++ b/test/literate/building-argumentpacks0.cpp
@@ -1,6 +1,8 @@

+#line 1744 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
+#line 1733 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(index)

 template <class ArgumentPack>
@@ -12,6 +14,7 @@ int print_index(ArgumentPack const& args)

 int x = print_index(_index = 3);  // prints "index = 3"

+#line 1752 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(name)

 template <class ArgumentPack>
@@ -24,11 +27,13 @@ int print_name_and_index(ArgumentPack const& args)
 int y = print_name_and_index((_index = 3, _name = "jones"));


+#line 1787 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace parameter = boost::parameter;
 using parameter::required;
 using parameter::optional;
 using boost::is_convertible;
 using boost::mpl::_;
+#line 1773 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 parameter::parameters<
    required<tag::name, is_convertible<_,char const*> >
  , optional<tag::index, is_convertible<_,int> >
@@ -42,6 +47,7 @@ int z0 = print_name_and_index( spec(sam, twelve) );
 int z1 = print_name_and_index(
   spec(_index=12, _name="sam")
 );
+#line 1794 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {}

--- a/test/literate/class-template-skeleton0.cpp
+++ b/test/literate/class-template-skeleton0.cpp
@@ -1,5 +1,7 @@

+#line 1387 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
+#line 1373 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 template <
--- a/test/literate/deduced-parameters0.cpp
+++ b/test/literate/deduced-parameters0.cpp
@@ -1,4 +1,5 @@

+#line 1062 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 BOOST_PARAMETER_NAME(name)
@@ -30,6 +31,7 @@ default_call_policies some_policies;

 void f()
 {}
+#line 1029 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace mpl = boost::mpl;

 BOOST_PARAMETER_FUNCTION(
@@ -62,13 +64,17 @@ BOOST_PARAMETER_FUNCTION(
 }


+#line 1111 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {
+#line 1108 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 def("f", &f, some_policies, "Documentation for f");
 def("f", &f, "Documentation for f", some_policies);

+#line 1121 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 def(
    "f", &f
   , _policies = some_policies, "Documentation for f");
+#line 1124 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 }

--- a/test/literate/deduced-template-parameters0.cpp
+++ b/test/literate/deduced-template-parameters0.cpp
@@ -1,9 +1,9 @@

+#line 1557 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <boost/mpl/is_sequence.hpp>
 #include <boost/noncopyable.hpp>
 #include <memory>
-#include <boost/config.hpp>

 using namespace boost::parameter;
 using boost::mpl::_;
@@ -16,6 +16,7 @@ BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
 BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)

 }}
+#line 1546 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 namespace detail { struct bases_base {}; }
@@ -27,8 +28,10 @@ struct bases : detail::bases_base
 }}


+#line 1600 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/type_traits/is_class.hpp>
 namespace boost { namespace python {
+#line 1578 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 typedef parameter::parameters<
    required<tag::class_type, is_class<_> >

@@ -50,6 +53,7 @@ typedef parameter::parameters<
  , parameter::optional<deduced<tag::copyable>, is_same<noncopyable,_> >

 > class_signature;
+#line 1604 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 template <
    class A0
  , class A1 = parameter::void_
@@ -81,22 +85,16 @@ struct class_



+#line 1644 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 struct B {};
 struct D {};

 using boost::python::bases;
+#line 1640 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 typedef boost::python::class_<B, boost::noncopyable> c1;

-#if defined(BOOST_NO_CXX11_SMART_PTR)
-
 typedef boost::python::class_<D, std::auto_ptr<D>, bases<B> > c2;
-
-#else
-
-typedef boost::python::class_<D, std::unique_ptr<D>, bases<B> > c2;
-
-#endif
-
+#line 1650 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_MPL_ASSERT((boost::is_same<c1::class_type, B>));
 BOOST_MPL_ASSERT((boost::is_same<c1::base_list, bases<> >));
 BOOST_MPL_ASSERT((boost::is_same<c1::held_type, B>));
@@ -106,19 +104,8 @@ BOOST_MPL_ASSERT((

 BOOST_MPL_ASSERT((boost::is_same<c2::class_type, D>));
 BOOST_MPL_ASSERT((boost::is_same<c2::base_list, bases<B> >));
-
-#if defined(BOOST_NO_CXX11_SMART_PTR)
-
 BOOST_MPL_ASSERT((
    boost::is_same<c2::held_type, std::auto_ptr<D> >
 ));
-
-#else
-
-BOOST_MPL_ASSERT((
-    boost::is_same<c2::held_type, std::unique_ptr<D> >
-));
-
-#endif
-
 BOOST_MPL_ASSERT((boost::is_same<c2::copyable, void>));
+
--- a/test/literate/default-expression-evaluation0.cpp
+++ b/test/literate/default-expression-evaluation0.cpp
@@ -1,4 +1,5 @@

+#line 730 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>

@@ -7,6 +8,7 @@ BOOST_PARAMETER_NAME(visitor)
 BOOST_PARAMETER_NAME(root_vertex)
 BOOST_PARAMETER_NAME(index_map)
 BOOST_PARAMETER_NAME(color_map)
+#line 702 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/graph/depth_first_search.hpp> // for dfs_visitor

 BOOST_PARAMETER_FUNCTION(
--- a/test/literate/defining-the-keywords0.cpp
+++ b/test/literate/defining-the-keywords0.cpp
@@ -1,3 +1,4 @@
+#line 397 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/name.hpp>

 namespace graphs
--- a/test/literate/defining-the-keywords1.cpp
+++ b/test/literate/defining-the-keywords1.cpp
@@ -1,5 +1,7 @@

+#line 424 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/keyword.hpp>
+#line 413 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace graphs
 {
  namespace tag { struct graph; } // keyword tag type
--- a/test/literate/exercising-the-code-so-far0.cpp
+++ b/test/literate/exercising-the-code-so-far0.cpp
@@ -1,10 +1,10 @@

+#line 1415 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <boost/mpl/is_sequence.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/type_traits/is_class.hpp>
 #include <memory>
-#include <boost/config.hpp>

 using namespace boost::parameter;

@@ -20,6 +20,7 @@ struct bases
 {};

 }}
+#line 1402 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 using boost::mpl::_;
@@ -33,6 +34,7 @@ typedef parameter::parameters<

 }}

+#line 1454 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 template <
@@ -65,6 +67,7 @@ struct class_
 }}


+#line 1 "None"
 using boost::python::class_type;
 using boost::python::copyable;
 using boost::python::held_type;
@@ -73,24 +76,16 @@ using boost::python::bases;

 struct B {};
 struct D {};
+#line 1495 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 typedef boost::python::class_<
    class_type<B>, copyable<boost::noncopyable>
 > c1;

 typedef boost::python::class_<
-
-#if defined(BOOST_NO_CXX11_SMART_PTR)
-
    D, held_type<std::auto_ptr<D> >, base_list<bases<B> >
-    
-#else
-
-    D, held_type<std::unique_ptr<D> >, base_list<bases<B> >
-    
-#endif
-
 > c2;

+#line 1515 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_MPL_ASSERT((boost::is_same<c1::class_type, B>));
 BOOST_MPL_ASSERT((boost::is_same<c1::base_list, bases<> >));
 BOOST_MPL_ASSERT((boost::is_same<c1::held_type, B>));
@@ -100,19 +95,7 @@ BOOST_MPL_ASSERT((

 BOOST_MPL_ASSERT((boost::is_same<c2::class_type, D>));
 BOOST_MPL_ASSERT((boost::is_same<c2::base_list, bases<B> >));
-
-#if defined(BOOST_NO_CXX11_SMART_PTR)
-
 BOOST_MPL_ASSERT((
    boost::is_same<c2::held_type, std::auto_ptr<D> >
 ));
-
-#else
-
-BOOST_MPL_ASSERT((
-    boost::is_same<c2::held_type, std::unique_ptr<D> >
-));
-
-#endif
-
 BOOST_MPL_ASSERT((boost::is_same<c2::copyable, void>));
--- a/test/literate/extracting-parameter-types0.cpp
+++ b/test/literate/extracting-parameter-types0.cpp
@@ -1,6 +1,8 @@

+#line 1830 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <cassert>
+#line 1813 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(name)
 BOOST_PARAMETER_NAME(index)

@@ -17,6 +19,7 @@ int deduce_arg_types(ArgumentPack const& args)
 {
    return deduce_arg_types_impl(args[_name], args[_index|42]);
 }
+#line 1834 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int a1 = deduce_arg_types((_name = "foo"));
 int a2 = deduce_arg_types((_name = "foo", _index = 3));

--- a/test/literate/extracting-parameter-types1.cpp
+++ b/test/literate/extracting-parameter-types1.cpp
@@ -1,9 +1,11 @@

+#line 1863 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <cassert>

 namespace parameter = boost::parameter;
+#line 1852 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(index)

 template <class ArgumentPack>
@@ -14,6 +16,7 @@ twice_index(ArgumentPack const& args)
 }

 int six = twice_index(_index = 3);
+#line 1871 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {
    assert(six == 6);
--- a/test/literate/fine-grained-name-control0.cpp
+++ b/test/literate/fine-grained-name-control0.cpp
@@ -1,5 +1,7 @@

+#line 1703 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
+#line 1693 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME((pass_foo, keywords) foo)

 BOOST_PARAMETER_FUNCTION(
@@ -10,6 +12,7 @@ BOOST_PARAMETER_FUNCTION(
 }

 int x = f(pass_foo = 41);
+#line 1704 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {}

--- a/test/literate/handling-out-parameters0.cpp
+++ b/test/literate/handling-out-parameters0.cpp
@@ -1,4 +1,5 @@

+#line 620 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 namespace boost
@@ -19,6 +20,7 @@ BOOST_PARAMETER_NAME(color_map)

 BOOST_PARAMETER_FUNCTION((void), f, tag,
  (required (graph, *))
+#line 612 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 (optional
    (visitor,            *, boost::dfs_visitor<>())
    (root_vertex,        *, *vertices(graph).first)
@@ -26,5 +28,6 @@ BOOST_PARAMETER_FUNCTION((void), f, tag,
    (in_out(color_map), *,
      default_color_map(num_vertices(graph), index_map) )
 )
+#line 642 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 ) {}

--- a/test/literate/headers-and-namespaces0.cpp
+++ b/test/literate/headers-and-namespaces0.cpp
@@ -1,3 +1,5 @@
+#line 274 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/keyword.hpp>
+#line 283 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 using boost::parameter::keyword;

--- a/test/literate/lazy-default-computation0.cpp
+++ b/test/literate/lazy-default-computation0.cpp
@@ -1,8 +1,10 @@

+#line 1911 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <string>

 namespace parameter = boost::parameter;
+#line 1894 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(s1)
 BOOST_PARAMETER_NAME(s2)
 BOOST_PARAMETER_NAME(s3)
@@ -19,6 +21,7 @@ std::string f(ArgumentPack const& args)
 }

 std::string x = f((_s1="hello,", _s2=" world", _s3="hi world"));
+#line 1917 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {}

--- a/test/literate/lazy-default-computation1.cpp
+++ b/test/literate/lazy-default-computation1.cpp
@@ -1,4 +1,5 @@

+#line 1943 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/bind.hpp>
 #include <boost/ref.hpp>
 #include <boost/parameter.hpp>
@@ -16,10 +17,12 @@ std::string f(ArgumentPack const& args)
 {
    std::string const& s1 = args[_s1];
    std::string const& s2 = args[_s2];
+#line 1938 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 typename parameter::binding<
    ArgumentPack, tag::s3, std::string
 >::type s3 = args[_s3
    || boost::bind(std::plus<std::string>(), boost::ref(s1), boost::ref(s2)) ];
+#line 1962 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
    return s3;
 }

--- a/test/literate/namespaces0.cpp
+++ b/test/literate/namespaces0.cpp
@@ -1,6 +1,9 @@

+#line 2082 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
+#line 2085 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
+#line 2071 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace lib
 {
  BOOST_PARAMETER_NAME(name)
@@ -15,6 +18,8 @@ namespace lib
      return index;
  }
 }
+#line 2098 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int x = lib::f(lib::_name = "jill", lib::_index = 1);
+#line 2102 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {}

--- a/test/literate/namespaces1.cpp
+++ b/test/literate/namespaces1.cpp
@@ -1,6 +1,9 @@

+#line 2100 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
+#line 2085 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
+#line 2071 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace lib
 {
  BOOST_PARAMETER_NAME(name)
@@ -15,9 +18,11 @@ namespace lib
      return index;
  }
 }
+#line 2111 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 using lib::_name;
 using lib::_index;

 int x = lib::f(_name = "jill", _index = 1);
+#line 2120 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {}

--- a/test/literate/namespaces2.cpp
+++ b/test/literate/namespaces2.cpp
@@ -1,6 +1,9 @@

+#line 2114 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
+#line 2085 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
+#line 2071 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace lib
 {
  BOOST_PARAMETER_NAME(name)
@@ -15,7 +18,9 @@ namespace lib
      return index;
  }
 }
+#line 2128 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 using namespace lib;
 int x = f(_name = "jill", _index = 3);
+#line 2134 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {}

--- a/test/literate/namespaces3.cpp
+++ b/test/literate/namespaces3.cpp
@@ -1,6 +1,8 @@

+#line 2161 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
+#line 2143 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace lib
 {
  namespace keywords
@@ -19,7 +21,9 @@ namespace lib
  }
 }

+#line 2170 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 using namespace lib::keywords;
 int y = lib::f(_name = "bob", _index = 2);
+#line 2172 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {}

--- a/test/literate/optional-parameters0.cpp
+++ b/test/literate/optional-parameters0.cpp
@@ -1,4 +1,5 @@

+#line 571 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 namespace boost
@@ -18,11 +19,13 @@ BOOST_PARAMETER_NAME(color_map)

 BOOST_PARAMETER_FUNCTION((void), f, tag,
  (required (graph, *))
+#line 563 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 (optional     (visitor,           *, boost::dfs_visitor<>())
    (root_vertex,       *, *vertices(graph).first)
    (index_map,         *, get(boost::vertex_index,graph))
    (in_out(color_map), *,
      default_color_map(num_vertices(graph), index_map) )
 )
+#line 592 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 ) {}

--- a/test/literate/parameter-enabled-constructors0.cpp
+++ b/test/literate/parameter-enabled-constructors0.cpp
@@ -1,6 +1,8 @@

+#line 1248 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
+#line 1234 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(name)
 BOOST_PARAMETER_NAME(index)

@@ -15,6 +17,7 @@ struct myclass_impl
    }
 };

+#line 1261 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 struct myclass : myclass_impl
 {
    BOOST_PARAMETER_CONSTRUCTOR(
@@ -23,9 +26,12 @@ struct myclass : myclass_impl
 };


+#line 1275 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {
+#line 1272 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 myclass x("bob", 3);                     // positional
 myclass y(_index = 12, _name = "sally"); // named
 myclass z("june");                       // positional/defaulted
+#line 1275 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 }

--- a/test/literate/parameter-enabled-member-functions0.cpp
+++ b/test/literate/parameter-enabled-member-functions0.cpp
@@ -1,7 +1,9 @@

+#line 1154 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
 using namespace boost::parameter;
+#line 1142 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(arg1)
 BOOST_PARAMETER_NAME(arg2)

--- a/test/literate/parameter-enabled-member-functions1.cpp
+++ b/test/literate/parameter-enabled-member-functions1.cpp
@@ -1,9 +1,11 @@

+#line 1177 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 BOOST_PARAMETER_NAME(arg1)
 BOOST_PARAMETER_NAME(arg2)
 using namespace boost::parameter;
+#line 1166 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 struct callable2
 {
    BOOST_PARAMETER_CONST_MEMBER_FUNCTION(
--- a/test/literate/predicate-requirements0.cpp
+++ b/test/literate/predicate-requirements0.cpp
@@ -1,4 +1,5 @@

+#line 935 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/depth_first_search.hpp>
@@ -10,6 +11,7 @@ BOOST_PARAMETER_NAME((_index_map, graphs) index_map)
 BOOST_PARAMETER_NAME((_color_map, graphs) color_map)

 using boost::mpl::_;
+#line 859 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 // We first need to define a few metafunction that we use in the
 // predicates below.

@@ -85,6 +87,7 @@ BOOST_PARAMETER_FUNCTION(
       , default_color_map(num_vertices(graph), index_map) )
    )
 )
+#line 949 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 {}

 int main()
@@ -97,7 +100,7 @@ int main()
                 E(w,z), E(z, z)};
    G g(edges, edges + sizeof(edges) / sizeof(E), N);

-    ::depth_first_search(g);
-    ::depth_first_search(g, _root_vertex = (int)x);
+    depth_first_search(g);
+    depth_first_search(g, _root_vertex = (int)x);
 }

--- a/test/literate/required-parameters0.cpp
+++ b/test/literate/required-parameters0.cpp
@@ -1,9 +1,12 @@

+#line 540 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 BOOST_PARAMETER_NAME(graph)

 BOOST_PARAMETER_FUNCTION((void), f, tag,
+#line 531 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 (required (graph, *) )
+#line 547 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 ) {}

--- a/test/literate/static-member-functions0.cpp
+++ b/test/literate/static-member-functions0.cpp
@@ -1,7 +1,9 @@

+#line 1206 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
 using namespace boost::parameter;
+#line 1195 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(arg1)

 struct somebody
--- a/test/literate/template-keywords0.cpp
+++ b/test/literate/template-keywords0.cpp
@@ -1,5 +1,7 @@

+#line 1337 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
+#line 1329 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
--- a/test/literate/template-keywords1.cpp
+++ b/test/literate/template-keywords1.cpp
@@ -1,5 +1,7 @@

+#line 1353 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
+#line 1344 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 namespace tag { struct class_type; } // keyword tag type
--- a/test/literate/top-level0.cpp
+++ b/test/literate/top-level0.cpp
@@ -1,4 +1,5 @@

+#line 35 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 namespace test
@@ -30,6 +31,7 @@ namespace test
 }
 using namespace test;
 int x = 
+#line 19
 new_window("alert", _width=10, _titlebar=false);

 smart_ptr<
--- a/test/literate/writing-the-function0.cpp
+++ b/test/literate/writing-the-function0.cpp
@@ -1,4 +1,5 @@

+#line 472 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/name.hpp>

 BOOST_PARAMETER_NAME(graph)
@@ -16,6 +17,7 @@ struct dfs_visitor
 int vertex_index = 0;

 }
+#line 446 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/preprocessor.hpp>

 namespace graphs
--- a/test/macros.cpp
+++ b/test/macros.cpp
@@ -52,6 +52,6 @@ int main()
     , index = boost::ref(x), name = "foo"
   );

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

--- a/test/preprocessor.cpp
+++ b/test/preprocessor.cpp
@@ -477,6 +477,6 @@ int main()
      , test::index = 2
    );

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

--- a/test/python_test.cpp
+++ b/test/python_test.cpp
@@ -2,7 +2,6 @@
 // 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)

-#include <math.h>
 #include <boost/python.hpp>
 #include <boost/parameter/preprocessor.hpp>
 #include <boost/parameter/keyword.hpp>
Author	SHA1	Message	Date
Daniel James	a3c2f26522	Quickbook: Merge from trunk to quickbook-dev. [SVN r76255]	2012-01-01 13:35:27 +00:00
Daniel James	ca9906cd83	Quickbook: Merge from trunk to quickbook-dev. [SVN r75846]	2011-12-07 09:40:30 +00:00
Daniel James	a151206a9d	Quickbook: Merge from trunk to quickbook-dev [SVN r75739]	2011-11-30 01:35:25 +00:00
Daniel James	f252fa2b38	Quickbook: New branch for development. From now on this will be my development branch. [SVN r70613]	2011-03-27 10:17:05 +00:00