Fix link to Python bindings

improve aux::arg_list<>::operator[]()

.travis.yml

@@ -0,0 +1,136 @@
+# 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

appveyor.yml

@@ -0,0 +1,37 @@
+# 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%

doc/Jamfile.v2

@@ -1,9 +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 ;
 
-import path ;
-sources = [ path.glob . : *.rst ] ;
+sources = [ 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" ;
@@ -13,9 +16,15 @@ for local b in $(bases)
     html $(b) : $(b).rst : 
       
       # 
-      <docutils-html>"-gdt --traceback --trim-footnote-reference-space --footnote-references=superscript "$(stylesheet)
+      <docutils-html>"-gdt --link-stylesheet --traceback --trim-footnote-reference-space --footnote-references=superscript "$(stylesheet)
   ;
 }
 
 alias htmls : $(bases) ;
 stage html : $(bases) ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : html ;
+explicit boostrelease ;

doc/README.txt

@@ -0,0 +1,17 @@
+.. -*-rst-*-
+
+.. Copyright David Abrahams 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)
+
+To build the html::
+
+  bjam html
+
+To test the code in this documentation:
+
+.. parsed-literal::
+
+  python ../../../tools/litre/tool.py `pwd`/index.rst --dump_dir=../test/literate
+  cd ../test/literate
+  bjam

doc/html/rst.css

