# The Boost Parameter Library Reference Documentation

Authors: | David Abrahams Daniel Wallin
Contact: | dave@boost-consulting.com, daniel@boostpro.com
Organization: | BoostPro Computing
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)

Contents

# 1 Preliminaries

This section covers some basic information you'll need to know in order to understand this reference.

## 1.1 Namespaces

In this document, all unqualified identifiers should be assumed to be defined in namespace `boost::parameter` unless otherwise specified.

## 1.2 Exceptions

No operation described in this document throws an exception unless otherwise specified.

## 1.3 Thread Safety

All components of this library can be used safely from multiple threads without synchronization.1

## 1.4 Typography

Names written in sans serif type represent concepts.

In code blocks, italic type represents unspecified text that satisfies the requirements given in the detailed description that follows the code block.

In a specification of the tokens generated by a macro, bold type is used to highlight the position of the expanded macro argument in the result.

The special character β represents the value of `BOOST_PARAMETER_MAX_ARITY`.

# 2 Terminology

keyword
  The name of a function parameter.

keyword tag type
  A type used to uniquely identify a function parameter. Typically its name will be the same as that of the parameter.

positional argument
  An argument passed with no explicit keyword. Its parameter is determined in the usual C++ way: by position with respect to a parameter list.

tag type
  Shorthand for “keyword tag type.”

keyword object
  An instance of `keyword``<T>` for some tag type `T`.

tagged reference

  An object whose type is associated with a keyword tag type (the object's keyword), and that holds a reference (to the object's value).

  As a shorthand, a “tagged reference to `x`” means a tagged reference whose value is `x`.

tagged default
  A tagged reference whose value represents the value of a default argument.

tagged lazy default
  A tagged reference whose value, when invoked with no arguments, computes a default argument value.

intended argument type
  The intended argument type of a single-element ArgumentPack is the type of its element's value. The intended argument type of any other type `X` is `X` itself.

Note

In this reference, we will use concept names (and other names) to describe both types and objects, depending on context. So for example, “an ArgumentPack” can refer to a type that models ArgumentPack or an object of such a type.

# 3 Concepts

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

## 3.1 ArgumentPack

An ArgumentPack is a collection of tagged references to the actual arguments passed to a function. Every ArgumentPack is also a valid MPL Forward Sequence and MPL Associative Sequence consisting of the keyword tag types in its tagged references. If `BOOST_PARAMETER_CAN_USE_MP11` is defined, then every ArgumentPack is also a valid Boost.MP11 map whose keys are keyword tag types. The singular.cpp, compose.cpp, and mpl.cpp test programs demonstrate this functionality.

### Requirements

In the table below,

- `A` is a model of ArgumentPack
- `x` is an instance of `A`
- `u` is a keyword object of type `K`
- `v` is a tagged default with tag type `L` and value of type `D`
- `w` is a tagged lazy default with tag type `M` and value of type `E const`
- `z` is an ArgumentPack containing a single element (as created by `keyword``<…>::operator=`)

Any exceptions thrown from the invocation of `w`'s value will be propagated to the caller.

ArgumentPack requirements
Expression | Type | Requirements | Semantics/Notes
--- | --- | --- | ---
`x[u]` | `binding<A, K>::type` | `x` contains an element b whose keyword is `K` | Returns b's value (by reference).
`x[u]` | `binding<A, L, D>::type` | none | If `x` contains an element b whose keyword is the same as `u`'s, returns b's value (by reference). Otherwise, returns `u`'s value.
`x[w]` | `lazy_binding<A, M, E>::type` | none | If `x` contains an element b whose keyword is the same as `w`'s, returns b's value (by reference). Otherwise, invokes `w`'s value and returns the result.
`x, z` | Model of ArgumentPack | none | Returns an ArgumentPack containing all the elements of both `x` and `z`.

## 3.2 ParameterSpec

A ParameterSpec describes the type requirements for arguments corresponding to a given keyword and indicates whether the argument is optional or required. The table below details the allowed forms and describes their condition for satisfaction by an actual argument type. In each row,

- `K` is the ParameterSpec's keyword tag type
- `A` is an intended argument type associated with `K`, if any
- `P` is a model of ArgumentPack that contains `A`
- `F` is an MPL Binary Metafunction Class

ParameterSpec allowed forms and conditions of satisfaction
Type | `A` required | Condition `A` must satisfy
--- | --- | ---
`K` | no | n/a
`optional``<K,F>` | no | `mpl::apply2<F,A,P>::type::value` is `true`.
`required``<K,F>` | yes | `mpl::apply2<F,A,P>::type::value` is `true`.

The information in a ParameterSpec is used to limit the arguments that will be matched by forwarding functions.

# 4 Class Templates

## 4.1 `keyword`

The type of every keyword object is a specialization of `keyword`.

Defined in: | boost/parameter/keyword.hpp

    template <typename Tag>
    struct keyword
    {
        typedef Tag tag;

        template <typename T>
        constexpr typename boost::enable_if<
            typename boost::mpl::eval_if<
                boost::is_scalar<T>
              , mpl::true_ // Enable this overload for scalar types.
              , boost::mpl::eval_if<
                    boost::is_same<
                        typename Tag::qualifier
                      , boost::parameter::in_reference
                    >
                  , mpl::true_ // Enable this overload for "in" references.
                  , mpl::if_<
                        boost::is_same<
                            typename Tag::qualifier
                          , boost::parameter::forward_reference
                        >
                      , mpl::true_ // Enable this overload for "forward" references.
                      , mpl::false_ // Disable this overload for all other reference categories.
                    >
                >
            >::type
          , ArgumentPack
        >::type
            operator=(T const& value) const;

        template <typename T>
        constexpr typename boost::enable_if<
            typename boost::mpl::eval_if<
                typename boost::mpl::eval_if<
                    boost::is_same<
                        typename Tag::qualifier
                      , boost::parameter::out_reference
                    >
                  , mpl::true_ // The reference category is "out".
                  , mpl::if_<
                        boost::is_same<
                            typename Tag::qualifier
                          , boost::parameter::forward_reference
                        >
                      , mpl::true_ // The reference category is "forward".
                      , mpl::false_ // The reference category is neither "out" nor "forward".
                    >
                >::type
              , mpl::if_<
                    boost::is_const<T>
                  , mpl::false_ // Disable this overload for reference-to-const types.
                  , mpl::true_ // Enable this overload for referece-to-mutable types.
                >
              , mpl::false_ // Disable this overload for references neither "out" nor "forward".
            >::type
          , ArgumentPack
        >::type
            operator=(T& value) const;

        template <typename T>
        constexpr typename boost::enable_if<
            typename boost::mpl::eval_if<
                boost::is_scalar<T>
              , mpl::false_ // Disable this overload for scalar types.
              , boost::mpl::eval_if<
                    boost::is_same<
                        typename Tag::qualifier
                      , boost::parameter::in_reference
                    >
                  , mpl::true_ // Enable this overload for "in" references.
                  , mpl::if_<
                        boost::is_same<
                            typename Tag::qualifier
                          , boost::parameter::forward_reference
                        >
                      , mpl::true_ // Enable this overload for "forward" references.
                      , mpl::false_ // Disable this overload for all other reference categories.
                    >
                >
            >::type
          , ArgumentPack
        >::type
            operator=(T const&& value) const;

        template <typename T>
        constexpr typename boost::enable_if<
            typename boost::mpl::eval_if<
                boost::is_scalar<T>
              , mpl::false_ // Disable this overload for scalar types.
              , boost::mpl::eval_if<
                    boost::is_same<
                        typename Tag::qualifier
                      , boost::parameter::consume_reference
                    >
                  , mpl::true_ // Enable this overload for "consume" references.
                  , mpl::if_<
                        boost::is_same<
                            typename Tag::qualifier
                          , boost::parameter::forward_reference
                        >
                      , mpl::true_ // Enable this overload for "forward" references.
                      , mpl::false_ // Disable this overload for all other reference categories.
                    >
                >
            >::type
          , ArgumentPack
        >::type
            operator=(T&& value) const;

        template <typename T>
        constexpr typename boost::enable_if<
            typename boost::mpl::eval_if<
                boost::is_scalar<T>
              , mpl::true_ // Enable this overload for scalar types.
              , boost::mpl::eval_if<
                    boost::is_same<
                        typename Tag::qualifier
                      , boost::parameter::in_reference
                    >
                  , mpl::true_ // Enable this overload for "in" references.
                  , mpl::if_<
                        boost::is_same<
                            typename Tag::qualifier
                          , boost::parameter::forward_reference
                        >
                      , mpl::true_ // Enable this overload for "forward" references.
                      , mpl::false_ // Disable this overload for all other reference categories.
                    >
                >
            >::type
          , tagged default
        >::type
            operator|(T const& x) const;

        template <typename T>
        constexpr typename boost::enable_if<
            typename boost::mpl::eval_if<
                typename boost::mpl::eval_if<
                    boost::is_same<
                        typename Tag::qualifier
                      , boost::parameter::out_reference
                    >
                  , mpl::true_ // The reference category is "out".
                  , mpl::if_<
                        boost::is_same<
                            typename Tag::qualifier
                          , boost::parameter::forward_reference
                        >
                      , mpl::true_ // The reference category is "forward".
                      , mpl::false_ // The reference category is neither "out" nor "forward".
                    >
                >::type
              , mpl::if_<
                    boost::is_const<T>
                  , mpl::false_ // Disable this overload for reference-to-const types.
                  , mpl::true_ // Enable this overload for referece-to-mutable types.
                >
              , mpl::false_ // Disable this overload for references neither "out" nor "forward".
            >::type
          , tagged default
        >::type
            operator|(T& x) const;

        template <typename T>
        constexpr typename boost::enable_if<
            typename boost::mpl::eval_if<
                boost::is_scalar<T>
              , mpl::false_ // Disable this overload for scalar types.
              , boost::mpl::eval_if<
                    boost::is_same<
                        typename Tag::qualifier
                      , boost::parameter::in_reference
                    >
                  , mpl::true_ // Enable this overload for "in" references.
                  , mpl::if_<
                        boost::is_same<
                            typename Tag::qualifier
                          , boost::parameter::forward_reference
                        >
                      , mpl::true_ // Enable this overload for "forward" references.
                      , mpl::false_ // Disable this overload for all other reference categories.
                    >
                >
            >::type
          , tagged default
        >::type
            operator|(T const&& x) const;

        template <typename T>
        constexpr typename boost::enable_if<
            typename boost::mpl::eval_if<
                boost::is_scalar<T>
              , mpl::false_ // Disable this overload for scalar types.
              , boost::mpl::eval_if<
                    boost::is_same<
                        typename Tag::qualifier
                      , boost::parameter::consume_reference
                    >
                  , mpl::true_ // Enable this overload for "consume" references.
                  , mpl::if_<
                        boost::is_same<
                            typename Tag::qualifier
                          , boost::parameter::forward_reference
                        >
                      , mpl::true_ // Enable this overload for "forward" references.
                      , mpl::false_ // Disable this overload for all other reference categories.
                    >
                >
            >::type
          , tagged default
        >::type constexpr
            operator|(T&& value) const;

        template <typename F>
        constexpr tagged lazy default operator||(F const&) const;

        template <typename F>
        constexpr tagged lazy default operator||(F&) const;

        static keyword<Tag> const& instance;

        static keyword<Tag>& get();
    };

`operator=`

Synopsis: |

    template <typename T>
    constexpr ArgumentPack operator=(T const& value) const;

    template <typename T>
    constexpr ArgumentPack operator=(T& value) const;

    template <typename T>
    constexpr ArgumentPack operator=(T const&& value) const;

    template <typename T>
    constexpr ArgumentPack operator=(T&& value) const;

Requires: | one of the following:

- The nested `qualifier` type of `Tag` must be `forward_reference`.
- To use the `const` lvalue reference overload, `T` must be scalar, or the nested `qualifier` type of `Tag` must be `in_reference`.
- To use the mutable lvalue reference overload, the nested `qualifier` type of `Tag` must be `out_reference` or `in_out_reference`, and `T` must not be `const`-qualified.
- To use the `const` rvalue reference overload for non-scalar `T`, the nested `qualifier` type of `Tag` must be `in_reference`.
- To use the mutable rvalue reference overload for non-scalar `T`, the nested `qualifier` type of `Tag` must be `consume_reference` or `move_from_reference`.

Returns: | an ArgumentPack containing a single tagged reference to `value` with keyword `Tag`

`operator|`

Synopsis: |

    template <typename T>
    constexpr tagged default operator|(T const& x) const;

    template <typename T>
    constexpr tagged default operator|(T& x) const;

    template <typename T>
    constexpr tagged default operator|(T const&& x) const;

    template <typename T>
    constexpr tagged default operator|(T&& x) const;

Requires: | one of the following:

- The nested `qualifier` type of `Tag` must be `forward_reference`.
- To use the `const` lvalue reference overload, `T` must be scalar, or the nested `qualifier` type of `Tag` must be `in_reference`.
- To use the mutable lvalue reference overload, the nested `qualifier` type of `Tag` must be `out_reference` or `in_out_reference`, and `T` must not be `const`-qualified.
- To use the `const` rvalue reference overload for non-scalar `T`, the nested `qualifier` type of `Tag` must be `in_reference`.
- To use the mutable rvalue reference overload for non-scalar `T`, the nested `qualifier` type of `Tag` must be `consume_reference` or `move_from_reference`.

Returns: | a tagged default with value `x` and keyword `Tag`.

`operator||`

Synopsis: |

    template <typename F>
    constexpr tagged lazy default operator||(F const& g) const;

    template <typename F>
    constexpr tagged lazy default operator||(F& g) const;

Requires: | `g()` must be valid, with type `boost::result_of``<F()>::type`.2
Returns: | a tagged lazy default with value `g` and keyword `Tag`.

`instance`

Synopsis: |

    static keyword<Tag> const& instance;

Returns: | a “singleton instance”: the same object will be returned on each invocation of `instance`.
Thread Safety: | `instance` can be accessed from multiple threads simultaneously.

`get`

Synopsis: |

    static keyword<Tag>& get();

Deprecated

This function has been deprecated in favor of `instance`.

Returns: | a “singleton instance”: the same object will be returned on each invocation of `get()`.
Thread Safety: | `get()` can be called from multiple threads simultaneously.

## 4.2 `template_keyword`

This class template encapsulates a named template parameter. Every type generated by the `BOOST_PARAMETER_TEMPLATE_KEYWORD` macro is a specialization of `template_keyword`.

Defined in: | boost/parameter/template_keyword.hpp

    template <typename Tag, typename T>
    struct template_keyword
    {
        typedef Tag key_type;
        typedef T value_type;
        typedef implementation defined reference;
    };

The test/ntp.cpp test program demonstrates proper usage of this class template.

## 4.3 `parameters`

Provides an interface for assembling the actual arguments to a forwarding function into an ArgumentPack, in which any positional arguments will be tagged according to the corresponding template argument to `parameters`.

