| Home | Libraries | People | FAQ | More

## Reference

### Concepts

- CallableTransform
- Domain
- Expr
- ObjectTransform
- PolymorphicFunctionObject
- PrimitiveTransform
- Transform

### Classes

- ``proto::_``
- ``proto::_byref``
- ``proto::_byval``
- ``proto::_child_c``
- ``proto::_data``
- ``proto::_default``
- ``proto::_expr``
- ``proto::_state``
- ``proto::_value``
- ``proto::_void``
- ``proto::address_of``
- ``proto::and_``
- ``proto::arity_of``
- ``proto::assign``
- ``proto::basic_expr``
- ``proto::binary_expr``
- ``proto::bitwise_and``
- ``proto::bitwise_and_assign``
- ``proto::bitwise_or``
- ``proto::bitwise_or_assign``
- ``proto::bitwise_xor``
- ``proto::bitwise_xor_assign``
- ``proto::by_value_generator``
- ``proto::call``
- ``proto::callable``
- ``proto::comma``
- ``proto::complement``
- ``proto::compose_generators``
- ``proto::context::callable_context``
- ``proto::context::callable_eval``
- ``proto::context::default_context``
- ``proto::context::default_eval``
- ``proto::context::null_context``
- ``proto::context::null_eval``
- ``proto::convertible_to``
- ``proto::deduce_domain``
- ``proto::default_domain``
- ``proto::default_generator``
- ``proto::dereference``
- ``proto::divides``
- ``proto::divides_assign``
- ``proto::domain``
- ``proto::domain::as_child``
- ``proto::domain::as_expr``
- ``proto::domain_of``
- ``proto::equal_to``
- ``proto::exact``
- ``proto::expr``
- ``proto::extends``
- ``proto::fold``
- ``proto::fold_tree``
- ``proto::function``
- ``proto::functional::as_child``
- ``proto::functional::as_expr``
- ``proto::functional::child``
- ``proto::functional::child_c``
- ``proto::functional::deep_copy``
- ``proto::functional::display_expr``
- ``proto::functional::eval``
- ``proto::functional::flatten``
- ``proto::functional::left``
- ``proto::functional::make_expr``
- ``proto::functional::pop_front``
- ``proto::functional::reverse``
- ``proto::functional::right``
- ``proto::functional::unpack_expr``
- ``proto::functional::value``
- ``proto::generator``
- ``proto::greater``
- ``proto::greater_equal``
- ``proto::if_``
- ``proto::if_else_``
- ``proto::is_aggregate``
- ``proto::is_callable``
- ``proto::is_domain``
- ``proto::is_expr``
- ``proto::is_extension``
- ``proto::is_proto_expr``
- ``proto::lazy``
- ``proto::less``
- ``proto::less_equal``
- ``proto::list1<>, proto::list2<>, ...``
- ``proto::literal``
- ``proto::logical_and``
- ``proto::logical_not``
- ``proto::logical_or``
- ``proto::make``
- ``proto::matches``
- ``proto::mem_ptr``
- ``proto::minus``
- ``proto::minus_assign``
- ``proto::modulus``
- ``proto::modulus_assign``
- ``proto::multiplies``
- ``proto::multiplies_assign``
- ``proto::nary_expr``
- ``proto::negate``
- ``proto::noinvoke``
- ``proto::not_``
- ``proto::not_equal_to``
- ``proto::nullary_expr``
- ``proto::or_``
- ``proto::otherwise``
- ``proto::pass_through``
- ``proto::plus``
- ``proto::plus_assign``
- ``proto::pod_generator``
- ``proto::post_dec``
- ``proto::post_inc``
- ``proto::pre_dec``
- ``proto::pre_inc``
- ``proto::protect``
- ``proto::result_of::as_child``
- ``proto::result_of::as_expr``
- ``proto::result_of::child``
- ``proto::result_of::child_c``
- ``proto::result_of::deep_copy``
- ``proto::result_of::eval``
- ``proto::result_of::flatten``
- ``proto::result_of::left``
- ``proto::result_of::make_expr``
- ``proto::result_of::right``
- ``proto::result_of::unpack_expr``
- ``proto::result_of::value``
- ``proto::reverse_fold``
- ``proto::reverse_fold_tree``
- ``proto::shift_left``
- ``proto::shift_left_assign``
- ``proto::shift_right``
- ``proto::shift_right_assign``
- ``proto::subscript``
- ``proto::switch_``
- ``proto::tag::address_of``
- ``proto::tag::assign``
- ``proto::tag::bitwise_and``
- ``proto::tag::bitwise_and_assign``
- ``proto::tag::bitwise_or``
- ``proto::tag::bitwise_or_assign``
- ``proto::tag::bitwise_xor``
- ``proto::tag::bitwise_xor_assign``
- ``proto::tag::comma``
- ``proto::tag::complement``
- ``proto::tag::dereference``
- ``proto::tag::divides``
- ``proto::tag::divides_assign``
- ``proto::tag::equal_to``
- ``proto::tag::function``
- ``proto::tag::greater``
- ``proto::tag::greater_equal``
- ``proto::tag::if_else_``
- ``proto::tag::less``
- ``proto::tag::less_equal``
- ``proto::tag::logical_and``
- ``proto::tag::logical_not``
- ``proto::tag::logical_or``
- ``proto::tag::mem_ptr``
- ``proto::tag::minus``
- ``proto::tag::minus_assign``
- ``proto::tag::modulus``
- ``proto::tag::modulus_assign``
- ``proto::tag::multiplies``
- ``proto::tag::multiplies_assign``
- ``proto::tag::negate``
- ``proto::tag::not_equal_to``
- ``proto::tag::plus``
- ``proto::tag::plus_assign``
- ``proto::tag::post_dec``
- ``proto::tag::post_inc``
- ``proto::tag::pre_dec``
- ``proto::tag::pre_inc``
- ``proto::tag::shift_left``
- ``proto::tag::shift_left_assign``
- ``proto::tag::shift_right``
- ``proto::tag::shift_right_assign``
- ``proto::tag::subscript``
- ``proto::tag::terminal``
- ``proto::tag::unary_plus``
- ``proto::tag_of``
- ``proto::term``
- ``proto::terminal``
- ``proto::transform``
- ``proto::transform_impl``
- ``proto::unary_expr``
- ``proto::unary_plus``
- ``proto::use_basic_expr``
- ``proto::unexpr``
- ``proto::vararg``
- ``proto::wants_basic_expr``
- ``proto::when``