@@ -1,3 +1,8 @@
+/* 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 "../../../../rst.css";
 
 div.section div.section div.section dl {
@@ -14,8 +19,12 @@ img {
 }
 
 span.vellipsis {
-  line-height: 30% ;
-  font-size: 200% ;
+  display: block;
+  width: 5px;
+  height: 22px;
+  background: url("vellipsis.gif");
+  margin-left: 3em;
+  text-indent: -1000px;
 }
 
 

doc/reference.rst

@@ -2,6 +2,16 @@
  The Boost Parameter Library Reference Documentation 
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
+:Authors:       David Abrahams, Daniel Wallin
+:Contact:       dave@boost-consulting.com, daniel@boostpro.com
+:organization:  `BoostPro Computing`_
+:date:          $Date: 2005/07/17 19:53:01 $
+
+:copyright:     Copyright David Abrahams, Daniel Wallin
+                2005-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)
+
 |(logo)|__
 
 .. |(logo)| image:: ../../../../boost.png
@@ -9,17 +19,7 @@
 
 __ ../../../../index.htm
 
-:Authors:       David Abrahams, Daniel Wallin
-:Contact:       dave@boost-consulting.com, dalwan01@student.umu.se
-:organization:  `Boost Consulting`_
-:date:          $Date: 2005/07/17 19:53:01 $
-
-:copyright:     Copyright David Abrahams, Daniel Wallin
-                2005. Distributed under the Boost Software License,
-                Version 1.0. (See accompanying file LICENSE_1_0.txt
-                or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
+.. _`BoostPro Computing`: http://www.boostpro.com
 
 
 //////////////////////////////////////////////////////////////////////////////
@@ -39,6 +39,7 @@ __ ../../../../index.htm
     :class: function
 
 .. |ArgumentPack| replace:: :concept:`ArgumentPack`
+.. |ForwardSequence| replace:: :concept:`Forward Sequence`
 .. |ParameterSpec| replace:: :concept:`ParameterSpec`
 
 .. role:: vellipsis
@@ -173,13 +174,17 @@ Concepts
 
 This section describes the generic type concepts_ used by the Parameter library. 
 
-.. _concepts: ../../../../more/generic_programming.html#concept
+.. _concepts: http://www.boost.org/more/generic_programming.html#concept
 
 |ArgumentPack|
 --------------
 
 An |ArgumentPack| is a collection of |tagged reference|\ s to the
-actual arguments passed to a function.
+actual arguments passed to a function.  Every |ArgumentPack| is
+also a valid MPL |ForwardSequence|__ consisting of the |keyword tag
+type|\ s in its |tagged reference|\ s.
+
+__ ../../../mpl/doc/refmanual/forward-sequence.html
 
 Requirements
 ............
@@ -248,7 +253,7 @@ argument type. In each row,
    +----------------------+--------------+--------------------------------+
    |Type                  |``A`` required|Condition ``A`` must satisfy    |
    +======================+==============+================================+
-   ||keyword|_\ ``<K>``   |no            |*n/a*                           |
+   |``K``                 |no            |*n/a*                           |
    +----------------------+--------------+--------------------------------+
    ||optional|_\ ``<K,F>``|no            |``mpl::apply<F,A>::type::value``|
    |                      |              |is ``true``.                    |
@@ -376,16 +381,15 @@ __ ../../../../boost/parameter/parameters.hpp
         };
 
         template <class A0>
-        |ArgumentPack|_ `operator()`_\(A0 const& a0) const;
+        |ArgumentPack|_ `operator()`_\(A0& a0) const;
 
         template <class A0, class A1>
-        |ArgumentPack|_ `operator()`_\(A0 const& a0, A1 const& a1) const; :vellipsis:`\ 
-       .
-       .
-       .
-     `
+        |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1) const; 
+
+        :vellipsis:`⋮`
+
         template <class A0, class A1, …class A\ β>
-        |ArgumentPack|_ `operator()`_\(A0 const& a0, A1 const& a1, …A\ β const& a\ β) const;
+        |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1, …A\ β& a\ β) const;
     };
 
 
@@ -398,13 +402,22 @@ __ ../../../../boost/parameter/parameters.hpp
   follows, for any argument type ``A``\ *i*:
 
 
+     | let ``D0`` the set [d0, …, d\ *j*] of all **deduced** *parameter specs* in [``P0``, …, ``P``\ β]
      | ``R``\ *i* is ``A``\ *i*\ 's |intended argument type|
      |
-     |  if ``A``\ *i* is a result type of ``keyword<T>::``\ |operator=|_
-     |  then 
-     |      ``K``\ *i* is ``T``
-     |  else 
-     |      ``K``\ *i* is ``P``\ *i*\ 's |keyword tag type|.
+     | if ``A``\ *i* is a result type of ``keyword<T>::``\ |operator=|_
+     | then 
+     |     ``K``\ *i* is ``T``
+     | else
+     |     if some ``A``\ *j* where *j*\ ≤\ *i* is a result type of ``keyword<T>::``\ |operator=|_
+     |     *or* some ``P``\ *j* in *j*\ ≤\ *i* is **deduced**
+     |     then
+     |         if some *parameter spec* ``d``\ *j* in ``D``\ *i* matches ``A``\ *i*
+     |         then
+     |             ``K``\ *i* is ``d``\ *j*\ 's |keyword tag type|.
+     |             ``D``\ :sub:`i+1` is ``D``\ *i* - [``d``\ *j*]
+     |     else
+     |         ``K``\ *i* is ``P``\ *i*\ 's |keyword tag type|.
 
 
 .. _match:
@@ -420,7 +433,7 @@ __ ../../../../boost/parameter/parameters.hpp
   every *j* in 0…β, either:
 
   * ``P``\ *j* is the *unspecified* default
-  * **or**, ``P``\ *j* is a specialization of |keyword|_,
+  * **or**, ``P``\ *j* is a *keyword tag type*
 
   * **or**, ``P``\ *j* is |optional|_ ``<X,F>`` and either
 
@@ -438,11 +451,10 @@ __ ../../../../boost/parameter/parameters.hpp
 ``operator()``
   .. parsed-literal::
 
-      template <class A0> |ArgumentPack|_ operator()(A0 const& a0) const; :vellipsis:`\ 
-        .
-        .
-        .
-       `
+      template <class A0> |ArgumentPack|_ operator()(A0 const& a0) const; 
+
+      :vellipsis:`⋮`
+
       template <class A0, …class A\ β> |ArgumentPack|_ `operator()`_\(A0 const& a0, …A\ β const& a\ β) const;
 
   :Returns:
@@ -483,6 +495,23 @@ The default value of ``Predicate`` is an unspecified |Metafunction|_ that return
 .. |Metafunction| replace:: :concept:`Metafunction`
 .. _Metafunction: ../../../mpl/doc/refmanual/metafunction.html
 
+
+``deduced``
+-----------
+
+This template is used to wrap the *keyword tag* argument to
+``optional`` or ``required``.
+
+:Defined in: `boost/parameter/parameters.hpp`__
+
+__ ../../../../boost/parameter/parameters.hpp
+
+.. parsed-literal::
+
+    template <class Tag>
+    struct deduced;
+
+
 //////////////////////////////////////////////////////////////////////////////
 
 Metafunctions
@@ -541,6 +570,37 @@ __ ../../../../boost/parameter/binding.hpp
   reference| exists, returns ``boost::``\ |result_of|_\ ``<F()>::type``. [#no_result_of]_
 
 
+``value_type``
+--------------
+
+Returns the result type of indexing an argument pack with a
+|keyword tag type| or with a |tagged default|.
+
+:Defined n: `boost/parameter/value_type.hpp`__
+
+__ ../../../../boost/parameter/value_type.hpp
+
+.. parsed-literal::
+
+    template <class A, class K, class D = void>
+    struct value_type
+    {
+        typedef … type;
+    };
+
+:Requires: ``A`` is a model of |ArgumentPack|_.
+
+:Returns: the type of the |tagged reference| in ``A``
+  having |keyword tag type| ``K``, if any.  If no such |tagged
+  reference| exists, returns ``D``. Equivalent to::
+
+    typename remove_reference<
+      typename binding<A, K, D>::type
+    >::type
+
+  … when ``D`` is not a reference type.
+
+
 //////////////////////////////////////////////////////////////////////////////
 
 Code Generation Macros
@@ -549,9 +609,256 @@ Code Generation Macros
 Macros in this section can be used to ease the writing of code
 using the Parameter libray by eliminating repetitive boilerplate.
 
+
+``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)``
+-----------------------------------------------------------------
+
+:Defined in: `boost/parameter/preprocessor.hpp`__
+
+__ ../../../../boost/parameter/preprocessor.hpp
+
+:Requires: ``result`` is the parenthesized return type of the function.
+  ``name`` is the base name of the function, this is the name of the
+  generated forwarding functions. ``tag_namespace`` is the namespace in
+  which the keywords used by the function resides. ``arguments`` is
+  a list of *argument specifiers*, as defined below.
+
+
+:Argument specifiers syntax:
+  .. parsed-literal::
+
+    argument-specifiers ::= *specifier-group* {*specifier-group*}
+
+    specifier-group0 ::= *specifier-group1* |
+                         ( '**(**' '**deduced**' *specifier-group1* {*specifier-group1*} '**)**' )
+
+    specifier-group1 ::= ( '**(**' '**optional**' *optional-specifier* {*optional-specifier*} '**)**' ) |
+                         ( '**(**' '**required**' *required-specifier* {*required-specifier*} '**)**' )
+
+    optional-specifier ::= '**(**' *name* '**,**' *restriction* '**,**' *default-value* ')'
+    required-specifier ::= '**(**' *name* '**,**' *restriction* ')'
+
+    restriction ::= ('*****' '**(**' *lambda-expression* '**)**' ) |
+                    ( '**(**' *typename* '**)**' ) |
+                    '*****'
+
+  ``name`` is any valid C++ identifier. ``default-value`` is any valid
+  C++ expression. ``typename`` is the name of a type.
+  ``lambda-expression`` is an `MPL lambda expression`_.
+
+.. _`MPL lambda expression`: ../../../mpl/doc/refmanual/lambda-expression.html
+
+:Generated names in enclosing scope:
+  * ``boost_param_result_ ## __LINE__ ## name``
+  * ``boost_param_params_ ## __LINE__ ## name``
+  * ``boost_param_parameters_ ## __LINE__ ## name``
+  * ``boost_param_impl ## name``
+  * ``boost_param_default_ ## __LINE__ ## name``
+
+
+Approximate expansion:
+  **Where**:
+
+  * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
+  * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
+
+  .. parsed-literal::
+
+    template <class T>
+    struct boost_param_result\_ ## __LINE__ ## **name**
+    {
+        typedef **result** type;
+    };
+
+    struct boost_param_params\_ ## __LINE__ ## **name**
+      : boost::parameter::parameters<
+            *list of parameter specifications, based on arguments*
+        >
+    {};
+
+    typedef boost_param_params\_ ## __LINE__ ## **name** 
+      boost_param_parameters\_ ## __LINE__ ## **name**;
+
+    template <class A0, …, class A\ **n**>
+    *result type* **name**\ (
+        A0 *cv*\ & a0, …, A\ **n** *cv*\ & a\ **n**
+      , typename boost_param_parameters\_ ## __LINE__ ## **name**::match<
+          A0 *cv*, …, A\ **n** *cv*
+        >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
+    )
+    {
+        *… forward to implementation …*
+    }
+
+    :vellipsis:`⋮`
+
+    template <class A0, …, class A\ **m**>
+    *result type* **name**\ (
+        A0 *cv*\ & a0, …, A\ **m** *cv*\ & a\ **m**
+      , typename boost_param_parameters\_ ## __LINE__ ## **name**::match<
+          A0 *cv*, …, A\ **m** *cv*
+        >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
+    )
+    {
+        *… forward to implementation …*
+    }
+
+    template <
+        class ResultType
+      , class *argument name*\ **0** ## _type
+        …
+      , class *argument name*\ **m** ## _type
+    >
+    ResultType boost_param_default\_ ## __LINE__ ## **name**\ (
+        (ResultType(*)())
+      , *argument name*\ **0** ## _type& *argument name*\ **0**
+        …
+      , *argument name*\ **m** ## _type& *argument name*\ **m**
+    )
+
+
+
+``BOOST_PARAMETER_MEMBER_FUNCTION(result,name,tag_namespace,arguments)``
+------------------------------------------------------------------------
+
+:Defined in: `boost/parameter/preprocessor.hpp`__
+
+__ ../../../../boost/parameter/preprocessor.hpp
+
+See ``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)``
+
+
+
+``BOOST_PARAMETER_CONSTRUCTOR(cls, impl, tag_namespace, arguments)``
+--------------------------------------------------------------------
+
+:Defined in: `boost/parameter/preprocessor.hpp`__
+
+__ ../../../../boost/parameter/preprocessor.hpp
+
+:Requires: ``cls`` is the name of this class. ``impl`` is the 
+  parenthesized implementation base class for ``cls``.
+  ``tag_namespace`` is the namespace in which the keywords 
+  used by the function resides. ``arguments`` is
+  a list of *argument specifiers*, as defined in 
+  ``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)``.
+
+:Generated names in enclosing scope:
+  * ``boost_param_params_ ## __LINE__ ## ctor``
+  * ``constructor_parameters ## __LINE__``
+
+Approximate expansion:
+  **Where**:
+
+  * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
+  * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
+
+  .. parsed-literal::
+
+    struct boost_param_params\_ ## __LINE__ ## ctor
+      : boost::parameter::parameters<
+            *list of parameter specifications, based on arguments*
+        >
+    {};
+
+    typedef boost_param_params\_ ## __LINE__ ## **name** 
+      constructor_parameters ## __LINE__;
+
+    template <class A0, …, class A\ **n**>
+    *cls*\ (A0 const& a0, …, A\ **n** const& a\ **n**)
+      : *impl*\ (constructor_parameters ## __LINE__(a0, …, a\ **n**))
+    {}
+
+    :vellipsis:`⋮`
+
+    template <class A0, …, class A\ **m**>
+    *cls*\ (A0 const& a0, …, A\ **n** const& a\ **m**)
+      : *impl*\ (constructor_parameters ## __LINE__(a0, …, a\ **m**))
+    {}
+
+
+``BOOST_PARAMETER_NAME(name)``
+------------------------------
+
+Declares a tag-type and keyword object.
+
+Expands to:
+
+**If** *name* is of the form:
+
+.. parsed-literal::
+
+  (*tag-name*, *namespace-name*) *object-name*
+
+**then**
+
+.. parsed-literal::
+
+  namespace *namespace-name* 
+  {
+    struct *tag-name*
+    {
+        static char const* keyword_name()
+        {
+            return ##\ *tag-name*;
+        }
+
+        typedef *unspecified* _;
+        typedef *unspecified* _1;
+    };
+  }
+
+  ::boost::parameter::keyword<*tag-namespace*\ ::\ *tag-name*\ > const& *object-name*
+      = ::boost::parameter::keyword<*tag-namespace*\ ::\ *tag-name*\ >::instance;
+
+**Else**
+
+.. parsed-literal::
+
+  namespace tag
+  {
+    struct *name*
+    {
+        static char const* keyword_name()
+        {
+            return ##\ *name*;
+        }
+
+        typedef *unspecified* _;
+        typedef *unspecified* _1;
+    };
+  }
+
+  ::boost::parameter::keyword<tag::\ *name*\ > const& _\ *name*
+      = ::boost::parameter::keyword<tag::\ *name*\ >::instance;
+
+
+``BOOST_PARAMETER_TEMPLATE_KEYWORD(name)``
+------------------------------------------
+
+Expands to:
+
+.. parsed-literal::
+
+  namespace tag
+  {
+    struct *name*;
+  }
+
+  template <class T>
+  struct *name* 
+    : ::boost::parameter::template_keyword<tag::\ *name*, T>
+  {};
+
+
 ``BOOST_PARAMETER_FUN(r,n,l,h,p)``
 ----------------------------------
 
+.. admonition:: Deprecated
+
+  This macro has been deprecated in favor of
+  ``BOOST_PARAMETER_FUNCTION``.
+
 Generates a sequence of `forwarding function`_ templates named
 ``n``, with arities ranging from ``l`` to ``h`` , returning ``r``,
 and using ``p`` to control overload resolution and assign tags to
@@ -582,11 +889,10 @@ Generates
       , typename **p**::match<A1,A2,…A\ **l**,A\ ##\ BOOST_PP_INC_\ (**l**)>::type p = **p**\ ())
     {
        return **name**\ _with_named_params(**p**\ (x1,x2,…x\ **l**,x\ ##\ BOOST_PP_INC_\ (**l**)));
-    } :vellipsis:`\ 
-      .
-      .
-      .
-     `
+    }
+
+    :vellipsis:`⋮`
+
     template <class A1, class A2, …class A\ **h**>
     r name(
         A1 const& a1, A2 const& a2, …A\ **h** const& x\ **h**
@@ -601,6 +907,11 @@ Generates
 ``BOOST_PARAMETER_KEYWORD(n,k)``
 --------------------------------
 
+.. admonition:: Deprecated
+
+  This macro has been deprecated in favor of
+  ``BOOST_PARAMETER_NAME``.
+
 Generates the declaration of a |keyword tag type| named ``k`` in
 namespace ``n``, and a corresponding |keyword object| definition in
 the enclosing namespace.
@@ -659,7 +970,7 @@ already ``#defined``.
 
 __ ../../../../boost/parameter/config.hpp
 
-:Default Value: ``5``
+:Default Value: ``8``
 
 Tutorial
 ========
@@ -686,4 +997,5 @@ __ index.html#tutorial
 .. _result_of: ../../../utility/utility.htm#result_of
 
 .. |BOOST_NO_RESULT_OF| replace:: ``BOOST_NO_RESULT_OF``
-.. _BOOST_NO_RESULT_OF: ../../../utility/utility.htm#BOOST_NO_RESULT_OF
+.. _BOOST_NO_RESULT_OF: ../../../utility/utility.htm#BOOST_NO_RESULT_OF
+

include/boost/parameter.hpp

@@ -3,14 +3,19 @@
 // (See accompanying file LICENSE_1_0.txt or copy at 
 // http://www.boost.org/LICENSE_1_0.txt)
 
+//  See www.boost.org/libs/parameter for documentation.
+
 #ifndef BOOST_PARAMETER_050401_HPP
 #define BOOST_PARAMETER_050401_HPP
 
 #include <boost/parameter/parameters.hpp>
 #include <boost/parameter/keyword.hpp>
 #include <boost/parameter/binding.hpp>
+#include <boost/parameter/value_type.hpp>
 #include <boost/parameter/macros.hpp>
 #include <boost/parameter/match.hpp>
+#include <boost/parameter/name.hpp>
+#include <boost/parameter/preprocessor.hpp>
 
 #endif // BOOST_PARAMETER_050401_HPP
 

include/boost/parameter/aux_/arg_list.hpp

@@ -11,24 +11,31 @@
 #include <boost/parameter/aux_/default.hpp>
 #include <boost/parameter/aux_/parameter_requirements.hpp>
 #include <boost/parameter/aux_/yesno.hpp>
+#include <boost/parameter/aux_/is_maybe.hpp>
 #include <boost/parameter/config.hpp>
 
 #include <boost/mpl/apply.hpp>
 #include <boost/mpl/assert.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/iterator_tags.hpp>
 
 #include <boost/type_traits/add_reference.hpp>
 #include <boost/type_traits/is_same.hpp>
-
 #include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/facilities/intercept.hpp>
 
-namespace boost { namespace parameter { 
+namespace boost { namespace parameter {
 
 // Forward declaration for aux::arg_list, below.
 template<class T> struct keyword;
 
 namespace aux {
 
+// Tag type passed to MPL lambda.
+struct lambda_tag;
+
 //
 // Structures used to build the tuple of actual arguments.  The
 // tuple is a nested cons-style list of arg_list specializations
@@ -39,7 +46,10 @@ namespace aux {
 // declarations to build member function overload sets that can
 // match against keywords.
 //
-  
+
+// MPL sequence support
+struct arg_list_tag;
+
 // Terminates arg_list<> and represents an empty list.  Since this
 // is just the terminating case you might want to look at arg_list
 // first, to get a feel for what's really happening here.
@@ -61,26 +71,22 @@ struct empty_arg_list
     // lookup given that default
     struct binding
     {
-        template<class KW, class Default>
+        template<class KW, class Default, class Reference>
         struct apply
         {
             typedef Default type;
         };
     };
 
-#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(BOOST_MSVC, <= 1300) \
-    || (BOOST_WORKAROUND(__GNUC__, < 3)) \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
     // The overload set technique doesn't work with these older
     // compilers, so they need some explicit handholding.
-      
+
     // A metafunction class that, given a keyword, returns the type
     // of the base sublist whose get() function can produce the
     // value for that key
@@ -131,20 +137,25 @@ struct empty_arg_list
     // was found if we match this overload, so unless that parameter
     // has a default, we indicate that the actual arguments don't
     // match the function's requirements.
-    template <class ParameterRequirements>
+    template <class ParameterRequirements, class ArgPack>
     static typename ParameterRequirements::has_default
-    satisfies(ParameterRequirements*);
-};
+    satisfies(ParameterRequirements*, ArgPack*);
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-template<class KW>
-no_tag operator*(empty_arg_list, KW*);
-#endif
+    // MPL sequence support
+    typedef empty_arg_list type;   // convenience
+    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
+};
 
 // Forward declaration for arg_list::operator,
 template <class KW, class T>
 struct tagged_argument;
 
+template <class T>
+struct get_reference
+{
+    typedef typename T::reference type;
+};
+
 // A tuple of tagged arguments, terminated with empty_arg_list.
 // Every TaggedArg is an instance of tagged_argument<>.
 template <class TaggedArg, class Next = empty_arg_list>
@@ -152,8 +163,20 @@ struct arg_list : Next
 {
     typedef arg_list<TaggedArg,Next> self;
     typedef typename TaggedArg::key_type key_type;
-    typedef typename TaggedArg::value_type value_type;
-    typedef typename TaggedArg::reference reference;
+
+    typedef typename is_maybe<typename TaggedArg::value_type>::type holds_maybe;
+
+    typedef typename mpl::eval_if<
+        holds_maybe
+      , get_reference<typename TaggedArg::value_type>
+      , get_reference<TaggedArg>
+    >::type reference;
+
+    typedef typename mpl::if_<
+        holds_maybe
+      , reference
+      , typename TaggedArg::value_type
+    >::type value_type;
 
     TaggedArg arg;      // Stores the argument
 
@@ -161,12 +184,12 @@ struct arg_list : Next
     template< // class A0, class A1, ...
         BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
     >
-    arg_list( // A0 const& a0, A1 const& a1, ...
-        BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PARAMETER_MAX_ARITY, A, const & a)
+    arg_list( // A0& a0, A1& a1, ...
+        BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PARAMETER_MAX_ARITY, A, & a)
     )
       : Next( // a1, a2, ...
             BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PARAMETER_MAX_ARITY, a)
-          , void_()
+          , void_reference()
         )
       , arg(a0)
     {}
@@ -174,54 +197,59 @@ struct arg_list : Next
     // Create a new list by prepending arg to a copy of tail.  Used
     // when incrementally building this structure with the comma
     // operator.
-    arg_list(TaggedArg arg, Next const& tail)
+    arg_list(TaggedArg head, Next const& tail)
       : Next(tail)
-      , arg(arg)
+      , arg(head)
     {}
 
-
     // A metafunction class that, given a keyword and a default
     // type, returns the appropriate result type for a keyword
     // lookup given that default
     struct binding
     {
-        template <class KW, class Default>
+        template <class KW, class Default, class Reference>
         struct apply
         {
           typedef typename mpl::eval_if<
                 boost::is_same<KW, key_type>
-              , mpl::identity<reference>
-              , mpl::apply_wrap2<typename Next::binding, KW, Default>
+              , mpl::if_<Reference, reference, value_type>
+              , mpl::apply_wrap3<typename Next::binding, KW, Default, Reference>
           >::type type;
         };
     };
 
-#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
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
     // 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(BOOST_PARAMETER_CALL_HAS_KEY(Next,key_type)) == sizeof(no_tag)
+        sizeof(Next::has_key((key_type*)0)) == sizeof(no_tag)
       , duplicate_keyword, (key_type)
     );
 
-#undef BOOST_PARAMETER_CALL_HAS_KEY
-    
+#endif
     //
     // Begin implementation of indexing operators for looking up
     // specific arguments by name
     //
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
-    || BOOST_WORKAROUND(__GNUC__, < 3) \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    // Helpers that handle the case when TaggedArg is
+    // empty<T>.
+    template <class D>
+    reference get_default(D const&, mpl::false_) const
+    {
+        return arg.value;
+    }
+
+    template <class D>
+    reference get_default(D const& d, mpl::true_) const
+    {
+        return arg.value ? arg.value.get() : arg.value.construct(d.value);
+    }
+
+#if 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
@@ -245,7 +273,7 @@ struct arg_list : Next
     // Outer indexing operators that dispatch to the right node's
     // get() function.
     template <class KW>
-    typename mpl::apply_wrap2<binding, KW, void_>::type
+    typename mpl::apply_wrap3<binding, KW, void_, mpl::true_>::type
     operator[](keyword<KW> const& x) const
     {
         typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
@@ -253,7 +281,7 @@ struct arg_list : Next
     }
 
     template <class KW, class Default>
-    typename mpl::apply_wrap2<binding, KW, Default&>::type
+    typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type
     operator[](default_<KW, Default> x) const
     {
         typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
@@ -261,9 +289,10 @@ struct arg_list : Next
     }
 
     template <class KW, class F>
-    typename mpl::apply_wrap2<
+    typename mpl::apply_wrap3<
         binding,KW
       , typename result_of0<F>::type
+      , mpl::true_
     >::type
     operator[](lazy_default<KW,F> x) const
     {
@@ -277,13 +306,14 @@ struct arg_list : Next
     // passed, compilation fails.
     reference get(keyword<key_type> const&) const
     {
+        BOOST_MPL_ASSERT_NOT((holds_maybe));
         return arg.value;
     }
 
     template <class Default>
-    reference get(default_<key_type,Default>) const
+    reference get(default_<key_type,Default> const& d) const
     {
-        return arg.value;
+        return get_default(d, holds_maybe());
     }
 
     template <class Default>
@@ -291,23 +321,25 @@ struct arg_list : Next
     {
         return arg.value;
     }
-    
+
 #else
 
     reference operator[](keyword<key_type> const&) const
     {
+        BOOST_MPL_ASSERT_NOT((holds_maybe));
         return arg.value;
     }
 
     template <class Default>
-    reference operator[](default_<key_type, Default>) const
+    reference operator[](default_<key_type, Default> const& d) const
     {
-        return arg.value;
+        return get_default(d, holds_maybe());
     }
 
     template <class Default>
     reference operator[](lazy_default<key_type, Default>) const
     {
+        BOOST_MPL_ASSERT_NOT((holds_maybe));
         return arg.value;
     }
 
@@ -327,10 +359,14 @@ struct arg_list : Next
     // compile-time computation and never really called, so a
     // declaration is enough.
     //
-    template <class HasDefault, class Predicate>
-    static typename mpl::apply1<Predicate, value_type>::type
+    template <class HasDefault, class Predicate, class ArgPack>
+    static typename mpl::apply_wrap2<
+        typename mpl::lambda<Predicate, lambda_tag>::type
+      , value_type, ArgPack
+    >::type
     satisfies(
         parameter_requirements<key_type,Predicate,HasDefault>*
+      , ArgPack*
     );
 
     // Builds an overload set including satisfies functions defined
@@ -341,18 +377,61 @@ struct arg_list : Next
     // Comma operator to compose argument list without using parameters<>.
     // Useful for argument lists with undetermined length.
     template <class KW, class T2>
-    arg_list<tagged_argument<KW, T2>, self> 
-    operator,(tagged_argument<KW,T2> x)
+    arg_list<tagged_argument<KW, T2>, self>
+    operator,(tagged_argument<KW,T2> x) const
     {
         return arg_list<tagged_argument<KW,T2>, self>(x, *this);
     }
+
+    // MPL sequence support
+    typedef self type;             // Convenience for users
+    typedef Next tail_type;        // For the benefit of iterators
+    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
+{
+    typedef mpl::forward_iterator_tag category;
 
-}}} // namespace boost::parameter::aux
+    // The incremented iterator
+    typedef arg_list_iterator<typename ArgumentPack::tail_type> next;
+
+    // dereferencing yields the key type
+    typedef typename ArgumentPack::key_type type;
+};
+
+template <>
+struct arg_list_iterator<empty_arg_list> {};
+
+}} // namespace parameter::aux
+
+// MPL sequence support
+namespace mpl
+{
+  template <>
+  struct begin_impl<parameter::aux::arg_list_tag>
+  {
+      template <class S>
+      struct apply
+      {
+          typedef parameter::aux::arg_list_iterator<S> type;
+      };
+  };
+
+  template <>
+  struct end_impl<parameter::aux::arg_list_tag>
+  {
+      template <class>
+      struct apply
+      {
+          typedef parameter::aux::arg_list_iterator<parameter::aux::empty_arg_list> type;
+      };
+  };
+}
+
+} // namespace boost
 
 #endif // ARG_LIST_050329_HPP
 

include/boost/parameter/aux_/cast.hpp

@@ -0,0 +1,141 @@
+// 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_CAST_060902_HPP
+# define BOOST_PARAMETER_CAST_060902_HPP
+
+# include <boost/detail/workaround.hpp>
+
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#  include <boost/type_traits/add_reference.hpp>
+#  include <boost/type_traits/remove_const.hpp>
+# endif
+
+namespace boost { namespace parameter { namespace aux {
+
+struct use_default_tag {};
+
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+#  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) value
+
+# else
+
+// Handles possible implicit casts. Used by preprocessor.hpp to
+// normalize user input.
+//
+// cast<void*>::execute() is identity
+// cast<void*(X)>::execute() is identity
+// cast<void(X)>::execute() casts to X
+//
+// preprocessor.hpp uses this like this:
+//
+//   #define X(value, predicate)
+//      cast<void predicate>::execute(value)
+//
+//   X(something, *)
+//   X(something, *(predicate))
+//   X(something, (int))
+
+template <class T, class Args>
+struct cast;
+
+template <class Args>
+struct cast<void*, Args>
+{
+    static use_default_tag execute(use_default_tag)
+    {
+        return use_default_tag();
+    }
+
+    static use_default_tag remove_const(use_default_tag)
+    {
+        return use_default_tag();
+    }
+
+    template <class U>
+    static U& execute(U& value)
+    {
+        return value;
+    }
+
+    template <class U>
+    static U& remove_const(U& x)
+    {
+        return x;
+    }
+};
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
+
+typedef void* voidstar;
+
+template <class T, class Args>
+struct cast<voidstar(T), Args>
+  : cast<void*, Args>
+{
+};
+
+#else
+
+template <class T, class Args>
+struct cast<void*(T), Args>
+  : cast<void*, Args>
+{
+};
+
+#endif
+
+// This is a hack used in cast<> to turn the user supplied type,
+// which may or may not be a placeholder expression into one, so
+// that it will be properly evaluated by mpl::apply.
+template <class T, class Dummy = mpl::_1>
+struct as_placeholder_expr
+{
+    typedef T type;
+};
+
+template <class T, class Args>
+struct cast<void(T), Args>
+{
+    typedef typename mpl::apply2<
+        as_placeholder_expr<T>, Args, Args>::type type0;
+
+    typedef typename boost::add_reference<
+        typename boost::remove_const<type0>::type 
+    >::type reference;
+
+    static use_default_tag execute(use_default_tag)
+    {
+        return use_default_tag();
+    }
+
+    static use_default_tag remove_const(use_default_tag)
+    {
+        return use_default_tag();
+    }
+
+    static type0 execute(type0 value)
+    {
+        return value;
+    }
+
+    template <class U>
+    static reference remove_const(U const& x)
+    {
+        return const_cast<reference>(x);
+    }
+};
+
+#  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate, args) \
+    boost::parameter::aux::cast<void predicate, args>::remove_const( \
+        boost::parameter::aux::cast<void predicate, args>::execute(value) \
+    )
+
+# endif
+
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_CAST_060902_HPP
+

include/boost/parameter/aux_/default.hpp

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

include/boost/parameter/aux_/is_maybe.hpp

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

include/boost/parameter/aux_/maybe.hpp

@@ -0,0 +1,120 @@
+// 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)
+
+//
+// 2009.10.21 TDS remove depenency on boost::python::detail::referent_storage
+//
+#ifndef BOOST_PARAMETER_MAYBE_091021_HPP
+# define BOOST_PARAMETER_MAYBE_091021_HPP
+
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/identity.hpp>
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/optional.hpp>
+# include <boost/aligned_storage.hpp>
+# include <boost/type_traits/remove_cv.hpp>
+# include <boost/type_traits/add_const.hpp>
+# include <boost/parameter/aux_/is_maybe.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+template <class T> struct referent_size;
+
+template <class T>
+struct referent_size<T&>
+{
+  BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(T));
+};
+
+// A metafunction returning a POD type which can store U, where T ==
+// U&. If T is not a reference type, returns a POD which can store T.
+template <class T>
+struct referent_storage
+{
+  typedef typename boost::aligned_storage<
+    referent_size<T>::value
+    >::type type;
+};
+
+template <class T>
+struct maybe : maybe_base
+{
+    typedef typename add_reference<
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+        T const
+# else
+        typename add_const<T>::type
+# endif
+    >::type reference;
+
+    typedef typename remove_cv<
+        BOOST_DEDUCED_TYPENAME remove_reference<reference>::type
+    >::type non_cv_value;
+
+    explicit maybe(T value_)
+      : value(value_)
+      , constructed(false)
+    {}
+
+    maybe()
+      : constructed(false)
+    {}
+
+    ~maybe()
+    {
+        if (constructed)
+            this->destroy();
+    }
+
+    reference construct(reference value_) const
+    {
+        return value_;
+    }
+
+    template <class U>
+    reference construct2(U const& value_) const
+    {
+        new (m_storage.address()) non_cv_value(value_);
+        constructed = true;
+        return *(non_cv_value*)m_storage.address();
+    }
+
+    template <class U>
+    reference construct(U const& value_) const
+    {
+        return this->construct2(value_);
+    }
+
+    void destroy()
+    {
+        ((non_cv_value*)m_storage.address())->~non_cv_value();
+    }
+
+    typedef reference(maybe<T>::*safe_bool)() const;
+
+    operator safe_bool() const
+    {
+        return value ? &maybe<T>::get : 0 ;
+    }
+
+    reference get() const
+    {
+        return value.get();
+    }
+
+private:
+    boost::optional<T> value;
+    mutable bool constructed;
+
+
+    mutable typename referent_storage<
+        reference
+    >::type m_storage;
+};
+
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_MAYBE_060211_HPP
+

include/boost/parameter/aux_/overloads.hpp

@@ -44,29 +44,40 @@
 #define N BOOST_PP_ITERATION()
 
 #define BOOST_PARAMETER_open_list(z, n, text) \
-    aux::make_arg_list< \
+    aux::item< \
         BOOST_PP_CAT(PS, n), BOOST_PP_CAT(A, n)
 
 #define BOOST_PARAMETER_close_list(z, n, text) > 
 
 #define BOOST_PARAMETER_arg_list(n) \
-    mpl::apply_wrap1< \
-    BOOST_PP_ENUM(N, BOOST_PARAMETER_open_list, _) \
-  , mpl::always<aux::empty_arg_list> \
-    BOOST_PP_REPEAT(N, BOOST_PARAMETER_close_list, _) \
-  , unnamed_list>
+    aux::make_arg_list< \
+        BOOST_PP_ENUM(N, BOOST_PARAMETER_open_list, _) \
+      , void_ \
+        BOOST_PP_REPEAT(N, BOOST_PARAMETER_close_list, _) \
+      , deduced_list \
+      , aux::tag_keyword_arg \
+    >
+
+#define BOOST_PARAMETER_arg_pack_init(z, n, limit) \
+    BOOST_PP_CAT(a, BOOST_PP_SUB(limit,n))
 
 template<BOOST_PP_ENUM_PARAMS(N, class A)>
-typename BOOST_PARAMETER_arg_list(N)::type
-operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a)) const
+typename mpl::first<
+    typename BOOST_PARAMETER_arg_list(N)::type
+>::type
+operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, & a)) const
 {
-    typedef typename BOOST_PARAMETER_arg_list(N)::type arg_tuple;
+    typedef typename BOOST_PARAMETER_arg_list(N)::type result;
 
-    return arg_tuple(
-        BOOST_PP_ENUM_PARAMS(N, a)
+    typedef typename mpl::first<result>::type result_type;
+    typedef typename mpl::second<result>::type error;
+    error();
+
+    return result_type(
+        BOOST_PP_ENUM(N, BOOST_PARAMETER_arg_pack_init, BOOST_PP_DEC(N))
         BOOST_PP_ENUM_TRAILING_PARAMS(
             BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, N)
-          , aux::void_() BOOST_PP_INTERCEPT
+          , aux::void_reference() BOOST_PP_INTERCEPT
         ));
 }
 

include/boost/parameter/aux_/parenthesized_type.hpp

@@ -0,0 +1,35 @@
+// 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)
+#ifndef BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP
+# define BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP
+
+# include <boost/config.hpp>
+# include <boost/detail/workaround.hpp>
+
+namespace boost { namespace parameter { namespace aux { 
+
+// A macro that takes a parenthesized C++ type name (T) and transforms
+// it into an un-parenthesized type expression equivalent to T.
+#  define BOOST_PARAMETER_PARENTHESIZED_TYPE(x)                    \
+    boost::parameter::aux::unaryfunptr_arg_type< void(*)x >::type
+
+// A metafunction that transforms void(*)(T) -> T
+template <class UnaryFunctionPointer>
+struct unaryfunptr_arg_type;
+
+template <class Arg>
+struct unaryfunptr_arg_type<void(*)(Arg)>
+{
+    typedef Arg type;
+};
+
+template <>
+struct unaryfunptr_arg_type<void(*)(void)>
+{
+    typedef void type;
+};
+    
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP

include/boost/parameter/aux_/preprocessor/flatten.hpp

@@ -0,0 +1,115 @@
+// 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_FLATTEN_051217_HPP
+# define BOOST_PARAMETER_FLATTEN_051217_HPP
+
+# include <boost/preprocessor/tuple/elem.hpp>
+# include <boost/preprocessor/tuple/rem.hpp>
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/seq/for_each.hpp>
+# include <boost/preprocessor/seq/for_each_i.hpp>
+# include <boost/preprocessor/identity.hpp>
+# include <boost/preprocessor/selection/max.hpp>
+# include <boost/preprocessor/arithmetic/sub.hpp>
+# include <boost/preprocessor/repetition/enum_trailing.hpp>
+# include <boost/parameter/aux_/preprocessor/for_each.hpp>
+
+# define BOOST_PARAMETER_FLATTEN_SPLIT_required required,
+# define BOOST_PARAMETER_FLATTEN_SPLIT_optional optional,
+# define BOOST_PARAMETER_FLATTEN_SPLIT_deduced deduced,
+
+# define BOOST_PARAMETER_FLATTEN_SPLIT(sub) \
+    BOOST_PP_CAT(BOOST_PARAMETER_FLATTEN_SPLIT_, sub)
+
+# define BOOST_PARAMETER_FLATTEN_QUALIFIER(sub) \
+    BOOST_PP_SPLIT(0, BOOST_PARAMETER_FLATTEN_SPLIT(sub))
+
+# define BOOST_PARAMETER_FLATTEN_ARGS(sub) \
+    BOOST_PP_SPLIT(1, BOOST_PARAMETER_FLATTEN_SPLIT(sub))
+
+# define BOOST_PARAMETER_FLATTEN_ARITY_optional(arities) \
+    BOOST_PP_TUPLE_ELEM(3,0,arities)
+
+# define BOOST_PARAMETER_FLATTEN_ARITY_required(arities) \
+    BOOST_PP_TUPLE_ELEM(3,1,arities)
+
+# define BOOST_PARAMETER_FLATTEN_SPEC0_DUMMY_ELEM(z, n, data) ~
+# define BOOST_PARAMETER_FLATTEN_SPEC0(r, n, elem, data) \
+    (( \
+        BOOST_PP_TUPLE_ELEM(3,2,data) \
+      , BOOST_PP_TUPLE_REM(BOOST_PP_TUPLE_ELEM(3,0,data)) elem \
+        BOOST_PP_ENUM_TRAILING( \
+            BOOST_PP_SUB( \
+                BOOST_PP_TUPLE_ELEM(3,1,data) \
+              , BOOST_PP_TUPLE_ELEM(3,0,data) \
+            ) \
+          , BOOST_PARAMETER_FLATTEN_SPEC0_DUMMY_ELEM \
+          , ~ \
+        ) \
+    ))
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_AUX(r, arity, max_arity, spec, transform) \
+    BOOST_PARAMETER_FOR_EACH_R( \
+        r \
+      , arity \
+      , BOOST_PARAMETER_FLATTEN_ARGS(spec) \
+      , (arity, max_arity, transform(BOOST_PARAMETER_FLATTEN_QUALIFIER(spec))) \
+      , BOOST_PARAMETER_FLATTEN_SPEC0 \
+    )
+
+# define BOOST_PARAMETER_FLATTEN_IDENTITY(x) x
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_optional(r, arities, spec) \
+    BOOST_PARAMETER_FLATTEN_SPEC_AUX( \
+        r \
+      , BOOST_PP_CAT( \
+            BOOST_PARAMETER_FLATTEN_ARITY_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \
+        )(arities) \
+      , BOOST_PP_TUPLE_ELEM(3,2,arities) \
+      , spec \
+      , BOOST_PARAMETER_FLATTEN_IDENTITY \
+    )
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_required(r, arities, spec) \
+    BOOST_PARAMETER_FLATTEN_SPEC_optional(r, arities, spec)
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_AS_DEDUCED(x) BOOST_PP_CAT(deduced_,x)
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_deduced_M(r, arities, n, spec) \
+    BOOST_PARAMETER_FLATTEN_SPEC_AUX( \
+        r \
+      , BOOST_PP_CAT( \
+            BOOST_PARAMETER_FLATTEN_ARITY_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \
+        )(arities) \
+      , BOOST_PP_TUPLE_ELEM(3,2,arities) \
+      , spec \
+      , BOOST_PARAMETER_FLATTEN_SPEC_AS_DEDUCED \
+    )
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_deduced(r, arities, spec) \
+    BOOST_PP_SEQ_FOR_EACH_I_R( \
+        r \
+      , BOOST_PARAMETER_FLATTEN_SPEC_deduced_M \
+      , arities \
+      , BOOST_PARAMETER_FLATTEN_ARGS(spec) \
+    )
+
+# define BOOST_PARAMETER_FLATTEN_SPEC(r, arities, spec) \
+    BOOST_PP_CAT( \
+        BOOST_PARAMETER_FLATTEN_SPEC_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \
+    )(r, arities, spec)
+
+# define BOOST_PARAMETER_FLATTEN(optional_arity, required_arity, wanted_arity, specs) \
+    BOOST_PP_SEQ_FOR_EACH( \
+        BOOST_PARAMETER_FLATTEN_SPEC \
+      , ( \
+            optional_arity, required_arity \
+          , wanted_arity \
+        ) \
+      , specs \
+    )
+
+#endif // BOOST_PARAMETER_FLATTEN_051217_HPP
+

include/boost/parameter/aux_/preprocessor/for_each.hpp

@@ -0,0 +1,103 @@
+// 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_FOR_EACH_051217_HPP
+# define BOOST_PARAMETER_FOR_EACH_051217_HPP
+
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/detail/split.hpp>
+# include <boost/preprocessor/logical/not.hpp>
+# include <boost/preprocessor/facilities/is_empty.hpp>
+# include <boost/preprocessor/tuple/eat.hpp>
+# include <boost/preprocessor/arithmetic/inc.hpp>
+# include <boost/preprocessor/repeat.hpp>
+# include <boost/preprocessor/punctuation/comma_if.hpp>
+# include <boost/preprocessor/for.hpp>
+# include <boost/preprocessor/repetition/deduce_r.hpp>
+
+# define BOOST_PARAMETER_FOR_EACH_head_aux2(x,y) (x,y), ~
+# define BOOST_PARAMETER_FOR_EACH_head_aux3(x,y,z) (x,y,z), ~
+# define BOOST_PARAMETER_FOR_EACH_head_aux4(x,y,z,u) (x,y,z,u), ~
+# define BOOST_PARAMETER_FOR_EACH_head(n,x) \
+    BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_head_aux,n) x)
+
+# define BOOST_PARAMETER_FOR_EACH_pred_aux_BOOST_PARAMETER_FOR_EACH_END_SENTINEL
+# define BOOST_PARAMETER_FOR_EACH_pred_aux_check(x) \
+    BOOST_PP_NOT(BOOST_PP_IS_EMPTY( \
+        BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_pred_aux_, x) \
+    )), ~
+
+# define BOOST_PARAMETER_FOR_EACH_pred_aux2(x,y) \
+    BOOST_PARAMETER_FOR_EACH_pred_aux_check(x)
+# define BOOST_PARAMETER_FOR_EACH_pred_aux3(x,y,z) \
+    BOOST_PARAMETER_FOR_EACH_pred_aux_check(x)
+# define BOOST_PARAMETER_FOR_EACH_pred_aux4(x,y,z,u) \
+    BOOST_PARAMETER_FOR_EACH_pred_aux_check(x)
+
+# define BOOST_PARAMETER_FOR_EACH_pred_aux0(n,x) \
+    BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_pred_aux,n) x
+
+# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
+#  define BOOST_PARAMETER_FOR_EACH_pred_SPLIT_FIRST(x) \
+    BOOST_PP_SPLIT(0, x)
+
+#  define BOOST_PARAMETER_FOR_EACH_pred(r, state) \
+    BOOST_PARAMETER_FOR_EACH_pred_SPLIT_FIRST( \
+        BOOST_PARAMETER_FOR_EACH_pred_aux0( \
+            BOOST_PP_TUPLE_ELEM(5,3,state) \
+          , BOOST_PP_TUPLE_ELEM(5,0,state) \
+        ) \
+    )
+# else
+#  define BOOST_PARAMETER_FOR_EACH_pred(r, state) \
+    BOOST_PP_SPLIT( \
+        0 \
+      , BOOST_PARAMETER_FOR_EACH_pred_aux0( \
+            BOOST_PP_TUPLE_ELEM(5,3,state) \
+          , BOOST_PP_TUPLE_ELEM(5,0,state) \
+        ) \
+    )
+# endif
+
+# define BOOST_PARAMETER_FOR_EACH_op(r, state) \
+    ( \
+        BOOST_PP_TUPLE_EAT(BOOST_PP_TUPLE_ELEM(5,3,state)) \
+          BOOST_PP_TUPLE_ELEM(5,0,state) \
+      , BOOST_PP_TUPLE_ELEM(5,1,state) \
+      , BOOST_PP_TUPLE_ELEM(5,2,state) \
+      , BOOST_PP_TUPLE_ELEM(5,3,state) \
+      , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(5,4,state)) \
+    )
+
+# define BOOST_PARAMETER_FOR_EACH_macro(r, state) \
+    BOOST_PP_TUPLE_ELEM(5,2,state)( \
+        r \
+      , BOOST_PP_TUPLE_ELEM(5,4,state) \
+      , BOOST_PARAMETER_FOR_EACH_head( \
+            BOOST_PP_TUPLE_ELEM(5,3,state) \
+          , BOOST_PP_TUPLE_ELEM(5,0,state) \
+        ) \
+      , BOOST_PP_TUPLE_ELEM(5,1,state) \
+    )
+
+# define BOOST_PARAMETER_FOR_EACH_build_end_sentinel(z,n,text) \
+    BOOST_PP_COMMA_IF(n) BOOST_PARAMETER_FOR_EACH_END_SENTINEL
+# define BOOST_PARAMETER_FOR_EACH_build_end_sentinel_tuple(arity) \
+    ( \
+        BOOST_PP_REPEAT(arity, BOOST_PARAMETER_FOR_EACH_build_end_sentinel, _) \
+    )
+
+# define BOOST_PARAMETER_FOR_EACH_R(r, arity, list, data, macro) \
+    BOOST_PP_CAT(BOOST_PP_FOR_, r)( \
+        (list BOOST_PARAMETER_FOR_EACH_build_end_sentinel_tuple(arity), data, macro, arity, 0) \
+      , BOOST_PARAMETER_FOR_EACH_pred \
+      , BOOST_PARAMETER_FOR_EACH_op \
+      , BOOST_PARAMETER_FOR_EACH_macro \
+    )
+
+# define BOOST_PARAMETER_FOR_EACH(arity, list, data, macro) \
+    BOOST_PARAMETER_FOR_EACH_R(BOOST_PP_DEDUCE_R(), arity, list, data, macro)
+
+#endif // BOOST_PARAMETER_FOR_EACH_051217_HPP
+

include/boost/parameter/aux_/set.hpp

@@ -0,0 +1,66 @@
+// 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_SET_060912_HPP
+# define BOOST_PARAMETER_SET_060912_HPP
+
+# include <boost/detail/workaround.hpp>
+
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#  include <boost/mpl/insert.hpp>
+#  include <boost/mpl/set/set0.hpp>
+#  include <boost/mpl/has_key.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+typedef mpl::set0<> set0;
+
+template <class Set, class K>
+struct insert_
+{
+    typedef typename mpl::insert<Set, K>::type type;
+};
+
+template <class Set, class K>
+struct has_key_
+{
+    typedef typename mpl::has_key<Set, K>::type type;
+};
+
+}}} // namespace boost::parameter::aux
+
+# else
+
+#  include <boost/mpl/list.hpp>
+#  include <boost/mpl/end.hpp>
+#  include <boost/mpl/find.hpp>
+#  include <boost/mpl/not.hpp>
+#  include <boost/mpl/push_front.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+typedef mpl::list0<> set0;
+
+template <class Set, class K>
+struct insert_
+{
+    typedef typename mpl::push_front<Set, K>::type type;
+};
+
+template <class Set, class K>
+struct has_key_
+{
+    typedef typename mpl::find<Set, K>::type iter;
+    typedef mpl::not_<
+        is_same<iter, typename mpl::end<Set>::type> 
+    > type;
+};
+
+}}} // namespace boost::parameter::aux
+
+# endif
+
+
+#endif // BOOST_PARAMETER_SET_060912_HPP
+

include/boost/parameter/aux_/tagged_argument.hpp

@@ -3,20 +3,32 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TAGGED_ARGUMENT_050328_HPP
-#define TAGGED_ARGUMENT_050328_HPP
+#ifndef BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
+# define BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
 
-#include <boost/parameter/aux_/void.hpp>
-#include <boost/parameter/aux_/arg_list.hpp>
-#include <boost/detail/is_xxx.hpp>
+# include <boost/parameter/aux_/void.hpp>
+# include <boost/parameter/aux_/arg_list.hpp>
+# include <boost/parameter/aux_/result_of0.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/apply_wrap.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+# include <boost/type_traits/is_reference.hpp>
 
 namespace boost { namespace parameter { namespace aux {
 
+struct empty_arg_list;
+struct arg_list_tag;
+
+struct tagged_argument_base {};
+
 // Holds a reference to an argument of type Arg associated with
 // keyword Keyword
     
 template <class Keyword, class Arg>
-struct tagged_argument
+struct tagged_argument : tagged_argument_base
 {
     typedef Keyword key_type;
     typedef Arg value_type;
@@ -24,6 +36,22 @@ struct tagged_argument
 
     tagged_argument(reference x) : value(x) {}
 
+    // A metafunction class that, given a keyword and a default
+    // type, returns the appropriate result type for a keyword
+    // lookup given that default
+    struct binding
+    {
+        template <class KW, class Default, class Reference>
+        struct apply
+        {
+          typedef typename mpl::eval_if<
+                boost::is_same<KW, key_type>
+              , mpl::if_<Reference, reference, value_type>
+              , mpl::identity<Default>
+          >::type type;
+        };
+    };
+
     // Comma operator to compose argument list without using parameters<>.
     // Useful for argument lists with undetermined length.
     template <class Keyword2, class Arg2>
@@ -41,20 +69,120 @@ struct tagged_argument
           , arg_list<tagged_argument<Keyword2, Arg2> >(x, empty_arg_list())
         );
     }
-    
+
+    reference operator[](keyword<Keyword> const&) const
+    {
+        return value;
+    }
+
+# if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    template <class KW, class Default>
+    Default& get_with_default(default_<KW,Default> const& x, int) const
+    {
+        return x.value;
+    }
+
+    template <class Default>
+    reference get_with_default(default_<key_type,Default> const&, long) const
+    {
+        return value;
+    }
+
+    template <class KW, class Default>
+    typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type
+    operator[](default_<KW,Default> const& x) const
+    {
+        return get_with_default(x, 0L);
+    }
+
+    template <class KW, class F>
+    typename result_of0<F>::type 
+    get_with_lazy_default(lazy_default<KW,F> const& x, int) const
+    {
+        return x.compute_default();
+    }
+
+    template <class F>
+    reference get_with_lazy_default(lazy_default<key_type,F> const&, long) const
+    {
+        return value;
+    }
+
+    template <class KW, class F>
+    typename mpl::apply_wrap3<
+        binding,KW
+      , typename result_of0<F>::type
+      , mpl::true_
+    >::type
+    operator[](lazy_default<KW,F> const& x) const
+    {
+        return get_with_lazy_default(x, 0L);
+    }
+# else
+    template <class Default>
+    reference operator[](default_<key_type,Default> const& ) const
+    {
+        return value;
+    }
+
+    template <class F>
+    reference operator[](lazy_default<key_type,F> const& ) const
+    {
+        return value;
+    }
+
+    template <class KW, class Default>
+    Default& operator[](default_<KW,Default> const& x) const
+    {
+        return x.value;
+    }
+
+    template <class KW, class F>
+    typename result_of0<F>::type operator[](lazy_default<KW,F> const& x) const
+    {
+        return x.compute_default();
+    }
+
+    template <class ParameterRequirements>
+    static typename ParameterRequirements::has_default
+    satisfies(ParameterRequirements*);
+
+    template <class HasDefault, class Predicate>
+    static typename mpl::apply1<Predicate, value_type>::type
+    satisfies(
+        parameter_requirements<key_type,Predicate,HasDefault>*
+    );
+# endif
+
     reference value;
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
     // warning suppression
  private:
     void operator=(tagged_argument const&);
-#endif 
+ public:    
+# endif
+    // MPL sequence support
+    typedef tagged_argument type;            // Convenience for users
+    typedef empty_arg_list tail_type;        // For the benefit of iterators
+    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
 };
 
 // Defines a metafunction, is_tagged_argument, that identifies
-// tagged_argument specializations.
-BOOST_DETAIL_IS_XXX_DEF(tagged_argument,tagged_argument,2)
+// tagged_argument specializations and their derived classes.
+template <class T>
+struct is_tagged_argument_aux
+  : is_convertible<T*,tagged_argument_base const*>
+{};
+
+template <class T>
+struct is_tagged_argument
+  : mpl::and_<
+        mpl::not_<is_reference<T> >
+      , is_tagged_argument_aux<T>
+    >
+{};
 
 }}} // namespace boost::parameter::aux
 
-#endif // TAGGED_ARGUMENT_050328_HPP
+#endif // BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
 

include/boost/parameter/aux_/template_keyword.hpp

@@ -0,0 +1,47 @@
+// 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_TEMPLATE_KEYWORD_060203_HPP
+# define BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP
+
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+# include <boost/type_traits/is_reference.hpp>
+
+namespace boost { namespace parameter { 
+
+namespace aux 
+{
+
+  struct template_keyword_tag {}; 
+
+  template <class T, class U>
+  struct is_pointer_convertible
+    : is_convertible<T*, U*>
+  {};
+
+  template <class T>
+  struct is_template_keyword
+    : mpl::and_<
+          mpl::not_<is_reference<T> >
+        , is_pointer_convertible<T, template_keyword_tag>
+      >
+  {};
+
+} // namespace aux
+
+template <class Tag, class T>
+struct template_keyword
+  : aux::template_keyword_tag
+{
+    typedef Tag key_type;
+    typedef T value_type;
+    typedef value_type reference;
+};
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP
+

include/boost/parameter/aux_/unwrap_cv_reference.hpp

@@ -44,12 +44,6 @@ 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>

include/boost/parameter/aux_/void.hpp

@@ -3,16 +3,27 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef VOID_050329_HPP
-#define VOID_050329_HPP
+#ifndef BOOST_PARAMETER_VOID_050329_HPP
+#define BOOST_PARAMETER_VOID_050329_HPP
 
-namespace boost { namespace parameter { namespace aux {
+namespace boost { namespace parameter { 
 
 // A placemarker for "no argument passed."
 // MAINTAINER NOTE: Do not make this into a metafunction
 struct void_ {}; 
 
-}}} // namespace boost::parameter::aux
+namespace aux 
+{
 
-#endif // VOID_050329_HPP
+  inline void_& void_reference()
+  {
+      static void_ instance;
+      return instance;
+  }
+
+} // namespace aux
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_VOID_050329_HPP
 

include/boost/parameter/binding.hpp

@@ -5,38 +5,60 @@
 # define BOOST_PARAMETER_BINDING_DWA200558_HPP
 
 # include <boost/mpl/apply.hpp>
+# include <boost/mpl/assert.hpp>
+# include <boost/mpl/and.hpp>
 # include <boost/parameter/aux_/result_of0.hpp>
-
-#  include <boost/parameter/aux_/void.hpp>
-
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-#  include <boost/parameter/aux_/void.hpp>
-#  include <boost/type_traits/is_same.hpp>
-# endif 
+# include <boost/parameter/aux_/void.hpp>
+# include <boost/type_traits/is_same.hpp>
 
 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(BOOST_MSVC, < 1300)
-template <class Parameters, class Keyword, class Default = void>
-struct binding
-  : mpl::apply_wrap2<
-        typename Parameters::binding,Keyword,Default
-    >
-{};
-# else
-template <class Parameters, class Keyword, class Default = aux::void_>
-struct binding
+
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <class Parameters, class Keyword, class Default>
+struct binding0
 {
-    typedef typename mpl::apply_wrap2<
-        typename Parameters::binding,Keyword,
-        typename mpl::if_<is_same<Default,aux::void_>,void,Default>::type
+    typedef typename mpl::apply_wrap3<
+        typename Parameters::binding,Keyword,Default,mpl::true_
     >::type type;
+
+    BOOST_MPL_ASSERT_NOT((
+        mpl::and_<
+            is_same<Default, void_>
+          , is_same<type, void_>
+        >
+    ));
 };
 # endif
 
+template <class Parameters, class Keyword, class Default = void_>
+struct binding
+{
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    typedef typename mpl::eval_if<
+        mpl::is_placeholder<Parameters>
+      , mpl::identity<int>
+      , binding0<Parameters,Keyword,Default>
+    >::type type;
+# else
+    typedef typename mpl::apply_wrap3<
+        typename Parameters::binding,Keyword,Default,mpl::true_
+    >::type type;
+
+    BOOST_MPL_ASSERT_NOT((
+        mpl::and_<
+            is_same<Default, void_>
+          , is_same<type, void_>
+        >
+    ));
+# endif
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default))
+};
+
 // 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 the type returned by invoking
@@ -44,10 +66,11 @@ struct binding
 template <class Parameters, class Keyword, class DefaultFn>
 struct lazy_binding
 {
-  typedef typename mpl::apply_wrap2<
+  typedef typename mpl::apply_wrap3<
       typename Parameters::binding
     , Keyword
     , typename aux::result_of0<DefaultFn>::type
+    , mpl::true_
   >::type type;
 };
 

include/boost/parameter/config.hpp

@@ -7,7 +7,7 @@
 #define BOOST_PARAMETER_CONFIG_050403_HPP
 
 #ifndef BOOST_PARAMETER_MAX_ARITY
-# define BOOST_PARAMETER_MAX_ARITY 5
+# define BOOST_PARAMETER_MAX_ARITY 8
 #endif
 
 #endif // BOOST_PARAMETER_CONFIG_050403_HPP

include/boost/parameter/keyword.hpp

@@ -9,7 +9,6 @@
 #include <boost/parameter/aux_/unwrap_cv_reference.hpp>
 #include <boost/parameter/aux_/tag.hpp>
 #include <boost/parameter/aux_/default.hpp>
-#include <boost/noncopyable.hpp>
 
 namespace boost { namespace parameter {
 
@@ -29,10 +28,10 @@ namespace boost { namespace parameter {
 //    f(rate = 1, skew = 2.4);
 //
 template <class Tag>
-struct keyword : noncopyable
+struct keyword
 {
     template <class T>
-    typename aux::tag<Tag, T>::type
+    typename aux::tag<Tag, T>::type const
     operator=(T& x) const
     {
         typedef typename aux::tag<Tag, T>::type result;
@@ -53,23 +52,17 @@ struct keyword : noncopyable
         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
+    typename aux::tag<Tag, T const>::type const
     operator=(T const& x) const
     {
         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_);
     }
@@ -77,13 +70,9 @@ struct keyword : noncopyable
     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
     
@@ -92,42 +81,41 @@ struct keyword : noncopyable
     // every instantiation of a function template is the same object.
     // We provide a reference to a common instance of each keyword
     // object and prevent construction by users.
-    
+    static keyword<Tag> const instance;
+
+    // This interface is deprecated
     static keyword<Tag>& get()
     {
-        static keyword<Tag> result;
-        return result;
+        return const_cast<keyword<Tag>&>(instance);
     }
-    
- private:
-    keyword() {}
 };
 
+template <class Tag>
+keyword<Tag> const keyword<Tag>::instance = {};
+
 // Reduces boilerplate required to declare and initialize keywords
 // without violating ODR.  Declares a keyword tag type with the given
 // name in namespace tag_namespace, and declares and initializes a
 // 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 ::boost::parameter::keyword<tag_namespace::name>& name   \
-       = ::boost::parameter::keyword<tag_namespace::name>::get();
-
-#else
-
 #define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                 \
-    namespace tag_namespace { struct name; }                        \
+    namespace tag_namespace                                         \
+    {                                                               \
+      struct name                                                   \
+      {                                                             \
+          static char const* keyword_name()                         \
+          {                                                         \
+              return #name;                                         \
+          }                                                         \
+      };                                                            \
+    }                                                               \
     namespace                                                       \
     {                                                               \
-       ::boost::parameter::keyword<tag_namespace::name>& name       \
-       = ::boost::parameter::keyword<tag_namespace::name>::get();   \
+       ::boost::parameter::keyword<tag_namespace::name> const& name \
+       = ::boost::parameter::keyword<tag_namespace::name>::instance;\
     }
 
-#endif
-
 }} // namespace boost::parameter
 
 #endif // KEYWORD_050328_HPP

include/boost/parameter/macros.hpp

@@ -15,13 +15,14 @@
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/cat.hpp>
+#include <boost/detail/workaround.hpp>
 
 #define BOOST_PARAMETER_FUN_TEMPLATE_HEAD1(n) \
     template<BOOST_PP_ENUM_PARAMS(n, class T)>
 
 #define BOOST_PARAMETER_FUN_TEMPLATE_HEAD0(n)
 
-#ifndef BOOST_NO_SFINAE
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) 
 
 # define BOOST_PARAMETER_MATCH_TYPE(n, param)           \
             BOOST_PP_EXPR_IF(n, typename) param::match  \
@@ -78,7 +79,7 @@
 #define BOOST_PARAMETER_FUN(ret, name, lo, hi, parameters)                          \
                                                                                     \
     template<class Params>                                                          \
-    ret BOOST_PP_CAT(name, _with_named_params)(Params const&);                      \
+    ret BOOST_PP_CAT(name, _with_named_params)(Params const& p);                    \
                                                                                     \
     BOOST_PP_REPEAT_FROM_TO(                                                        \
         lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL, (ret, name, parameters))    \

include/boost/parameter/match.hpp

@@ -29,7 +29,7 @@
                 BOOST_PARAMETER_MAX_ARITY                       \
               , BOOST_PP_SEQ_SIZE(ArgTypes)                     \
             )                                                   \
-          , ::boost::parameter::aux::void_ BOOST_PP_INTERCEPT   \
+          , ::boost::parameter::void_ BOOST_PP_INTERCEPT   \
         )
 
 # else

include/boost/parameter/name.hpp

@@ -0,0 +1,146 @@
+// 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_NAME_060806_HPP
+# define BOOST_PARAMETER_NAME_060806_HPP
+
+# include <boost/parameter/keyword.hpp>
+# include <boost/parameter/value_type.hpp>
+# include <boost/detail/workaround.hpp>
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/stringize.hpp>
+# include <boost/preprocessor/control/iif.hpp>
+# include <boost/preprocessor/tuple/eat.hpp>
+# include <boost/preprocessor/tuple/elem.hpp>
+# include <boost/mpl/placeholders.hpp>
+
+# if !defined(BOOST_NO_SFINAE) \
+  && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+
+#  include <boost/utility/enable_if.hpp>
+#  include <boost/mpl/lambda.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+// Tag type passed to MPL lambda.
+struct lambda_tag;
+
+struct name_tag_base
+{};
+
+template <class Tag>
+struct name_tag
+{};
+
+template <class T>
+struct is_name_tag
+  : mpl::false_
+{};
+
+}}} // namespace boost::parameter::aux
+
+namespace boost { namespace mpl {
+
+template <class T>
+struct lambda<
+    T
+  , typename boost::enable_if<
+        parameter::aux::is_name_tag<T>, parameter::aux::lambda_tag
+    >::type
+>
+{
+    typedef true_ is_le;
+    typedef bind3< quote3<parameter::value_type>, arg<2>, T, void> result_;
+    typedef result_ type;
+};
+
+}} // namespace boost::mpl
+
+# endif
+
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# include <boost/preprocessor/detail/split.hpp>
+// From Paul Mensonides
+#  define BOOST_PARAMETER_IS_BINARY(x) \
+    BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_BINARY_C x BOOST_PP_COMMA() 0) \
+    /**/
+#  define BOOST_PARAMETER_IS_BINARY_C(x,y) \
+    ~, 1 BOOST_PP_RPAREN() \
+    BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ \
+    /**/
+# else
+#  include <boost/preprocessor/detail/is_binary.hpp>
+#  define BOOST_PARAMETER_IS_BINARY(x) BOOST_PP_IS_BINARY(x)
+# endif
+
+# define BOOST_PARAMETER_BASIC_NAME(tag_namespace, tag, name)       \
+    namespace tag_namespace                                         \
+    {                                                               \
+      struct tag                                                    \
+      {                                                             \
+          static char const* keyword_name()                         \
+          {                                                         \
+              return BOOST_PP_STRINGIZE(tag);                       \
+          }                                                         \
+                                                                    \
+          typedef boost::parameter::value_type<                     \
+              boost::mpl::_2, tag, boost::parameter::void_          \
+          > _;                                                      \
+                                                                    \
+          typedef boost::parameter::value_type<                     \
+              boost::mpl::_2, tag, boost::parameter::void_          \
+          > _1;                                                     \
+      };                                                            \
+    }                                                               \
+    namespace                                                       \
+    {                                                               \
+       ::boost::parameter::keyword<tag_namespace::tag> const& name  \
+       = ::boost::parameter::keyword<tag_namespace::tag>::instance; \
+    }
+
+# define BOOST_PARAMETER_COMPLEX_NAME_TUPLE1(tag,namespace)         \
+    (tag, namespace), ~
+
+# define BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name)                   \
+    BOOST_PP_TUPLE_ELEM(2, 0, (BOOST_PARAMETER_COMPLEX_NAME_TUPLE1 name))
+
+# define BOOST_PARAMETER_COMPLEX_NAME_TAG(name)                     \
+    BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name))
+
+# define BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name)               \
+    BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name))
+
+# define BOOST_PARAMETER_COMPLEX_NAME(name)                         \
+    BOOST_PARAMETER_BASIC_NAME(                                     \
+        BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name)                \
+      , BOOST_PP_TUPLE_EAT(2) name                                  \
+      , BOOST_PARAMETER_COMPLEX_NAME_TAG(name)                      \
+    )                                                               \
+/**/
+
+# define BOOST_PARAMETER_SIMPLE_NAME(name)                          \
+    BOOST_PARAMETER_BASIC_NAME(tag, name, BOOST_PP_CAT(_, name))
+
+# define BOOST_PARAMETER_NAME(name)                                 \
+    BOOST_PP_IIF(                                                   \
+        BOOST_PARAMETER_IS_BINARY(name)                             \
+      , BOOST_PARAMETER_COMPLEX_NAME                                \
+      , BOOST_PARAMETER_SIMPLE_NAME                                 \
+    )(name)                                                         \
+/**/
+
+
+# define BOOST_PARAMETER_TEMPLATE_KEYWORD(name)                     \
+    namespace tag                                                   \
+    {                                                               \
+      struct name;                                                  \
+    }                                                               \
+    template <class T>                                              \
+    struct name                                                     \
+      : boost::parameter::template_keyword<tag::name, T>            \
+    {};                                                             \
+/**/
+
+#endif // BOOST_PARAMETER_NAME_060806_HPP
+