Defined in: | boost/parameter/parameters.hpp

    template <typename ...PSpec>
    struct parameters
    {
        template <typename ...Args>
        struct match
        {
            typedef … type;
        };

        template <typename ...Args>
        ArgumentPack operator()(Args&&... args) const;
    };

Requires: | Each element in the `PSpec` parameter pack must be a model of ParameterSpec.

Note

In this section, `R` ## i and `K` ## i are defined as follows, for any argument type `A` ## i:

let `D0` the set [d0, …, d ## j] of all deduced
parameter specs in the `PSpec` parameter pack
`R` ## i is the intended argument type of `A` ## i
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 the keyword tag type of `d` ## j.
`D`i+1 is `D` ## i - [ `d` ## j]
else
`K` ## i is the keyword tag type of `P` ## i.

`match`
  A Metafunction used to remove a forwarding function from overload resolution.

Returns: | if all elements in `Params...` are satisfied (see below), then `parameters<Params...>`. Otherwise, `match<Args...>::type` is not defined.

Each element `P` in `Params...` is satisfied if either:

- `P` is the unspecified default
- or, `P` is a keyword tag type
- or, `P` is `optional` `<X,F>` and either
    - `X` is not `K` ## i for any i,
    - or `X` is some `K` ## i and `mpl::apply<F,R` ## i
        `>::type::value` is `true`
- or, `P` is `required` `<X,F>`, and
    - `X` is some `K` ## i, and
    - `mpl::apply<F,R` ## i `>::type::value` is `true`

`operator()`

Synopsis: |

    template <typename ...Args>
    ArgumentPack operator()(Args&&... args) const;

Returns: | An ArgumentPack containing, for each `a` ## i, if `a` ## i is a single-element ArgumentPack, its element Otherwise, a tagged reference with keyword `K` ## i and value `a` ## i

## 4.4 `optional`, `required`

These templates describe the requirements on a function parameter.

`optional` is defined in: boost/parameter/optional.hpp

`required` is defined in: boost/parameter/required.hpp

Both headers are included by: boost/parameter/preprocessor.hpp

Specializations model:
| ParameterSpec

    template <typename Tag, typename Predicate = unspecified>
    struct optional;

    template <typename Tag, typename Predicate = unspecified>
    struct required;

The default value of `Predicate` is an unspecified MPL Binary Metafunction Class that returns `mpl::true_` for any argument. If `BOOST_PARAMETER_CAN_USE_MP11` is defined, then the default value of `Predicate` is also a Boost.MP11-style quoted metafunction that returns `mp11::mp_true` for any argument.

## 4.5 `deduced`

This template is used to wrap the keyword tag argument to `optional` or `required`.

Defined in: | boost/parameter/deduced.hpp
Included by: | boost/parameter/preprocessor.hpp

    template <typename Tag>
    struct deduced;

Requires: | nothing

# 5 Metafunctions

A Metafunction is conceptually a function that operates on, and returns, C++ types.

## 5.1 `binding`

Returns the result type of indexing an argument pack with a keyword tag type or with a tagged default.

Defined in: | boost/parameter/binding.hpp

    template <typename A, typename K, typename D = void_>
    struct binding
    {
        typedef … type;
    };

Requires: | `A` must be a model of ArgumentPack.
Returns: | the reference type of the tagged reference in `A` having keyword tag type `K`, if any. If no such tagged reference exists, returns `D`.

## 5.2 `lazy_binding`

Returns the result type of indexing an argument pack with a tagged lazy default.

Defined in: | boost/parameter/binding.hpp

    template <typename A, typename K, typename F>
    struct lazy_binding
    {
        typedef … type;
    };

Requires: | `A` must be a model of ArgumentPack.
Returns: | the reference type of the tagged reference in `A` having keyword tag type `K`, if any. If no such tagged reference exists, returns `boost::result_of``<F()>::type`.2

## 5.3 `value_type`

Returns the result type of indexing an argument pack with a keyword tag type or with a tagged default.

Defined in: | boost/parameter/value_type.hpp

    template <typename A, typename K, typename D = void_>
    struct value_type
    {
        typedef … type;
    };

Requires: | `A` must be a model of ArgumentPack.
Returns: | the (possibly const-qualified) 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 boost::remove_reference<
        typename binding<A, K, D>::type
    >::type
… when `D` is not a reference type.

## 5.4 `lazy_value_type`

Returns the result type of indexing an argument pack with a tagged lazy default.

Defined in: | boost/parameter/value_type.hpp

    template <typename A, typename K, typename F>
    struct lazy_value_type
    {
        typedef … type;
    };

Requires: | `A` must be a model of ArgumentPack.
Returns: | the (possibly const-qualified) type of the tagged reference in `A` having keyword tag type `K`, if any. If no such tagged reference exists, returns `boost::result_of``<F()>::type`.2

## 5.5 `are_tagged_arguments`

Defined in: | boost/parameter/are_tagged_arguments.hpp

    template <typename T0, typename ...Pack>
    struct are_tagged_arguments
        // : mpl::true_ if T0 and all elements in Pack are
        // tagged reference types, mpl::false_ otherwise.
    {
    };

Returns: | `mpl::true_` if `T0` and all elements in parameter pack `Pack` are tagged reference types, `mpl::false_` otherwise.
Example usage: |

When implementing a Boost.Parameter-enabled constructor for a container that conforms to the C++ standard, one needs to remember that the standard requires the presence of other constructors that are typically defined as templates, such as range constructors. To avoid overload ambiguities between the two constructors, use this metafunction in conjunction with `disable_if` to define the range constructor.

    template <typename B>
    class frontend : public B
    {
        struct _enabler
        {
        };

     public:
        BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR(frontend, (B))

        template <typename Iterator>
        frontend(
            Iterator itr
          , Iterator itr_end
          , typename boost::disable_if<
                are_tagged_arguments<Iterator>
              , _enabler
            >::type = _enabler()
        ) : B(itr, itr_end)
        {
        }
    };

## 5.6 `is_argument_pack`

Defined in: | boost/parameter/is_argument_pack.hpp

    template <typename T>
    struct is_argument_pack
        // : mpl::true_ if T is a model of ArgumentPack,
        // mpl::false_ otherwise.
    {
    };

Returns: | `mpl::true_` if `T` is a model of ArgumentPack, `mpl::false_` otherwise.
Example usage: |

To avoid overload ambiguities between a constructor that takes in an ArgumentPack and a templated conversion constructor, use this metafunction in conjunction with `enable_if`.

    BOOST_PARAMETER_NAME(a0)

    template <typename T>
    class backend0
    {
        struct _enabler
        {
        };

        T a0;

     public:
        template <typename ArgPack>
        explicit backend0(
            ArgPack const& args
          , typename boost::enable_if<
                is_argument_pack<ArgPack>
              , _enabler
            >::type = _enabler()
        ) : a0(args[_a0])
        {
        }

        template <typename U>
        backend0(
            backend0<U> const& copy
          , typename boost::enable_if<
                boost::is_convertible<U,T>
              , _enabler
            >::type = _enabler()
        ) : a0(copy.get_a0())
        {
        }

        T const& get_a0() const
        {
            return this->a0;
        }
    };

## 5.7 `result_of::compose`

Returns the result type of the `compose` function.

Defined in: | boost/parameter/compose.hpp

    template <typename ...TaggedArgs>
    struct compose
      : boost::enable_if<
            are_tagged_arguments<T0,Pack...>
          , ArgumentPack
        >
    {
    };

    template <>
    struct compose<>
    {
        typedef empty ArgumentPack type;
    };

Requires: | All elements in `TaggedArgs` must be tagged reference types, if specified.
Returns: | the result type of the `compose` function.

# 6 Function Templates

## 6.1 `compose`

Defined in: | boost/parameter/compose.hpp

    template <typename ...Pack>
    constexpr typename result_of::compose<Pack...>::type
        compose(Pack const&... args);

This function facilitates easier variadic argument composition. It is used by the `BOOST_PARAMETER_NO_SPEC_FUNCTION`, `BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION`, `BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION`, `BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR`, `BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR`, `BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR`, and `BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR` code generation macros. You can use it to write your own code generation macros if the ones provided by this library do not suffice.

Unlike the tagged reference comma operator, the `compose()` function is variadic, as mentioned before. However, the tagged reference comma operator can be invoked indefinitely and therefore does not limit the size of the resulting ArgumentPack, while the `compose()` function cannot take in more than `BOOST_PARAMETER_COMPOSE_MAX_ARITY` arguments for compilers that do not support perfect forwarding.

Requires: | All elements in `args` must be tagged reference objects, if specified.
Returns: | an ArgumentPack containing all elements in `args`, if specified; an empty ArgumentPack otherwise.
Example usage: |

    BOOST_PARAMETER_NAME(index)
    BOOST_PARAMETER_NAME(name)

    template <typename ArgumentPack>
    int print_name_and_index(ArgumentPack const& args)
    {
        std::cout << "index = " << args[_index];
        std::cout << "name = " << args[_name];
        std::cout << "; " << std::endl;
        return 0;
    }

    int y = print_name_and_index(compose(_index = 3, _name = "jones"));

The compose.cpp test program shows more examples using this function.

# 7 Code Generation Macros

Macros in this section can be used to ease the writing of code using the Parameter library by eliminating repetitive boilerplate.

## 7.1 `BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, arguments)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a function that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `kw` in this case. The identifiers with leading underscores can be passed to the bracket operator of `args` to extract the same argument to which the corresponding named parameter (without underscores) is bound, as will be shown later.

    BOOST_PARAMETER_NAME((_lrc, kw) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw) consume(rr))

Use the macro as a substitute for a normal function header. Enclose the return type `bool` in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. Otherwise, just as with a normal function, the order in which you specify the parameters determines their position. Also, just as with a normal function, optional parameters have default values, whereas required parameters do not. Within the function body, either simply use the parameter name or pass the matching identifier with the leading underscore to the bracket operator of `args` to extract the corresponding argument. Note that the second method doesn't require `std::forward` to preserve value categories.

    BOOST_PARAMETER_FUNCTION((bool), evaluate, kw,
        (deduced
            (required
                (lrc, (std::bitset<1>))
                (lr, (std::bitset<2>))
            )
            (optional
                (rrc, (std::bitset<3>), rvalue_const_bitset<2>())
                (rr, (std::bitset<4>), rvalue_bitset<3>())
            )
        )
    )
    {
        BOOST_TEST_EQ(
            passed_by_lvalue_reference_to_const
          , U::evaluate_category<0>(lrc)
        );
        BOOST_TEST_EQ(
            passed_by_lvalue_reference
          , U::evaluate_category<1>(lr)
        );
        BOOST_TEST_EQ(
            passed_by_rvalue_reference_to_const
          , U::evaluate_category<2>(std::forward<rrc0_type>(rrc0))
        );
        BOOST_TEST_EQ(
            passed_by_rvalue_reference
          , U::evaluate_category<3>(args[_rr0])
        );

        return true;
    }

The following function calls are legal.

    evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
      , rvalue_bitset<3>()
    );
    evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
    );
    evaluate((  // composed arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    ));
    evaluate(  // named arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    evaluate(  // named arguments
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

Because the parameters were wrapped in a `(deduced …)` clause, the following function calls are also legal.

    evaluate(  // deduced arguments
        rvalue_bitset<3>()
      , lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
    );
    evaluate(  // deduced arguments
        lvalue_bitset<1>()
      , lvalue_const_bitset<0>()
    );

The preprocessor.cpp, preprocessor_deduced.cpp, and preprocessor_eval_category.cpp test programs demonstrate proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function.
- `name` is the base name of the function; it determines the name of the generated forwarding functions.
- `tag_namespace` is the namespace in which the keywords used by the function resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                optional-specifier {optional-specifier}
            ')'
        ) | (
            '(' 'required'
                required-specifier {required-specifier}
            ')'
        )

    optional-specifier ::=
        '('
            argument-name ',' restriction ',' default-value
        ')'

    required-specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `default-value` is any valid C++ expression; if necessary, user code can compute it in terms of `previous-name ## _type`, where `previous-name` is the `argument-name` in a previous `specifier-group0` or `specifier-group1`. This expression will be invoked exactly once.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type. If `restriction` uses this form, then the type of the generated name `argument-name ## _type` will be computed in terms of the target type, and the generated reference `argument-name` (but not its corresponding entry in `args`) will be cast to that type.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_ ## __LINE__ ## name = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_ ## __LINE__ ## name
    {
        typedef result type;
    };

    struct boost_param_params_ ## __LINE__ ## name
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_ ## __LINE__ ## name
        boost_param_parameters_ ## __LINE__ ## name;

    template <typename Args>
    typename boost_param_result_ ## __LINE__ ## name<Args>::type
        boost_param_impl ## __LINE__ ## name(Args const&);

    template <typename A0, …, typename A ## n>
    result name(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_ ## __LINE__ ## name
        ::match<A0, …, A ## n>::type
        = boost_param_parameters_ ## __LINE__ ## name()
    )
    {
        return boost_param_impl ## __LINE__ ## name(
            boost_param_parameters_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result name(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_ ## __LINE__ ## name
        ::match<A0, …, A ## m>::type
        = boost_param_parameters_ ## __LINE__ ## name()
    )
    {
        return boost_param_impl ## __LINE__ ## name(
            boost_param_parameters_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## n ## _type
    >
    ResultType
        boost_param_dispatch_0boost_ ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## n ## _type&& argument name ## m
        );

    ⋮

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## m ## _type
    >
    ResultType
        boost_param_dispatch_0boost_ ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## m ## _type&& argument name ## m
        );

    template <typename Args>
    typename boost_param_result_ ## __LINE__ ## name<Args>::type
        boost_param_impl ## __LINE__ ## name(Args const& args)
    {
        return boost_param_dispatch_0boost_ ## __LINE__ ## name(
            static_cast<
                typename boost_param_result_ ## __LINE__ ## name<
                    Args
                >::type(*)()
            >(std::nullptr)
          , args
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## 0
                >::type
            >(args[ keyword object of required parameter ## 0])
          , …
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## n
                >::type
            >(args[ keyword object of required parameter ## n])
        );
    }

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## n ## _type
    >
    ResultType
        boost_param_dispatch_0boost_ ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## n ## _type&& argument name ## n
        )
    {
        return boost_param_dispatch_0boost_ ## __LINE__ ## name(
            static_cast<ResultType(*)()>(std::nullptr)
          , (args, keyword object of optional parameter ## n + 1 =
                default value of optional parameter ## n + 1
            )
          , std::forward<argument name ## 0 ## _type>(
                argument name ## 0
            )
          , …
          , std::forward<argument name ## n ## _type>(
                argument name ## n
            )
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of optional parameter ## n + 1
                >::type
            >(default value of optional parameter ## n + 1)
        );
    }

    ⋮

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## m ## _type
    >
    ResultType
        boost_param_dispatch_0boost_ ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## m ## _type&& argument name ## m
        )

## 7.2 `BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_namespace, arguments)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a member function that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `kw` in this case. The identifiers with leading underscores can be passed to the bracket operator of `args` to extract the same argument to which the corresponding named parameter (without underscores) is bound, as will be shown later.

    BOOST_PARAMETER_NAME((_lrc, kw) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw) consume(rr))