### Functions

- ``proto::as_child()``
- ``proto::as_expr()``
- ``proto::assert_matches()``
- ``proto::assert_matches_not()``
- ``proto::child()``
- ``proto::child_c()``
- ``proto::deep_copy()``
- ``proto::display_expr()``
- ``proto::eval()``
- ``proto::flatten()``
- ``proto::if_else()``
- ``proto::left()``
- ``proto::lit()``
- ``proto::make_expr()``
- ``proto::right()``
- ``proto::unpack_expr()``
- ``proto::value()``

### Header <boost/proto/args.hpp>

Contains definitions of the `proto::term<>`, `proto::list1<>`, `proto::list2<>`, etc. class templates.

    namespace boost {
      namespace proto {
        template<typename T> struct term;
        template<typename... Arg> struct listN;
      }
    }

### Header <boost/proto/core.hpp>

Includes all of Proto, except the contexts, transforms, debug utilities and Boost.Typeof registrations.

### Header <boost/proto/debug.hpp>

Utilities for debugging Proto expression trees

    BOOST_PROTO_ASSERT_MATCHES(expr, Grammar)
    BOOST_PROTO_ASSERT_MATCHES_NOT(expr, Grammar)

    namespace boost {
      namespace proto {
        template<typename Expr> void display_expr(Expr const &, std::ostream &);
        template<typename Expr> void display_expr(Expr const &);
        template<typename Grammar, typename Expr>
          void assert_matches(Expr const &);
        template<typename Grammar, typename Expr>
          void assert_matches_not(Expr const &);
        namespace functional {
          struct display_expr;
        }
      }
    }

### Header <boost/proto/deep_copy.hpp>

Replace all nodes stored by reference by nodes stored by value.

    namespace boost {
      namespace proto {
        template<typename Expr>
          typename proto::result_of::deep_copy<Expr>::type deep_copy(Expr const &);
        namespace result_of {
          template<typename Expr> struct deep_copy;
        }
        namespace functional {
          struct deep_copy;
        }
      }
    }

### Header <boost/proto/domain.hpp>

Contains definition of the `proto::domain<>` class template and helpers for defining domains with a generator for customizing expression construction and a grammar for controlling operator overloading.

    namespace boost {
      namespace proto {
        template<typename Generator = proto::default_generator,
                 typename Grammar = proto::_, typename Super = unspecified>
          struct domain;
        struct default_domain;
        struct deduce_domain;
        template<typename T> struct is_domain;
        template<typename T> struct domain_of;
      }
    }

### Header <boost/proto/eval.hpp>

Contains the `proto::eval()` expression evaluator.

    namespace boost {
      namespace proto {
        template<typename Expr, typename Context>
          typename proto::result_of::eval< Expr, Context >::type
          eval(Expr &, Context &);
        template<typename Expr, typename Context>
          typename proto::result_of::eval< Expr, Context >::type
          eval(Expr &, Context const &);
        namespace functional {
          struct eval;
        }
        namespace result_of {
          template<typename Expr, typename Context> struct eval;
        }
      }
    }

### Header <boost/proto/expr.hpp>

    namespace boost {
      namespace proto {
        template<typename Tag, typename Args, long Arity = Args::arity>
          struct basic_expr;
        template<typename Tag, typename Args, long Arity = Args::arity> struct expr;
        template<typename Expr> struct unexpr;
      }
    }