include/boost/parameter/value_type.hpp

@@ -0,0 +1,82 @@
+// 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_VALUE_TYPE_060921_HPP
+# define BOOST_PARAMETER_VALUE_TYPE_060921_HPP
+
+# include <boost/mpl/apply.hpp>
+# include <boost/mpl/assert.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/parameter/aux_/result_of0.hpp>
+# include <boost/parameter/aux_/void.hpp>
+# include <boost/type_traits/is_same.hpp>
+
+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))
+template <class Parameters, class Keyword, class Default>
+struct value_type0
+{
+    typedef typename mpl::apply_wrap3<
+        typename Parameters::binding,Keyword,Default,mpl::false_
+    >::type type;
+
+    BOOST_MPL_ASSERT_NOT((
+        mpl::and_<
+            is_same<Default, void_>
+          , is_same<type, void_>
+        >
+    ));
+};
+# endif
+
+template <class Parameters, class Keyword, class Default = void_>
+struct value_type
+{
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    typedef typename mpl::eval_if<
+        mpl::is_placeholder<Parameters>
+      , mpl::identity<int>
+      , value_type0<Parameters,Keyword,Default>
+    >::type type;
+# else
+    typedef typename mpl::apply_wrap3<
+        typename Parameters::binding,Keyword,Default,mpl::false_
+    >::type type;
+
+    BOOST_MPL_ASSERT_NOT((
+        mpl::and_<
+            is_same<Default, void_>
+          , is_same<type, void_>
+        >
+    ));
+# endif
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
+};
+
+// 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 the type returned by invoking
+// DefaultFn
+template <class Parameters, class Keyword, class DefaultFn>
+struct lazy_value_type
+{
+  typedef typename mpl::apply_wrap3<
+      typename Parameters::binding
+    , Keyword
+    , typename aux::result_of0<DefaultFn>::type
+    , mpl::false_
+  >::type type;
+};
+
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_VALUE_TYPE_060921_HPP
+