Use the macro as a substitute for a normal `static` member function header. Enclose the return type `bool` in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. Otherwise, just as with a normal function, the order in which you specify the parameters determines their position. Also, just as with a normal function, optional parameters have default values, whereas required parameters do not. Within the function body, either simply use the parameter name or pass the matching identifier with the leading underscore to the bracket operator of `args` to extract the corresponding argument. Note that the second method doesn't require `std::forward` to preserve value categories.

    struct B
    {
        BOOST_PARAMETER_MEMBER_FUNCTION((bool), static evaluate, kw,
            (deduced
                (required
                    (lrc, (std::bitset<1>))
                    (lr, (std::bitset<2>))
                )
                (optional
                    (rrc, (std::bitset<3>), rvalue_const_bitset<2>())
                    (rr, (std::bitset<4>), rvalue_bitset<3>())
                )
            )
        )
        {
            BOOST_TEST_EQ(
                passed_by_lvalue_reference_to_const
              , U::evaluate_category<0>(lrc)
            );
            BOOST_TEST_EQ(
                passed_by_lvalue_reference
              , U::evaluate_category<1>(lr)
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference_to_const
              , U::evaluate_category<2>(std::forward<rrc0_type>(rrc0))
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference
              , U::evaluate_category<3>(args[_rr0])
            );

            return true;
        }
    };

The following function calls are legal.

    B::evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
      , rvalue_bitset<3>()
    );
    B::evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
    );
    B::evaluate((  // composed arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    ));
    B::evaluate(  // named arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    B::evaluate(  // named arguments
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

Because the parameters were wrapped in a `(deduced …)` clause, the following function calls are also legal.

    B::evaluate(  // deduced arguments
        rvalue_bitset<3>()
      , lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
    );
    B::evaluate(  // deduced arguments
        lvalue_bitset<1>()
      , lvalue_const_bitset<0>()
    );

The preprocessor.cpp and preprocessor_eval_category.cpp test programs demonstrate proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function.
- `name` is the base name of the function; it determines the name of the generated forwarding functions. `name` may be qualified by the `static` keyword to declare the member function and its helpers as not associated with any object of the enclosing type.
- `tag_namespace` is the namespace in which the keywords used by the function resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                optional-specifier {optional-specifier}
            ')'
        ) | (
            '(' 'required'
                required-specifier {required-specifier}
            ')'
        )

    optional-specifier ::=
        '('
            argument-name ',' restriction ',' default-value
        ')'

    required-specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `default-value` is any valid C++ expression; if necessary, user code can compute it in terms of `previous-name ## _type`, where `previous-name` is the `argument-name` in a previous `specifier-group0` or `specifier-group1`. This expression will be invoked exactly once.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type. If `restriction` uses this form, then the type of the generated name `argument-name ## _type` will be computed in terms of the target type, and the generated reference `argument-name` (but not its corresponding entry in `args`) will be cast to that type.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_ ## __LINE__ ## name = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_ ## __LINE__ ## name
    {
        typedef result type;
    };

    struct boost_param_params_ ## __LINE__ ## name
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_ ## __LINE__ ## name
        boost_param_parameters_ ## __LINE__ ## name;

    template <typename A0, …, typename A ## n>
    result name(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_ ## __LINE__ ## name
        ::match<A0, …, A ## n>::type
        = boost_param_parameters_ ## __LINE__ ## name()
    )
    {
        return this->boost_param_impl ## __LINE__ ## name(
            boost_param_parameters_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result name(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_ ## __LINE__ ## name
        ::match<A0, …, A ## m>::type
        = boost_param_parameters_ ## __LINE__ ## name()
    )
    {
        return this->boost_param_impl ## __LINE__ ## name(
            boost_param_parameters_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <typename Args>
    typename boost_param_result_ ## __LINE__ ## name<Args>::type
        boost_param_impl ## __LINE__ ## name(Args const& args)
    {
        return this->boost_param_dispatch_0boost_ ## __LINE__ ## name(
            static_cast<
                typename boost_param_result_ ## __LINE__ ## name<
                    Args
                >::type(*)()
            >(std::nullptr)
          , args
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## 0
                >::type
            >(args[ keyword object of required parameter ## 0])
          , …
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## n
                >::type
            >(args[ keyword object of required parameter ## n])
        );
    }

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## n ## _type
    >
    ResultType
        boost_param_dispatch_0boost_ ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## n ## _type&& argument name ## n
        )
    {
        return this->boost_param_dispatch_0boost_ ## __LINE__ ## name(
            static_cast<ResultType(*)()>(std::nullptr)
          , (args, keyword object of optional parameter ## n + 1 =
                default value of optional parameter ## n + 1
            )
          , std::forward<argument name ## 0 ## _type>(
                argument name ## 0
            )
          , …
          , std::forward<argument name ## n ## _type>(
                argument name ## n
            )
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of optional parameter ## n + 1
                >::type
            >(default value of optional parameter ## n + 1)
        );
    }

    ⋮

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## m ## _type
    >
    ResultType
        boost_param_dispatch_0boost_ ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## m ## _type&& argument name ## m
        )

## 7.3 `BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_ns, arguments)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a member function that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `kw` in this case. The identifiers with leading underscores can be passed to the bracket operator of `args` to extract the same argument to which the corresponding named parameter (without underscores) is bound, as will be shown later.

    BOOST_PARAMETER_NAME((_lrc, kw) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw) consume(rr))

Use the macro as a substitute for a normal `const` member function header. Enclose the return type `bool` in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. Otherwise, just as with a normal function, the order in which you specify the parameters determines their position. Also, just as with a normal function, optional parameters have default values, whereas required parameters do not. Within the function body, either simply use the parameter name or pass the matching identifier with the leading underscore to the bracket operator of `args` to extract the corresponding argument. Note that the second method doesn't require `std::forward` to preserve value categories.

    struct B
    {
        B()
        {
        }

        BOOST_PARAMETER_CONST_MEMBER_FUNCTION((bool), evaluate, kw,
            (deduced
                (required
                    (lrc, (std::bitset<1>))
                    (lr, (std::bitset<2>))
                )
                (optional
                    (rrc, (std::bitset<3>), rvalue_const_bitset<2>())
                    (rr, (std::bitset<4>), rvalue_bitset<3>())
                )
            )
        )
        {
            BOOST_TEST_EQ(
                passed_by_lvalue_reference_to_const
              , U::evaluate_category<0>(lrc)
            );
            BOOST_TEST_EQ(
                passed_by_lvalue_reference
              , U::evaluate_category<1>(lr)
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference_to_const
              , U::evaluate_category<2>(std::forward<rrc0_type>(rrc0))
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference
              , U::evaluate_category<3>(args[_rr0])
            );

            return true;
        }
    };

The following function calls are legal.

    B const b = B();
    b.evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
      , rvalue_bitset<3>()
    );
    b.evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
    );
    b.evaluate((  // composed arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    ));
    b.evaluate(  // named arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    b.evaluate(  // named arguments
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

Because the parameters were wrapped in a `(deduced …)` clause, the following function calls are also legal.

    b.evaluate(  // deduced arguments
        rvalue_bitset<3>()
      , lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
    );
    b.evaluate(  // deduced arguments
        lvalue_bitset<1>()
      , lvalue_const_bitset<0>()
    );

The preprocessor.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function.
- `name` is the base name of the function; it determines the name of the generated forwarding functions.
- `tag_namespace` is the namespace in which the keywords used by the function resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                optional-specifier {optional-specifier}
            ')'
        ) | (
            '(' 'required'
                required-specifier {required-specifier}
            ')'
        )

    optional-specifier ::=
        '('
            argument-name ',' restriction ',' default-value
        ')'

    required-specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `default-value` is any valid C++ expression; if necessary, user code can compute it in terms of `previous-name ## _type`, where `previous-name` is the `argument-name` in a previous `specifier-group0` or `specifier-group1`. This expression will be invoked exactly once.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type. If `restriction` uses this form, then the type of the generated name `argument-name ## _type` will be computed in terms of the target type, and the generated reference `argument-name` (but not its corresponding entry in `args`) will be cast to that type.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_const_ ## __LINE__ ## name = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_const_ ## __LINE__ ## name
    {
        typedef result type;
    };

    struct boost_param_params_const_ ## __LINE__ ## name
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_const_ ## __LINE__ ## name
        boost_param_parameters_const_ ## __LINE__ ## name;

    template <typename A0, …, typename A ## n>
    result name(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_const_ ## __LINE__ ## name
        ::match<A0, …, A ## n>::type
        = boost_param_parameters_const_ ## __LINE__ ## name()
    ) const
    {
        return this->boost_param_impl_const ## __LINE__ ## name(
            boost_param_parameters_const_ ## __LINE__ ## name(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result name(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_const_ ## __LINE__ ## name
        ::match<A0, …, A ## m>::type
        = boost_param_parameters_const_ ## __LINE__ ## name()
    ) const
    {
        return this->boost_param_impl_const ## __LINE__ ## name(
            boost_param_parameters_const_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <typename Args>
    typename boost_param_result_const_ ## __LINE__ ## name<Args>::type
        boost_param_impl_const ## __LINE__ ## name(Args const& args) const
    {
        return this->
        boost_param_dispatch_const_0boost_ ## __LINE__ ## name(
            static_cast<
                typename boost_param_result_const_ ## __LINE__ ## name<
                    Args
                >::type(*)()
            >(std::nullptr)
          , args
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## 0
                >::type
            >(args[ keyword object of required parameter ## 0])
          , …
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## n
                >::type
            >(args[ keyword object of required parameter ## n])
        );
    }

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## n ## _type
    >
    ResultType
        boost_param_dispatch_const_0boost_ ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## n ## _type&& argument name ## n
        ) const
    {
        return this->
        boost_param_dispatch_const_0boost_ ## __LINE__ ## name(
            static_cast<ResultType(*)()>(std::nullptr)
          , (args, keyword object of optional parameter ## n + 1 =
                default value of optional parameter ## n + 1
            )
          , std::forward<argument name ## 0 ## _type>(
                argument name ## 0
            )
          , …
          , std::forward<argument name ## n ## _type>(
                argument name ## n
            )
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of optional parameter ## n + 1
                >::type
            >(default value of optional parameter ## n + 1)
        );
    }

    ⋮

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## m ## _type
    >
    ResultType
        boost_param_dispatch_const_0boost_ ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## m ## _type&& argument name ## m
        ) const

## 7.4 `BOOST_PARAMETER_FUNCTION_CALL_OPERATOR(result, tag_namespace, arguments)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a function call operator that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `tag` by default.

    BOOST_PARAMETER_NAME(y)
    BOOST_PARAMETER_NAME(z)

Use the macro as a substitute for a normal function call operator header. Enclose the return type in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. This is especially useful when implementing multiple Boost.Parameter-enabled function call operator overloads.

    class char_reader
    {
        int index;
        char const* key;

     public:
        explicit char_reader(char const* k) : index(0), key(k)
        {
        }

        BOOST_PARAMETER_FUNCTION_CALL_OPERATOR((void), tag,
            (deduced
                (required
                    (y, (int))
                    (z, (char const*))
                )
            )
        )
        {
            this->index = y;
            this->key = z;
        }

        BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR((char), tag,
            (deduced
                (required
                    (y, (bool))
                    (z, (std::map<char const*, std::string>))
                )
            )
        )
        {
            return y ? (
                (z.find(this->key)->second)[this->index]
            ) : this->key[this->index];
        }
    };

As with regular argument-dependent lookup, the value types of the arguments passed in determine which function call operator overload gets invoked.

    char const* keys[] = {"foo", "bar", "baz"};
    std::map<char const*, std::string> k2s;
    k2s[keys[0]] = std::string("qux");
    k2s[keys[1]] = std::string("wmb");
    k2s[keys[2]] = std::string("zxc");
    char_reader r(keys[0]);

    // positional arguments
    BOOST_TEST_EQ('q', (r(true, k2s)));
    BOOST_TEST_EQ('f', (r(false, k2s)));

    // named arguments
    r(_z = keys[1], _y = 1);
    BOOST_TEST_EQ('m', (r(_z = k2s, _y = true)));
    BOOST_TEST_EQ('a', (r(_z = k2s, _y = false)));

    // deduced arguments
    r(keys[2], 2);
    BOOST_TEST_EQ('c', (r(k2s, true)));
    BOOST_TEST_EQ('z', (r(k2s, false)));

The preprocessor.cpp and preprocessor_deduced.cpp test programs demonstrate proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function call operator.
- `tag_namespace` is the namespace in which the keywords used by the function call operator resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                optional-specifier {optional-specifier}
            ')'
        ) | (
            '(' 'required'
                required-specifier {required-specifier}
            ')'
        )

    optional-specifier ::=
        '('
            argument-name ',' restriction ',' default-value
        ')'

    required-specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `default-value` is any valid C++ expression; if necessary, user code can compute it in terms of `previous-name ## _type`, where `previous-name` is the `argument-name` in a previous `specifier-group0` or `specifier-group1`. This expression will be invoked exactly once.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type. If `restriction` uses this form, then the type of the generated name `argument-name ## _type` will be computed in terms of the target type, and the generated reference `argument-name` (but not its corresponding entry in `args`) will be cast to that type.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_ ## __LINE__ ## operator = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_ ## __LINE__ ## operator
    {
        typedef result type;
    };

    struct boost_param_params_ ## __LINE__ ## operator
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_ ## __LINE__ ## operator
        boost_param_parameters_ ## __LINE__ ## operator;

    template <typename A0, …, typename A ## n>
    result operator()(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_ ## __LINE__ ## operator::match<
            A0, …, A ## n
        >::type = boost_param_parameters_ ## __LINE__ ## operator()
    )
    {
        return this->boost_param_impl ## __LINE__ ## operator(
            boost_param_parameters_ ## __LINE__ ## operator()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result operator()(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_ ## __LINE__ ## operator::match<
            A0, …, A ## m
        >::type = boost_param_parameters_ ## __LINE__ ## operator()
    )
    {
        return this->boost_param_impl ## __LINE__ ## operator(
            boost_param_parameters_ ## __LINE__ ## operator()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <typename Args>
    typename boost_param_result_ ## __LINE__ ## operator<Args>::type
        boost_param_impl ## __LINE__ ## operator(Args const& args)
    {
        return this->boost_param_dispatch_0boost_ ## __LINE__ ## operator(
            static_cast<
                typename boost_param_result_ ## __LINE__ ## operator<
                    Args
                >::type(*)()
            >(std::nullptr)
          , args
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## 0
                >::type
            >(args[ keyword object of required parameter ## 0])
          , …
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## n
                >::type
            >(args[ keyword object of required parameter ## n])
        );
    }

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## n ## _type
    >
    ResultType
        boost_param_dispatch_0boost_ ## __LINE__ ## operator(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## n ## _type&& argument name ## n
        )
    {
        return this->boost_param_dispatch_0boost_ ## __LINE__ ## operator(
            static_cast<ResultType(*)()>(std::nullptr)
          , (args, keyword object of optional parameter ## n + 1 =
                default value of optional parameter ## n + 1
            )
          , std::forward<argument name ## 0 ## _type>(
                argument name ## 0
            )
          , …
          , std::forward<argument name ## n ## _type>(
                argument name ## n
            )
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of optional parameter ## n + 1
                >::type
            >(default value of optional parameter ## n + 1)
        );
    }

    ⋮

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## m ## _type
    >
    ResultType
        boost_param_dispatch_0boost_ ## __LINE__ ## operator(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## m ## _type&& argument name ## m
        )

## 7.5 `BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR(result, tag_ns, arguments)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a function call operator that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `kw` in this case. The identifiers with leading underscores can be passed to the bracket operator of `args` to extract the same argument to which the corresponding named parameter (without underscores) is bound, as will be shown later.

    BOOST_PARAMETER_NAME((_lrc, kw) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw) consume(rr))