### Header <boost/proto/extends.hpp>

Macros and a base class for defining end-user expression types

    BOOST_PROTO_EXTENDS(Expr, Derived, Domain)
    BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain)
    BOOST_PROTO_EXTENDS_ASSIGN()
    BOOST_PROTO_EXTENDS_FUNCTION()
    BOOST_PROTO_EXTENDS_SUBSCRIPT()
    BOOST_PROTO_EXTENDS_USING_ASSIGN(Derived)
    BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(Derived)

    namespace boost {
      namespace proto {
        struct is_proto_expr;
        template<typename Expr, typename Derived,
                 typename Domain = proto::default_domain>
          struct extends;
      }
    }

### Header <boost/proto/fusion.hpp>

Make any Proto expression a valid Fusion sequence

    namespace boost {
      namespace proto {
        template<typename Expr>
          typename proto::result_of::flatten< Expr >::type const flatten(Expr &);
        template<typename Expr>
          typename proto::result_of::flatten< Expr const >::type const
          flatten(Expr const &);
        namespace functional {
          struct flatten;
          struct pop_front;
          struct reverse;
        }
        namespace result_of {
          template<typename Expr> struct flatten;
        }
      }
    }

### Header <boost/proto/generate.hpp>

Contains definition of `proto::default_generator`, `proto::generator<>`, `proto::pod_generator<>` and other utilities that users can use to post-process new expression objects that Proto creates.

    namespace boost {
      namespace proto {
        struct default_generator;
        template<template< typename > class Extends> struct generator;
        template<template< typename > class Extends> struct pod_generator;
        struct by_value_generator;
        template<typename First, typename Second> struct compose_generators;
        template<typename Generator> struct use_basic_expr;
        template<typename Generator> struct wants_basic_expr;
      }
    }

### Header <boost/proto/literal.hpp>

The `proto::literal<>` terminal wrapper, and the `proto::lit()` function for creating `proto::literal<>` wrappers.

    namespace boost {
      namespace proto {
        template<typename T, typename Domain = proto::default_domain>
          struct literal;
        template<typename T> proto::literal< T & > const lit(T &);
        template<typename T> proto::literal< T const & > const lit(T const &);
      }
    }

### Header <boost/proto/make_expr.hpp>

Definition of the `proto::make_expr()` and `proto::unpack_expr()` utilities for building Proto expression nodes from child nodes or from a Fusion sequence of child nodes, respectively.

    namespace boost {
      namespace proto {
        template<typename Tag, typename... A>
          typename proto::result_of::make_expr<Tag, A const...>::type const
          make_expr(A const &...);
        template<typename Tag, typename Domain, typename... A>
          typename proto::result_of::make_expr<Tag, Domain, A const...>::type const
          make_expr(A const &...);
        template<typename Tag, typename Sequence>
          typename proto::result_of::unpack_expr<Tag, Sequence const>::type const
          unpack_expr(Sequence const &);
        template<typename Tag, typename Domain, typename Sequence>
          typename proto::result_of::unpack_expr<Tag, Domain, Sequence const>::type const
          unpack_expr(Sequence const &);
        namespace functional {
          template<typename Tag, typename Domain = proto::deduce_domain>
            struct make_expr;
          template<typename Tag, typename Domain = proto::deduce_domain>
            struct unpack_expr;
        }
        namespace result_of {
          template<typename Tag, typename... A> struct make_expr;

          template<typename Tag, typename Domain, typename... A>
            struct make_expr<Tag, Domain, A...>;

          template<typename Tag, typename Sequence, typename Void = void>
            struct unpack_expr;

          template<typename Tag, typename Domain, typename Sequence>
            struct unpack_expr<Tag, Domain, Sequence>;
        }
      }
    }

### Header <boost/proto/matches.hpp>

Contains definition of the `proto::matches<>` metafunction for determining if a given expression matches a given pattern.

    namespace boost {
      namespace proto {
        struct _;
        template<typename Grammar> struct not_;
        template<typename If, typename Then = proto::_,
                 typename Else = proto::not_<proto::_> >
          struct if_;
        template<typename... G> struct or_;
        template<typename... G> struct and_;
        template<typename Cases> struct switch_;
        template<typename T> struct exact;
        template<typename T> struct convertible_to;
        template<typename Grammar> struct vararg;
        template<typename Expr, typename Grammar> struct matches;
      }
    }

### Header <boost/proto/operators.hpp>