meta/libraries.json

@@ -0,0 +1,17 @@
+{
+    "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>"
+    ]
+}

test/Jamfile

@@ -1,17 +0,0 @@
-# Boost Parameter Library test Jamfile
-
-subproject libs/parameter/test ;
-
-# bring in rules for testing
-import testing ;
-
-test-suite "parameter"
-  :  [ run basics.cpp ]
-     [ run sfinae.cpp ]
-     [ run macros.cpp ]
-     [ run unnamed.cpp ]
-     [ run tutorial.cpp ]
-     [ run efficiency.cpp : : : : : release ]
-     [ compile unwrap_cv_reference.cpp ]
-     [ compile-fail duplicates.cpp ]
-  ;

test/Jamfile.v2

@@ -1,11 +1,38 @@
+# Copyright David Abrahams, Daniel Wallin 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)
+
 # Boost Parameter Library test Jamfile
 
+import python ;
+
+project boost/parameter
+  : default-build <warnings>off
+  ;
+
+build-project literate ;
+  
 test-suite "parameter"
   :  [ run basics.cpp ]
      [ run sfinae.cpp ]
      [ run macros.cpp ]
-     [ run unnamed.cpp ]
+     [ run earwicker.cpp ]
      [ run tutorial.cpp ]
-     [ run efficiency.cpp : : : <variant>release ]
+     [ run singular.cpp ]
+     [ run mpl.cpp ]
+     [ run preprocessor.cpp ]
+     [ run preprocessor_deduced.cpp ]
+     [ run efficiency.cpp : : : : : <variant>release ]
+     [ run maybe.cpp ]
+     [ run deduced.cpp ]
+     [ run optional_deduced_sfinae.cpp ]
+     [ run deduced_dependent_predicate.cpp ]
+     [ run normalized_argument_types.cpp ]
+     [ compile ntp.cpp ]
      [ compile unwrap_cv_reference.cpp ]
