Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: /// \file make_expr.hpp
Chris@16: /// Definition of the \c make_expr() and \c unpack_expr() utilities for
Chris@16: /// building Proto expression nodes from child nodes or from a Fusion
Chris@16: /// sequence of child nodes, respectively.
Chris@16: //
Chris@16: //  Copyright 2008 Eric Niebler. Distributed under the Boost
Chris@16: //  Software License, Version 1.0. (See accompanying file
Chris@16: //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: 
Chris@16: #ifndef BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
Chris@16: #define BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
Chris@16: 
Chris@16: #include <boost/preprocessor/cat.hpp>
Chris@16: #include <boost/preprocessor/arithmetic/inc.hpp>
Chris@16: #include <boost/preprocessor/arithmetic/dec.hpp>
Chris@16: #include <boost/preprocessor/arithmetic/sub.hpp>
Chris@16: #include <boost/preprocessor/punctuation/comma_if.hpp>
Chris@16: #include <boost/preprocessor/iteration/iterate.hpp>
Chris@16: #include <boost/preprocessor/facilities/intercept.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_binary_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/repeat.hpp>
Chris@16: #include <boost/ref.hpp>
Chris@16: #include <boost/mpl/if.hpp>
Chris@16: #include <boost/mpl/assert.hpp>
Chris@16: #include <boost/mpl/eval_if.hpp>
Chris@16: #include <boost/utility/enable_if.hpp>
Chris@16: #include <boost/type_traits/add_const.hpp>
Chris@16: #include <boost/type_traits/add_reference.hpp>
Chris@16: #include <boost/type_traits/remove_cv.hpp>
Chris@16: #include <boost/proto/proto_fwd.hpp>
Chris@16: #include <boost/proto/traits.hpp>
Chris@16: #include <boost/proto/domain.hpp>
Chris@16: #include <boost/proto/generate.hpp>
Chris@16: #include <boost/fusion/include/at_c.hpp>
Chris@16: #include <boost/fusion/include/begin.hpp>
Chris@16: #include <boost/fusion/include/next.hpp>
Chris@16: #include <boost/fusion/include/value_of.hpp>
Chris@16: #include <boost/fusion/include/size.hpp>
Chris@16: #include <boost/proto/detail/poly_function.hpp>
Chris@16: #include <boost/proto/detail/deprecated.hpp>
Chris@16: 
Chris@101: #if defined(_MSC_VER)
Chris@16: # pragma warning(push)
Chris@16: # pragma warning(disable : 4180) // qualifier applied to function type has no meaning; ignored
Chris@16: # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
Chris@16: #endif
Chris@16: 
Chris@16: namespace boost { namespace proto
Chris@16: {
Chris@16: /// INTERNAL ONLY
Chris@16: ///
Chris@16: #define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA)                                                   \
Chris@16:     typename boost::proto::detail::protoify<                                                    \
Chris@16:         BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N)                                        \
Chris@16:       , BOOST_PP_TUPLE_ELEM(3, 2, DATA)                                                         \
Chris@16:     >::result_type                                                                              \
Chris@16:     /**/
Chris@16: 
Chris@16: /// INTERNAL ONLY
Chris@16: ///
Chris@16: #define BOOST_PROTO_AS_CHILD(Z, N, DATA)                                                        \
Chris@16:     boost::proto::detail::protoify<                                                             \
Chris@16:         BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N)                                        \
Chris@16:       , BOOST_PP_TUPLE_ELEM(3, 2, DATA)                                                         \
Chris@16:     >()(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 1, DATA), N))                                       \
Chris@16:     /**/
Chris@16: 
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         template<typename T, typename Domain>
Chris@16:         struct protoify
Chris@16:           : Domain::template as_expr<T>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename Domain>
Chris@16:         struct protoify<T &, Domain>
Chris@16:           : Domain::template as_child<T>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename Domain>
Chris@16:         struct protoify<boost::reference_wrapper<T>, Domain>
Chris@16:           : Domain::template as_child<T>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename Domain>
Chris@16:         struct protoify<boost::reference_wrapper<T> const, Domain>
Chris@16:           : Domain::template as_child<T>
Chris@16:         {};
Chris@16: 
Chris@16:         // Definition of detail::unpack_expr_
Chris@16:         #include <boost/proto/detail/unpack_expr_.hpp>
Chris@16: 
Chris@16:         // Definition of detail::make_expr_
Chris@16:         #include <boost/proto/detail/make_expr_.hpp>
Chris@16:     }
Chris@16: 
Chris@16:     namespace result_of
Chris@16:     {
Chris@16:         /// \brief Metafunction that computes the return type of the
Chris@16:         /// \c make_expr() function, with a domain deduced from the
Chris@16:         /// domains of the children.
Chris@16:         ///
Chris@16:         /// Use the <tt>result_of::make_expr\<\></tt> metafunction to
Chris@16:         /// compute the return type of the \c make_expr() function.
Chris@16:         ///
Chris@16:         /// In this specialization, the domain is deduced from the
Chris@16:         /// domains of the child types. (If
Chris@16:         /// <tt>is_domain\<A0\>::value</tt> is \c true, then another
Chris@16:         /// specialization is selected.)
Chris@16:         template<
Chris@16:             typename Tag
Chris@16:           , BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename A)
Chris@16:           , typename Void1  // = void
Chris@16:           , typename Void2  // = void
Chris@16:         >
Chris@16:         struct make_expr
Chris@16:         {
Chris@16:             /// Same as <tt>result_of::make_expr\<Tag, D, A0, ... AN\>::type</tt>
Chris@16:             /// where \c D is the deduced domain, which is calculated as follows:
Chris@16:             ///
Chris@16:             /// For each \c x in <tt>[0,N)</tt> (proceeding in order beginning with
Chris@16:             /// <tt>x=0</tt>), if <tt>domain_of\<Ax\>::type</tt> is not
Chris@16:             /// \c default_domain, then \c D is <tt>domain_of\<Ax\>::type</tt>.
Chris@16:             /// Otherwise, \c D is \c default_domain.
Chris@16:             typedef
Chris@16:                 typename detail::make_expr_<
Chris@16:                     Tag
Chris@16:                   , deduce_domain
Chris@16:                     BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
Chris@16:                 >::result_type
Chris@16:             type;
Chris@16:         };
Chris@16: 
Chris@16:         /// \brief Metafunction that computes the return type of the
Chris@16:         /// \c make_expr() function, within the specified domain.
Chris@16:         ///
Chris@16:         /// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute
Chris@16:         /// the return type of the \c make_expr() function.
Chris@16:         template<
Chris@16:             typename Tag
Chris@16:           , typename Domain
Chris@16:             BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, typename A)
Chris@16:         >
Chris@16:         struct make_expr<
Chris@16:             Tag
Chris@16:           , Domain
Chris@16:             BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
Chris@16:           , typename Domain::proto_is_domain_
Chris@16:         >
Chris@16:         {
Chris@16:             /// If \c Tag is <tt>tag::terminal</tt>, then \c type is a
Chris@16:             /// typedef for <tt>boost::result_of\<Domain(expr\<tag::terminal,
Chris@16:             /// term\<A0\> \>)\>::type</tt>.
Chris@16:             ///
Chris@16:             /// Otherwise, \c type is a typedef for <tt>boost::result_of\<Domain(expr\<Tag,
Chris@16:             /// listN\< as_child\<A0\>::type, ... as_child\<AN\>::type\>)
Chris@16:             /// \>::type</tt>, where \c N is the number of non-void template
Chris@16:             /// arguments, and <tt>as_child\<A\>::type</tt> is evaluated as
Chris@16:             /// follows:
Chris@16:             ///
Chris@16:             /// \li If <tt>is_expr\<A\>::value</tt> is \c true, then the
Chris@16:             /// child type is \c A.
Chris@16:             /// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>,
Chris@16:             /// and <tt>is_expr\<B\>::value</tt> is \c true, then the
Chris@16:             /// child type is <tt>B &</tt>.
Chris@16:             /// \li If <tt>is_expr\<A\>::value</tt> is \c false, then the
Chris@16:             /// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<A\> \>
Chris@16:             /// )\>::type</tt>.
Chris@16:             /// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>,
Chris@16:             /// and <tt>is_expr\<B\>::value</tt> is \c false, then the
Chris@16:             /// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<B &\> \>
Chris@16:             /// )\>::type</tt>.
Chris@16:             typedef
Chris@16:                 typename detail::make_expr_<
Chris@16:                     Tag
Chris@16:                   , Domain
Chris@16:                     BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
Chris@16:                 >::result_type
Chris@16:             type;
Chris@16:         };
Chris@16: 
Chris@16:         /// \brief Metafunction that computes the return type of the
Chris@16:         /// \c unpack_expr() function, with a domain deduced from the
Chris@16:         /// domains of the children.
Chris@16:         ///
Chris@16:         /// Use the <tt>result_of::unpack_expr\<\></tt> metafunction to
Chris@16:         /// compute the return type of the \c unpack_expr() function.
Chris@16:         ///
Chris@16:         /// \c Sequence is a Fusion Forward Sequence.
Chris@16:         ///
Chris@16:         /// In this specialization, the domain is deduced from the
Chris@16:         /// domains of the child types. (If
Chris@16:         /// <tt>is_domain\<Sequence>::value</tt> is \c true, then another
Chris@16:         /// specialization is selected.)
Chris@16:         template<
Chris@16:             typename Tag
Chris@16:           , typename Sequence
Chris@16:           , typename Void1  // = void
Chris@16:           , typename Void2  // = void
Chris@16:         >
Chris@16:         struct unpack_expr
Chris@16:         {
Chris@16:             /// Let \c S be the type of a Fusion Random Access Sequence
Chris@16:             /// equivalent to \c Sequence. Then \c type is the
Chris@16:             /// same as <tt>result_of::make_expr\<Tag,
Chris@16:             /// fusion::result_of::value_at_c\<S, 0\>::type, ...
Chris@16:             /// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>,
Chris@16:             /// where \c N is the size of \c S.
Chris@16:             typedef
Chris@16:                 typename detail::unpack_expr_<
Chris@16:                     Tag
Chris@16:                   , deduce_domain
Chris@16:                   , Sequence
Chris@16:                   , fusion::result_of::size<Sequence>::type::value
Chris@16:                 >::type
Chris@16:             type;
Chris@16:         };
Chris@16: 
Chris@16:         /// \brief Metafunction that computes the return type of the
Chris@16:         /// \c unpack_expr() function, within the specified domain.
Chris@16:         ///
Chris@16:         /// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute
Chris@16:         /// the return type of the \c make_expr() function.
Chris@16:         template<typename Tag, typename Domain, typename Sequence>
Chris@16:         struct unpack_expr<Tag, Domain, Sequence, typename Domain::proto_is_domain_>
Chris@16:         {
Chris@16:             /// Let \c S be the type of a Fusion Random Access Sequence
Chris@16:             /// equivalent to \c Sequence. Then \c type is the
Chris@16:             /// same as <tt>result_of::make_expr\<Tag, Domain,
Chris@16:             /// fusion::result_of::value_at_c\<S, 0\>::type, ...
Chris@16:             /// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>,
Chris@16:             /// where \c N is the size of \c S.
Chris@16:             typedef
Chris@16:                 typename detail::unpack_expr_<
Chris@16:                     Tag
Chris@16:                   , Domain
Chris@16:                   , Sequence
Chris@16:                   , fusion::result_of::size<Sequence>::type::value
Chris@16:                 >::type
Chris@16:             type;
Chris@16:         };
Chris@16:     }
Chris@16: 
Chris@16:     namespace functional
Chris@16:     {
Chris@16:         /// \brief A callable function object equivalent to the
Chris@16:         /// \c proto::make_expr() function.
Chris@16:         ///
Chris@16:         /// In all cases, <tt>functional::make_expr\<Tag, Domain\>()(a0, ... aN)</tt>
Chris@16:         /// is equivalent to <tt>proto::make_expr\<Tag, Domain\>(a0, ... aN)</tt>.
Chris@16:         ///
Chris@16:         /// <tt>functional::make_expr\<Tag\>()(a0, ... aN)</tt>
Chris@16:         /// is equivalent to <tt>proto::make_expr\<Tag\>(a0, ... aN)</tt>.
Chris@16:         template<typename Tag, typename Domain  /* = deduce_domain*/>
Chris@16:         struct make_expr
Chris@16:         {
Chris@16:             BOOST_PROTO_CALLABLE()
Chris@16:             BOOST_PROTO_POLY_FUNCTION()
Chris@16: 
Chris@16:             template<typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template<typename This, typename A0>
Chris@16:             struct result<This(A0)>
Chris@16:             {
Chris@16:                 typedef
Chris@16:                     typename result_of::make_expr<
Chris@16:                         Tag
Chris@16:                       , Domain
Chris@16:                       , A0
Chris@16:                     >::type
Chris@16:                 type;
Chris@16:             };
Chris@16: 
Chris@16:             /// Construct an expression node with tag type \c Tag
Chris@16:             /// and in the domain \c Domain.
Chris@16:             ///
Chris@16:             /// \return <tt>proto::make_expr\<Tag, Domain\>(a0,...aN)</tt>
Chris@16:             template<typename A0>
Chris@16:             BOOST_FORCEINLINE
Chris@16:             typename result_of::make_expr<
Chris@16:                 Tag
Chris@16:               , Domain
Chris@16:               , A0 const
Chris@16:             >::type const
Chris@16:             operator ()(A0 const &a0) const
Chris@16:             {
Chris@16:                 return proto::detail::make_expr_<
Chris@16:                     Tag
Chris@16:                   , Domain
Chris@16:                   , A0 const
Chris@16:                 >()(a0);
Chris@16:             }
Chris@16: 
Chris@16:             // Additional overloads generated by the preprocessor ...
Chris@16:             #include <boost/proto/detail/make_expr_funop.hpp>
Chris@16: 
Chris@16:             /// INTERNAL ONLY
Chris@16:             ///
Chris@16:             template<
Chris@16:                 BOOST_PP_ENUM_BINARY_PARAMS(
Chris@16:                     BOOST_PROTO_MAX_ARITY
Chris@16:                   , typename A
Chris@16:                   , = void BOOST_PP_INTERCEPT
Chris@16:                 )
Chris@16:             >
Chris@16:             struct impl
Chris@16:               : detail::make_expr_<
Chris@16:                     Tag
Chris@16:                   , Domain
Chris@16:                     BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
Chris@16:                 >
Chris@16:             {};
Chris@16:         };
Chris@16: 
Chris@16:         /// \brief A callable function object equivalent to the
Chris@16:         /// \c proto::unpack_expr() function.
Chris@16:         ///
Chris@16:         /// In all cases, <tt>functional::unpack_expr\<Tag, Domain\>()(seq)</tt>
Chris@16:         /// is equivalent to <tt>proto::unpack_expr\<Tag, Domain\>(seq)</tt>.
Chris@16:         ///
Chris@16:         /// <tt>functional::unpack_expr\<Tag\>()(seq)</tt>
Chris@16:         /// is equivalent to <tt>proto::unpack_expr\<Tag\>(seq)</tt>.
Chris@16:         template<typename Tag, typename Domain /* = deduce_domain*/>
Chris@16:         struct unpack_expr
Chris@16:         {
Chris@16:             BOOST_PROTO_CALLABLE()
Chris@16: 
Chris@16:             template<typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template<typename This, typename Sequence>
Chris@16:             struct result<This(Sequence)>
Chris@16:             {
Chris@16:                 typedef
Chris@16:                     typename result_of::unpack_expr<
Chris@16:                         Tag
Chris@16:                       , Domain
Chris@16:                       , typename remove_reference<Sequence>::type
Chris@16:                     >::type
Chris@16:                 type;
Chris@16:             };
Chris@16: 
Chris@16:             /// Construct an expression node with tag type \c Tag
Chris@16:             /// and in the domain \c Domain.
Chris@16:             ///
Chris@16:             /// \param sequence A Fusion Forward Sequence
Chris@16:             /// \return <tt>proto::unpack_expr\<Tag, Domain\>(sequence)</tt>
Chris@16:             template<typename Sequence>
Chris@16:             BOOST_FORCEINLINE
Chris@16:             typename result_of::unpack_expr<Tag, Domain, Sequence const>::type const
Chris@16:             operator ()(Sequence const &sequence) const
Chris@16:             {
Chris@16:                 return proto::detail::unpack_expr_<
Chris@16:                     Tag
Chris@16:                   , Domain
Chris@16:                   , Sequence const
Chris@16:                   , fusion::result_of::size<Sequence>::type::value
Chris@16:                 >::call(sequence);
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:     } // namespace functional
Chris@16: 
Chris@16:     /// \brief Construct an expression of the requested tag type
Chris@16:     /// with a domain and with the specified arguments as children.
Chris@16:     ///
Chris@16:     /// This function template may be invoked either with or without
Chris@16:     /// specifying a \c Domain argument. If no domain is specified,
Chris@16:     /// the domain is deduced by examining in order the domains of
Chris@16:     /// the given arguments and taking the first that is not
Chris@16:     /// \c default_domain, if any such domain exists, or
Chris@16:     /// \c default_domain otherwise.
Chris@16:     ///
Chris@16:     /// Let \c wrap_(x) be defined such that:
Chris@16:     /// \li If \c x is a <tt>boost::reference_wrapper\<\></tt>,
Chris@16:     /// \c wrap_(x) is equivalent to <tt>as_child\<Domain\>(x.get())</tt>.
Chris@16:     /// \li Otherwise, \c wrap_(x) is equivalent to
Chris@16:     /// <tt>as_expr\<Domain\>(x)</tt>.
Chris@16:     ///
Chris@16:     /// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as
Chris@16:     /// <tt>expr\<Tag, listN\<C0,...CN\> \>::make(c0,...cN)</tt>
Chris@16:     /// where \c Bx is the type of \c bx.
Chris@16:     ///
Chris@16:     /// \return <tt>Domain()(make_\<Tag\>(wrap_(a0),...wrap_(aN)))</tt>.
Chris@16:     template<typename Tag, typename A0>
Chris@16:     BOOST_FORCEINLINE
Chris@16:     typename lazy_disable_if<
Chris@16:         is_domain<A0>
Chris@16:       , result_of::make_expr<
Chris@16:             Tag
Chris@16:           , A0 const
Chris@16:         >
Chris@16:     >::type const
Chris@16:     make_expr(A0 const &a0)
Chris@16:     {
Chris@16:         return proto::detail::make_expr_<
Chris@16:             Tag
Chris@16:           , deduce_domain
Chris@16:           , A0 const
Chris@16:         >()(a0);
Chris@16:     }
Chris@16: 
Chris@16:     /// \overload
Chris@16:     ///
Chris@16:     template<typename Tag, typename Domain, typename C0>
Chris@16:     BOOST_FORCEINLINE
Chris@16:     typename result_of::make_expr<
Chris@16:         Tag
Chris@16:       , Domain
Chris@16:       , C0 const
Chris@16:     >::type const
Chris@16:     make_expr(C0 const &c0)
Chris@16:     {
Chris@16:         return proto::detail::make_expr_<
Chris@16:             Tag
Chris@16:           , Domain
Chris@16:           , C0 const
Chris@16:         >()(c0);
Chris@16:     }
Chris@16: 
Chris@16:     // Additional overloads generated by the preprocessor...
Chris@16:     #include <boost/proto/detail/make_expr.hpp>
Chris@16: 
Chris@16:     /// \brief Construct an expression of the requested tag type
Chris@16:     /// with a domain and with childres from the specified Fusion
Chris@16:     /// Forward Sequence.
Chris@16:     ///
Chris@16:     /// This function template may be invoked either with or without
Chris@16:     /// specifying a \c Domain argument. If no domain is specified,
Chris@16:     /// the domain is deduced by examining in order the domains of the
Chris@16:     /// elements of \c sequence and taking the first that is not
Chris@16:     /// \c default_domain, if any such domain exists, or
Chris@16:     /// \c default_domain otherwise.
Chris@16:     ///
Chris@16:     /// Let \c s be a Fusion Random Access Sequence equivalent to \c sequence.
Chris@16:     /// Let <tt>wrap_\<N\>(s)</tt>, where \c s has type \c S, be defined
Chris@16:     /// such that:
Chris@16:     /// \li If <tt>fusion::result_of::value_at_c\<S,N\>::type</tt> is a reference,
Chris@16:     /// <tt>wrap_\<N\>(s)</tt> is equivalent to
Chris@16:     /// <tt>as_child\<Domain\>(fusion::at_c\<N\>(s))</tt>.
Chris@16:     /// \li Otherwise, <tt>wrap_\<N\>(s)</tt> is equivalent to
Chris@16:     /// <tt>as_expr\<Domain\>(fusion::at_c\<N\>(s))</tt>.
Chris@16:     ///
Chris@16:     /// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as
Chris@16:     /// <tt>expr\<Tag, listN\<B0,...BN\> \>::make(b0,...bN)</tt>
Chris@16:     /// where \c Bx is the type of \c bx.
Chris@16:     ///
Chris@16:     /// \param sequence a Fusion Forward Sequence.
Chris@16:     /// \return <tt>Domain()(make_\<Tag\>(wrap_\<0\>(s),...wrap_\<N-1\>(s)))</tt>,
Chris@16:     /// where N is the size of \c Sequence.
Chris@16:     template<typename Tag, typename Sequence>
Chris@16:     BOOST_FORCEINLINE
Chris@16:     typename lazy_disable_if<
Chris@16:         is_domain<Sequence>
Chris@16:       , result_of::unpack_expr<Tag, Sequence const>
Chris@16:     >::type const
Chris@16:     unpack_expr(Sequence const &sequence)
Chris@16:     {
Chris@16:         return proto::detail::unpack_expr_<
Chris@16:             Tag
Chris@16:           , deduce_domain
Chris@16:           , Sequence const
Chris@16:           , fusion::result_of::size<Sequence>::type::value
Chris@16:         >::call(sequence);
Chris@16:     }
Chris@16: 
Chris@16:     /// \overload
Chris@16:     ///
Chris@16:     template<typename Tag, typename Domain, typename Sequence2>
Chris@16:     BOOST_FORCEINLINE
Chris@16:     typename result_of::unpack_expr<Tag, Domain, Sequence2 const>::type const
Chris@16:     unpack_expr(Sequence2 const &sequence2)
Chris@16:     {
Chris@16:         return proto::detail::unpack_expr_<
Chris@16:             Tag
Chris@16:           , Domain
Chris@16:           , Sequence2 const
Chris@16:           , fusion::result_of::size<Sequence2>::type::value
Chris@16:         >::call(sequence2);
Chris@16:     }
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename Tag, typename Domain>
Chris@16:     struct is_callable<functional::make_expr<Tag, Domain> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename Tag, typename Domain>
Chris@16:     struct is_callable<functional::unpack_expr<Tag, Domain> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16: }}
Chris@16: 
Chris@101: #if defined(_MSC_VER)
Chris@16: # pragma warning(pop)
Chris@16: #endif
Chris@16: 
Chris@16: #endif // BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005