// Boost Lambda Library  ret.hpp -----------------------------------------

 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)

 //

 // 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)

 //

 // For more information, see www.boost.org

 #ifndef BOOST_LAMBDA_RET_HPP

 #define BOOST_LAMBDA_RET_HPP

 namespace boost { 

 namespace lambda {

   // TODO:

 //  Add specializations for function references for ret, protect and unlambda

 //  e.g void foo(); unlambda(foo); fails, as it would add a const qualifier

   // for a function type. 

   // on the other hand unlambda(*foo) does work

 // -- ret -------------------------

 // the explicit return type template 

   // TODO: It'd be nice to make ret a nop for other than lambda functors

   // but causes an ambiguiyty with gcc (not with KCC), check what is the

   // right interpretation.

   //  // ret for others than lambda functors has no effect

   // template <class U, class T>

   // inline const T& ret(const T& t) { return t; }

 template<class RET, class Arg>

 inline const 

 lambda_functor<

   lambda_functor_base<

     explicit_return_type_action<RET>, 

     tuple<lambda_functor<Arg> >

   > 

 >

 ret(const lambda_functor<Arg>& a1)

 {

   return  

     lambda_functor_base<

       explicit_return_type_action<RET>, 

       tuple<lambda_functor<Arg> >

     > 

     (tuple<lambda_functor<Arg> >(a1));

 }

 // protect ------------------

   // protecting others than lambda functors has no effect

 template <class T>

 inline const T& protect(const T& t) { return t; }

 template<class Arg>

 inline const 

 lambda_functor<

   lambda_functor_base<

     protect_action, 

     tuple<lambda_functor<Arg> >

   > 

 >

 protect(const lambda_functor<Arg>& a1)

 {

   return 

       lambda_functor_base<

         protect_action, 

         tuple<lambda_functor<Arg> >

       > 

     (tuple<lambda_functor<Arg> >(a1));

 }

 // -------------------------------------------------------------------

 // Hides the lambda functorness of a lambda functor. 

 // After this, the functor is immune to argument substitution, etc.

 // This can be used, e.g. to make it safe to pass lambda functors as 

 // arguments to functions, which might use them as target functions

 // note, unlambda and protect are different things. Protect hides the lambda

 // functor for one application, unlambda for good.

 template <class LambdaFunctor>

 class non_lambda_functor

 {

   LambdaFunctor lf;

 public:

   // This functor defines the result_type typedef.

   // The result type must be deducible without knowing the arguments

   template <class SigArgs> struct sig {

     typedef typename 

       LambdaFunctor::inherited:: 

         template sig<typename SigArgs::tail_type>::type type;

   };

   explicit non_lambda_functor(const LambdaFunctor& a) : lf(a) {}

   typename LambdaFunctor::nullary_return_type  

   operator()() const {

     return lf.template 

       call<typename LambdaFunctor::nullary_return_type>

         (cnull_type(), cnull_type(), cnull_type(), cnull_type()); 

   }

   template<class A>

   typename sig<tuple<const non_lambda_functor, A&> >::type 

   operator()(A& a) const {

     return lf.template call<typename sig<tuple<const non_lambda_functor, A&> >::type >(a, cnull_type(), cnull_type(), cnull_type()); 

   }

   template<class A, class B>

   typename sig<tuple<const non_lambda_functor, A&, B&> >::type 

   operator()(A& a, B& b) const {

     return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&> >::type >(a, b, cnull_type(), cnull_type()); 

   }

   template<class A, class B, class C>

   typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type 

   operator()(A& a, B& b, C& c) const {

     return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type>(a, b, c, cnull_type()); 

   }

 };

 template <class Arg>

 inline const Arg& unlambda(const Arg& a) { return a; }

 template <class Arg>

 inline const non_lambda_functor<lambda_functor<Arg> > 

 unlambda(const lambda_functor<Arg>& a)

 {

   return non_lambda_functor<lambda_functor<Arg> >(a);

 }

   // Due to a language restriction, lambda functors cannot be made to

   // accept non-const rvalue arguments. Usually iterators do not return 

   // temporaries, but sometimes they do. That's why a workaround is provided.

   // Note, that this potentially breaks const correctness, so be careful!

 // any lambda functor can be turned into a const_incorrect_lambda_functor

 // The operator() takes arguments as consts and then casts constness

 // away. So this breaks const correctness!!! but is a necessary workaround

 // in some cases due to language limitations.

 // Note, that this is not a lambda_functor anymore, so it can not be used

 // as a sub lambda expression.

 template <class LambdaFunctor>

 struct const_incorrect_lambda_functor {

   LambdaFunctor lf;

 public:

   explicit const_incorrect_lambda_functor(const LambdaFunctor& a) : lf(a) {}

   template <class SigArgs> struct sig {

     typedef typename

       LambdaFunctor::inherited::template 

         sig<typename SigArgs::tail_type>::type type;

   };

   // The nullary case is not needed (no arguments, no parameter type problems)

   template<class A>

   typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type

   operator()(const A& a) const {

     return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type >(const_cast<A&>(a), cnull_type(), cnull_type(), cnull_type());

   }

   template<class A, class B>

   typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type

   operator()(const A& a, const B& b) const {

     return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type >(const_cast<A&>(a), const_cast<B&>(b), cnull_type(), cnull_type());

   }

   template<class A, class B, class C>

   typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type

   operator()(const A& a, const B& b, const C& c) const {

     return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type>(const_cast<A&>(a), const_cast<B&>(b), const_cast<C&>(c), cnull_type());

   }

 };

 // ------------------------------------------------------------------------

 // any lambda functor can be turned into a const_parameter_lambda_functor

 // The operator() takes arguments as const.

 // This is useful if lambda functors are called with non-const rvalues.

 // Note, that this is not a lambda_functor anymore, so it can not be used

 // as a sub lambda expression.

 template <class LambdaFunctor>

 struct const_parameter_lambda_functor {

   LambdaFunctor lf;

 public:

   explicit const_parameter_lambda_functor(const LambdaFunctor& a) : lf(a) {}

   template <class SigArgs> struct sig {

     typedef typename

       LambdaFunctor::inherited::template 

         sig<typename SigArgs::tail_type>::type type;

   };

   // The nullary case is not needed: no arguments, no constness problems.

   template<class A>

   typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type

   operator()(const A& a) const {

     return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type >(a, cnull_type(), cnull_type(), cnull_type());

   }

   template<class A, class B>

   typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type

   operator()(const A& a, const B& b) const {

     return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type >(a, b, cnull_type(), cnull_type());

   }

   template<class A, class B, class C>

   typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&>

 >::type

   operator()(const A& a, const B& b, const C& c) const {

     return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&> >::type>(a, b, c, cnull_type());

   }

 };

 template <class Arg>

 inline const const_incorrect_lambda_functor<lambda_functor<Arg> >

 break_const(const lambda_functor<Arg>& lf)

 {

   return const_incorrect_lambda_functor<lambda_functor<Arg> >(lf);

 }

 template <class Arg>

 inline const const_parameter_lambda_functor<lambda_functor<Arg> >

 const_parameters(const lambda_functor<Arg>& lf)

 {

   return const_parameter_lambda_functor<lambda_functor<Arg> >(lf);

 }

 // make void ------------------------------------------------

 // make_void( x ) turns a lambda functor x with some return type y into

 // another lambda functor, which has a void return type

 // when called, the original return type is discarded

 // we use this action. The action class will be called, which means that

 // the wrapped lambda functor is evaluated, but we just don't do anything

 // with the result.

 struct voidifier_action {

   template<class Ret, class A> static void apply(A&) {}

 };

 template<class Args> struct return_type_N<voidifier_action, Args> {

   typedef void type;

 };

 template<class Arg1>

 inline const 

 lambda_functor<

   lambda_functor_base<

     action<1, voidifier_action>,

     tuple<lambda_functor<Arg1> >

   > 

 > 

 make_void(const lambda_functor<Arg1>& a1) { 

 return 

     lambda_functor_base<

       action<1, voidifier_action>,

       tuple<lambda_functor<Arg1> >

     > 

   (tuple<lambda_functor<Arg1> > (a1));

 }

 // for non-lambda functors, make_void does nothing 

 // (the argument gets evaluated immediately)

 template<class Arg1>

 inline const 

 lambda_functor<

   lambda_functor_base<do_nothing_action, null_type> 

 > 

 make_void(const Arg1& a1) { 

 return 

     lambda_functor_base<do_nothing_action, null_type>();

 }

 // std_functor -----------------------------------------------------

 //  The STL uses the result_type typedef as the convention to let binders know

 //  the return type of a function object. 

 //  LL uses the sig template.

 //  To let LL know that the function object has the result_type typedef 

 //  defined, it can be wrapped with the std_functor function.

 // Just inherit form the template parameter (the standard functor), 

 // and provide a sig template. So we have a class which is still the

 // same functor + the sig template.

 template<class T>

 struct result_type_to_sig : public T {

   template<class Args> struct sig { typedef typename T::result_type type; };

   result_type_to_sig(const T& t) : T(t) {}

 };

 template<class F>

 inline result_type_to_sig<F> std_functor(const F& f) { return f; }

 } // namespace lambda 

 } // namespace boost

 #endif