FM / transform

/usr/include/boost/proto/transform

Name	Size	Mode	Actions
detail/	-	0755	rm
arg.hpp	9900	0644	edit dl rm
call.hpp	16228	0644	edit dl rm
default.hpp	28465	0644	edit dl rm
env.hpp	19842	0644	edit dl rm
fold.hpp	8565	0644	edit dl rm
fold_tree.hpp	6494	0644	edit dl rm
impl.hpp	21669	0644	edit dl rm
integral_c.hpp	2500	0644	edit dl rm
lazy.hpp	2045	0644	edit dl rm
make.hpp	9691	0644	edit dl rm
pass_through.hpp	5067	0644	edit dl rm
when.hpp	9903	0644	edit dl rm

Edit: /usr/include/boost/proto/transform/lazy.hpp (2045B)

#ifndef BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007
#define BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007

#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/transform/make.hpp>
#include <boost/proto/transform/call.hpp>
#include <boost/proto/transform/impl.hpp>
#include <boost/proto/transform/detail/pack.hpp>

namespace boost { namespace proto
{
    /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build
    /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it.
    ///
    /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the
    /// transform to be applied depends on the current state of the
    /// transformation. The invocation of the <tt>make\<\></tt> transform
    /// evaluates any nested transforms, and the resulting type is treated
    /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>.
    template<typename Object>
    struct lazy : transform<lazy<Object> >
    {
        template<typename Expr, typename State, typename Data>
        struct impl
          : call<
                typename make<Object>::template impl<Expr, State, Data>::result_type
            >::template impl<Expr, State, Data>
        {};
    };

/// INTERNAL ONLY
    template<typename Fun>
    struct lazy<detail::msvc_fun_workaround<Fun> >
      : lazy<Fun>
    {};

#include <boost/proto/transform/detail/lazy.hpp>

/// INTERNAL ONLY
    ///
    template<typename Object>
    struct is_callable<lazy<Object> >
      : mpl::true_
    {};

}}

#endif

/////////////////////////////////////////////////////////////////////////////// /// \file lazy.hpp /// Contains definition of the lazy<> transform. // // Copyright 2008 Eric Niebler. 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) #ifndef BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007 #define BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007 #include #include #include #include #include #include #include #include namespace boost { namespace proto { /// \brief A PrimitiveTransform that uses make\<\> to build /// a CallableTransform, and then uses call\<\> to apply it. /// /// lazy\<\> is useful as a higher-order transform, when the /// transform to be applied depends on the current state of the /// transformation. The invocation of the make\<\> transform /// evaluates any nested transforms, and the resulting type is treated /// as a CallableTransform, which is evaluated with call\<\>. template struct lazy : transform > { template struct impl : call< typename make