Contains all the overloaded operators that make it possible to build Proto expression trees.

    BOOST_PROTO_DEFINE_OPERATORS(Trait, Domain)

    namespace boost {
      namespace proto {
        template<typename T> struct is_extension;
        template<typename Arg> unspecified operator+(Arg & arg);
        template<typename Arg> unspecified operator+(Arg const & arg);
        template<typename Arg> unspecified operator-(Arg & arg);
        template<typename Arg> unspecified operator-(Arg const & arg);
        template<typename Arg> unspecified operator*(Arg & arg);
        template<typename Arg> unspecified operator*(Arg const & arg);
        template<typename Arg> unspecified operator~(Arg & arg);
        template<typename Arg> unspecified operator~(Arg const & arg);
        template<typename Arg> unspecified operator&(Arg & arg);
        template<typename Arg> unspecified operator&(Arg const & arg);
        template<typename Arg> unspecified operator!(Arg & arg);
        template<typename Arg> unspecified operator!(Arg const & arg);
        template<typename Arg> unspecified operator++(Arg & arg);
        template<typename Arg> unspecified operator++(Arg const & arg);
        template<typename Arg> unspecified operator--(Arg & arg);
        template<typename Arg> unspecified operator--(Arg const & arg);
        template<typename Arg> unspecified operator++(Arg & arg, int);
        template<typename Arg> unspecified operator++(Arg const & arg, int);
        template<typename Arg> unspecified operator--(Arg & arg, int);
        template<typename Arg> unspecified operator--(Arg const & arg, int);
        template<typename Left, typename Right>
          unspecified operator<<(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator<<(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator<<(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator<<(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator>>(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator>>(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator>>(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator>>(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator*(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator*(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator*(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator*(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator/(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator/(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator/(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator/(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator%(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator%(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator%(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator%(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator+(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator+(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator+(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator+(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator-(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator-(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator-(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator-(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator<(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator<(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator<(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator<(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator>(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator>(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator>(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator>(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator<=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator<=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator<=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator<=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator>=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator>=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator>=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator>=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator==(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator==(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator==(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator==(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator!=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator!=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator!=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator!=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator||(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator||(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator||(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator||(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator&&(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator&&(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator&&(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator&&(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator&(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator&(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator&(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator&(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator|(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator|(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator|(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator|(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator^(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator^(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator^(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator^(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator,(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator,(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator,(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator,(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator->*(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator->*(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator->*(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator->*(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator<<=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator<<=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator<<=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator<<=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator>>=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator>>=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator>>=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator>>=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator*=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator*=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator*=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator*=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator/=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator/=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator/=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator/=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator%=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator%=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator%=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator%=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator+=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator+=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator+=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator+=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator-=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator-=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator-=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator-=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator&=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator&=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator&=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator&=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator|=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator|=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator|=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator|=(Left const & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator^=(Left & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator^=(Left & left, Right const & right);
        template<typename Left, typename Right>
          unspecified operator^=(Left const & left, Right & right);
        template<typename Left, typename Right>
          unspecified operator^=(Left const & left, Right const & right);
        template<typename A0, typename A1, typename A2>
          typename proto::result_of::make_expr<
            proto::tag::if_else_,
            proto::deduce_domain,
            A0 const &,
            A1 const &,
            A2 const &
          >::type const
          if_else(A0 const & a0, A1 const & a1, A2 const & a2);
      }
    }

### Header <boost/proto/proto.hpp>

Includes all of Proto, except the Boost.Typeof registrations.

### Header <boost/proto/proto_fwd.hpp>

Forward declarations of all of proto's public types and functions.

    BOOST_PROTO_MAX_ARITY
    BOOST_PROTO_MAX_LOGICAL_ARITY
    BOOST_PROTO_MAX_FUNCTION_CALL_ARITY

    namespace boost {
      namespace proto {
        struct callable;

        int const N;

        typedef proto::functional::flatten _flatten;
        typedef proto::functional::pop_front _pop_front;
        typedef proto::functional::reverse _reverse;
        typedef proto::functional::eval _eval;
        typedef proto::functional::deep_copy _deep_copy;
        typedef proto::functional::make_expr< proto::tag::terminal > _make_terminal;
        typedef proto::functional::make_expr< proto::tag::unary_plus > _make_unary_plus;
        typedef proto::functional::make_expr< proto::tag::negate > _make_negate;
        typedef proto::functional::make_expr< proto::tag::dereference > _make_dereference;
        typedef proto::functional::make_expr< proto::tag::complement > _make_complement;
        typedef proto::functional::make_expr< proto::tag::address_of > _make_address_of;
        typedef proto::functional::make_expr< proto::tag::logical_not > _make_logical_not;
        typedef proto::functional::make_expr< proto::tag::pre_inc > _make_pre_inc;
        typedef proto::functional::make_expr< proto::tag::pre_dec > _make_pre_dec;
        typedef proto::functional::make_expr< proto::tag::post_inc > _make_post_inc;
        typedef proto::functional::make_expr< proto::tag::post_dec > _make_post_dec;
        typedef proto::functional::make_expr< proto::tag::shift_left > _make_shift_left;
        typedef proto::functional::make_expr< proto::tag::shift_right > _make_shift_right;
        typedef proto::functional::make_expr< proto::tag::multiplies > _make_multiplies;
        typedef proto::functional::make_expr< proto::tag::divides > _make_divides;
        typedef proto::functional::make_expr< proto::tag::modulus > _make_modulus;
        typedef proto::functional::make_expr< proto::tag::plus > _make_plus;
        typedef proto::functional::make_expr< proto::tag::minus > _make_minus;
        typedef proto::functional::make_expr< proto::tag::less > _make_less;
        typedef proto::functional::make_expr< proto::tag::greater > _make_greater;
        typedef proto::functional::make_expr< proto::tag::less_equal > _make_less_equal;
        typedef proto::functional::make_expr< proto::tag::greater_equal > _make_greater_equal;
        typedef proto::functional::make_expr< proto::tag::equal_to > _make_equal_to;
        typedef proto::functional::make_expr< proto::tag::not_equal_to > _make_not_equal_to;
        typedef proto::functional::make_expr< proto::tag::logical_or > _make_logical_or;
        typedef proto::functional::make_expr< proto::tag::logical_and > _make_logical_and;
        typedef proto::functional::make_expr< proto::tag::bitwise_and > _make_bitwise_and;
        typedef proto::functional::make_expr< proto::tag::bitwise_or > _make_bitwise_or;
        typedef proto::functional::make_expr< proto::tag::bitwise_xor > _make_bitwise_xor;
        typedef proto::functional::make_expr< proto::tag::comma > _make_comma;
        typedef proto::functional::make_expr< proto::tag::mem_ptr > _make_mem_ptr;
        typedef proto::functional::make_expr< proto::tag::assign > _make_assign;
        typedef proto::functional::make_expr< proto::tag::shift_left_assign > _make_shift_left_assign;
        typedef proto::functional::make_expr< proto::tag::shift_right_assign > _make_shift_right_assign;
        typedef proto::functional::make_expr< proto::tag::multiplies_assign > _make_multiplies_assign;
        typedef proto::functional::make_expr< proto::tag::divides_assign > _make_divides_assign;
        typedef proto::functional::make_expr< proto::tag::modulus_assign > _make_modulus_assign;
        typedef proto::functional::make_expr< proto::tag::plus_assign > _make_plus_assign;
        typedef proto::functional::make_expr< proto::tag::minus_assign > _make_minus_assign;
        typedef proto::functional::make_expr< proto::tag::bitwise_and_assign > _make_bitwise_and_assign;
        typedef proto::functional::make_expr< proto::tag::bitwise_or_assign > _make_bitwise_or_assign;
        typedef proto::functional::make_expr< proto::tag::bitwise_xor_assign > _make_bitwise_xor_assign;
        typedef proto::functional::make_expr< proto::tag::subscript > _make_subscript;
        typedef proto::functional::make_expr< proto::tag::if_else_ > _make_if_else;
        typedef proto::functional::make_expr< proto::tag::function > _make_function;
        typedef proto::_child_c< N > _childN;  // For each N in [0,BOOST_PROTO_MAX_ARITY)
        typedef proto::_child0 _child;
        typedef proto::_child0 _left;
        typedef proto::_child1 _right;
        namespace functional {
          typedef proto::functional::make_expr< proto::tag::terminal > make_terminal;
          typedef proto::functional::make_expr< proto::tag::unary_plus > make_unary_plus;
          typedef proto::functional::make_expr< proto::tag::negate > make_negate;
          typedef proto::functional::make_expr< proto::tag::dereference > make_dereference;
          typedef proto::functional::make_expr< proto::tag::complement > make_complement;
          typedef proto::functional::make_expr< proto::tag::address_of > make_address_of;
          typedef proto::functional::make_expr< proto::tag::logical_not > make_logical_not;
          typedef proto::functional::make_expr< proto::tag::pre_inc > make_pre_inc;
          typedef proto::functional::make_expr< proto::tag::pre_dec > make_pre_dec;
          typedef proto::functional::make_expr< proto::tag::post_inc > make_post_inc;
          typedef proto::functional::make_expr< proto::tag::post_dec > make_post_dec;
          typedef proto::functional::make_expr< proto::tag::shift_left > make_shift_left;
          typedef proto::functional::make_expr< proto::tag::shift_right > make_shift_right;
          typedef proto::functional::make_expr< proto::tag::multiplies > make_multiplies;
          typedef proto::functional::make_expr< proto::tag::divides > make_divides;
          typedef proto::functional::make_expr< proto::tag::modulus > make_modulus;
          typedef proto::functional::make_expr< proto::tag::plus > make_plus;
          typedef proto::functional::make_expr< proto::tag::minus > make_minus;
          typedef proto::functional::make_expr< proto::tag::less > make_less;
          typedef proto::functional::make_expr< proto::tag::greater > make_greater;
          typedef proto::functional::make_expr< proto::tag::less_equal > make_less_equal;
          typedef proto::functional::make_expr< proto::tag::greater_equal > make_greater_equal;
          typedef proto::functional::make_expr< proto::tag::equal_to > make_equal_to;
          typedef proto::functional::make_expr< proto::tag::not_equal_to > make_not_equal_to;
          typedef proto::functional::make_expr< proto::tag::logical_or > make_logical_or;
          typedef proto::functional::make_expr< proto::tag::logical_and > make_logical_and;
          typedef proto::functional::make_expr< proto::tag::bitwise_and > make_bitwise_and;
          typedef proto::functional::make_expr< proto::tag::bitwise_or > make_bitwise_or;
          typedef proto::functional::make_expr< proto::tag::bitwise_xor > make_bitwise_xor;
          typedef proto::functional::make_expr< proto::tag::comma > make_comma;
          typedef proto::functional::make_expr< proto::tag::mem_ptr > make_mem_ptr;
          typedef proto::functional::make_expr< proto::tag::assign > make_assign;
          typedef proto::functional::make_expr< proto::tag::shift_left_assign > make_shift_left_assign;
          typedef proto::functional::make_expr< proto::tag::shift_right_assign > make_shift_right_assign;
          typedef proto::functional::make_expr< proto::tag::multiplies_assign > make_multiplies_assign;
          typedef proto::functional::make_expr< proto::tag::divides_assign > make_divides_assign;
          typedef proto::functional::make_expr< proto::tag::modulus_assign > make_modulus_assign;
          typedef proto::functional::make_expr< proto::tag::plus_assign > make_plus_assign;
          typedef proto::functional::make_expr< proto::tag::minus_assign > make_minus_assign;
          typedef proto::functional::make_expr< proto::tag::bitwise_and_assign > make_bitwise_and_assign;
          typedef proto::functional::make_expr< proto::tag::bitwise_or_assign > make_bitwise_or_assign;
          typedef proto::functional::make_expr< proto::tag::bitwise_xor_assign > make_bitwise_xor_assign;
          typedef proto::functional::make_expr< proto::tag::subscript > make_subscript;
          typedef proto::functional::make_expr< proto::tag::if_else_ > make_if_else;
          typedef proto::functional::make_expr< proto::tag::function > make_function;
        }
      }
    }

### Header <boost/proto/proto_typeof.hpp>

Boost.Typeof registrations for Proto's types, and definition of the `BOOST_PROTO_AUTO()` macro.

    BOOST_PROTO_AUTO(Var, Expr)

### Header <boost/proto/repeat.hpp>

Contains macros to ease the generation of repetitious code constructs.

    BOOST_PROTO_REPEAT(MACRO)
    BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO)
    BOOST_PROTO_REPEAT_EX(MACRO, typename_A, A, A_a, a)
    BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, typename_A, A, A_a, a)
    BOOST_PROTO_LOCAL_ITERATE()
    BOOST_PROTO_typename_A(N)
    BOOST_PROTO_A_const_ref(N)
    BOOST_PROTO_A_ref(N)
    BOOST_PROTO_A(N)
    BOOST_PROTO_A_const(N)
    BOOST_PROTO_A_const_ref_a(N)
    BOOST_PROTO_A_ref_a(N)
    BOOST_PROTO_ref_a(N)
    BOOST_PROTO_a(N)

### Header <boost/proto/tags.hpp>

Contains the tags for all the overloadable operators in C++

    namespace boost {
      namespace proto {
        namespace tag {
          struct terminal;
          struct unary_plus;
          struct negate;
          struct dereference;
          struct complement;
          struct address_of;
          struct logical_not;
          struct pre_inc;
          struct pre_dec;
          struct post_inc;
          struct post_dec;
          struct shift_left;
          struct shift_right;
          struct multiplies;
          struct divides;
          struct modulus;
          struct plus;
          struct minus;
          struct less;
          struct greater;
          struct less_equal;
          struct greater_equal;
          struct equal_to;
          struct not_equal_to;
          struct logical_or;
          struct logical_and;
          struct bitwise_and;
          struct bitwise_or;
          struct bitwise_xor;
          struct comma;
          struct mem_ptr;
          struct assign;
          struct shift_left_assign;
          struct shift_right_assign;
          struct multiplies_assign;
          struct divides_assign;
          struct modulus_assign;
          struct plus_assign;
          struct minus_assign;
          struct bitwise_and_assign;
          struct bitwise_or_assign;
          struct bitwise_xor_assign;
          struct subscript;
          struct if_else_;
          struct function;
        }
      }
    }

### Header <boost/proto/traits.hpp>

Contains definitions for various expression traits and utilities like `proto::tag_of<>` and `proto::arity_of<>`; the functions `proto::value()`, `proto::left()` and `proto::right()`; `proto::child()`, `proto::child_c()`, `proto::as_expr()`, `proto::as_child()`, and assorted helpers.

    namespace boost {
      namespace proto {
        template<typename T> struct is_callable;
        template<typename T> struct is_aggregate;

        template<typename T> struct terminal;
        template<typename T, typename U, typename V> struct if_else_;
        template<typename T> struct unary_plus;
        template<typename T> struct negate;
        template<typename T> struct dereference;
        template<typename T> struct complement;
        template<typename T> struct address_of;
        template<typename T> struct logical_not;
        template<typename T> struct pre_inc;
        template<typename T> struct pre_dec;
        template<typename T> struct post_inc;
        template<typename T> struct post_dec;
        template<typename T, typename U> struct shift_left;
        template<typename T, typename U> struct shift_right;
        template<typename T, typename U> struct multiplies;
        template<typename T, typename U> struct divides;
        template<typename T, typename U> struct modulus;
        template<typename T, typename U> struct plus;
        template<typename T, typename U> struct minus;
        template<typename T, typename U> struct less;
        template<typename T, typename U> struct greater;
        template<typename T, typename U> struct less_equal;
        template<typename T, typename U> struct greater_equal;
        template<typename T, typename U> struct equal_to;
        template<typename T, typename U> struct not_equal_to;
        template<typename T, typename U> struct logical_or;
        template<typename T, typename U> struct logical_and;
        template<typename T, typename U> struct bitwise_and;
        template<typename T, typename U> struct bitwise_or;
        template<typename T, typename U> struct bitwise_xor;
        template<typename T, typename U> struct comma;
        template<typename T, typename U> struct mem_ptr;
        template<typename T, typename U> struct assign;
        template<typename T, typename U> struct shift_left_assign;
        template<typename T, typename U> struct shift_right_assign;
        template<typename T, typename U> struct multiplies_assign;
        template<typename T, typename U> struct divides_assign;
        template<typename T, typename U> struct modulus_assign;
        template<typename T, typename U> struct plus_assign;
        template<typename T, typename U> struct minus_assign;
        template<typename T, typename U> struct bitwise_and_assign;
        template<typename T, typename U> struct bitwise_or_assign;
        template<typename T, typename U> struct bitwise_xor_assign;
        template<typename T, typename U> struct subscript;
        template<typename... A> struct function;
        template<typename Tag, typename T> struct nullary_expr;
        template<typename Tag, typename T> struct unary_expr;
        template<typename Tag, typename T, typename U> struct binary_expr;
        template<typename Tag, typename... A> struct nary_expr;
        template<typename T> struct is_expr;
        template<typename Expr> struct tag_of;
        template<typename Expr> struct arity_of;
        template<typename T>
          typename proto::result_of::as_expr< T >::type as_expr(T &);
        template<typename T>
          typename proto::result_of::as_expr< T const >::type as_expr(T const &);
        template<typename Domain, typename T>
          typename proto::result_of::as_expr< T, Domain >::type as_expr(T &);
        template<typename Domain, typename T>
          typename proto::result_of::as_expr< T const, Domain >::type
          as_expr(T const &);
        template<typename T>
          typename proto::result_of::as_child< T >::type as_child(T &);
        template<typename T>
          typename proto::result_of::as_child< T const >::type as_child(T const &);
        template<typename Domain, typename T>
          typename proto::result_of::as_child< T, Domain >::type as_child(T &);
        template<typename Domain, typename T>
          typename proto::result_of::as_child< T const, Domain >::type
          as_child(T const &);
        template<typename N, typename Expr>
          typename proto::result_of::child< Expr &, N >::type child(Expr &);
        template<typename N, typename Expr>
          typename proto::result_of::child< Expr const &, N >::type
          child(Expr const &);
        template<typename Expr>
          typename proto::result_of::child< Expr & >::type child(Expr &);
        template<typename Expr>
          typename proto::result_of::child< Expr const & >::type
          child(Expr const &);
        template<long N, typename Expr>
          typename proto::result_of::child_c< Expr &, N >::type child_c(Expr &);
        template<long N, typename Expr>
          typename proto::result_of::child_c< Expr const &, N >::type
          child_c(Expr const &);
        template<typename Expr>
          typename proto::result_of::value< Expr & >::type value(Expr &);
        template<typename Expr>
          typename proto::result_of::value< Expr const & >::type
          value(Expr const &);
        template<typename Expr>
          typename proto::result_of::left< Expr & >::type left(Expr &);
        template<typename Expr>
          typename proto::result_of::left< Expr const & >::type left(Expr const &);
        template<typename Expr>
          typename proto::result_of::right< Expr & >::type right(Expr &);
        template<typename Expr>
          typename proto::result_of::right< Expr const & >::type
          right(Expr const &);
        namespace functional {
          template<typename Domain = proto::default_domain> struct as_expr;
          template<typename Domain = proto::default_domain> struct as_child;
          template<long N> struct child_c;
          template<typename N = mpl::long_<0> > struct child;
          struct value;
          struct left;
          struct right;
        }
        namespace result_of {
          template<typename T, typename Domain = proto::default_domain>
            struct as_expr;
          template<typename T, typename Domain = proto::default_domain>
            struct as_child;
          template<typename Expr, typename N = mpl::long_<0> > struct child;
          template<typename Expr> struct value;
          template<typename Expr> struct left;
          template<typename Expr> struct right;
          template<typename Expr, long N> struct child_c;
        }
      }
    }

### Header <boost/proto/transform/arg.hpp>

Contains definition of the childN transforms and friends.

    namespace boost {
      namespace proto {
        struct _expr;
        struct _state;
        struct _data;
        template<int N> struct _child_c;
        struct _value;
        struct _void;
        struct _byref;
        struct _byval;
      }
    }

### Header <boost/proto/transform/call.hpp>

Contains definition of the call<> transform.

    namespace boost {
      namespace proto {
        template<typename T> struct call;
      }
    }

### Header <boost/proto/transform/default.hpp>

    namespace boost {
      namespace proto {
        template<typename Grammar = unspecified> struct _default;
      }
    }

### Header <boost/proto/transform/fold.hpp>

Contains definition of the `proto::fold<>` and `proto::reverse_fold<>` transforms.

    namespace boost {
      namespace proto {
        template<typename Sequence, typename State0, typename Fun> struct fold;
        template<typename Sequence, typename State0, typename Fun>
          struct reverse_fold;
      }
    }

### Header <boost/proto/transform/fold_tree.hpp>

Contains definition of the `proto::fold_tree<>` and `proto::reverse_fold_tree<>` transforms.

    namespace boost {
      namespace proto {
        template<typename Sequence, typename State0, typename Fun> struct fold_tree;
        template<typename Sequence, typename State0, typename Fun>
          struct reverse_fold_tree;
      }
    }

### Header <boost/proto/transform/impl.hpp>

Contains definition of transform<> and transform_impl<> helpers.

    namespace boost {
      namespace proto {
        template<typename PrimitiveTransform> struct transform;
        template<typename Expr, typename State, typename Data>
          struct transform_impl;
      }
    }

### Header <boost/proto/transform/lazy.hpp>

Contains definition of the `proto::lazy<>` transform.

    namespace boost {
      namespace proto {
        template<typename T> struct lazy;
      }
    }

### Header <boost/proto/transform/make.hpp>

Contains definition of the `proto::make<>` and `proto::protect<>` transforms.

    namespace boost {
      namespace proto {
        template<typename T> struct noinvoke;
        template<typename PrimitiveTransform> struct protect;
        template<typename T> struct make;
      }
    }

### Header <boost/proto/transform/pass_through.hpp>

Definition of the `proto::pass_through<>` transform, which is the default transform of all of the expression generator metafunctions such as `proto::unary_plus<>`, `proto::plus<>` and `proto::nary_expr<>`.

    namespace boost {
      namespace proto {
        template<typename Grammar> struct pass_through;
      }
    }

### Header <boost/proto/transform/when.hpp>

Definition of the `proto::when<>` and `proto::otherwise<>` transforms.

    namespace boost {
      namespace proto {
        template<typename Grammar, typename PrimitiveTransform = Grammar>
          struct when;

        template<typename Grammar, typename Fun> struct when<Grammar, Fun *>;
        template<typename Grammar, typename R, typename... A>
          struct when<Grammar, R(A...)>;

        template<typename Fun> struct otherwise;
      }
    }

### Header <boost/proto/context/callable.hpp>

Definintion of `proto::context::callable_context<>`, an evaluation context for `proto::eval()` that fans out each node and calls the derived context type with the expressions constituents. If the derived context doesn't have an overload that handles this node, fall back to some other context.

    namespace boost {
      namespace proto {
        namespace context {
          template<typename Expr, typename Context> struct callable_eval;
          template<typename Context,
                   typename DefaultCtx = proto::context::default_context>
            struct callable_context;
        }
      }
    }

### Header <boost/proto/context/default.hpp>

    namespace boost {
      namespace proto {
        namespace context {
          template<typename Expr, typename Context> struct default_eval;
          struct default_context;
        }
      }
    }

### Header <boost/proto/context/null.hpp>

Definintion of `proto::context::null_context<>`, an evaluation context for `proto::eval()` that simply evaluates each child expression, doesn't combine the results at all, and returns void.

    namespace boost {
      namespace proto {
        namespace context {
          template<typename Expr, typename Context> struct null_eval;
          struct null_context;
        }
      }
    }