###

# Boost.Python

## Header <boost/python/def.hpp>

## Contents

Introduction
Functions
  def
Example

## Introduction

`def()` is the function which can be used to expose C++ functions and callable objects as Python functions in the current `scope`.

## Functions

def

    template <class F>
    void def(char const* name, F f);

    template <class Fn, class A1>
    void def(char const* name, Fn fn, A1 const&);

    template <class Fn, class A1, class A2>
    void def(char const* name, Fn fn, A1 const&, A2 const&);

    template <class Fn, class A1, class A2, class A3>
    void def(char const* name, Fn fn, A1 const&, A2 const&, A3 const&);

Requires: `name` is an ntbs which conforms to Python's identifier naming rules.
  - If `Fn` is [derived from] `object`, it will be added to the current scope as a single overload. To be useful, `fn` should be callable.
  - If `a1` is the result of an overload-dispatch-expression, only the second form is allowed and fn must be a pointer to function or pointer to member function whose arity is the same as A1's maximum arity.
    Effects: For each prefix P of `Fn`'s sequence of argument types, beginning with the one whose length is `A1`'s minimum arity, adds a `name(`...`)` function overload to the current scope. Each overload generated invokes `a1`'s call-expression with P, using a copy of `a1`'s call policies. If the longest valid prefix of `A1` contains N types and `a1` holds M keywords, an initial sequence of the keywords are used for all but the first N - M arguments of each overload.
  - Otherwise, fn must be a non-null function or member function pointer, and a single function overload built around fn is added to the current scope. If any of `a1`-`a3` are supplied, they may be selected in any order from the table below.

  Memnonic Name | Requirements/Type properties | Effects
  --- | --- | ---
  docstring | Any ntbs. | Value will be bound to the `__doc__` attribute of the resulting method overload.
  policies | A model of CallPolicies | A copy will be used as the call policies of the resulting method overload.
  keywords | The result of a keyword-expression specifying no more arguments than the arity of `fn`. | A copy will be used as the call policies of the resulting method overload.

## Example

    #include <boost/python/def.hpp>
    #include <boost/python/module.hpp>
    #include <boost/python/args.hpp>

    using namespace boost::python;

    char const* foo(int x, int y) { return "foo"; }

    BOOST_PYTHON_MODULE(def_test)
    {
        def("foo", foo, args("x", "y"), "foo's docstring");
    }

7 March, 2003

© Copyright Dave Abrahams 2002.