Use the macro as a substitute for a normal `const` function call operator header. Enclose the return type `bool` in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. Otherwise, just as with a normal function, the order in which you specify the parameters determines their position. Also, just as with a normal function, optional parameters have default values, whereas required parameters do not. Within the function body, either simply use the parameter name or pass the matching identifier with the leading underscore to the bracket operator of `args` to extract the corresponding argument. Note that the second method doesn't require `std::forward` to preserve value categories.

    struct B
    {
        B()
        {
        }

        BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR((bool), kw,
            (deduced
                (required
                    (lrc, (std::bitset<1>))
                    (lr, (std::bitset<2>))
                )
                (optional
                    (rrc, (std::bitset<3>), rvalue_const_bitset<2>())
                    (rr, (std::bitset<4>), rvalue_bitset<3>())
                )
            )
        )
        {
            BOOST_TEST_EQ(
                passed_by_lvalue_reference_to_const
              , U::evaluate_category<0>(lrc)
            );
            BOOST_TEST_EQ(
                passed_by_lvalue_reference
              , U::evaluate_category<1>(lr)
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference_to_const
              , U::evaluate_category<2>(std::forward<rrc0_type>(rrc0))
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference
              , U::evaluate_category<3>(args[_rr0])
            );

            return true;
        }
    };