+     [ compile-fail duplicates.cpp ]
+     [ compile-fail deduced_unmatched_arg.cpp ]
+     [ compile compose.cpp ]
+     [ bpl-test python_test ]
   ;
+

test/basics.cpp

@@ -11,7 +11,6 @@
 
 #include "basics.hpp"
 
-
 namespace test
 {
   // A separate function for getting the "value" key, so we can deduce
@@ -107,6 +106,7 @@ int main()
 #endif
    
    //f(index = 56, name = 55); // won't compile
-   return 0;
+
+   return boost::report_errors();
 }
 

test/basics.hpp

@@ -6,8 +6,13 @@
 #ifndef BASICS_050424_HPP
 #define BASICS_050424_HPP
 
-#include <boost/static_assert.hpp>
 #include <boost/parameter/keyword.hpp>
+#include <boost/parameter/parameters.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/assert.hpp>
+#include <boost/mpl/assert.hpp>
+#include <cstring>
+#include <boost/detail/lightweight_test.hpp>
 
 namespace test {
 
@@ -40,12 +45,14 @@ inline bool equal(T const& x, T const& y)
 
 inline bool equal(char const* s1, char const* s2)
 {
+    using namespace std;
     return !strcmp(s1,s2);
 }
 
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 inline bool equal(char* s1, char* s2)
 {
+    using namespace std;
     return !strcmp(s1,s2);
 }
 #endif 
@@ -69,13 +76,13 @@ struct values_t
             || BOOST_WORKAROUND(BOOST_MSVC, < 1310))                    \
             || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 # else 
-        BOOST_STATIC_ASSERT((boost::is_same<Index,Index_>::value));
-        BOOST_STATIC_ASSERT((boost::is_same<Value,Value_>::value));
-        BOOST_STATIC_ASSERT((boost::is_same<Name,Name_>::value));
+        BOOST_MPL_ASSERT((boost::is_same<Index,Index_>));
+        BOOST_MPL_ASSERT((boost::is_same<Value,Value_>));
+        BOOST_MPL_ASSERT((boost::is_same<Name,Name_>));
 #endif
-        assert(equal(n, n_));
-        assert(equal(v, v_));
-        assert(equal(i, i_));
+        BOOST_TEST(equal(n, n_));
+        BOOST_TEST(equal(v, v_));
+        BOOST_TEST(equal(i, i_));
     }
 
     Name const& n;

test/compose.cpp

@@ -0,0 +1,43 @@
+//~ Copyright Rene Rivera 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)
+
+#include <boost/parameter.hpp>
+
+namespace param
+{
+    BOOST_PARAMETER_KEYWORD(Tag,a0)
+    BOOST_PARAMETER_KEYWORD(Tag,a1)
+    BOOST_PARAMETER_KEYWORD(Tag,a2)
+}
+
+namespace test
+{
+    struct A
+    {
+        int i;
+        int j;
+        
+        template <typename ArgPack> A(ArgPack const & args)
+        {
+            i = args[param::a0];
+            j = args[param::a1];
+        }
+    };
+
+    struct B : A
+    {
+        template <typename ArgPack> B(ArgPack const & args)
+            : A((args, param::a0 = 1))
+        {
+        }
+    };
+}
+
+int main()
+{
+    test::A a((param::a0 = 1, param::a1 = 13, param::a2 = 6));
+    test::B b0((param::a1 = 13));
+    test::B b1((param::a1 = 13, param::a2 = 6));
+}

test/deduced.cpp

@@ -0,0 +1,114 @@
+// 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)
+
+#include <boost/parameter/parameters.hpp>
+#include <boost/parameter/name.hpp>
+#include <boost/parameter/binding.hpp>
+#include "deduced.hpp"
+
+namespace parameter = boost::parameter;
+namespace mpl = boost::mpl;
+
+BOOST_PARAMETER_NAME(x)
+BOOST_PARAMETER_NAME(y)
+BOOST_PARAMETER_NAME(z)
+
+int main()
+{
+    using namespace parameter;
+
+    check<
+        parameters<
+            tag::x
+          , tag::y
+        >
+    >(
+        (_x = 0, _y = 1)
+      , 0
+      , 1
+    );
+
+    check<
+        parameters<
+            tag::x
+          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
+          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
+        >
+    >(
+        (_x = 0, _y = not_present, _z = "foo")
+      , _x = 0
+      , "foo"
+    );
+
+    check<
+        parameters<
+            tag::x
+          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
+          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
+        >
+    >(
+        (_x = 0, _y = 1, _z = "foo")
+      , 0
+      , "foo"
+      , 1
+    );
+
+    check<
+        parameters<
+            tag::x
+          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
+          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
+        >
+    >(
+        (_x = 0, _y = 1, _z = "foo")
+      , 0
+      , 1
+      , "foo"
+    );
+
+    check<
+        parameters<
+            tag::x
+          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
+          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
+        >
+    >(
+        (_x = 0, _y = 1, _z = "foo")
+      , 0
+      , _y = 1
+      , "foo"
+    );
+
+    check<
+        parameters<
+            tag::x
+          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
+          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
+        >
+    >(
+        (_x = 0, _y = 1, _z = "foo")
+      , _z = "foo"
+      , _x = 0
+      , 1
+    );
+
+    // Fails becasue of parameters.hpp:428
+/*
+    check<
+        parameters<
+            tag::x
+          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
+          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
+        >
+    >(
+        (_x = 0, _y = 1, _z = "foo")
+      , _x = 0
+      , (long*)0
+      , 1
+    );
+*/
+
+    return 0;
+};
+

test/deduced.hpp

@@ -0,0 +1,77 @@
+// 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_DEDUCED_060920_HPP
+# define BOOST_DEDUCED_060920_HPP
+
+# include <boost/mpl/for_each.hpp>
+# include "basics.hpp"
+
+struct not_present_tag {};
+not_present_tag not_present;
+
+template <class E, class ArgPack>
+struct assert_expected
+{
+    assert_expected(E const& e, ArgPack const& args)
+      : expected(e)
+      , args(args)
+    {}
+
+    template <class T>
+    bool check_not_present(T const&) const
+    {
+        BOOST_MPL_ASSERT((boost::is_same<T,not_present_tag>));
+        return true;
+    }
+
+    template <class K>
+    bool check1(K const& k, not_present_tag const&, long) const
+    {
+        return check_not_present(args[k | not_present]);
+    }
+
+    template <class K, class Expected>
+    bool check1(K const& k, Expected const& expected, int) const
+    {
+        return test::equal(args[k], expected);
+    }
+
+    template <class K>
+    void operator()(K) const
+    {
+        boost::parameter::keyword<K> const& k = boost::parameter::keyword<K>::get();
+        assert(check1(k, expected[k], 0L));
+    }
+
+    E const& expected;
+    ArgPack const& args;
+};
+
+template <class E, class ArgPack>
+void check0(E const& e, ArgPack const& args)
+{
+    boost::mpl::for_each<E>(assert_expected<E,ArgPack>(e, args));
+}
+
+template <class P, class E, class A0>
+void check(E const& e, A0 const& a0)
+{
+    check0(e, P()(a0));
+}
+
+template <class P, class E, class A0, class A1>
+void check(E const& e, A0 const& a0, A1 const& a1)
+{
+    check0(e, P()(a0,a1));
+}
+
+template <class P, class E, class A0, class A1, class A2>
+void check(E const& e, A0 const& a0, A1 const& a1, A2 const& a2)
+{
+    check0(e, P()(a0,a1,a2));
+}
+
+#endif // BOOST_DEDUCED_060920_HPP
+

test/deduced_dependent_predicate.cpp

@@ -0,0 +1,109 @@
+// 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)
+
+#include <boost/parameter/parameters.hpp>
+#include <boost/parameter/name.hpp>
+#include <boost/parameter/binding.hpp>
+#include <boost/type_traits.hpp>
+#include "deduced.hpp"
+
+namespace parameter = boost::parameter;
+namespace mpl = boost::mpl;
+
+BOOST_PARAMETER_NAME(x)
+BOOST_PARAMETER_NAME(y)
+BOOST_PARAMETER_NAME(z)
+
+int main()
+{
+    using namespace parameter;
+    using boost::is_same;
+    using boost::remove_reference;
+    using boost::add_reference;
+
+    check<
+        parameters<
+            tag::x
+          , optional<
+                deduced<tag::y>
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
+              , is_same<
+                    mpl::_1
+                  , remove_reference<binding<mpl::_2,tag::x> >
+                > 
+#else
+              , is_same<
+                    add_reference<mpl::_1>
+                  , binding<mpl::_2,tag::x>
+                > 
+#endif
+            >
+        >
+    >(
+        (_x = 0, _y = 1)
+      , 0
+      , 1
+    );
+
+    check<
+        parameters<
+            tag::x
+          , optional<
+                deduced<tag::y>
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
+              , is_same<
+                    mpl::_1
+                  , remove_reference<binding<mpl::_2,tag::x> >
+                > 
+#else
+              , is_same<
+                    add_reference<mpl::_1>
+                  , binding<mpl::_2,tag::x>
+                > 
+#endif
+            >
+        >
+    >(
+        (_x = 0U, _y = 1U)
+      , 0U
+      , 1U
+    );
+
+    check<
+        parameters<
+            tag::x
+          , optional<
+                deduced<tag::y>
+              , is_same<
+                    mpl::_1
+                  , tag::x::_
+                > 
+            >
+        >
+    >(
+        (_x = 0U, _y = 1U)
+      , 0U
+      , 1U
+    );
+
+    check<
+        parameters<
+            tag::x
+          , optional<
+                deduced<tag::y>
+              , is_same<
+                    mpl::_1
+                  , tag::x::_1
+                > 
+            >
+        >
+    >(
+        (_x = 0U, _y = 1U)
+      , 0U
+      , 1U
+    );
+
+    return 0;
+}
+

test/deduced_unmatched_arg.cpp

@@ -0,0 +1,25 @@
+// 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)
+
+#include <boost/parameter/parameters.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace parameter = boost::parameter;
+namespace mpl = boost::mpl;
+
+BOOST_PARAMETER_NAME(x)
+
+int main()
+{
+    using namespace parameter;
+    using boost::is_convertible;
+    using mpl::_;
+
+    parameters<
+        optional<
+            deduced<tag::x>, is_convertible<_,int>
+        >
+    >()("foo");
+}
+

test/duplicates.cpp

@@ -16,7 +16,7 @@ int main()
 {
    using namespace test;
 
-   f((name = 1, value = 1, index = 1, tester = 1,
+   f((name = 1, value = 1, test::index = 1, tester = 1,
       value = 1 // repeated keyword: should not compile
    ));
    return 0;

test/earwicker.cpp

@@ -0,0 +1,56 @@
+// Copyright David Abrahams, 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/parameter.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <iostream>
+
+namespace test {
+
+BOOST_PARAMETER_KEYWORD(tag, x)
+BOOST_PARAMETER_KEYWORD(tag, y)
+BOOST_PARAMETER_KEYWORD(tag, z)
+
+using namespace boost::parameter;
+using namespace boost::mpl::placeholders;
+
+struct f_parameters // vc6 is happier with inheritance than with a typedef
+  : parameters<
+        optional<tag::x,boost::is_convertible<_,int> >
+      , optional<tag::y,boost::is_convertible<_,int> >
+      , optional<tag::z,boost::is_convertible<_,int> >
+    >
+{};
+
+#ifdef BOOST_NO_VOID_RETURNS
+BOOST_PARAMETER_FUN(int, f, 0, 3, f_parameters)
+#else 
+BOOST_PARAMETER_FUN(void, f, 0, 3, f_parameters)
+#endif 
+{
+    std::cout << "x = " << p[x | -1] << std::endl;
+    std::cout << "y = " << p[y | -2] << std::endl;
+    std::cout << "z = " << p[z | -3] << std::endl;
+    std::cout <<  "================" << std::endl;
+#ifdef BOOST_NO_VOID_RETURNS
+    return 0;
+#endif 
+}
+
+}
+
+
+int main()
+{
+    using namespace test;
+    f(x = 1, y = 2, z = 3);
+    f(x = 1);
+    f(y = 2);
+    f(z = 3);
+    f(z = 3, x = 1);
+}
+
+

test/literate/Jamfile.v2

@@ -0,0 +1,33 @@
+
+import testing ;
+
+run extracting-parameter-types0.cpp ;
+run extracting-parameter-types1.cpp ;
+compile template-keywords0.cpp ;
+compile template-keywords1.cpp ;
+compile top-level0.cpp ;
+compile headers-and-namespaces0.cpp ;
+compile predicate-requirements0.cpp ;
+compile handling-out-parameters0.cpp ;
+compile writing-the-function0.cpp ;
+run building-argumentpacks0.cpp ;
+compile defining-the-keywords0.cpp ;
+compile defining-the-keywords1.cpp ;
+compile exercising-the-code-so-far0.cpp ;
+run lazy-default-computation0.cpp ;
+run lazy-default-computation1.cpp ;
+run namespaces0.cpp ;
+run namespaces1.cpp ;
+run namespaces2.cpp ;
+run namespaces3.cpp ;
+compile optional-parameters0.cpp ;
+compile static-member-functions0.cpp ;
+run parameter-enabled-constructors0.cpp ;
+compile required-parameters0.cpp ;
+compile class-template-skeleton0.cpp ;
+compile deduced-template-parameters0.cpp ;
+compile deduced-parameters0.cpp ;
+compile default-expression-evaluation0.cpp ;
+compile parameter-enabled-member-functions0.cpp ;
+compile parameter-enabled-member-functions1.cpp ;
+run fine-grained-name-control0.cpp ;

test/literate/README

@@ -0,0 +1,6 @@
+These tests were extracted from the Boost.Parameter documentation
+with:
+
+python ../../../../tools/litre/tool.py \
+       ../../../../libs/parameter/doc/index.rst \
+       --dump_dir=.

test/literate/building-argumentpacks0.cpp

@@ -0,0 +1,47 @@
+
+#include <boost/parameter.hpp>
+#include <iostream>
+BOOST_PARAMETER_NAME(index)
+
+template <class ArgumentPack>
+int print_index(ArgumentPack const& args)
+{
+    std::cout << "index = " << args[_index] << std::endl;
+    return 0;
+}
+
+int x = print_index(_index = 3);  // prints "index = 3"
+
+BOOST_PARAMETER_NAME(name)
+
+template <class ArgumentPack>
+int print_name_and_index(ArgumentPack const& args)
+{
+    std::cout << "name = " << args[_name] << "; ";
+    return print_index(args);
+}
+
+int y = print_name_and_index((_index = 3, _name = "jones"));
+
+
+namespace parameter = boost::parameter;
+using parameter::required;
+using parameter::optional;
+using boost::is_convertible;
+using boost::mpl::_;
+parameter::parameters<
+    required<tag::name, is_convertible<_,char const*> >
+  , optional<tag::index, is_convertible<_,int> >
+> spec;
+
+char const sam[] = "sam";
+int twelve = 12;
+
+int z0 = print_name_and_index( spec(sam, twelve) );
+
+int z1 = print_name_and_index(
+   spec(_index=12, _name="sam")
+);
+int main()
+{}
+

test/literate/class-template-skeleton0.cpp

@@ -0,0 +1,16 @@
+
+#include <boost/parameter.hpp>
+namespace boost { namespace python {
+
+template <
+    class A0
+  , class A1 = parameter::void_
+  , class A2 = parameter::void_
+  , class A3 = parameter::void_
+>
+struct class_
+{
+    
+};
+
+}}

test/literate/deduced-parameters0.cpp

@@ -0,0 +1,74 @@
+
+#include <boost/parameter.hpp>
+
+BOOST_PARAMETER_NAME(name)
+BOOST_PARAMETER_NAME(func)
+BOOST_PARAMETER_NAME(docstring)
+BOOST_PARAMETER_NAME(keywords)
+BOOST_PARAMETER_NAME(policies)
+
+struct default_call_policies
+{};
+
+struct no_keywords
+{};
+
+struct keywords
+{};
+
+template <class T>
+struct is_keyword_expression
+  : boost::mpl::false_
+{};
+
+template <>
+struct is_keyword_expression<keywords>
+  : boost::mpl::true_
+{};
+
+default_call_policies some_policies;
+
+void f()
+{}
+namespace mpl = boost::mpl;
+
+BOOST_PARAMETER_FUNCTION(
+    (void), def, tag,
+
+    (required (name,(char const*)) (func,*) )   // nondeduced
+
+    (deduced
+      (optional
+        (docstring, (char const*), "")
+
+        (keywords
+           , *(is_keyword_expression<mpl::_>) // see 5
+           , no_keywords())
+
+        (policies
+           , *(mpl::not_<
+                 mpl::or_<
+                     boost::is_convertible<mpl::_, char const*>
+                   , is_keyword_expression<mpl::_> // see 5
+                 >
+             >)
+           , default_call_policies()
+         )
+       )
+     )
+ )
+ {
+    
+ }
+
+
+int main()
+{
+def("f", &f, some_policies, "Documentation for f");
+def("f", &f, "Documentation for f", some_policies);
+
+def(
+    "f", &f
+   , _policies = some_policies, "Documentation for f");
+}
+

test/literate/deduced-template-parameters0.cpp

@@ -0,0 +1,124 @@
+
+#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::_;
+
+namespace boost { namespace python {
+
+BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
+BOOST_PARAMETER_TEMPLATE_KEYWORD(base_list)
+BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
+BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)
+
+}}
+namespace boost { namespace python {
+
+namespace detail { struct bases_base {}; }
+
+template <class A0 = void, class A1 = void, class A2 = void  >
+struct bases : detail::bases_base
+{};
+
+}}
+
+
+#include <boost/type_traits/is_class.hpp>
+namespace boost { namespace python {
+typedef parameter::parameters<
+    required<tag::class_type, is_class<_> >
+
+  , parameter::optional<
+        deduced<tag::base_list>
+      , is_base_and_derived<detail::bases_base,_>
+    >
+
+  , parameter::optional<
+        deduced<tag::held_type>
+      , mpl::not_<
+            mpl::or_<
+                is_base_and_derived<detail::bases_base,_>
+              , is_same<noncopyable,_>
+            >
+        >
+    >
+
+  , parameter::optional<deduced<tag::copyable>, is_same<noncopyable,_> >
+
+> class_signature;
+template <
+    class A0
+  , class A1 = parameter::void_
+  , class A2 = parameter::void_
+  , class A3 = parameter::void_
+>
+struct class_
+{
+    // Create ArgumentPack
+    typedef typename
+      class_signature::bind<A0,A1,A2,A3>::type
+    args;
+
+    // Extract first logical parameter.
+    typedef typename parameter::value_type<
+      args, tag::class_type>::type class_type;
+
+    typedef typename parameter::value_type<
+      args, tag::base_list, bases<> >::type base_list;
+
+    typedef typename parameter::value_type<
+      args, tag::held_type, class_type>::type held_type;
+
+    typedef typename parameter::value_type<
+      args, tag::copyable, void>::type copyable;
+};
+
+}}
+
+
+
+struct B {};
+struct D {};
+
+using boost::python::bases;
+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
+
+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>));
+BOOST_MPL_ASSERT((
+     boost::is_same<c1::copyable, boost::noncopyable>
+));
+
+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>));

