## boost/python/implicit.hpp

### Introduction

`implicitly_convertible` allows Boost.Python to implicitly take advantage of a C++ implicit or explicit conversion when matching Python objects to C++ argument types.

### Function template `implicit_convertible`

    template <class Source, class Target>
    void implicitly_convertible();

Parameter | Description
--- | ---
Source | The source type of the implicit conversion
Target | The target type of the implicit conversion

Requires

  The declaration `Target t(s);`, where s is of type Source, is valid.

Effects

  registers an rvalue `from_python` converter to Target which can succeed for any `PyObject* p` iff there exists any registered converter which can produce Source rvalues

Rationale

  C++ users expect to be able to take advantage of the same sort of interoperability in Python as they do in C++.

### Example

In C++:

    #include <boost/python/class.hpp>
    #include <boost/python/implicit.hpp>
    #include <boost/python/module.hpp>

    using namespace boost::python;

    struct X
    {
        X(int x) : v(x) {}
        operator int() const { return v; }
        int v;
    };

    int x_value(X const& x)
    {
        return x.v;
    }

    X make_x(int n) { return X(n); }

    BOOST_PYTHON_MODULE(implicit_ext)
    {
        def("x_value", x_value);
        def("make_x", make_x);

        class_<X>("X",
            init<int>())
            ;

        implicitly_convertible<X,int>();
        implicitly_convertible<int,X>();
    }

In Python:

    >>> from implicit_ext import *
    >>> x_value(X(42))
    42
    >>> x_value(42)
    42
    >>> x = make_x(X(42))
    >>> x_value(x)
    42