The following function calls are legal.

    B const b = B();
    b(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
      , rvalue_bitset<3>()
    );
    b(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
    );
    b((  // composed arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    ));
    b(  // named arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    b(  // named arguments
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

Because the parameters were wrapped in a `(deduced …)` clause, the following function calls are also legal.

    b(  // deduced arguments
        rvalue_bitset<3>()
      , lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
    );
    b(  // deduced arguments
        lvalue_bitset<1>()
      , lvalue_const_bitset<0>()
    );

The preprocessor.cpp, preprocessor_deduced.cpp, and preprocessor_eval_cat_8.cpp test programs demonstrate proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function call operator.
- `tag_namespace` is the namespace in which the keywords used by the function call operator resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                optional-specifier {optional-specifier}
            ')'
        ) | (
            '(' 'required'
                required-specifier {required-specifier}
            ')'
        )

    optional-specifier ::=
        '('
            argument-name ',' restriction ',' default-value
        ')'

    required-specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `default-value` is any valid C++ expression; if necessary, user code can compute it in terms of `previous-name ## _type`, where `previous-name` is the `argument-name` in a previous `specifier-group0` or `specifier-group1`. This expression will be invoked exactly once.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type. If `restriction` uses this form, then the type of the generated name `argument-name ## _type` will be computed in terms of the target type, and the generated reference `argument-name` (but not its corresponding entry in `args`) will be cast to that type.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_const_ ## __LINE__ ## operator = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_const_ ## __LINE__ ## operator
    {
        typedef result type;
    };

    struct boost_param_params_const_ ## __LINE__ ## operator
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_const_ ## __LINE__ ## operator
        boost_param_parameters_const_ ## __LINE__ ## operator;

    template <typename A0, …, typename A ## n>
    result operator()(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_const_ ## __LINE__ ## operator
        ::match<A0, …, A ## n>::type
        = boost_param_parameters_const_ ## __LINE__ ## operator()
    ) const
    {
        return this->boost_param_impl_const ## __LINE__ ## operator(
            boost_param_parameters_const_ ## __LINE__ ## operator()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result operator()(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_const_ ## __LINE__ ## operator
        ::match<A0, …, A ## m>::type
        = boost_param_parameters_const_ ## __LINE__ ## operator()
    ) const
    {
        return this->boost_param_impl_const ## __LINE__ ## operator(
            boost_param_parameters_const_ ## __LINE__ ## operator()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <typename Args>
    typename boost_param_result_const_ ## __LINE__ ## operator<Args>::type
        boost_param_impl_const ## __LINE__ ## operator(Args const& args) const
    {
        return this->
        boost_param_dispatch_const_0boost_ ## __LINE__ ## operator(
            static_cast<
                typename boost_param_result_const_ ## __LINE__ ## operator<
                    Args
                >::type(*)()
            >(std::nullptr)
          , args
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## 0
                >::type
            >(args[ keyword object of required parameter ## 0])
          , …
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of required parameter ## n
                >::type
            >(args[ keyword object of required parameter ## n])
        );
    }

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## n ## _type
    >
    ResultType
        boost_param_dispatch_const_0boost_ ## __LINE__ ## operator(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## n ## _type&& argument name ## n
        ) const
    {
        return this->
        boost_param_dispatch_const_0boost_ ## __LINE__ ## operator(
            static_cast<ResultType(*)()>(std::nullptr)
          , (args, keyword object of optional parameter ## n + 1 =
                default value of optional parameter ## n + 1
            )
          , std::forward<argument name ## 0 ## _type>(
                argument name ## 0
            )
          , …
          , std::forward<argument name ## n ## _type>(
                argument name ## n
            )
          , std::forward<
                typename value_type<
                    Args
                  , keyword tag type of optional parameter ## n + 1
                >::type
            >(default value of optional parameter ## n + 1)
        );
    }

    ⋮

    template <
        typename ResultType
      , typename Args
      , typename argument name ## 0 ## _type
      , …
      , typename argument name ## m ## _type
    >
    ResultType
        boost_param_dispatch_const_0boost_ ## __LINE__ ## operator(
            (ResultType(*)())
          , Args const& args
          , argument name ## 0 ## _type&& argument name ## 0
          , …
          , argument name ## m ## _type&& argument name ## m
        ) const

## 7.6 `BOOST_PARAMETER_CONSTRUCTOR(cls, impl, tag_namespace, arguments)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a constructor that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `tag` by default.

    BOOST_PARAMETER_NAME(y)
    BOOST_PARAMETER_NAME(z)

In the base class, implement a delegate constructor template that takes in an ArgumentPack. You must pass the identifiers with leading underscores to `args` in order to extract the corresponding arguments.

    class char_read_base
    {
        int index;
        char const* key;

     public:
        template <typename Args>
        explicit char_read_base(Args const& args)
          : index(args[_y]), key(args[_z])
        {
        }

        BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR((char), tag,
            (deduced
                (required
                    (y, (bool))
                    (z, (std::map<char const*, std::string>))
                )
            )
        )
        {
            return y ? (
                (z.find(this->key)->second)[this->index]
            ) : this->key[this->index];
        }
    };

Use the macro as a substitute for a normal constructor definition. Note the lack of an explicit body. Enclose the base type in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause.

    struct char_reader : public char_read_base
    {
        BOOST_PARAMETER_CONSTRUCTOR(char_reader, (char_read_base), tag,
            (deduced
                (required
                    (y, (int))
                    (z, (char const*))
                )
            )
        )
    };

The following `char_reader` constructor calls are legal.

    char const* keys[] = {"foo", "bar", "baz"};
    std::map<char const*, std::string> k2s;
    k2s[keys[0]] = std::string("qux");
    k2s[keys[1]] = std::string("wmb");
    k2s[keys[2]] = std::string("zxc");

    // positional arguments
    char_reader r0(0, keys[0]);
    BOOST_TEST_EQ('q', (r0(true, k2s)));
    BOOST_TEST_EQ('f', (r0(false, k2s)));

    // named arguments
    char_reader r1(_z = keys[1], _y = 1);
    BOOST_TEST_EQ('m', (r1(_z = k2s, _y = true)));
    BOOST_TEST_EQ('a', (r1(_z = k2s, _y = false)));

    // deduced arguments
    char_reader r2(keys[2], 2);
    BOOST_TEST_EQ('c', (r2(k2s, true)));
    BOOST_TEST_EQ('z', (r2(k2s, false)));

The preprocessor.cpp and preprocessor_deduced.cpp test programs demonstrate proper usage of this macro.

Macro parameters:

- `cls` is the name of the enclosing class.
- `impl` is the parenthesized implementation base class for `cls`.
- `tag_namespace` is the namespace in which the keywords used by the constructor resides.
- `arguments` is a list of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                specifier {specifier}
            ')'
        ) | (
            '(' 'required'
                specifier {specifier}
            ')'
        )

    specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type.

Note that specifier does not include default-value. It is up to the delegate constructor in `impl` to determine the default value of all optional arguments.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    struct boost_param_params_ ## __LINE__ ## ctor
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_ ## __LINE__ ## ctor
        constructor_parameters ## __LINE__;

    template <typename A0, …, typename A ## n>
    cls(A0&& a0, …, A ## n && a ## n)
      : impl(
            constructor_parameters ## __LINE__(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        )
    {
    }

    ⋮

    template <typename A0, …, typename A ## m>
    cls(A0&& a0, …, A ## m && a ## m)
      : impl(
            constructor_parameters ## __LINE__(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        )
    {
    }

## 7.7 `BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, arguments)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a function that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `kw` in this case. The identifiers with leading underscores can be passed to the bracket operator of `args` to extract the same argument to which the corresponding named parameter (without underscores) is bound, as will be shown later.

    BOOST_PARAMETER_NAME((_lrc, kw) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw) consume(rr))

Use the macro as a substitute for a normal function header. Enclose the return type `bool` in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. Otherwise, just as with a normal function, the order in which you specify the parameters determines their position. However, unlike a normal function, default values must be specified within the function body. Also within the function body, you must pass the matching identifier with the leading underscore to the bracket operator of `args` to extract the corresponding argument, but at least this doesn't require `std::forward` to preserve value categories.

    BOOST_PARAMETER_BASIC_FUNCTION((bool), evaluate, kw,
        (deduced
            (required
                (lrc, (std::bitset<1>))
                (lr, (std::bitset<2>))
            )
            (optional
                (rrc, (std::bitset<3>))
                (rr, (std::bitset<4>))
            )
        )
    )
    {
        BOOST_TEST_EQ(
            passed_by_lvalue_reference_to_const
          , U::evaluate_category<0>(args[_lrc])
        );
        BOOST_TEST_EQ(
            passed_by_lvalue_reference
          , U::evaluate_category<1>(args[_lr])
        );
        BOOST_TEST_EQ(
            passed_by_rvalue_reference_to_const
          , U::evaluate_category<2>(
                args[_rrc0 | rvalue_const_bitset<2>()]
            )
        );
        BOOST_TEST_EQ(
            passed_by_rvalue_reference
          , U::evaluate_category<3>(args[_rr0 | rvalue_bitset<3>()])
        );

        return true;
    }

The following function calls are legal.

    evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
      , rvalue_bitset<3>()
    );
    evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
    );
    evaluate((  // composed arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    ));
    evaluate(  // named arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    evaluate(  // named arguments
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

Because the parameters were wrapped in a `(deduced …)` clause, the following function calls are also legal.

    evaluate(  // deduced arguments
        rvalue_bitset<3>()
      , lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
    );
    evaluate(  // deduced arguments
        lvalue_bitset<1>()
      , lvalue_const_bitset<0>()
    );

The preprocessor.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function.
- `name` is the base name of the function; it determines the name of the generated forwarding functions.
- `tag_namespace` is the namespace in which the keywords used by the function resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                specifier {specifier}
            ')'
        ) | (
            '(' 'required'
                specifier {specifier}
            ')'
        )

    specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type.

Note that specifier does not include default-value. It is up to the function body to determine the default value of all optional arguments.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_ ## __LINE__ ## name = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_ ## __LINE__ ## name
    {
        typedef result type;
    };

    struct boost_param_params_ ## __LINE__ ## name
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_ ## __LINE__ ## name
        boost_param_parameters_ ## __LINE__ ## name;

    template <typename Args>
    typename boost_param_result_ ## __LINE__ ## name<Args>::type
        boost_param_impl ## name(Args const&);

    template <typename A0, …, typename A ## n>
    result name(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_ ## __LINE__ ## name
        ::match<A0, …, A ## n>::type
        = boost_param_parameters_ ## __LINE__ ## name()
    )
    {
        return boost_param_impl ## __LINE__ ## name(
            boost_param_parameters_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result name(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_ ## __LINE__ ## name
        ::match<A0, …, A ## m>::type
        = boost_param_parameters_ ## __LINE__ ## name()
    )
    {
        return boost_param_impl ## __LINE__ ## name(
            boost_param_parameters_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <typename Args>
    typename boost_param_result_ ## __LINE__ ## name<Args>::type
        boost_param_impl ## __LINE__ ## name(Args const& args)

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function body.

## 7.8 `BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_ns, arguments)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a member function that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `kw` in this case. The identifiers with leading underscores can be passed to the bracket operator of `args` to extract the same argument to which the corresponding named parameter (without underscores) is bound, as will be shown later.

    BOOST_PARAMETER_NAME((_lrc, kw) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw) consume(rr))

Use the macro as a substitute for a normal `static` member function header. Enclose the return type `bool` in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. Otherwise, just as with a normal function, the order in which you specify the parameters determines their position. However, unlike a normal function, default values must be specified within the function body. Also within the function body, you must pass the matching identifier with the leading underscore to the bracket operator of `args` to extract the corresponding argument, but at least this doesn't require `std::forward` to preserve value categories.

    struct B
    {
        BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((bool), static evaluate, kw,
            (deduced
                (required
                    (lrc, (std::bitset<1>))
                    (lr, (std::bitset<2>))
                )
                (optional
                    (rrc, (std::bitset<3>))
                    (rr, (std::bitset<4>))
                )
            )
        )
        {
            BOOST_TEST_EQ(
                passed_by_lvalue_reference_to_const
              , U::evaluate_category<0>(args[_lrc])
            );
            BOOST_TEST_EQ(
                passed_by_lvalue_reference
              , U::evaluate_category<1>(args[_lr])
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference_to_const
              , U::evaluate_category<2>(
                    args[_rrc0 | rvalue_const_bitset<2>()]
                )
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference
              , U::evaluate_category<3>(
                    args[_rr0 | rvalue_bitset<3>()]
                )
            );

            return true;
        }
    };

The following function calls are legal.

    B::evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
      , rvalue_bitset<3>()
    );
    B::evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
    );
    B::evaluate((  // composed arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    ));
    B::evaluate(  // named arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    B::evaluate(  // named arguments
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

Because the parameters were wrapped in a `(deduced …)` clause, the following function calls are also legal.

    B::evaluate(  // deduced arguments
        rvalue_bitset<3>()
      , lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
    );
    B::evaluate(  // deduced arguments
        lvalue_bitset<1>()
      , lvalue_const_bitset<0>()
    );

The preprocessor.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function.
- `name` is the base name of the function; it determines the name of the generated forwarding functions. `name` may be qualified by the `static` keyword to declare the member function and its helpers as not associated with any object of the enclosing type.
- `tag_namespace` is the namespace in which the keywords used by the function resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                specifier {specifier}
            ')'
        ) | (
            '(' 'required'
                specifier {specifier}
            ')'
        )

    specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type.

Note that specifier does not include default-value. It is up to the function body to determine the default value of all optional arguments.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_ ## __LINE__ ## name = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_ ## __LINE__ ## name
    {
        typedef result type;
    };

    struct boost_param_params_ ## __LINE__ ## name
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_ ## __LINE__ ## name
        boost_param_parameters_ ## __LINE__ ## name;

    template <typename A0, …, typename A ## n>
    result name(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_ ## __LINE__ ## name
        ::match<A0, …, A ## n>::type
        = boost_param_parameters_ ## __LINE__ ## name()
    )
    {
        return this->boost_param_impl ## name(
            boost_param_parameters_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result name(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_ ## __LINE__ ## name
        ::match<A0, …, A ## m>::type
        = boost_param_parameters_ ## __LINE__ ## name()
    )
    {
        return this->boost_param_impl ## name(
            boost_param_parameters_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <typename Args>
    typename boost_param_result_ ## __LINE__ ## name<Args>::type
        boost_param_impl ## name(Args const& args)

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function body.

## 7.9 `BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(result, name, tag_ns, args)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a member function that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `kw` in this case. The identifiers with leading underscores can be passed to the bracket operator of `args` to extract the same argument to which the corresponding named parameter (without underscores) is bound, as will be shown later.

    BOOST_PARAMETER_NAME((_lrc, kw) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw) consume(rr))

Use the macro as a substitute for a normal `const` member function header. Enclose the return type `bool` in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. Otherwise, just as with a normal function, the order in which you specify the parameters determines their position. However, unlike a normal function, default values must be specified within the function body. Also within the function body, you must pass the matching identifier with the leading underscore to the bracket operator of `args` to extract the corresponding argument, but at least this doesn't require `std::forward` to preserve value categories.

    struct B
    {
        B()
        {
        }

        BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION((bool), evaluate, kw,
            (deduced
                (required
                    (lrc, (std::bitset<1>))
                    (lr, (std::bitset<2>))
                )
                (optional
                    (rrc, (std::bitset<3>))
                    (rr, (std::bitset<4>))
                )
            )
        )
        {
            BOOST_TEST_EQ(
                passed_by_lvalue_reference_to_const
              , U::evaluate_category<0>(args[_lrc])
            );
            BOOST_TEST_EQ(
                passed_by_lvalue_reference
              , U::evaluate_category<1>(args[_lr])
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference_to_const
              , U::evaluate_category<2>(
                    args[_rrc0 | rvalue_const_bitset<2>()]
                )
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference
              , U::evaluate_category<3>(
                    args[_rr0 | rvalue_bitset<3>()]
                )
            );

            return true;
        }
    };

The following function calls are legal.

    B const b = B();
    b.evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
      , rvalue_bitset<3>()
    );
    b.evaluate(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
    );
    b.evaluate((  // composed arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    ));
    b.evaluate(  // named arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    b.evaluate(  // named arguments
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

Because the parameters were wrapped in a `(deduced …)` clause, the following function calls are also legal.

    b.evaluate(  // deduced arguments
        rvalue_bitset<3>()
      , lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
    );
    b.evaluate(  // deduced arguments
        lvalue_bitset<1>()
      , lvalue_const_bitset<0>()
    );

The preprocessor.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function.
- `name` is the base name of the function; it determines the name of the generated forwarding functions.
- `tag_namespace` is the namespace in which the keywords used by the function resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                specifier {specifier}
            ')'
        ) | (
            '(' 'required'
                specifier {specifier}
            ')'
        )

    specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type.

Note that specifier does not include default-value. It is up to the function body to determine the default value of all optional arguments.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_const_ ## __LINE__ ## name = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_const_ ## __LINE__ ## name
    {
        typedef result type;
    };

    struct boost_param_params_const_ ## __LINE__ ## name
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_const_ ## __LINE__ ## name
        boost_param_parameters_const_ ## __LINE__ ## name;

    template <typename A0, …, typename A ## n>
    result name(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_const_ ## __LINE__ ## name
        ::match<A0, …, A ## n>::type
        = boost_param_parameters_const_ ## __LINE__ ## name()
    ) const
    {
        return this->boost_param_impl_const ## __LINE__ ## name(
            boost_param_parameters_const_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result name(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_const_ ## __LINE__ ## name
        ::match<A0, …, A ## m>::type
        = boost_param_parameters_const_ ## __LINE__ ## name()
    ) const
    {
        return this->boost_param_impl_const ## __LINE__ ## name(
            boost_param_parameters_const_ ## __LINE__ ## name()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <typename Args>
    typename boost_param_result_const_ ## __LINE__ ## name<Args>::type
        boost_param_impl_const ## __LINE__ ## name(Args const& args) const

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function body.

## 7.10 `BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR(result, tag_ns, arguments)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a function call operator that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `tag` by default.

    BOOST_PARAMETER_NAME(y)
    BOOST_PARAMETER_NAME(z)

Use the macro as a substitute for a normal function call operator header. Enclose the return type in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. This is especially useful when implementing multiple Boost.Parameter-enabled function call operator overloads.

    class char_reader
    {
        int index;
        char const* key;

     public:
        explicit char_reader(char const* k) : index(0), key(k)
        {
        }

        BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR((void), tag,
            (deduced
                (required
                    (y, (int))
                    (z, (char const*))
                )
            )
        )
        {
            this->index = args[_y];
            this->key = args[_z];
        }

        BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR((char), tag,
            (deduced
                (required
                    (y, (bool))
                    (z, (std::map<char const*, std::string>))
                )
            )
        )
        {
            return args[_y] ? (
                (args[_z].find(this->key)->second)[this->index]
            ) : this->key[this->index];
        }
    };

As with regular argument-dependent lookup, the value types of the arguments passed in determine which function call operator overload gets invoked.

    char const* keys[] = {"foo", "bar", "baz"};
    std::map<char const*, std::string> k2s;
    k2s[keys[0]] = std::string("qux");
    k2s[keys[1]] = std::string("wmb");
    k2s[keys[2]] = std::string("zxc");
    char_reader r(keys[0]);

    // positional arguments
    BOOST_TEST_EQ('q', (r(true, k2s)));
    BOOST_TEST_EQ('f', (r(false, k2s)));

    // named arguments
    r(_z = keys[1], _y = 1);
    BOOST_TEST_EQ('m', (r(_z = k2s, _y = true)));
    BOOST_TEST_EQ('a', (r(_z = k2s, _y = false)));

    // deduced arguments
    r(keys[2], 2);
    BOOST_TEST_EQ('c', (r(k2s, true)));
    BOOST_TEST_EQ('z', (r(k2s, false)));

The preprocessor.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function call operator.
- `tag_namespace` is the namespace in which the keywords used by the function call operator resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                specifier {specifier}
            ')'
        ) | (
            '(' 'required'
                specifier {specifier}
            ')'
        )

    specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type.

Note that specifier does not include default-value. It is up to the function body to determine the default value of all optional arguments.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_ ## __LINE__ ## operator = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_ ## __LINE__ ## operator
    {
        typedef result type;
    };

    struct boost_param_params_ ## __LINE__ ## operator
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_ ## __LINE__ ## operator
        boost_param_parameters_ ## __LINE__ ## operator;

    template <typename A0, …, typename A ## n>
    result operator()(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_ ## __LINE__ ## operator::match<
            A0, …, A ## n
        >::type = boost_param_parameters_ ## __LINE__ ## operator()
    )
    {
        return this->boost_param_impl ## __LINE__ ## operator(
            boost_param_parameters_ ## __LINE__ ## operator()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result operator()(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_ ## __LINE__ ## operator::match<
            A0, …, A ## m
        >::type = boost_param_parameters_ ## __LINE__ ## operator()
    )
    {
        return this->boost_param_impl ## __LINE__ ## operator(
            boost_param_parameters_ ## __LINE__ ## operator()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <typename Args>
    typename boost_param_result_ ## __LINE__ ## operator<Args>::type
        boost_param_impl ## __LINE__ ## operator(Args const& args)

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function call operator body.

## 7.11 `BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR(result, tag_ns, args)`

Defined in: | boost/parameter/preprocessor.hpp

Generates a function call operator that can take in positional arguments, composed arguments, named arguments, and deduced arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Define the named parameters that will comprise the argument specification that this macro will use. Ensure that all their tag types are in the same namespace, which is `kw` in this case. The identifiers with leading underscores can be passed to the bracket operator of `args` to extract the same argument to which the corresponding named parameter (without underscores) is bound, as will be shown later.

    BOOST_PARAMETER_NAME((_lrc, kw) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw) consume(rr))

Use the macro as a substitute for a normal `const` function call operator header. Enclose the return type `bool` in parentheses. For each parameter, also enclose the expected value type in parentheses. Since the value types are mutually exclusive, you can wrap the parameters in a `(deduced …)` clause. Otherwise, just as with a normal function, the order in which you specify the parameters determines their position. However, unlike a normal function, default values must be specified within the function body. Also within the function body, you must pass the matching identifier with the leading underscore to the bracket operator of `args` to extract the corresponding argument, but at least this doesn't require `std::forward` to preserve value categories.

    struct B
    {
        B()
        {
        }

        BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR((bool), kw,
            (deduced
                (required
                    (lrc, (std::bitset<1>))
                    (lr, (std::bitset<2>))
                )
                (optional
                    (rrc, (std::bitset<3>))
                    (rr, (std::bitset<4>))
                )
            )
        )
        {
            BOOST_TEST_EQ(
                passed_by_lvalue_reference_to_const
              , U::evaluate_category<0>(args[_lrc])
            );
            BOOST_TEST_EQ(
                passed_by_lvalue_reference
              , U::evaluate_category<1>(args[_lr])
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference_to_const
              , U::evaluate_category<2>(
                    args[_rrc0 | rvalue_const_bitset<2>()]
                )
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference
              , U::evaluate_category<3>(
                    args[_rr0 | rvalue_bitset<3>()]
                )
            );

            return true;
        }
    };

The following function calls are legal.

    B const b = B();
    b(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
      , rvalue_bitset<3>()
    );
    b(  // positional arguments
        lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
    );
    b((  // composed arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    ));
    b(  // named arguments
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    b(  // named arguments
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

Because the parameters were wrapped in a `(deduced …)` clause, the following function calls are also legal.

    b(  // deduced arguments
        rvalue_bitset<3>()
      , lvalue_const_bitset<0>()
      , lvalue_bitset<1>()
      , rvalue_const_bitset<2>()
    );
    b(  // deduced arguments
        lvalue_bitset<1>()
      , lvalue_const_bitset<0>()
    );

The preprocessor.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function call operator.
- `tag_namespace` is the namespace in which the keywords used by the function call operator resides.
- `arguments` is a Boost.Preprocessor sequence of argument-specifiers, as defined below.

Argument specifiers syntax:

    argument-specifiers ::= specifier-group0 {specifier-group0}

    specifier-group0 ::= specifier-group1 |
        (
            '(' 'deduced'
                specifier-group1 {specifier-group1}
            ')'
        )

    specifier-group1 ::=
        (
            '(' 'optional'
                specifier {specifier}
            ')'
        ) | (
            '(' 'required'
                specifier {specifier}
            ')'
        )

    specifier ::=
        '(' argument-name ',' restriction ')'

    restriction ::=
        ( '*' '(' mfc ')' ) |
        ( '(' type-name ')' ) |
        '*'

- `argument-name` is any valid C++ identifier.
- `mfc` is an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is a Boolean Integral Constant; however, user code cannot compute `mfc` in terms of `previous-name ## _type`.
- `type-name` is either the name of a target type or an MPL Binary Metafunction Class whose first argument will be the type of the corresponding `argument-name`, whose second argument will be the entire ArgumentPack, and whose return type is the target type.

Note that specifier does not include default-value. It is up to the function body to determine the default value of all optional arguments.

Approximate expansion:

Where:

- `n` denotes the minimum arity, as determined from `arguments`.
- `m` denotes the maximum arity, as determined from `arguments`.

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename Args>
    using boost_param_result_const_ ## __LINE__ ## operator = result;

    // If result is a simple return type:
    template <typename Args>
    struct boost_param_result_const_ ## __LINE__ ## operator
    {
        typedef result type;
    };

    struct boost_param_params_const_ ## __LINE__ ## operator
      : parameters<
            list of parameter specifications, based on arguments
        >
    {
    };

    typedef boost_param_params_const_ ## __LINE__ ## operator
        boost_param_parameters_const_ ## __LINE__ ## operator;

    template <typename A0, …, typename A ## n>
    result operator()(
        A0&& a0, …, A ## n&& a ## n
      , typename boost_param_parameters_const_ ## __LINE__ ## operator
        ::match<A0, …, A ## n>::type
        = boost_param_parameters_const_ ## __LINE__ ## operator()
    ) const
    {
        return this->boost_param_impl_const ## __LINE__ ## operator(
            boost_param_parameters_const_ ## __LINE__ ## operator()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## n>(a ## n)
            )
        );
    }

    ⋮

    template <typename A0, …, typename A ## m>
    result operator()(
        A0&& a0, …, A ## m&& a ## m
      , typename boost_param_parameters_const_ ## __LINE__ ## operator
        ::match<A0, …, A ## m>::type
        = boost_param_parameters_const_ ## __LINE__ ## operator()
    ) const
    {
        return this->boost_param_impl_const ## __LINE__ ## operator(
            boost_param_parameters_const_ ## __LINE__ ## operator()(
                std::forward<A0>(a0)
              , …
              , std::forward<A ## m>(a ## m)
            )
        );
    }

    template <typename Args>
    typename boost_param_result_const_ ## __LINE__ ## operator<Args>::type
        boost_param_impl_const ## __LINE__ ## operator(Args const& args) const

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function call operator body.

## 7.12 `BOOST_PARAMETER_NO_SPEC_FUNCTION(result, name)`

Defined in: | boost/parameter/preprocessor_no_spec.hpp

Generates a function that can take in named arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Named parameters are required when invoking the function; however, none of their tags need to be in the same namespace.

    BOOST_PARAMETER_NAME((_lrc, kw0) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw1) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw2) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw3) consume(rr))

Use the macro as a substitute for a variadic function header. Enclose the return type `bool` in parentheses.

    BOOST_PARAMETER_NO_SPEC_FUNCTION((bool), evaluate)
    {
        BOOST_TEST_EQ(
            passed_by_lvalue_reference_to_const
          , U::evaluate_category<0>(args[_lrc])
        );
        BOOST_TEST_EQ(
            passed_by_lvalue_reference
          , U::evaluate_category<1>(args[_lr])
        );
        BOOST_TEST_EQ(
            passed_by_rvalue_reference_to_const
          , U::evaluate_category<2>(
                args[_rrc | rvalue_const_bitset<2>()]
            )
        );
        BOOST_TEST_EQ(
            passed_by_rvalue_reference
          , U::evaluate_category<3>(args[_rr | rvalue_bitset<3>()])
        );

        return true;
    }

To invoke the function, bind all its arguments to named parameters.

    evaluate(
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    evaluate(
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

The preprocessor_eval_cat_no_spec.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function.
- `name` is the base name of the function; it determines the name of the generated implementation function.

Argument specifiers syntax:

None.

Approximate expansion:

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename TaggedArg0, typename ...TaggedArgs>
    using boost_param_no_spec_result_ ## __LINE__ ## name = result;

    // If result is a simple return type:
    template <typename TaggedArg0, typename ...TaggedArgs>
    struct boost_param_no_spec_result_ ## __LINE__ ## name
    {
        typedef result type;
    };

    template <typename ResultType, typename Args>
    ResultType
        boost_param_no_spec_impl ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
        );

    template <typename TaggedArg0, typename ...TaggedArgs>
    inline typename boost::lazy_enable_if<
        are_tagged_arguments<TaggedArg0,TaggedArgs...>
      , boost_param_no_spec_result_ ## __LINE__ ## name<
            TaggedArg0
          , TaggedArgs...
        >
    >::type
        name(TaggedArg0 const& arg0, TaggedArgs const&... args)
    {
        return boost_param_no_spec_impl ## __LINE__ ## name(
            static_cast<
                typename
                boost_param_no_spec_result_ ## __LINE__ ## name<
                    TaggedArg0
                  , TaggedArgs...
                >::type(*)()
            >(std::nullptr)
          , compose(arg0, args...)
        );
    }

    template <typename ResultType, typename Args>
    ResultType
        boost_param_no_spec_impl ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
        )

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function body.

## 7.13 `BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION(result, name)`

Defined in: | boost/parameter/preprocessor_no_spec.hpp

Generates a member function that can take in named arguments.

Example usage: |

When designing a front-end class template whose back-end is configurable via parameterized inheritance, it can be useful to omit argument specifiers from a named-parameter member function so that the delegate member functions of the back-end classes can enforce their own specifications.

    template <typename B>
    struct frontend : B
    {
        frontend() : B()
        {
        }

        BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION((void), initialize)
        {
            this->initialize_impl(args);
        }
    };

Named parameters are required when invoking the member function; however, none of their tags need to be in the same namespace.

    BOOST_PARAMETER_NAME(a0)
    BOOST_PARAMETER_NAME(a1)
    BOOST_PARAMETER_NAME(a2)

For this example, each of the back-end class templates requires its own parameter to be present in the argument pack. In practice, such parameters should be optional, with default values.

    template <typename T>
    class backend0
    {
        T a0;

     public:
        backend0() : a0()
        {
        }

        T const& get_a0() const
        {
            return this->a0;
        }

     protected:
        template <typename ArgPack>
        void initialize_impl(ArgPack const& args)
        {
            this->a0 = args[_a0];
        }
    };

    template <typename B, typename T>
    class backend1 : public B
    {
        T a1;

     public:
        backend1() : B(), a1()
        {
        }

        T const& get_a1() const
        {
            return this->a1;
        }

     protected:
        template <typename ArgPack>
        void initialize_impl(ArgPack const& args)
        {
            B::initialize_impl(args);
            this->a1 = args[_a1];
        }
    };

    template <typename B, typename T>
    class backend2 : public B
    {
        T a2;

     public:
        backend2() : B(), a2()
        {
        }

        T const& get_a2() const
        {
            return this->a2;
        }

     protected:
        template <typename ArgPack>
        void initialize_impl(ArgPack const& args)
        {
            B::initialize_impl(args);
            this->a2 = args[_a2];
        }
    };

This example shows that while `backend0` must always be the root base class template and that `frontend` must always be the most derived class template, the other back-ends can be chained together in different orders.

    char const* p = "foo";
    frontend<
        backend2<backend1<backend0<char const*>, char>, int>
    > composed_obj0;
    frontend<
        backend1<backend2<backend0<char const*>, int>, char>
    > composed_obj1;
    composed_obj0.initialize(_a2 = 4, _a1 = ' ', _a0 = p);
    composed_obj1.initialize(_a0 = p, _a1 = ' ', _a2 = 4);
    BOOST_TEST_EQ(composed_obj0.get_a0(), composed_obj1.get_a0());
    BOOST_TEST_EQ(composed_obj0.get_a1(), composed_obj1.get_a1());
    BOOST_TEST_EQ(composed_obj0.get_a2(), composed_obj1.get_a2());

The parameterized_inheritance.cpp and preprocessor_eval_cat_no_spec.cpp test programs demonstrate proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function.
- `name` is the base name of the function; it determines the name of the generated implementation function. `name` may be qualified by the `static` keyword to declare the member function and its helpers as not associated with any object of the enclosing type.

Argument specifiers syntax:

None.

Approximate expansion:

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename TaggedArg0, typename ...TaggedArgs>
    using boost_param_no_spec_result_ ## __LINE__ ## name = result;

    // If result is a simple return type:
    template <typename TaggedArg0, typename ...TaggedArgs>
    struct boost_param_no_spec_result_ ## __LINE__ ## name
    {
        typedef result type;
    };

    template <typename TaggedArg0, typename ...TaggedArgs>
    inline typename boost::lazy_enable_if<
        are_tagged_arguments<TaggedArg0,TaggedArgs...>
      , boost_param_no_spec_result_ ## __LINE__ ## name<
            TaggedArg0
          , TaggedArgs...
        >
    >::type
        name(TaggedArg0 const& arg0, TaggedArgs const&... args)
    {
        return this->boost_param_no_spec_impl ## __LINE__ ## name(
            static_cast<
                typename
                boost_param_no_spec_result_ ## __LINE__ ## name<
                    TaggedArg0
                  , TaggedArgs...
                >::type(*)()
            >(std::nullptr)
          , compose(arg0, args...)
        );
    }

    template <typename ResultType, typename Args>
    ResultType
        boost_param_no_spec_impl ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
        )

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function body.

## 7.14 `BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION(result, name)`

Defined in: | boost/parameter/preprocessor_no_spec.hpp

Generates a member function that can take in named arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Named parameters are required when invoking the member function; however, none of their tags need to be in the same namespace.

    BOOST_PARAMETER_NAME((_lrc, kw0) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw1) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw2) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw3) consume(rr))