test/literate/default-expression-evaluation0.cpp

@@ -0,0 +1,39 @@
+
+#include <boost/parameter.hpp>
+#include <iostream>
+
+BOOST_PARAMETER_NAME(graph)
+BOOST_PARAMETER_NAME(visitor)
+BOOST_PARAMETER_NAME(root_vertex)
+BOOST_PARAMETER_NAME(index_map)
+BOOST_PARAMETER_NAME(color_map)
+#include <boost/graph/depth_first_search.hpp> // for dfs_visitor
+
+BOOST_PARAMETER_FUNCTION(
+    (void), depth_first_search, tag
+    
+, (required
+    (graph, *)
+    (visitor, *)
+    (root_vertex, *)
+    (index_map, *)
+    (color_map, *)
+  )
+
+)
+{
+   std::cout << "graph=" << graph << std::endl;
+   std::cout << "visitor=" << visitor << std::endl;
+   std::cout << "root_vertex=" << root_vertex << std::endl;
+   std::cout << "index_map=" << index_map << std::endl;
+   std::cout << "color_map=" << color_map << std::endl;
+}
+
+int main()
+{
+    depth_first_search(1, 2, 3, 4, 5);
+
+    depth_first_search(
+        "1", '2', _color_map = '5',
+        _index_map = "4", _root_vertex = "3");
+}

test/literate/defining-the-keywords0.cpp

@@ -0,0 +1,10 @@
+#include <boost/parameter/name.hpp>
+
+namespace graphs
+{
+  BOOST_PARAMETER_NAME(graph)    // Note: no semicolon
+  BOOST_PARAMETER_NAME(visitor)
+  BOOST_PARAMETER_NAME(root_vertex)
+  BOOST_PARAMETER_NAME(index_map)
+  BOOST_PARAMETER_NAME(color_map)
+}

test/literate/defining-the-keywords1.cpp

@@ -0,0 +1,13 @@
+
+#include <boost/parameter/keyword.hpp>
+namespace graphs
+{
+  namespace tag { struct graph; } // keyword tag type
+
+  namespace // unnamed
+  {
+    // A reference to the keyword object
+    boost::parameter::keyword<tag::graph>& _graph
+    = boost::parameter::keyword<tag::graph>::get();
+  }
+}

test/literate/exercising-the-code-so-far0.cpp

@@ -0,0 +1,118 @@
+
+#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;
+
+namespace boost { namespace python {
+
+BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
+BOOST_PARAMETER_TEMPLATE_KEYWORD(base_list)
+BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
+BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)
+
+template <class B = int>
+struct bases
+{};
+
+}}
+namespace boost { namespace python {
+
+using boost::mpl::_;
+
+typedef parameter::parameters<
+    required<tag::class_type, boost::is_class<_> >
+  , parameter::optional<tag::base_list, mpl::is_sequence<_> >
+  , parameter::optional<tag::held_type>
+  , parameter::optional<tag::copyable>
+> class_signature;
+
+}}
+
+namespace boost { namespace python {
+
+template <
+    class A0
+  , class A1 = parameter::void_
+  , class A2 = parameter::void_
+  , class A3 = parameter::void_
+>
+struct class_
+{
+    // Create ArgumentPack
+    typedef typename
+      class_signature::bind<A0,A1,A2,A3>::type
+    args;
+
+    // Extract first logical parameter.
+    typedef typename parameter::value_type<
+      args, tag::class_type>::type class_type;
+
+    typedef typename parameter::value_type<
+      args, tag::base_list, bases<> >::type base_list;
+
+    typedef typename parameter::value_type<
+      args, tag::held_type, class_type>::type held_type;
+
+    typedef typename parameter::value_type<
+      args, tag::copyable, void>::type copyable;
+};
+
+}}
+
+
+using boost::python::class_type;
+using boost::python::copyable;
+using boost::python::held_type;
+using boost::python::base_list;
+using boost::python::bases;
+
+struct B {};
+struct D {};
+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;
+
+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>));
+BOOST_MPL_ASSERT((
+     boost::is_same<c1::copyable, boost::noncopyable>
+));
+
+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>));

test/literate/extracting-parameter-types0.cpp

@@ -0,0 +1,28 @@
+
+#include <boost/parameter.hpp>
+#include <cassert>
+BOOST_PARAMETER_NAME(name)
+BOOST_PARAMETER_NAME(index)
+
+template <class Name, class Index>
+int deduce_arg_types_impl(Name& name, Index& index)
+{
+    Name& n2 = name;  // we know the types
+    Index& i2 = index;
+    return index;
+}
+
+template <class ArgumentPack>
+int deduce_arg_types(ArgumentPack const& args)
+{
+    return deduce_arg_types_impl(args[_name], args[_index|42]);
+}
+int a1 = deduce_arg_types((_name = "foo"));
+int a2 = deduce_arg_types((_name = "foo", _index = 3));
+
+int main()
+{
+    assert(a1 == 42);
+    assert(a2 == 3);
+}
+

test/literate/extracting-parameter-types1.cpp

@@ -0,0 +1,21 @@
+
+#include <boost/parameter.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <cassert>
+
+namespace parameter = boost::parameter;
+BOOST_PARAMETER_NAME(index)
+
+template <class ArgumentPack>
+typename parameter::value_type<ArgumentPack, tag::index, int>::type
+twice_index(ArgumentPack const& args)
+{
+    return 2 * args[_index|42];
+}
+
+int six = twice_index(_index = 3);
+int main()
+{
+    assert(six == 6);
+}
+

test/literate/fine-grained-name-control0.cpp

@@ -0,0 +1,15 @@
+
+#include <boost/parameter.hpp>
+BOOST_PARAMETER_NAME((pass_foo, keywords) foo)
+
+BOOST_PARAMETER_FUNCTION(
+  (int), f,
+  keywords, (required (foo, *)))
+{
+    return foo + 1;
+}
+
+int x = f(pass_foo = 41);
+int main()
+{}
+

test/literate/handling-out-parameters0.cpp

@@ -0,0 +1,30 @@
+
+#include <boost/parameter.hpp>
+
+namespace boost
+{
+  int vertex_index = 0;
+
+  template <class T = int>
+  struct dfs_visitor
+  {};
+}
+
+BOOST_PARAMETER_NAME(graph)
+
+BOOST_PARAMETER_NAME(visitor)
+BOOST_PARAMETER_NAME(root_vertex)
+BOOST_PARAMETER_NAME(index_map)
+BOOST_PARAMETER_NAME(color_map)
+
+BOOST_PARAMETER_FUNCTION((void), f, tag,
+  (required (graph, *))
+(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) )
+)
+) {}
+

test/literate/headers-and-namespaces0.cpp

@@ -0,0 +1,3 @@
+#include <boost/parameter/keyword.hpp>
+using boost::parameter::keyword;
+

test/literate/lazy-default-computation0.cpp

@@ -0,0 +1,24 @@
+
+#include <boost/parameter.hpp>
+#include <string>
+
+namespace parameter = boost::parameter;
+BOOST_PARAMETER_NAME(s1)
+BOOST_PARAMETER_NAME(s2)
+BOOST_PARAMETER_NAME(s3)
+
+template <class ArgumentPack>
+std::string f(ArgumentPack const& args)
+{
+    std::string const& s1 = args[_s1];
+    std::string const& s2 = args[_s2];
+    typename parameter::binding<
+        ArgumentPack,tag::s3,std::string
+    >::type s3 = args[_s3|(s1+s2)]; // always constructs s1+s2
+    return s3;
+}
+
+std::string x = f((_s1="hello,", _s2=" world", _s3="hi world"));
+int main()
+{}
+

test/literate/lazy-default-computation1.cpp

@@ -0,0 +1,30 @@
+
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+#include <boost/parameter.hpp>
+#include <string>
+#include <functional>
+
+namespace parameter = boost::parameter;
+
+BOOST_PARAMETER_NAME(s1)
+BOOST_PARAMETER_NAME(s2)
+BOOST_PARAMETER_NAME(s3)
+
+template <class ArgumentPack>
+std::string f(ArgumentPack const& args)
+{
+    std::string const& s1 = args[_s1];
+    std::string const& s2 = args[_s2];
+typename parameter::binding<
+    ArgumentPack, tag::s3, std::string
+>::type s3 = args[_s3
+    || boost::bind(std::plus<std::string>(), boost::ref(s1), boost::ref(s2)) ];
+    return s3;
+}
+
+std::string x = f((_s1="hello,", _s2=" world", _s3="hi world"));
+
+int main()
+{}
+

test/literate/namespaces0.cpp

@@ -0,0 +1,20 @@
+
+#include <boost/parameter.hpp>
+#include <iostream>
+namespace lib
+{
+  BOOST_PARAMETER_NAME(name)
+  BOOST_PARAMETER_NAME(index)
+
+  BOOST_PARAMETER_FUNCTION(
+    (int), f, tag,
+    (optional (name,*,"bob")(index,(int),1))
+  )
+  {
+      std::cout << name << ":" << index << std::endl;
+      return index;
+  }
+}
+int x = lib::f(lib::_name = "jill", lib::_index = 1);
+int main() {}
+

test/literate/namespaces1.cpp

@@ -0,0 +1,23 @@
+
+#include <boost/parameter.hpp>
+#include <iostream>
+namespace lib
+{
+  BOOST_PARAMETER_NAME(name)
+  BOOST_PARAMETER_NAME(index)
+
+  BOOST_PARAMETER_FUNCTION(
+    (int), f, tag,
+    (optional (name,*,"bob")(index,(int),1))
+  )
+  {
+      std::cout << name << ":" << index << std::endl;
+      return index;
+  }
+}
+using lib::_name;
+using lib::_index;
+
+int x = lib::f(_name = "jill", _index = 1);
+int main() {}
+

test/literate/namespaces2.cpp

@@ -0,0 +1,21 @@
+
+#include <boost/parameter.hpp>
+#include <iostream>
+namespace lib
+{
+  BOOST_PARAMETER_NAME(name)
+  BOOST_PARAMETER_NAME(index)
+
+  BOOST_PARAMETER_FUNCTION(
+    (int), f, tag,
+    (optional (name,*,"bob")(index,(int),1))
+  )
+  {
+      std::cout << name << ":" << index << std::endl;
+      return index;
+  }
+}
+using namespace lib;
+int x = f(_name = "jill", _index = 3);
+int main() {}
+

test/literate/namespaces3.cpp

@@ -0,0 +1,25 @@
+
+#include <boost/parameter.hpp>
+#include <iostream>
+namespace lib
+{
+  namespace keywords
+  {
+     BOOST_PARAMETER_NAME(name)
+     BOOST_PARAMETER_NAME(index)
+  }
+
+  BOOST_PARAMETER_FUNCTION(
+    (int), f, keywords::tag,
+    (optional (name,*,"bob")(index,(int),1))
+  )
+  {
+      std::cout << name << ":" << index << std::endl;
+      return index;
+  }
+}
+
+using namespace lib::keywords;
+int y = lib::f(_name = "bob", _index = 2);
+int main() {}
+

test/literate/optional-parameters0.cpp

@@ -0,0 +1,28 @@
+
+#include <boost/parameter.hpp>
+
+namespace boost
+{
+  int vertex_index = 0;
+
+  template <class T = int>
+  struct dfs_visitor
+  {};
+}
+
+BOOST_PARAMETER_NAME(graph)
+BOOST_PARAMETER_NAME(visitor)
+BOOST_PARAMETER_NAME(root_vertex)
+BOOST_PARAMETER_NAME(index_map)
+BOOST_PARAMETER_NAME(color_map)
+
+BOOST_PARAMETER_FUNCTION((void), f, tag,
+  (required (graph, *))
+(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) )
+)
+) {}
+

test/literate/parameter-enabled-constructors0.cpp

@@ -0,0 +1,31 @@
+
+#include <boost/parameter.hpp>
+#include <iostream>
+BOOST_PARAMETER_NAME(name)
+BOOST_PARAMETER_NAME(index)
+
+struct myclass_impl
+{
+    template <class ArgumentPack>
+    myclass_impl(ArgumentPack const& args)
+    {
+        std::cout << "name = " << args[_name]
+                  << "; index = " << args[_index | 42]
+                  << std::endl;
+    }
+};
+
+struct myclass : myclass_impl
+{
+    BOOST_PARAMETER_CONSTRUCTOR(
+        myclass, (myclass_impl), tag
+      , (required (name,*)) (optional (index,*))) // no semicolon
+};
+
+
+int main() {
+myclass x("bob", 3);                     // positional
+myclass y(_index = 12, _name = "sally"); // named
+myclass z("june");                       // positional/defaulted
+}
+

test/literate/parameter-enabled-member-functions0.cpp

@@ -0,0 +1,15 @@
+
+#include <boost/parameter.hpp>
+#include <iostream>
+using namespace boost::parameter;
+BOOST_PARAMETER_NAME(arg1)
+BOOST_PARAMETER_NAME(arg2)
+
+struct callable2
+{
+    BOOST_PARAMETER_CONST_MEMBER_FUNCTION(
+        (void), call, tag, (required (arg1,(int))(arg2,(int))))
+    {
+        std::cout << arg1 << ", " << arg2 << std::endl;
+    }
+};

test/literate/parameter-enabled-member-functions1.cpp

@@ -0,0 +1,16 @@
+
+#include <boost/parameter.hpp>
+
+BOOST_PARAMETER_NAME(arg1)
+BOOST_PARAMETER_NAME(arg2)
+using namespace boost::parameter;
+struct callable2
+{
+    BOOST_PARAMETER_CONST_MEMBER_FUNCTION(
+        (void), call, tag, (required (arg1,(int))(arg2,(int))))
+    {
+        call_impl(arg1,arg2);
+    }
+ private:
+    void call_impl(int, int); // implemented elsewhere.
+};

test/literate/predicate-requirements0.cpp

@@ -0,0 +1,103 @@
+
+#include <boost/parameter.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/depth_first_search.hpp>
+
+BOOST_PARAMETER_NAME((_graph, graphs) graph)
+BOOST_PARAMETER_NAME((_visitor, graphs) visitor)
+BOOST_PARAMETER_NAME((_root_vertex, graphs) root_vertex)
+BOOST_PARAMETER_NAME((_index_map, graphs) index_map)
+BOOST_PARAMETER_NAME((_color_map, graphs) color_map)
+
+using boost::mpl::_;
+// We first need to define a few metafunction that we use in the
+// predicates below.
+
+template <class G>
+struct traversal_category
+{
+    typedef typename boost::graph_traits<G>::traversal_category type;
+};
+
+template <class G>
+struct vertex_descriptor
+{
+    typedef typename boost::graph_traits<G>::vertex_descriptor type;
+};
+
+template <class G>
+struct value_type
+{
+    typedef typename boost::property_traits<G>::value_type type;
+};
+
+template <class G>
+struct key_type
+{
+    typedef typename boost::property_traits<G>::key_type type;
+};
+
+template<class Size, class IndexMap>
+boost::iterator_property_map<
+    boost::default_color_type*, IndexMap
+  , boost::default_color_type, boost::default_color_type&
+>
+default_color_map(Size num_vertices, IndexMap const& index_map)
+{
+   std::vector<boost::default_color_type> colors(num_vertices);
+   return &colors[0];
+}
+
+BOOST_PARAMETER_FUNCTION(
+    (void), depth_first_search, graphs
+
+  , (required
+      (graph
+       , *(boost::mpl::and_<
+               boost::is_convertible<
+                   traversal_category<_>, boost::incidence_graph_tag
+               >
+             , boost::is_convertible<
+                   traversal_category<_>, boost::vertex_list_graph_tag
+               >
+           >) ))
+
+    (optional
+      (visitor, *, boost::dfs_visitor<>()) // not checkable
+
+      (root_vertex
+        , (vertex_descriptor<graphs::graph::_>)
+        , *vertices(graph).first)
+
+      (index_map
+        , *(boost::mpl::and_<
+              boost::is_integral<value_type<_> >
+            , boost::is_same<
+                  vertex_descriptor<graphs::graph::_>, key_type<_>
+              >
+          >)
+        , get(boost::vertex_index,graph))
+
+      (in_out(color_map)
+        , *(boost::is_same<
+              vertex_descriptor<graphs::graph::_>, key_type<_>
+          >)
+       , default_color_map(num_vertices(graph), index_map) )
+    )
+)
+{}
+
+int main()
+{
+    typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS> G;
+
+    enum {u, v, w, x, y, z, N};
+    typedef std::pair<int, int> E;
+    E edges[] = {E(u, v), E(u, x), E(x, v), E(y, x), E(v, y), E(w, y),
+                 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);
+}
+

test/literate/required-parameters0.cpp

@@ -0,0 +1,9 @@
+
+#include <boost/parameter.hpp>
+
+BOOST_PARAMETER_NAME(graph)
+
+BOOST_PARAMETER_FUNCTION((void), f, tag,
+(required (graph, *) )
+) {}
+

test/literate/static-member-functions0.cpp

@@ -0,0 +1,14 @@
+
+#include <boost/parameter.hpp>
+#include <iostream>
+using namespace boost::parameter;
+BOOST_PARAMETER_NAME(arg1)
+
+struct somebody
+{
+    BOOST_PARAMETER_MEMBER_FUNCTION(
+        (void), static f, tag, (optional (arg1,(int),0)))
+    {
+        std::cout << arg1 << std::endl;
+    }
+};

