From aef38586e2356ce048eea8a70a42c6589f58cfc4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaakko=20J=C3=A4rvi?= <jarvi@cs.tamu.edu>
Date: Mon, 17 Dec 2001 22:44:14 +0000
Subject: [PATCH] adding bind<ret>(...) syntax

[SVN r12095]
---
 include/boost/lambda/detail/actions.hpp | 53 +++++++++++++++----------
 1 file changed, 32 insertions(+), 21 deletions(-)

diff --git a/include/boost/lambda/detail/actions.hpp b/include/boost/lambda/detail/actions.hpp
index a557eb9..995a79a 100644
--- a/include/boost/lambda/detail/actions.hpp
+++ b/include/boost/lambda/detail/actions.hpp
@@ -44,7 +44,18 @@ template <class RET> class explicit_return_type_action {};
 struct protect_action {};
    
 template <class Action> class return_void_action;
-template <int I> class function_action;
+
+namespace detail {
+  class unspecified {};
+}
+
+  // function action is a special case: bind functions can be called with 
+  // the return type specialized explicitly e.g. bind<int>(foo);
+  // If this call syntax is used, the return type is stored in the latter
+  // argument of function_action template. Otherwise the argument gets the type
+  // 'unspecified'.
+  // This argument is only relevant in the return type deduction code
+template <int I, class Result_type = detail::unspecified> class function_action {};
    
 // lambda_functor_action arise when the target function in a bind expression
 // is a lambda functor. We must use a separate action type to notify 
@@ -56,99 +67,99 @@ template <int I> class lambda_functor_action : public function_action<I> {};
 
 // ---------------------------------------------------------
 
-template<> class function_action<1> {
+template<class T> class function_action<1, T> {
 public:
   template<class RET, class A1>
   static RET apply(A1& a1) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply(a1);
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>(a1);
   }
 };
 
-template<> class function_action<2> {
+template<class T> class function_action<2, T> {
 public:
   template<class RET, class A1, class A2>
   static RET apply(A1& a1, A2& a2) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
            (a1, a2);
   }
 };
 
-template<> class function_action<3> {
+template<class T> class function_action<3, T> {
 public:
   template<class RET, class A1, class A2, class A3>
   static RET apply(A1& a1, A2& a2, A3& a3) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
            (a1, a2, a3);
   }
 };
 
-template<> class function_action<4> {
+template<class T> class function_action<4, T> {
 public:
   template<class RET, class A1, class A2, class A3, class A4>
   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
            (a1, a2, a3, a4);
   }
 };
 
-template<> class function_action<5> {
+template<class T> class function_action<5, T> {
 public:
   template<class RET, class A1, class A2, class A3, class A4, class A5>
   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
            (a1, a2, a3, a4, a5);
   }
 };
 
-template<> class function_action<6> {
+template<class T> class function_action<6, T> {
 public:
   template<class RET, class A1, class A2, class A3, class A4, class A5, 
            class A6>
   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
            (a1, a2, a3, a4, a5, a6);
   }
 };
 
-template<> class function_action<7> {
+template<class T> class function_action<7, T> {
 public:
   template<class RET, class A1, class A2, class A3, class A4, class A5,  
            class A6, class A7>
   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
            (a1, a2, a3, a4, a5, a6, a7);
   }
 };
 
-template<> class function_action<8> {
+template<class T> class function_action<8, T> {
 public:
   template<class RET, class A1, class A2, class A3, class A4, class A5, 
            class A6, class A7, class A8>
   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
                    A8& a8) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
            (a1, a2, a3, a4, a5, a6, a7, a8);
   }
 };
 
-template<> class function_action<9> {
+template<class T> class function_action<9, T> {
 public:
   template<class RET, class A1, class A2, class A3, class A4, class A5, 
            class A6, class A7, class A8, class A9>
   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
                    A8& a8, A9& a9) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
            (a1, a2, a3, a4, a5, a6, a7, a8, a9);
   }
 };
 
-template<> class function_action<10> {
+template<class T> class function_action<10, T> {
 public:
   template<class RET, class A1, class A2, class A3, class A4, class A5, 
            class A6, class A7, class A8, class A9, class A10>
   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
                    A8& a8, A9& a9, A10& a10) {
-    return function_adaptor<typename boost::remove_const<A1>::type>::apply
+    return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
            (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
   }
 };