Use the macro as a substitute for a variadic function header. Enclose the return type `bool` in parentheses. The macro will qualify the function with the `const` keyword.

    struct D
    {
        D()
        {
        }

        BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION((bool), evaluate_m)
        {
            BOOST_TEST_EQ(
                passed_by_lvalue_reference_to_const
              , U::evaluate_category<0>(args[_lrc])
            );
            BOOST_TEST_EQ(
                passed_by_lvalue_reference
              , U::evaluate_category<1>(args[_lr])
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference_to_const
              , U::evaluate_category<2>(
                    args[_rrc | rvalue_const_bitset<2>()]
                )
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference
              , U::evaluate_category<3>(
                    args[_rr | rvalue_bitset<3>()]
                )
            );

            return true;
        }
    };

To invoke the member function, bind all its arguments to named parameters.

    D const d = D();
    d.evaluate_m(
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    d.evaluate_m(
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

The preprocessor_eval_cat_no_spec.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function.
- `name` is the base name of the function; it determines the name of the generated implementation function.

Argument specifiers syntax:

None.

Approximate expansion:

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename TaggedArg0, typename ...TaggedArgs>
    using boost_param_no_spec_result_const_ ## __LINE__ ## name = result;

    // If result is a simple return type:
    template <typename TaggedArg0, typename ...TaggedArgs>
    struct boost_param_no_spec_result_const_ ## __LINE__ ## name
    {
        typedef result type;
    };

    template <typename TaggedArg0, typename ...TaggedArgs>
    inline typename boost::lazy_enable_if<
        are_tagged_arguments<TaggedArg0,TaggedArgs...>
      , boost_param_no_spec_result_const_ ## __LINE__ ## name<
            TaggedArg0
          , TaggedArgs...
        >
    >::type
        name(TaggedArg0 const& arg0, TaggedArgs const&... args) const
    {
        return this->boost_param_no_spec_impl_const ## __LINE__ ## name(
            static_cast<
                typename
                boost_param_no_spec_result_const_ ## __LINE__ ## name<
                    TaggedArg0
                  , TaggedArgs...
                >::type(*)()
            >(std::nullptr)
          , compose(arg0, args...)
        );
    }

    template <typename ResultType, typename Args>
    ResultType
        boost_param_no_spec_impl_const ## __LINE__ ## name(
            (ResultType(*)())
          , Args const& args
        ) const

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function body.

## 7.15 `BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR(result)`

Defined in: | boost/parameter/preprocessor_no_spec.hpp

Generates a function call operator that can take in named arguments.

Example usage: |

When designing a front-end class template whose back-end is configurable via parameterized inheritance, it can be useful to omit argument specifiers from a named-parameter function call operator so that the delegate member functions of the back-end classes can enforce their own specifications.

    template <typename B>
    struct frontend : B
    {
        frontend() : B()
        {
        }

        BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR((void))
        {
            this->initialize_impl(args);
        }
    };

Named parameters are required when invoking the function call operator; however, none of their tags need to be in the same namespace.

    BOOST_PARAMETER_NAME(a0)
    BOOST_PARAMETER_NAME(a1)
    BOOST_PARAMETER_NAME(a2)

For this example, each of the back-end class templates requires its own parameter to be present in the argument pack. In practice, such parameters should be optional, with default values.

    template <typename T>
    class backend0
    {
        T a0;

     public:
        backend0() : a0()
        {
        }

        T const& get_a0() const
        {
            return this->a0;
        }

     protected:
        template <typename ArgPack>
        void initialize_impl(ArgPack const& args)
        {
            this->a0 = args[_a0];
        }
    };

    template <typename B, typename T>
    class backend1 : public B
    {
        T a1;

     public:
        backend1() : B(), a1()
        {
        }

        T const& get_a1() const
        {
            return this->a1;
        }

     protected:
        template <typename ArgPack>
        void initialize_impl(ArgPack const& args)
        {
            B::initialize_impl(args);
            this->a1 = args[_a1];
        }
    };

    template <typename B, typename T>
    class backend2 : public B
    {
        T a2;

     public:
        backend2() : B(), a2()
        {
        }

        T const& get_a2() const
        {
            return this->a2;
        }

     protected:
        template <typename ArgPack>
        void initialize_impl(ArgPack const& args)
        {
            B::initialize_impl(args);
            this->a2 = args[_a2];
        }
    };

This example shows that while `backend0` must always be the root base class template and that `frontend` must always be the most derived class template, the other back-ends can be chained together in different orders.

    char const* p = "foo";
    frontend<
        backend2<backend1<backend0<char const*>, char>, int>
    > composed_obj0;
    frontend<
        backend1<backend2<backend0<char const*>, int>, char>
    > composed_obj1;
    composed_obj0(_a2 = 4, _a1 = ' ', _a0 = p);
    composed_obj1(_a0 = p, _a1 = ' ', _a2 = 4);
    BOOST_TEST_EQ(composed_obj0.get_a0(), composed_obj1.get_a0());
    BOOST_TEST_EQ(composed_obj0.get_a1(), composed_obj1.get_a1());
    BOOST_TEST_EQ(composed_obj0.get_a2(), composed_obj1.get_a2());

The parameterized_inheritance.cpp and preprocessor_eval_cat_no_spec.cpp test programs demonstrate proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function call operator.

Argument specifiers syntax:

None.

Approximate expansion:

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename TaggedArg0, typename ...TaggedArgs>
    using boost_param_no_spec_result_ ## __LINE__ ## operator = result;

    // If result is a simple return type:
    template <typename TaggedArg0, typename ...TaggedArgs>
    struct boost_param_no_spec_result_ ## __LINE__ ## operator
    {
        typedef result type;
    };

    template <typename TaggedArg0, typename ...TaggedArgs>
    inline typename boost::lazy_enable_if<
        are_tagged_arguments<TaggedArg0,TaggedArgs...>
      , boost_param_no_spec_result_ ## __LINE__ ## operator<
            TaggedArg0
          , TaggedArgs...
        >
    >::type
        operator()(TaggedArg0 const& arg0, TaggedArgs const&... args)
    {
        return this->boost_param_no_spec_impl ## __LINE__ ## operator(
            static_cast<
                typename
                boost_param_no_spec_result_ ## __LINE__ ## operator<
                    TaggedArg0
                  , TaggedArgs...
                >::type(*)()
            >(std::nullptr)
          , compose(arg0, args...)
        );
    }

    template <typename ResultType, typename Args>
    ResultType
        boost_param_no_spec_impl ## __LINE__ ## operator(
            (ResultType(*)())
          , Args const& args
        )

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function body.

## 7.16 `BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR(result)`

Defined in: | boost/parameter/preprocessor_no_spec.hpp

Generates a function call operator that can take in named arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Named parameters are required when invoking the function call operator; however, none of their tags need to be in the same namespace.

    BOOST_PARAMETER_NAME((_lrc, kw0) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw1) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw2) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw3) consume(rr))

Use the macro as a substitute for a variadic function call operator header. Enclose the return type `bool` in parentheses. The macro will qualify the function with the `const` keyword.

    struct D
    {
        D()
        {
        }

        BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR((bool))
        {
            BOOST_TEST_EQ(
                passed_by_lvalue_reference_to_const
              , U::evaluate_category<0>(args[_lrc])
            );
            BOOST_TEST_EQ(
                passed_by_lvalue_reference
              , U::evaluate_category<1>(args[_lr])
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference_to_const
              , U::evaluate_category<2>(
                    args[_rrc | rvalue_const_bitset<2>()]
                )
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference
              , U::evaluate_category<3>(
                    args[_rr | rvalue_bitset<3>()]
                )
            );

            return true;
        }
    };