test/literate/template-keywords0.cpp

@@ -0,0 +1,10 @@
+
+#include <boost/parameter.hpp>
+namespace boost { namespace python {
+
+BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
+BOOST_PARAMETER_TEMPLATE_KEYWORD(base_list)
+BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
+BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)
+
+}}

test/literate/template-keywords1.cpp

@@ -0,0 +1,11 @@
+
+#include <boost/parameter.hpp>
+namespace boost { namespace python {
+
+namespace tag { struct class_type; } // keyword tag type
+template <class T>
+struct class_type
+  : parameter::template_keyword<tag::class_type,T>
+{};
+
+}}

test/literate/top-level0.cpp

@@ -0,0 +1,38 @@
+
+#include <boost/parameter.hpp>
+
+namespace test
+{
+  BOOST_PARAMETER_NAME(title)
+  BOOST_PARAMETER_NAME(width)
+  BOOST_PARAMETER_NAME(titlebar)
+
+  BOOST_PARAMETER_FUNCTION(
+     (int), new_window, tag, (required (title,*)(width,*)(titlebar,*)))
+  {
+     return 0;
+  }
+
+  BOOST_PARAMETER_TEMPLATE_KEYWORD(deleter)
+  BOOST_PARAMETER_TEMPLATE_KEYWORD(copy_policy)
+
+  template <class T> struct Deallocate {};
+  struct DeepCopy {};
+
+  namespace parameter = boost::parameter;
+
+  struct Foo {};
+  template <class T, class A0, class A1>
+  struct smart_ptr
+  {
+      smart_ptr(Foo*);
+  };
+}
+using namespace test;
+int x = 
+new_window("alert", _width=10, _titlebar=false);
+
+smart_ptr<
+   Foo
+ , deleter<Deallocate<Foo> >
+ , copy_policy<DeepCopy> > p(new Foo);

test/literate/writing-the-function0.cpp

@@ -0,0 +1,43 @@
+
+#include <boost/parameter/name.hpp>
+
+BOOST_PARAMETER_NAME(graph)
+BOOST_PARAMETER_NAME(visitor)
+BOOST_PARAMETER_NAME(root_vertex)
+BOOST_PARAMETER_NAME(index_map)
+BOOST_PARAMETER_NAME(color_map)
+
+namespace boost {
+
+template <class T = int>
+struct dfs_visitor
+{};
+
+int vertex_index = 0;
+
+}
+#include <boost/parameter/preprocessor.hpp>
+
+namespace graphs
+{
+  BOOST_PARAMETER_FUNCTION(
+      (void),                // 1. parenthesized return type
+      depth_first_search,    // 2. name of the function template
+
+      tag,                   // 3. namespace of tag types
+
+      (required (graph, *) ) // 4. one required parameter, and
+
+      (optional              //    four optional parameters, with defaults
+        (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) )
+      )
+  )
+  {
+      // ... body of function goes here...
+      // use graph, visitor, index_map, and color_map
+  }
+}

test/macros.cpp

@@ -52,6 +52,6 @@ int main()
      , index = boost::ref(x), name = "foo"
    );
 
-   return 0;
+   return boost::report_errors();
 }
 

test/maybe.cpp

@@ -0,0 +1,35 @@
+// 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)
+
+#include <boost/parameter/keyword.hpp>
+#include <boost/parameter/aux_/maybe.hpp>
+#include <cassert>
+
+namespace test {
+
+BOOST_PARAMETER_KEYWORD(tag, kw)
+BOOST_PARAMETER_KEYWORD(tag, unused)
+    
+template <class Args>
+int f(Args const& args)
+{
+    return args[kw | 1.f];
+}
+
+} // namespace test
+
+int main()
+{
+    using test::kw;
+    using test::unused;
+    using test::f;
+    using boost::parameter::aux::maybe;
+
+    assert(f((kw = 0, unused = 0)) == 0);
+    assert(f(unused = 0) == 1);
+    assert(f((kw = maybe<int>(), unused = 0)) == 1);
+    assert(f((kw = maybe<int>(2), unused = 0)) == 2);
+    return 0;
+}
+

test/mpl.cpp

@@ -0,0 +1,80 @@
+// 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)
+
+#include "basics.hpp"
+#include <boost/mpl/list.hpp>
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/type_traits/add_pointer.hpp>
+
+# include <boost/mpl/contains.hpp>
+
+namespace test
+{
+  namespace mpl = boost::mpl;
+
+  template <class Set>
+  struct assert_in_set
+  {
+      template <class T>
+      void operator()(T*)
+      {
+          BOOST_MPL_ASSERT((mpl::contains<Set,T>));
+      }
+  };
+
+  
+  template<class Expected, class Params>
+  void f_impl(Params const& p BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Expected))
+  {
+      BOOST_MPL_ASSERT_RELATION(
+          mpl::size<Expected>::value
+        , ==
+        , mpl::size<Params>::value
+      );
+
+      mpl::for_each<Params, boost::add_pointer<mpl::_1> >(assert_in_set<Expected>());
+  }
+
+  template<class Expected, class Tester, class Name, class Value, class Index>
+  void f(Tester const& t, const Name& name_, 
+      const Value& value_, const Index& index_ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Expected))
+  {
+      f_impl<Expected>(f_parameters()(t, name_, value_, index_));
+  }
+
+  template<class Expected, class Tester, class Name, class Value>
+  void f(Tester const& t, const Name& name_, const Value& value_ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Expected))
+  {
+      f_impl<Expected>(f_parameters()(t, name_, value_));
+  }
+
+  template<class Expected, class Tester, class Name>
+  void f(Tester const& t, const Name& name_ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Expected))
+  {
+      f_impl<Expected>(f_parameters()(t, name_));
+  }
+
+  void run()
+  {
+      typedef test::tag::tester tester_;
+      typedef test::tag::name name_;
+      typedef test::tag::value value_;
+      typedef test::tag::index index_;
+
+      f<mpl::list4<tester_,name_,value_,index_> >(1, 2, 3, 4);
+      f<mpl::list3<tester_,name_,index_> >(1, 2, index = 3);
+      f<mpl::list3<tester_,name_,index_> >(1, index = 2, name = 3);
+      f<mpl::list2<name_,value_> >(name = 3, value = 4);
+      f_impl<mpl::list1<value_> >(value = 4);
+  }
+}
+
+int main()
+{
+    test::run();
+    return 0;
+}
+

test/normalized_argument_types.cpp

@@ -0,0 +1,85 @@
+// 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)
+
+#include <boost/parameter.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <cassert>
+
+struct count_instances
+{
+    count_instances()
+    {
+        ++count;
+    }
+
+    count_instances(count_instances const&)
+    {
+        ++count;
+    }
+
+    template <class T>
+    count_instances(T const&)
+    {
+        ++count;
+    }
+
+    ~count_instances()
+    {
+        --count;
+    }
+
+    static std::size_t count;
+};
+
+std::size_t count_instances::count = 0;
+
+BOOST_PARAMETER_NAME(x)
+BOOST_PARAMETER_NAME(y)
+
+BOOST_PARAMETER_FUNCTION((int), f, tag,
+    (required
+       (x, (int))
+       (y, (int))
+    )
+)
+{
+    BOOST_MPL_ASSERT((boost::is_same<x_type,int>));
+    BOOST_MPL_ASSERT((boost::is_same<y_type,int>));
+    return 0;
+}
+
+BOOST_PARAMETER_FUNCTION((int), g, tag,
+    (required
+       (x, (count_instances))
+    )
+)
+{
+    BOOST_MPL_ASSERT((boost::is_same<x_type,count_instances>));
+    assert(count_instances::count > 0);
+    return 0;
+}
+
+BOOST_PARAMETER_FUNCTION((int), h, tag,
+    (required
+       (x, (count_instances const&))
+    )
+)
+{
+    BOOST_MPL_ASSERT((boost::is_same<x_type,count_instances const>));
+    assert(count_instances::count == 1);
+    return 0;
+}
+
+int main()
+{
+    f(1, 2);
+    f(1., 2.f);
+    f(1U, 2L);
+
+    g(0);
+
+    h(0);
+}
+

test/ntp.cpp

@@ -0,0 +1,110 @@
+// 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)
+
+#include <boost/parameter.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+namespace mpl = boost::mpl;
+namespace parameter = boost::parameter;
+
+template <class T = int>
+struct a0_is
+  : parameter::template_keyword<a0_is<>, T>
+{};
+
+template <class T = int>
+struct a1_is
+  : parameter::template_keyword<a1_is<>, T>
+{};
+
+template <class T = int>
+struct a2_is
+  : parameter::template_keyword<a2_is<>, T>
+{};
+
+template <class T = int>
+struct a3_is
+  : parameter::template_keyword<a3_is<>, T>
+{};
+
+struct X {};
+struct Y : X {};
+
+template <
+    class A0 = parameter::void_
+  , class A1 = parameter::void_
+  , class A2 = parameter::void_
+  , class A3 = parameter::void_
+>
+struct with_ntp
+{
+    typedef typename parameter::parameters<
+        a0_is<>, a1_is<>, a2_is<>
+      , parameter::optional<
+            parameter::deduced<a3_is<> >
+          , boost::is_base_and_derived<X, mpl::_>
+        >
+    >::bind<A0,A1,A2,A3
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+          , parameter::void_
+#endif 
+            >::type args;
+
+    typedef typename parameter::binding<
+        args, a0_is<>, void*
+    >::type a0;
+
+    typedef typename parameter::binding<
+        args, a1_is<>, void*
+    >::type a1;
+
+    typedef typename parameter::binding<
+        args, a2_is<>, void*
+    >::type a2;
+
+    typedef typename parameter::binding<
+        args, a3_is<>, void*
+    >::type a3;
+
+    typedef void(*type)(a0,a1,a2,a3);
+};
+
+BOOST_MPL_ASSERT((boost::is_same<
+    with_ntp<>::type, void(*)(void*,void*,void*,void*)
+>));
+
+BOOST_MPL_ASSERT((boost::is_same<
+    with_ntp<a2_is<int> >::type, void(*)(void*,void*,int,void*)
+>));
+
+BOOST_MPL_ASSERT((boost::is_same<
+    with_ntp<a1_is<int> >::type, void(*)(void*,int,void*,void*)
+>));
+
+BOOST_MPL_ASSERT((boost::is_same<
+    with_ntp<a2_is<int const>, a1_is<float> >::type, void(*)(void*,float,int const,void*)
+>));
+
+BOOST_MPL_ASSERT((boost::is_same<
+    with_ntp<int const>::type, void(*)(int const, void*, void*,void*)
+>));
+
+BOOST_MPL_ASSERT((boost::is_same<
+    with_ntp<int, float>::type, void(*)(int, float, void*,void*)
+>));
+
+BOOST_MPL_ASSERT((boost::is_same<
+    with_ntp<int, float, char>::type, void(*)(int, float, char,void*)
+>));
+
+BOOST_MPL_ASSERT((boost::is_same<
+    with_ntp<a0_is<int>, Y>::type, void(*)(int,void*,void*, Y)
+>));
+
+BOOST_MPL_ASSERT((boost::is_same<
+    with_ntp<int&, a2_is<char>, Y>::type, void(*)(int&,void*,char, Y)
+>));
+

test/optional_deduced_sfinae.cpp

@@ -0,0 +1,73 @@
+// 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)
+
+#include <boost/parameter/preprocessor.hpp>
+#include <boost/parameter/name.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <string>
+#include "basics.hpp"
+#include <boost/utility/enable_if.hpp>
+
+namespace test {
+
+namespace mpl = boost::mpl;
+
+using mpl::_;
+using boost::is_convertible;
+
+BOOST_PARAMETER_NAME(x)
+
+// Sun has problems with this syntax:
+//
+//   template1< r* ( template2<x> ) >
+//
+// Workaround: factor template2<x> into a separate typedef
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
+
+typedef is_convertible<_,char const*> predicate;
+
+BOOST_PARAMETER_FUNCTION((int), sfinae, tag,
+  (deduced
+     (optional (x, *(predicate), 0))
+  )
+)
+{
+    return 1;
+}
+
+#else
+
+BOOST_PARAMETER_FUNCTION((int), sfinae, tag,
+  (deduced
+     (optional (x, *(is_convertible<_,char const*>), 0))
+  )
+)
+{
+    return 1;
+}
+
+#endif
+
+template<class A0>
+typename boost::enable_if<boost::is_same<int,A0>, int>::type
+sfinae(A0 const& a0)
+{
+    return 0;
+}
+
+} // namespace test
+
+int main()
+{
+    using namespace test;
+
+    assert(sfinae() == 1);
+    assert(sfinae("foo") == 1);
+    assert(sfinae(1) == 0);
+
+    return 0;
+}
+

test/preprocessor.cpp

@@ -0,0 +1,482 @@
+// 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)
+
+#include <boost/parameter/preprocessor.hpp>
+#include <boost/parameter/keyword.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <string>
+#include "basics.hpp"
+
+#ifndef BOOST_NO_SFINAE
+# include <boost/utility/enable_if.hpp>
+#endif
+
+namespace test {
+
+BOOST_PARAMETER_BASIC_FUNCTION((int), f, tag,
+    (required
+      (tester, *)
+      (name, *)
+    )
+    (optional
+      (value, *)
+      (out(index), (int))
+    )
+)
+{
+    typedef typename boost::parameter::binding<
+        Args, tag::index, int&
+    >::type index_type;
+
+    BOOST_MPL_ASSERT((boost::is_same<index_type, int&>));
+
+    args[tester](
+        args[name]
+      , args[value | 1.f]
+      , args[index | 2]
+    );
+
+    return 1;
+}
+
+BOOST_PARAMETER_BASIC_FUNCTION((int), g, tag,
+    (required
+      (tester, *)
+      (name, *)
+    )
+    (optional
+      (value, *)
+      (out(index), (int))
+    )
+)
+{
+    typedef typename boost::parameter::binding<
+        Args, tag::index, int const&
+    >::type index_type;
+
+    BOOST_MPL_ASSERT((boost::is_same<index_type, int const&>));
+
+    args[tester](
+        args[name]
+      , args[value | 1.f]
+      , args[index | 2]
+    );
+
+    return 1;
+}
+
+BOOST_PARAMETER_FUNCTION((int), h, tag,
+    (required
+      (tester, *)
+      (name, *)
+    )
+    (optional
+      (value, *, 1.f)
+      (out(index), (int), 2)
+    )
+)
+{
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
+  && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    BOOST_MPL_ASSERT((boost::is_same<index_type, int>));
+# endif
+
+    tester(
+        name
+      , value
+      , index
+    );
+
+    return 1;
+}
+
+BOOST_PARAMETER_FUNCTION((int), h2, tag,
+    (required
+      (tester, *)
+      (name, *)
+    )
+    (optional
+      (value, *, 1.f)
+      (out(index), (int), (int)value * 2)
+    )
+)
+{
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
+  && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    BOOST_MPL_ASSERT((boost::is_same<index_type, int>));
+# endif
+
+    tester(
+        name
+      , value
+      , index
+    );
+
+    return 1;
+}
+
+struct base
+{
+    template <class Args>
+    base(Args const& args)
+    {
+        args[tester](
+            args[name]
+          , args[value | 1.f]
+          , args[index | 2]
+        );
+    }
+};
+
+struct class_ : base
+{
+    BOOST_PARAMETER_CONSTRUCTOR(class_, (base), tag,
+        (required
+          (tester, *)
+          (name, *)
+        )
+        (optional
+          (value, *)
+          (index, *)
+        )
+    )
+
+    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((int), f, tag,
+        (required
+          (tester, *)
+          (name, *)
+        )
+        (optional
+          (value, *)
+          (index, *)
+        )
+    )
+    {
+        args[tester](
+            args[name]
+          , args[value | 1.f]
+          , args[index | 2]
+        );
+
+        return 1;
+    }
+
+    BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION((int), f, tag,
+        (required
+          (tester, *)
+          (name, *)
+        )
+        (optional
+          (value, *)
+          (index, *)
+        )
+    )
+    {
+        args[tester](
+            args[name]
+          , args[value | 1.f]
+          , args[index | 2]
+        );
+
+        return 1;
+    }
+
+    BOOST_PARAMETER_MEMBER_FUNCTION((int), f2, tag,
+        (required
+          (tester, *)
+          (name, *)
+        )
+        (optional
+          (value, *, 1.f)
+          (index, *, 2)
+        )
+    )
+    {
+        tester(name, value, index);
+        return 1;
+    }
+
+    BOOST_PARAMETER_CONST_MEMBER_FUNCTION((int), f2, tag,
+        (required
+          (tester, *)
+          (name, *)
+        )
+        (optional
+          (value, *, 1.f)
+          (index, *, 2)
+        )
+    )
+    {
+        tester(name, value, index);
+        return 1;
+    }
+
+
+    BOOST_PARAMETER_MEMBER_FUNCTION((int), static f_static, tag,
+        (required
+          (tester, *)
+          (name, *)
+        )
+        (optional
+          (value, *, 1.f)
+          (index, *, 2)
+        )
+    )
+    {
+        tester(name, value, index);
+        return 1;
+    }
+};
+
+BOOST_PARAMETER_FUNCTION(
+    (int), sfinae, tag,
+    (required
+       (name, (std::string))
+    )
+)
+{
+    return 1;
+}
+
+#ifndef BOOST_NO_SFINAE
+// On compilers that actually support SFINAE, add another overload
+// that is an equally good match and can only be in the overload set
+// when the others are not.  This tests that the SFINAE is actually
+// working.  On all other compilers we're just checking that
+// everything about SFINAE-enabled code will work, except of course
+// the SFINAE.
+template<class A0>
+typename boost::enable_if<boost::is_same<int,A0>, int>::type
+sfinae(A0 const& a0)
+{
+    return 0;
+}
+#endif
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
+
+// Sun has problems with this syntax:
+//
+//   template1< r* ( template2<x> ) >
+//
+// Workaround: factor template2<x> into a separate typedef
+typedef boost::is_convertible<boost::mpl::_, std::string> predicate;
+
+BOOST_PARAMETER_FUNCTION(
+    (int), sfinae1, tag,
+    (required
+       (name, *(predicate))
+    )
+)
+{
+    return 1;
+}
+
+#else
+
+BOOST_PARAMETER_FUNCTION(
+    (int), sfinae1, tag,
+    (required
+       (name, *(boost::is_convertible<boost::mpl::_, std::string>))
+    )
+)
+{
+    return 1;
+}
+#endif 
+
+#ifndef BOOST_NO_SFINAE
+// On compilers that actually support SFINAE, add another overload
+// that is an equally good match and can only be in the overload set
+// when the others are not.  This tests that the SFINAE is actually
+// working.  On all other compilers we're just checking that
+// everything about SFINAE-enabled code will work, except of course
+// the SFINAE.
+template<class A0>
+typename boost::enable_if<boost::is_same<int,A0>, int>::type
+sfinae1(A0 const& a0)
+{
+    return 0;
+}
+#endif
+
+template <class T>
+T const& as_lvalue(T const& x)
+{
+    return x;
+}
+
+struct udt
+{
+    udt(int foo, int bar)
+      : foo(foo)
+      , bar(bar)
+    {}
+
+    int foo;
+    int bar;
+};
+
+BOOST_PARAMETER_FUNCTION((int), lazy_defaults, tag,
+    (required
+      (name, *)
+    )
+    (optional
+      (value, *, name.foo)
+      (index, *, name.bar)
+    )
+)
+{
+    return 0;
+}
+
+} // namespace test
+
+int main()
+{
+    using namespace test;
+
+    f(
+        values(S("foo"), 1.f, 2)
+      , S("foo")
+    );
+
+    f(
+        tester = values(S("foo"), 1.f, 2)
+      , name = S("foo")
+    );
+
+    int index_lvalue = 2;
+
+    f(
+        tester = values(S("foo"), 1.f, 2)
+      , name = S("foo")
+      , value = 1.f
+      , test::index = index_lvalue
+    );
+
+    f(
+        values(S("foo"), 1.f, 2)
+      , S("foo")
+      , 1.f
+      , index_lvalue
+    );
+
+    g(
+        values(S("foo"), 1.f, 2)
+      , S("foo")
+      , 1.f
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+      , as_lvalue(2)
+#else
+      , 2
+#endif
+    );
+
+    h(
+        values(S("foo"), 1.f, 2)
+      , S("foo")
+      , 1.f
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+      , as_lvalue(2)
+#else
+      , 2
+#endif
+    );
+
+    h2(
+        tester = values(S("foo"), 1.f, 2)
+      , name = S("foo")
+      , value = 1.f
+    );
+
+    class_ x(
+        values(S("foo"), 1.f, 2)
+      , S("foo"), test::index = 2
+    );
+
+    x.f(
+        values(S("foo"), 1.f, 2)
+      , S("foo")
+    );
+
+    x.f(
+        tester = values(S("foo"), 1.f, 2)
+      , name = S("foo")
+    );
+
+    x.f2(
+        values(S("foo"), 1.f, 2)
+      , S("foo")
+    );
+
+    x.f2(
+        tester = values(S("foo"), 1.f, 2)
+      , name = S("foo")
+    );
+
+    class_ const& x_const = x;
+
+    x_const.f(
+        values(S("foo"), 1.f, 2)
+      , S("foo")
+    );
+
+    x_const.f(
+        tester = values(S("foo"), 1.f, 2)
+      , name = S("foo")
+    );
+
+    x_const.f2(
+        values(S("foo"), 1.f, 2)
+      , S("foo")
+    );
+
+    x_const.f2(
+        tester = values(S("foo"), 1.f, 2)
+      , name = S("foo")
+    );
+
+    x_const.f2(
+        tester = values(S("foo"), 1.f, 2)
+      , name = S("foo")
+    );
+
+    class_::f_static(
+        values(S("foo"), 1.f, 2)
+      , S("foo")
+    );
+
+    class_::f_static(
+        tester = values(S("foo"), 1.f, 2)
+      , name = S("foo")
+    );
+
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+    assert(sfinae("foo") == 1);
+    assert(sfinae(1) == 0);
+
+# if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
+    // Sun actually eliminates the desired overload for some reason.
+    // Disabling this part of the test because SFINAE abilities are
+    // not the point of this test.
+    assert(sfinae1("foo") == 1);
+# endif
+    
+    assert(sfinae1(1) == 0);
+#endif
+
+    lazy_defaults(
+        name = udt(0,1)
+    );
+
+    lazy_defaults(
+        name = 0
+      , value = 1
+      , test::index = 2
+    );
+
+    return boost::report_errors();
+}
+