To invoke the function call operator, bind all its arguments to named parameters.

    D const d = D();
    d(
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    d(
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

The preprocessor_eval_cat_no_spec.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `result` is the parenthesized return type of the function call operator.

Argument specifiers syntax:

None.

Approximate expansion:

    // If result is a template instantiation of boost::enable_if,
    // boost::enable_if_c, boost::lazy_enable_if,
    // boost::lazy_enable_if_c, boost::disable_if, boost::disable_if_c,
    // boost::lazy_disable_if, boost::lazy_disable_if_c, or
    // std::enable_if:
    template <typename TaggedArg0, typename ...TaggedArgs>
    using boost_param_no_spec_result_const_ ## __LINE__ ## operator = result;

    // If result is a simple return type:
    template <typename TaggedArg0, typename ...TaggedArgs>
    struct boost_param_no_spec_result_const_ ## __LINE__ ## operator
    {
        typedef result type;
    };

    template <typename TaggedArg0, typename ...TaggedArgs>
    inline typename boost::lazy_enable_if<
        are_tagged_arguments<TaggedArg0,TaggedArgs...>
      , boost_param_no_spec_result_const_ ## __LINE__ ## operator<
            TaggedArg0
          , TaggedArgs...
        >
    >::type
        operator()(
            TaggedArg0 const& arg0
          , TaggedArgs const&... args
        ) const
    {
        return this->boost_param_no_spec_impl_const ## __LINE__ ## operator(
            static_cast<
                typename
                boost_param_no_spec_result_const_ ## __LINE__ ## operator<
                    TaggedArg0
                  , TaggedArgs...
                >::type(*)()
            >(std::nullptr)
          , compose(arg0, args...)
        );
    }

    template <typename ResultType, typename Args>
    ResultType
        boost_param_no_spec_impl_const ## __LINE__ ## operator(
            (ResultType(*)())
          , Args const& args
        ) const

Only the ArgumentPack type `Args` and its object instance `args` are available for use within the function body.

## 7.17 `BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR(cls, impl)`

Defined in: | boost/parameter/preprocessor_no_spec.hpp

Generates a constructor that can take in named arguments.

Example usage: |

When designing a front-end class template whose back-end is configurable via parameterized inheritance, it can be useful to omit argument specifiers from a named-parameter constructor so that the delegate constructors of the back-end classes can enforce their own specifications.

    template <typename B>
    struct frontend : B
    {
        BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR(frontend, (B))
    };

Named parameters are required when invoking the constructor; however, none of their tags need to be in the same namespace.

    BOOST_PARAMETER_NAME(a0)
    BOOST_PARAMETER_NAME(a1)
    BOOST_PARAMETER_NAME(a2)

For this example, each of the back-end class templates requires its own parameter to be present in the argument pack. In practice, such parameters should be optional, with default values.

    struct _enabler
    {
    };

    template <typename T>
    class backend0
    {
        T a0;

     public:
        template <typename ArgPack>
        explicit backend0(
            ArgPack const& args
          , typename boost::enable_if<
                is_argument_pack<ArgPack>
              , _enabler
            >::type = _enabler()
        ) : a0(args[_a0])
        {
        }

        T const& get_a0() const
        {
            return this->a0;
        }
    };

    template <typename B, typename T>
    class backend1 : public B
    {
        T a1;

     public:
        template <typename ArgPack>
        explicit backend1(
            ArgPack const& args
          , typename boost::enable_if<
                is_argument_pack<ArgPack>
              , _enabler
            >::type = _enabler()
        ) : B(args), a1(args[_a1])
        {
        }

        T const& get_a1() const
        {
            return this->a1;
        }
    };

    template <typename B, typename T>
    class backend2 : public B
    {
        T a2;

     public:
        template <typename ArgPack>
        explicit backend2(
            ArgPack const& args
          , typename boost::enable_if<
                is_argument_pack<ArgPack>
              , _enabler
            >::type = _enabler()
        ) : B(args), a2(args[_a2])
        {
        }

        T const& get_a2() const
        {
            return this->a2;
        }
    };

This example shows that while `backend0` must always be the root base class template and that `frontend` must always be the most derived class template, the other back-ends can be chained together in different orders.

    char const* p = "foo";
    frontend<
        backend2<backend1<backend0<char const*>, char>, int>
    > composed_obj0(_a2 = 4, _a1 = ' ', _a0 = p);
    frontend<
        backend1<backend2<backend0<char const*>, int>, char>
    > composed_obj1(_a0 = p, _a1 = ' ', _a2 = 4);
    BOOST_TEST_EQ(composed_obj0.get_a0(), composed_obj1.get_a0());
    BOOST_TEST_EQ(composed_obj0.get_a1(), composed_obj1.get_a1());
    BOOST_TEST_EQ(composed_obj0.get_a2(), composed_obj1.get_a2());

The parameterized_inheritance.cpp and preprocessor_eval_cat_no_spec.cpp test programs demonstrate proper usage of this macro.

Macro parameters:

- `cls` is the name of the enclosing class.
- `impl` is the parenthesized implementation base class for `cls`.

Argument specifiers syntax:

None.

Approximate expansion:

    template <
        typename TaggedArg0
      , typename ...TaggedArgs
      , typename = typename boost::enable_if<
            are_tagged_arguments<TaggedArg0,TaggedArgs...>
        >::type
    >
    inline explicit cls(
        TaggedArg0 const& arg0
      , TaggedArgs const&... args
    ) : impl(compose(arg0, args...))
    {
    }

## 7.18 `BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR(cls, impl)`

Defined in: | boost/parameter/preprocessor_no_spec.hpp

Generates a constructor that can take in named arguments.

Example usage: |

The return type of each of the following function templates falls under a different value category.

    template <std::size_t N>
    std::bitset<N + 1> rvalue_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1> const rvalue_const_bitset()
    {
        return std::bitset<N + 1>();
    }

    template <std::size_t N>
    std::bitset<N + 1>& lvalue_bitset()
    {
        static std::bitset<N + 1> lset = std::bitset<N + 1>();
        return lset;
    }

    template <std::size_t N>
    std::bitset<N + 1> const& lvalue_const_bitset()
    {
        static std::bitset<N + 1> const clset = std::bitset<N + 1>();
        return clset;
    }

The `U::evaluate_category` static member function template has a simple job: to return the correct value category when passed in an object returned by one of the functions defined above. Assume that `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined.

    enum invoked
    {
        passed_by_lvalue_reference_to_const
      , passed_by_lvalue_reference
      , passed_by_rvalue_reference_to_const
      , passed_by_rvalue_reference
    };

    struct U
    {
        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&)
        {
            return passed_by_lvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&)
        {
            return passed_by_lvalue_reference;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1> const&&)
        {
            return passed_by_rvalue_reference_to_const;
        }

        template <std::size_t N>
        static invoked evaluate_category(std::bitset<N + 1>&&)
        {
            return passed_by_rvalue_reference;
        }
    };

Named parameters are required when invoking the constructor; however, none of their tags need to be in the same namespace.

    BOOST_PARAMETER_NAME((_lrc, kw0) in(lrc))
    BOOST_PARAMETER_NAME((_lr, kw1) in_out(lr))
    BOOST_PARAMETER_NAME((_rrc, kw2) in(rrc))
    BOOST_PARAMETER_NAME((_rr, kw3) consume(rr))

Unlike `BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR`, this macro doesn't require a base class, only a delegate function to which the generated constructor can pass its ArgumentPack.

    struct D
    {
        BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR(D, D::_evaluate)

     private:
        template <typename Args>
        static bool _evaluate(Args const& args)
        {
            BOOST_TEST_EQ(
                passed_by_lvalue_reference_to_const
              , U::evaluate_category<0>(args[_lrc])
            );
            BOOST_TEST_EQ(
                passed_by_lvalue_reference
              , U::evaluate_category<1>(args[_lr])
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference_to_const
              , U::evaluate_category<2>(
                    args[_rrc | rvalue_const_bitset<2>()]
                )
            );
            BOOST_TEST_EQ(
                passed_by_rvalue_reference
              , U::evaluate_category<3>(
                    args[_rr | rvalue_bitset<3>()]
                )
            );

            return true;
        }
    };

To invoke the constructor, bind all its arguments to named parameters.

    D dp0(
        _rr0 = rvalue_bitset<3>()
      , _lrc0 = lvalue_const_bitset<0>()
      , _lr0 = lvalue_bitset<1>()
      , _rrc0 = rvalue_const_bitset<2>()
    );
    D dp1(
        _lr0 = lvalue_bitset<1>()
      , _lrc0 = lvalue_const_bitset<0>()
    );

The preprocessor_eval_cat_no_spec.cpp test program demonstrates proper usage of this macro.

Macro parameters:

- `cls` is the name of the enclosing class.
- `func` is a function that takes in the ArgumentPack that the generated constructor passes on.

Argument specifiers syntax:

None.

Approximate expansion:

    template <
        typename TaggedArg0
      , typename ...TaggedArgs
      , typename = typename boost::enable_if<
            are_tagged_arguments<TaggedArg0,TaggedArgs...>
        >::type
    >
    inline explicit cls(
        TaggedArg0 const& arg0
      , TaggedArgs const&... args
    )
    {
        func(compose(arg0, args...));
    }

## 7.19 `BOOST_PARAMETER_NAME(name)`

Defined in: | boost/parameter/name.hpp

Declares a tag-type and keyword object.

If name is of the form:

    (object-name, namespace-name) qualifier(tag-name)

then

Requires: | qualifier is either `in`, `out`, `in_out`, `consume`, `move_from`, or `forward`.
Expands to: |

    namespace namespace-name {

        struct tag-name
        {
            static constexpr char const* keyword_name()
            {
                return ## tag-name;
            }

            typedef unspecified _;
            typedef unspecified _1;
            typedef boost::parameter::qualifier ## _reference qualifier;

            // The following definitions are available only when
            // BOOST_PARAMETER_CAN_USE_MP11 is defined.

            template <typename ArgumentPack>
            using binding_fn = typename binding<
                ArgumentPack
              , tag-name
            >::type;

            template <typename ArgumentPack>
            using fn = typename value_type<ArgumentPack, tag-name>::type;
        };
    }

    keyword<tag-namespace::tag-name> const& object-name
        = keyword<tag-namespace::tag-name>::instance;

Else If name is of the form:

    (tag-name, namespace-name) object-name

then

Treats name as if it were of the form:

    (forward(tag-name), namespace-name) object-name

Else If name is of the form:

    qualifier(tag-name)

then

Requires: | qualifier is either `in`, `out`, `in_out`, `consume`, `move_from`, or `forward`.
Expands to: |

    namespace tag {

        struct tag-name
        {
            static constexpr char const* keyword_name()
            {
                return ## tag-name;
            }

            typedef unspecified _;
            typedef unspecified _1;
            typedef boost::parameter::qualifier ## _reference qualifier;

            // The following definitions are available only when
            // BOOST_PARAMETER_CAN_USE_MP11 is defined.

            template <typename ArgumentPack>
            using binding_fn = typename binding<
                ArgumentPack
              , tag-name
            >::type;

            template <typename ArgumentPack>
            using fn = typename value_type<ArgumentPack, tag-name>::type;
        };
    }

    keyword<tag::tag-name> const& _ ## tag-name
        = keyword<tag::tag-name>::instance;

Else

Treats name as if it were of the form:

    forward(tag-name)

## 7.20 `BOOST_PARAMETER_NESTED_KEYWORD(tag_namespace, name, alias)`

Defined in: | boost/parameter/nested_keyword.hpp

Declares a tag-type, a keyword object, and an alias for that object nested in the tag-type.

If name is of the form:

    qualifier(tag-name)

then

Requires: | qualifier is either `in`, `out`, `in_out`, `consume`, `move_from`, or `forward`.
Expands to: |

    namespace tag {

        struct tag-name
        {
            static constexpr char const* keyword_name()
            {
                return ## tag-name ## _;
            }

            typedef unspecified _;
            typedef unspecified _1;
            typedef boost::parameter::qualifier ## _reference qualifier;
            static keyword<tag-name> const& alias;

            // The following definitions are available only when
            // BOOST_PARAMETER_CAN_USE_MP11 is defined.

            template <typename ArgumentPack>
            using binding_fn = typename binding<
                ArgumentPack
              , tag-name
            >::type;

            template <typename ArgumentPack>
            using fn = typename value_type<ArgumentPack, tag-name>::type;
        };

        keyword<tag-name> const& tag::tag-name::alias
            = keyword<tag-name>::instance;
    }

    keyword<tag::tag-name> const& tag::tag-name::name
        = keyword<tag::tag-name>::instance;

Else

Treats name as if it were of the form:

    forward(tag-name)

## 7.21 `BOOST_PARAMETER_TEMPLATE_KEYWORD(name)`

Defined in: | boost/parameter/template_keyword.hpp
Included by: | boost/parameter/name.hpp
Expands to: |

    namespace tag {

        struct name;
    }

    template <typename T>
    struct name : template_keyword<tag:: name, T>
    {
    };

The function_type_tpl_param.cpp test program demonstrates proper usage of this macro.

## 7.22 `BOOST_PARAMETER_FUN(r, n, l, h, p)`

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 positional arguments.

Defined in: | boost/parameter/macros.hpp
Requires: | `l` and `h` are nonnegative integer tokens such that `l` < `h`
Expands to: |

    template <typename A1, typename A2, …, typename A ## l>
    r
        name(
            A1 && a1, A2 && a2, …, A ## l && a ## l
          , typename p::match<A1, A2, …, A ## l>::type p = p()
        )
    {
        return name_with_named_params(
            p(
                std::forward<A1>(a1)
              , std::forward<A2>(a2)
              , …
              , std::forward<A ## l>(a ## l)
            )
        );
    }

    template <
        typename A1
      , typename A2
      , …
      , typename A ## l
      , typename A ## BOOST_PP_INC(l)
    >
    r
        name(
            A1 && a1, A2 && a2, …, A ## l && a ## l
          , A ## BOOST_PP_INC(l) const& a ## BOOST_PP_INC(l)
          , typename p::match<
                A1, A2, …, A ## l, A ## BOOST_PP_INC(l)
            >::type p = p()
        )
    {
        return name_with_named_params(
            p(
                std::forward<A1>(a1)
              , std::forward<A2>(a2)
              , …
              , std::forward<A ## l>(a ## l)
              , std::forward<A ## BOOST_PP_INC(l)>(
                    a ## BOOST_PP_INC(l)
                )
            )
        );
    }

    ⋮

    template <typename A1, typename A2, …, typename A ## h>
    r
        name(
            A1 && a1, A2 && a2, …, A ## h && x ## h
          , typename p::match<A1, A2, …, A ## h>::type p = p()
        )
    {
        return name_with_named_params(
            p(
                std::forward<A1>(a1)
              , std::forward<A2>(a2)
              , …
              , std::forward<A ## h>(a ## h)
            )
        );
    }

The macros.cpp and macros_eval_category.cpp test programs demonstrate proper usage of this macro.

## 7.23 `BOOST_PARAMETER_KEYWORD(n, k)`

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.

Defined in: | boost/parameter/keyword.hpp
Expands to: |

    namespace n {

        struct k
        {
            static constexpr char const* keyword_name()
            {
                return ## k;
            }

            typedef unspecified _;
            typedef unspecified _1;
            typedef boost::parameter::forward_reference qualifier;

            // The following definitions are available only when
            // BOOST_PARAMETER_CAN_USE_MP11 is defined.

            template <typename ArgumentPack>
            using binding_fn = typename binding<
                ArgumentPack
              , k
            >::type;

            template <typename ArgumentPack>
            using fn = typename value_type<ArgumentPack, k>::type;
        };
    }

    namespace {

        keyword<n::k> const& k
            = keyword<n::k>::instance;
    }

## 7.24 `BOOST_PARAMETER_MATCH(p, a, x)`

Generates a defaulted parameter declaration for a forwarding function.

Defined in: | boost/parameter/match.hpp
Requires: | `a` is a Boost.Preprocessor sequence of the form

    (A0)(A1)…(A ## n)

Expands to: |

    typename p::match<A0, A1, …, A ## n>::type
        x = p()

# 8 Configuration Macros

## 8.1 `BOOST_PARAMETER_HAS_PERFECT_FORWARDING`

Determines whether or not the library supports perfect forwarding, or the preservation of parameter value categories. Users can manually disable this macro by `#defining` the `BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING` macro. Otherwise, the library will `#define` this macro if and only if it is not already defined, and if the configuration macros `BOOST_NO_FUNCTION_TEMPLATE_ORDERING`, `BOOST_NO_SFINAE`, `BOOST_NO_CXX11_RVALUE_REFERENCES`, `BOOST_NO_CXX11_VARIADIC_TEMPLATES`, and `BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS` are not already defined by Boost.Config.