test/preprocessor_deduced.cpp

@@ -0,0 +1,171 @@
+// 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)
+
+#include <boost/parameter/preprocessor.hpp>
+#include <boost/parameter/name.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <string>
+#include "basics.hpp"
+
+#ifndef BOOST_NO_SFINAE
+# include <boost/utility/enable_if.hpp>
+#endif
+
+namespace test {
+
+namespace mpl = boost::mpl;
+
+using mpl::_;
+using boost::is_convertible;
+
+BOOST_PARAMETER_NAME(expected)
+BOOST_PARAMETER_NAME(x)
+BOOST_PARAMETER_NAME(y)
+BOOST_PARAMETER_NAME(z)
+
+// Sun has problems with this syntax:
+//
+//   template1< r* ( template2<x> ) >
+//
+// Workaround: factor template2<x> into a separate typedef
+typedef is_convertible<_, int> predicate1;
+typedef is_convertible<_, std::string> predicate2;
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
+
+BOOST_PARAMETER_FUNCTION((int), f, tag,
+    (required
+       (expected, *)
+    )
+    (deduced
+       (required
+          (x, *(predicate1))
+          (y, *(predicate2))
+       )
+    )
+)
+#else
+BOOST_PARAMETER_FUNCTION((int), f, tag,
+    (required
+       (expected, *)
+    )
+    (deduced
+       (required
+          (x, *(is_convertible<_, int>))
+          (y, *(is_convertible<_, std::string>))
+       )
+    )
+)
+#endif 
+{
+    assert(equal(x, boost::tuples::get<0>(expected)));
+    assert(equal(y, boost::tuples::get<1>(expected)));
+    return 1;
+}
+
+struct X 
+{
+    X(int x = -1)
+      : x(x)
+    {}
+    
+    bool operator==(X const& other) const
+    {
+        return x == other.x;
+    }
+    
+    int x;
+};
+
+typedef is_convertible<_, X> predicate3;  // SunPro workaround; see above
+
+BOOST_PARAMETER_FUNCTION((int), g, tag,
+    (required
+      (expected, *)
+    )
+    (deduced
+       (required
+          (x, *(is_convertible<_, int>))
+          (y, *(is_convertible<_, std::string>))
+       )
+       (optional
+          (z, *(predicate3), X())
+       )
+    )
+)
+{
+    assert(equal(x, boost::tuples::get<0>(expected)));
+    assert(equal(y, boost::tuples::get<1>(expected)));
+    assert(equal(z, boost::tuples::get<2>(expected)));
+    return 1;
+}
+
+BOOST_PARAMETER_FUNCTION(
+    (int), sfinae, tag,
+    (deduced
+      (required
+        (x, *(predicate2))
+      )
+    )
+)
+{
+    return 1;
+}
+
+#ifndef BOOST_NO_SFINAE
+// On compilers that actually support SFINAE, add another overload
+// that is an equally good match and can only be in the overload set
+// when the others are not.  This tests that the SFINAE is actually
+// working.  On all other compilers we're just checking that
+// everything about SFINAE-enabled code will work, except of course
+// the SFINAE.
+template<class A0>
+typename boost::enable_if<boost::is_same<int,A0>, int>::type
+sfinae(A0 const& a0)
+{
+    return 0;
+}
+#endif
+
+} // namespace test
+
+using boost::make_tuple;
+
+// make_tuple doesn't work with char arrays.
+char const* str(char const* s)
+{
+    return s;
+}
+
+int main()
+{
+    using namespace test;
+
+    f(make_tuple(0, str("foo")), _x = 0, _y = "foo");
+    f(make_tuple(0, str("foo")), _x = 0, _y = "foo");
+    f(make_tuple(0, str("foo")), 0, "foo");
+    f(make_tuple(0, str("foo")), "foo", 0);
+    f(make_tuple(0, str("foo")), _y = "foo", 0);
+    f(make_tuple(0, str("foo")), _x = 0, "foo");
+    f(make_tuple(0, str("foo")), 0, _y = "foo");
+
+    g(make_tuple(0, str("foo"), X()), _x = 0, _y = "foo");
+    g(make_tuple(0, str("foo"), X()), 0, "foo");
+    g(make_tuple(0, str("foo"), X()), "foo", 0);
+    g(make_tuple(0, str("foo"), X()), _y = "foo", 0);   
+    g(make_tuple(0, str("foo"), X()), _x = 0, "foo");
+    g(make_tuple(0, str("foo"), X()), 0, _y = "foo");
+
+    g(make_tuple(0, str("foo"), X(1)), 0, _y = "foo", X(1));
+    g(make_tuple(0, str("foo"), X(1)), X(1), 0, _y = "foo");
+
+#ifndef BOOST_NO_SFINAE
+    assert(sfinae("foo") == 1);
+    assert(sfinae(0) == 0);
+#endif
+
+    return 0;
+}
+

test/python_test.cpp

@@ -0,0 +1,172 @@
+// 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)
+
+#include <math.h>
+#include <boost/python.hpp>
+#include <boost/parameter/preprocessor.hpp>
+#include <boost/parameter/keyword.hpp>
+#include <boost/parameter/python.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace test {
+
+BOOST_PARAMETER_KEYWORD(tags, x)
+BOOST_PARAMETER_KEYWORD(tags, y)
+BOOST_PARAMETER_KEYWORD(tags, z)
+
+struct Xbase
+{
+    // We need the disable_if part for VC7.1/8.0.
+    template <class Args>
+    Xbase(
+        Args const& args
+      , typename boost::disable_if<
+            boost::is_base_and_derived<Xbase, Args>
+        >::type* = 0
+    )
+      : value(std::string(args[x | "foo"]) + args[y | "bar"])
+    {}
+
+    std::string value;
+};
+
+struct X : Xbase
+{
+    BOOST_PARAMETER_CONSTRUCTOR(X, (Xbase), tags,
+        (optional
+         (x, *)
+         (y, *)
+        )
+    )
+
+    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((int), f, tags,
+        (required
+         (x, *)
+         (y, *)
+        )
+        (optional
+         (z, *)
+        )
+    )
+    {
+        return args[x] + args[y] + args[z | 0];
+    }
+
+    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((std::string), g, tags,
+        (optional
+         (x, *)
+         (y, *)
+        )
+    )
+    {
+        return std::string(args[x | "foo"]) + args[y | "bar"];
+    }
+
+    BOOST_PARAMETER_MEMBER_FUNCTION((X&), h, tags,
+        (optional (x, *, "") (y, *, ""))
+    )
+    {
+        return *this;
+    }
+
+    template <class A0>
+    X& operator()(A0 const& a0)
+    {
+        return *this;
+    }
+};
+
+} // namespace test
+
+struct f_fwd
+{
+    template <class R, class T, class A0, class A1, class A2>
+    R operator()(boost::type<R>, T& self, A0 const& a0, A1 const& a1, A2 const& a2)
+    {
+        return self.f(a0,a1,a2);
+    }
+};
+
+struct g_fwd
+{
+    template <class R, class T, class A0, class A1>
+    R operator()(boost::type<R>, T& self, A0 const& a0, A1 const& a1)
+    {
+        return self.g(a0,a1);
+    }
+};
+
+struct h_fwd
+{
+    template <class R, class T>
+    R operator()(boost::type<R>, T& self)
+    {
+        return self.h();
+    }
+
+    template <class R, class T, class A0>
+    R operator()(boost::type<R>, T& self, A0 const& a0)
+    {
+        return self.h(a0);
+    }
+
+    template <class R, class T, class A0, class A1>
+    R operator()(boost::type<R>, T& self, A0 const& a0, A1 const& a1)
+    {
+        return self.h(a0,a1);
+    }
+};
+
+BOOST_PYTHON_MODULE(python_test_ext)
+{
+    namespace mpl = boost::mpl;
+    using namespace test;
+    using namespace boost::python;
+
+    class_<X>("X")
+        .def(
+            boost::parameter::python::init<
+                mpl::vector<
+                    tags::x*(std::string), tags::y*(std::string)
+                >
+            >()
+        )
+        .def(
+            "f"
+          , boost::parameter::python::function<
+                f_fwd
+              , mpl::vector<
+                    int, tags::x(int), tags::y(int), tags::z*(int)
+                >
+            >()
+        )
+        .def(
+            "g"
+          , boost::parameter::python::function<
+                g_fwd
+              , mpl::vector<
+                    std::string, tags::x*(std::string), tags::y*(std::string)
+                >
+            >()
+        )
+        .def(
+            "h"
+          , boost::parameter::python::function<
+                h_fwd
+              , mpl::vector<
+                    X&, tags::x**(std::string), tags::y**(std::string)
+                >
+            >()
+          , return_arg<>()
+        )
+        .def(
+            boost::parameter::python::call<
+                mpl::vector<
+                    X&, tags::x(int)
+                >
+            >() [ return_arg<>() ]
+        )
+        .def_readonly("value", &X::value);
+}
+

test/python_test.py

@@ -0,0 +1,41 @@
+# Copyright Daniel Wallin 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)
+
+'''
+>>> from python_test_ext import X
+>>> x = X(y = 'baz')
+>>> x.value
+'foobaz'
+>>> x.f(1,2)
+3
+>>> x.f(1,2,3)
+6
+>>> x.f(1,2, z = 3)
+6
+>>> x.f(z = 3, y = 2, x = 1)
+6
+>>> x.g()
+'foobar'
+>>> x.g(y = "baz")
+'foobaz'
+>>> x.g(x = "baz")
+'bazbar'
+>>> x.g(y = "foo", x = "bar")
+'barfoo'
+>>> y = x.h(x = "bar", y = "foo")
+>>> assert x == y
+>>> y = x(0)
+>>> assert x == y
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, python_test 
+    return doctest.testmod(python_test)
+
+if __name__ == '__main__':
+    import sys
+    sys.exit(run()[0])

test/sfinae.cpp

@@ -5,12 +5,11 @@
 
 #include <boost/parameter.hpp>
 #include <boost/parameter/match.hpp>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <string>
 #include <boost/type_traits/is_convertible.hpp>
-#include <iostream>
 
-#ifndef BOOST_NO_SFINAE
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
 # include <boost/utility/enable_if.hpp>
 # include <boost/type_traits/is_same.hpp>
 #endif 
@@ -35,16 +34,19 @@ namespace test
       >
   {};
 
-  template <class T> struct not_implemented;
+  // The use of assert_equal_string is just a nasty workaround for a
+  // vc++ 6 ICE.
+  void assert_equal_string(std::string x, std::string y)
+  {
+        BOOST_TEST(x == y);
+  }
   
   template<class P>
   void f_impl(P const& p)
   {
-      std::string s = p[name | "bar"];
       float v = p[value | 3.f];
-
-      assert(s == "foo");
-      assert(v == 3.f);
+      BOOST_TEST(v == 3.f);
+      assert_equal_string(p[name | "bar"], "foo");
   }
 
   void f()
@@ -52,8 +54,6 @@ namespace test
       f_impl(f_parameters()());
   }
 
-  using boost::parameter::aux::void_;
-  
   template<class A0>
   void f(
       A0 const& a0
@@ -70,7 +70,7 @@ namespace test
       f_impl(args(a0, a1));
   }
 
-#ifndef BOOST_NO_SFINAE
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
   // On compilers that actually support SFINAE, add another overload
   // that is an equally good match and can only be in the overload set
   // when the others are not.  This tests that the SFINAE is actually
@@ -96,10 +96,9 @@ int main()
     f("foo", 3.f);
     f(value = 3.f, name = "foo");
 
-#ifndef BOOST_NO_SFINAE
-    return f(3, 4);
-#else 
-    return 0;
-#endif 
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+    BOOST_TEST(f(3, 4) == 0);
+#endif
+    return boost::report_errors();
 }
 

test/singular.cpp

@@ -0,0 +1,42 @@
+// 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/parameter/keyword.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+BOOST_PARAMETER_KEYWORD(tag, x)
+BOOST_PARAMETER_KEYWORD(tag, y)
+    
+struct default_src
+{
+    typedef int result_type;
+
+    int operator()() const
+    {
+        return 0;
+    }
+};
+    
+template <class ArgumentPack, class K, class T>
+void check(ArgumentPack const& p, K const& kw, T const& value)
+{
+    BOOST_TEST(p[kw] == value);
+}
+
+int main()
+{
+    check(x = 20, x, 20);
+    check(y = 20, y, 20);
+
+    check(x = 20, x | 0, 20);
+    check(y = 20, y | 0, 20);
+
+    check(x = 20, x | default_src(), 20);
+    check(y = 20, y | default_src(), 20);
+    
+    check(y = 20, x | 0, 0);
+    check(y = 20, x || default_src(), 0);
+    return boost::report_errors();
+}
+

test/unnamed.cpp

@@ -1,75 +0,0 @@
-// Copyright David Abrahams, Daniel Wallin 2003. 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/parameter.hpp>
-#include <boost/parameter/match.hpp>
-#include <cassert>
-#include <boost/bind.hpp>
-#include <boost/ref.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <string>
-
-namespace test
-{
-  using namespace boost::parameter;
-  namespace mpl = boost::mpl;
-
-  BOOST_PARAMETER_KEYWORD(tag, name)
-  BOOST_PARAMETER_KEYWORD(tag, value)
-
-  struct g_parameters
-    : parameters<
-          unnamed<tag::name, boost::is_convertible<mpl::_, std::string> >
-        , unnamed<tag::value, boost::is_convertible<mpl::_, float> >
-      >
-  {};
-
-
-  // Keeping this out here avoids an ICE with vc-6.x
-  std::string const foo("foo");
-  
-  template<class Params>
-  int g_(Params const& p)
-  {
-      assert(p[name] == foo);
-      assert(p[value] == 3.14f);
-      return 1;
-  }
-  
-  template<class A0>
-  int g(A0 const& a0, BOOST_PARAMETER_MATCH(g_parameters, (A0), args))
-  {
-      return g_(args(a0));
-  }
-  
-  template<class A0, class A1>
-  int g(A0 const& a0, A1 const& a1, BOOST_PARAMETER_MATCH(g_parameters, (A0)(A1), args))
-  {
-      return g_(args(a0, a1));
-  }
-
-}
-
-#include <typeinfo>
-#include <iostream>
-
-int main()
-{
-   using test::g;
-   using test::name;
-   using test::value;
-
-   g("foo", 3.14f);
-   g(3.14f, "foo");
-
-   g(value = 3.14f, "foo");
-   g(name = "foo", 3.14f);
-   g(3.14f, name = "foo");
-   g(name = "foo", value = 3.14f);
-   
-   return 0;
-}
-