Defined in: | boost/parameter/config.hpp

## 8.2 `BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING`

It may be necessary to test user code in case perfect forwarding support is unavailable. Users can `#define` this macro either in their project settings or before including any library header files. Doing so will leave both `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` and `BOOST_PARAMETER_CAN_USE_MP11` undefined.

## 8.3 `BOOST_PARAMETER_CAN_USE_MP11`

Determines whether or not the library can use Boost.MP11, a C++11 metaprogramming library. Users can manually disable this macro by `#defining` the `BOOST_PARAMETER_DISABLE_MP11_USAGE` macro or the `BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING` macro. Otherwise, the library will `#define` this macro if and only if it is not already defined, if `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is defined, and if the configuration macros `BOOST_NO_CXX11_CONSTEXPR`, `BOOST_NO_CXX11_DECLTYPE_N3276`, `BOOST_NO_CXX11_AUTO_DECLARATIONS`, `BOOST_NO_CXX11_TEMPLATE_ALIASES`, `BOOST_NO_CXX11_STATIC_ASSERT`, `BOOST_NO_CXX11_HDR_TYPE_TRAITS`, `BOOST_NO_CXX11_HDR_INITIALIZER_LIST`, and `BOOST_NO_CXX11_HDR_TUPLE` are not already defined by Boost.Config.

Usage Note

Boost.MP11 and Boost.MPL are not mutually exclusive. It's perfectly acceptable to specify deduced parameters using both quoted metafunctions and metafunction classes, for example. See evaluate_category.cpp.

Defined in: | boost/parameter/config.hpp
Example usage: |

Given the following definitions:

    BOOST_PARAMETER_NAME(x)

    template <typename A0>
    typename boost::enable_if<std::is_same<int,A0>,int>::type
        sfinae(A0 const& a0)
    {
        return 0;
    }

Boost.MP11 allows deduced parameters to be defined more succinctly:

    template <typename T, typename Args>
    using predicate = std::is_convertible<T,char const*>;

    BOOST_PARAMETER_FUNCTION((int), sfinae, tag,
        (deduced
            (optional
                (x
                  , *(boost::mp11::mp_quote<predicate>)
                  , static_cast<char const*>(std::nullptr)
                )
            )
        )
    )
    {
        return 1;
    }

Without Boost.MP11, deduced parameter definitions tend to be more verbose:

    struct predicate
    {
        template <typename T, typename Args>
        struct apply
          : mpl::if_<
                boost::is_convertible<T,char const*>
              , mpl::true_  // Still have to convert to a
              , mpl::false_ // Boolean Integral Constant.
            >
        {
        };
    };

    BOOST_PARAMETER_FUNCTION((int), sfinae, tag,
        (deduced
            (optional
                (x
                  , *(predicate)
                  , static_cast<char const*>(std::nullptr)
                )
            )
        )
    )
    {
        return 1;
    }

Either way, the following assertions will succeed:

    assert(1 == sfinae());
    assert(1 == sfinae("foo"));
    assert(0 == sfinae(1));

As another example, given the following declarations and definitions:

    BOOST_PARAMETER_NAME(x)
    BOOST_PARAMETER_NAME(y)

    template <typename E, typename Args>
    void check0(E const& e, Args const& args);

    template <typename P, typename E, typename ...Args>
    void check(E const& e, Args const&... args)
    {
        check0(e, P()(args...));
    }

Argument packs qualify as Boost.MP11-style lists containing keyword tag types:

    template <typename Args>
    struct some_functor
    {
        template <typename K>
        void operator()(K&&) const
        {
            // K is one of tag::x, tag::y, etc.
        }
    };

    template <typename E, typename Args>
    void check0(E const& e, Args const& args)
    {
        boost::mp11::mp_for_each<E>(some_functor<Args>());
    }

The first check determines whether or not the argument type of `_y` is the same as the reference type of `_x`, while the second check determines whether or not the argument type of `_y` is convertible to the value type of `_x`. Here, it's possible to access the reference and value result types of indexing an argument pack a little more directly:

    // Use mp_bind on tag::x::binding_fn to access the reference type of _x.
    check<
        parameters<
            tag::x
          , optional<
                deduced<tag::y>
              , boost::mp11::mp_bind<
                    std::is_same // boost::is_same, standard version.
                  , boost::mp11::_1 // will be bound to the argument type of _y.
                  , boost::mp11::mp_bind<
                        tag::x::binding_fn
                      , boost::mp11::_2 // will be bound to the argument pack type.
                    >
                >
            >
        >
    >((_x = 0, _y = 1), 0, 1);

    // Use mp_bind_q on tag::x to access the value type of _x.
    check<
        parameters<
            tag::x
          , optional<
                deduced<tag::y>
              , boost::mp11::mp_bind<
                    std::is_convertible // boost::is_convertible, standard version.
                  , boost::mp11::_1 // will be bound to the argument type of _y.
                  , boost::mp11::mp_bind_q<
                        tag::x
                      , boost::mp11::_2 // will be bound to the argument pack type.
                    >
                >
            >
        >
    >((_x = 0U, _y = 1U), 0U, 1U);

Argument packs still qualify as Boost.MPL-style lists containing keyword tag types:

    template <typename Args>
    struct some_functor
    {
        template <typename K>
        void operator()(K) const
        {
            // K is one of tag::x, tag::y, etc.
        }
    };

    template <typename E, typename Args>
    void check0(E const& e, Args const& args)
    {
        boost::mpl::for_each<E>(some_functor<Args>());
    }

However, without Boost.MP11, the corresponding checks become a little more verbose:

    check<
        parameters<
            tag::x
          , optional<
                deduced<tag::y>
              , mpl::if_<
                    boost::is_same<
                        boost::add_lvalue_reference<boost::mp11::_1>
                      , binding<boost::mp11::_2, tag::x>
                    >
                  , mpl::true_  // Still have to convert to a
                  , mpl::false_ // Boolean Integral Constant.
                >
            >
        >
    >((_x = 0, _y = 1), 0, 1);

    // Use tag::x::_ or tag::x::_1 to access the value type of _x.
    check<
        parameters<
            tag::x
          , optional<
                deduced<tag::y>
              , mpl::if_<
                    boost::is_convertible<boost::mp11::_1, tag::x::_1>
                  , mpl::true_  // Still have to convert to a
                  , mpl::false_ // Boolean Integral Constant.
                >
            >
        >
    >((_x = 0U, _y = 1U), 0U, 1U);

The singular.cpp, compose.cpp, optional_deduced_sfinae.cpp, and deduced_dependent_predicate.cpp test programs demonstrate proper usage of this macro.

## 8.4 `BOOST_PARAMETER_DISABLE_MP11_USAGE`

It may be necessary to disable usage of Boost.MP11 for compilers that cannot support it. Users can `#define` this macro either in their project settings or before including any library header files. Doing so will leave `BOOST_PARAMETER_CAN_USE_MP11` undefined.

## 8.5 `BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE`

If `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is `#defined`, then determines the MPL Variadic Sequence underlying the nested `parameter_spec` type of `parameters`. If the user does not manually `#define` this macro, then the library will `#define` it as `boost::mp11::mp_list` if `BOOST_PARAMETER_CAN_USE_MP11` is defined, `boost::fusion::list` if `BOOST_FUSION_HAS_VARIADIC_LIST` is defined (by Boost.Fusion), `boost::fusion::deque` if `BOOST_FUSION_HAS_VARIADIC_DEQUE` is defined (by Boost.Fusion), or `boost::mpl::vector` otherwise.

Example: |

    #define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE boost::fusion::vector

Defined in: | boost/parameter/parameters.hpp

## 8.6 `BOOST_PARAMETER_MAX_ARITY`

If `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is `#defined`, then:

- If the MPL Variadic Sequence underlying the nested `parameter_spec` type of `parameters` does not have a size limit--which is the case with `boost::mp11::mp_list`, `boost::fusion::list`, and `boost::fusion::deque`, but not `boost::mpl::vector`--then this macro can be safely ignored. User code that manually defines `BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE` should also manually define this macro to the size limit of the sequence if it has one.

If `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is not `#defined`, then:

- Mutable references must be wrapped by `boost::ref` or `std::ref` if passed by position to Boost.Parameter-enabled functions with arity greater than or equal to `BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY`.

Defined in: | boost/parameter/config.hpp
Default Value: | `BOOST_MPL_LIMIT_VECTOR_SIZE` (defined by Boost.MPL) if perfect forwarding is supported, `8` otherwise.
Minimum Value: | `2`
Maximum Value: | `BOOST_PARAMETER_COMPOSE_MAX_ARITY`

## 8.7 `BOOST_PARAMETER_COMPOSE_MAX_ARITY`

If `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is not `#defined`, then determines the maximum number of arguments supported by the `compose` function and by the `BOOST_PARAMETER_NO_SPEC_FUNCTION`, `BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION`, `BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION`, `BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR`, `BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR`, `BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR`, and `BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR` code generation macros.

Defined in: | boost/parameter/config.hpp
Default Value: | `20` for a few older compilers, `64` otherwise
Minimum Value: | `2`

## 8.8 `BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY`

If this library does not support perfect forwarding, determines the number of arguments less than which `parameters` generates an exponential number of function call operator overloads, and greater than or equal to which `parameters` does not. Will only be `#defined` by the library if it is not already `#defined` and `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` is not `#defined`.

Defined in: | boost/parameter/config.hpp
Default Value: | `0`
Minimum Value: | `0`

## 8.9 ...Outside Of This Library

1. If Boost.Config defines the macro `BOOST_NO_FUNCTION_TEMPLATE_ORDERING`, then the macros `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` and `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined; otherwise, the code generation macros would not work correctly.
2. If Boost.Config defines the macro `BOOST_NO_SFINAE`, then the macros `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` and `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined; otherwise, keyword types generated by `BOOST_PARAMETER_NAME` and `BOOST_PARAMETER_NESTED_KEYWORD` would not work correctly.
3. If Boost.Config defines the macro `BOOST_NO_CXX11_RVALUE_REFERENCES`, then the macros `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` and `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
4. If Boost.Config defines the macro `BOOST_NO_CXX11_VARIADIC_TEMPLATES`, then the macros `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` and `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
5. If Boost.Config defines the macro `BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS`, then the macros `BOOST_PARAMETER_HAS_PERFECT_FORWARDING` and `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
6. If Boost.Config defines the macro `BOOST_NO_CXX11_CONSTEXPR`, then the macro `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
7. If Boost.Config defines the macro `BOOST_NO_CXX11_DECLTYPE_N3276`, then the macro `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
8. If Boost.Config defines the macro `BOOST_NO_CXX11_AUTO_DECLARATIONS`, then the macro `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
9. If Boost.Config defines the macro `BOOST_NO_CXX11_TEMPLATE_ALIASES`, then the macro `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
10. If Boost.Config defines the macro `BOOST_NO_CXX11_STATIC_ASSERT`, then the macro `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
11. If Boost.Config defines the macro `BOOST_NO_CXX11_HDR_TYPE_TRAITS`, then the macro `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
12. If Boost.Config defines the macro `BOOST_NO_CXX11_HDR_INITIALIZER_LIST`, then the macro `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
13. If Boost.Config defines the macro `BOOST_NO_CXX11_HDR_TUPLE`, then the macro `BOOST_PARAMETER_CAN_USE_MP11` will be left undefined.
14. If Boost.Fusion defines the macro `BOOST_FUSION_HAS_VARIADIC_LIST`, if this library defines the macro `BOOST_PARAMETER_HAS_PERFECT_FORWARDING`, and if `BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE` is left undefined, then the MPL Variadic Sequence underlying the nested `parameter_spec` type of `parameters` will be `boost::fusion::list`.
15. If Boost.Fusion defines the macro `BOOST_FUSION_HAS_VARIADIC_DEQUE`, if this library defines the macro `BOOST_PARAMETER_HAS_PERFECT_FORWARDING`, and if `BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE` is left undefined, then the MPL Variadic Sequence underlying the nested `parameter_spec` type of `parameters` will be `boost::fusion::deque`.
16. The value that Boost.MPL defines the macro `BOOST_MPL_LIMIT_VECTOR_SIZE` as will be the value that this library defines the macro `BOOST_PARAMETER_MAX_ARITY` as if this library defines the macro `BOOST_PARAMETER_HAS_PERFECT_FORWARDING`.

# 9 Tutorial

Follow this link to the Boost.Parameter tutorial documentation.

[1] | References to tag objects may be initialized multiple times. This scenario can only occur in the presence of threading. Because the C++ standard doesn't consider threading, it doesn't explicitly allow or forbid multiple initialization of references. That said, it's hard to imagine an implementation where it could make a difference.

[2] | (1, 2, 3) Where `BOOST_NO_RESULT_OF` is `#defined`, `boost::result_of``<F()>::type` is replaced by `F::result_type`.