Release 1.45.0

[SVN r66646]
merged changeset 63726 from trunk
2026-01-21 17:02:36 +00:00 · 2010-11-19 15:17:53 +00:00 · 2010-07-12 01:36:38 +00:00 · 2010-07-03 19:05:15 +00:00 · 2010-06-26 12:30:09 +00:00 · 2009-10-17 01:10:45 +00:00
54 changed files with 935 additions and 747 deletions
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -1,5 +1,12 @@
 project boost/doc ;
 import boostbook : boostbook ;

-boostbook lambda-doc : lambda.xml ;
+# Are these really the correct images??
+path-constant images : ../../spirit/phoenix/doc/html ;
+
+boostbook lambda-doc : lambda.xml 
+:
+   <xsl:param>boost.root=../../../..
+   <format>pdf:<xsl:param>img.src.path=$(images)/
+;

--- a/doc/lambda.xml
+++ b/doc/lambda.xml
@@ -1908,7 +1908,7 @@ For example:
 int foo(int); int bar(int);
 ...
 int i;
-bind(foo, bind(bar, _1)(i);
+bind(foo, bind(bar, _1))(i);
 </programlisting>

 The last line makes the call <literal>foo(bar(i));</literal>
--- a/include/boost/lambda/algorithm.hpp
+++ b/include/boost/lambda/algorithm.hpp
@@ -1,5 +1,5 @@
 // -- algorithm.hpp -- Boost Lambda Library -----------------------------------
-// Copyright (C) 2002 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/include/boost/lambda/bind.hpp
+++ b/include/boost/lambda/bind.hpp
@@ -1,6 +1,6 @@
 // -- bind.hpp -- Boost Lambda Library --------------------------------------

-// Copyright (C) 1999-2001 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999-2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //                         Gary Powell (gwpowell@hotmail.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/include/boost/lambda/casts.hpp
+++ b/include/boost/lambda/casts.hpp
@@ -1,7 +1,7 @@
 // - casts.hpp -- BLambda Library -------------
 //
 // Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -14,11 +14,17 @@
 #if !defined(BOOST_LAMBDA_CASTS_HPP)
 #define BOOST_LAMBDA_CASTS_HPP

+#include "boost/lambda/detail/suppress_unused.hpp"
+#include "boost/lambda/core.hpp"
+
 #include <typeinfo>

 namespace boost { 
 namespace lambda {

+template<class Act, class Args>
+struct return_type_N;
+
 template<class T> class cast_action;

 template<class T> class static_cast_action;
@@ -64,11 +70,12 @@ public:
  }
 };

-  // typedid action
+// typeid action
 class typeid_action {
 public:
  template<class RET, class Arg1>
  static RET apply(Arg1 &a1) {
+    detail::suppress_unused_variable_warnings(a1);
    return typeid(a1);
  }
 };
--- a/include/boost/lambda/closures.hpp
+++ b/include/boost/lambda/closures.hpp
@@ -251,7 +251,7 @@ private:
    closure& operator=(closure const&); // no assign

    template <int N, typename ClosureT>
-    friend struct closure_member;
+    friend class closure_member;

    template <typename ClosureT>
    friend class closure_frame;
--- a/include/boost/lambda/construct.hpp
+++ b/include/boost/lambda/construct.hpp
@@ -1,7 +1,7 @@
 // - construct.hpp -- Lambda Library -------------
 //
 // Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -14,6 +14,9 @@
 #if !defined(BOOST_LAMBDA_CONSTRUCT_HPP)
 #define BOOST_LAMBDA_CONSTRUCT_HPP

+#include "boost/type_traits/remove_cv.hpp"
+#include "boost/type_traits/is_pointer.hpp"
+
 namespace boost { 
 namespace lambda {

--- a/include/boost/lambda/control_structures.hpp
+++ b/include/boost/lambda/control_structures.hpp
@@ -1,5 +1,5 @@
 // -- control_structures.hpp -- Boost Lambda Library --------------------------
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -17,6 +17,7 @@
 #include "boost/lambda/detail/operator_actions.hpp"
 #include "boost/lambda/detail/operator_return_type_traits.hpp"

-#include "boost/lambda/detail/control_structures_impl.hpp"
+#include "boost/lambda/if.hpp"
+#include "boost/lambda/loops.hpp"

 #endif
--- a/include/boost/lambda/core.hpp
+++ b/include/boost/lambda/core.hpp
@@ -1,7 +1,7 @@
 // -- core.hpp -- Boost Lambda Library -------------------------------------
 //
 // Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/actions.hpp
+++ b/include/boost/lambda/detail/actions.hpp
@@ -1,6 +1,6 @@
 // -- Boost Lambda Library - actions.hpp ----------------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/arity_code.hpp
+++ b/include/boost/lambda/detail/arity_code.hpp
@@ -1,6 +1,6 @@
 // -- Boost Lambda Library -------------------------------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/bind_functions.hpp
+++ b/include/boost/lambda/detail/bind_functions.hpp
@@ -1,6 +1,6 @@
 // -- bind_functions.hpp -- Boost Lambda Library
 //
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/control_constructs_common.hpp
+++ b/include/boost/lambda/detail/control_constructs_common.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library -- control_constructs_common.hpp -------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/include/boost/lambda/detail/control_structures_impl.hpp
+++ b/include/boost/lambda/detail/control_structures_impl.hpp
@@ -1,550 +0,0 @@
-// Boost Lambda Library -- control_structures_impl.hpp ---------------------
-
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-//
-// 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
-
-// --------------------------------------------------------------------------
-
-#if !defined(BOOST_LAMBDA_CONTROL_CONSTRUCTS_HPP)
-#define BOOST_LAMBDA_CONTROL_CONSTRUCTS_HPP
-
-namespace boost { 
-namespace lambda {
-
-// -- void return control actions ----------------------
-
-class forloop_action {};
-class forloop_no_body_action {};
-class ifthen_action {};
-class ifthenelse_action {};
-class whileloop_action {};
-class whileloop_no_body_action {};
-class dowhileloop_action {};
-class dowhileloop_no_body_action {};
-// -- nonvoid return control actions ----------------------
-
-class ifthenelsereturn_action {};
-
-// For loop
-template <class Arg1, class Arg2, class Arg3, class Arg4>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    forloop_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-          lambda_functor<Arg3>, lambda_functor<Arg4> >
-  > 
->
-for_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2, 
-         const lambda_functor<Arg3>& a3, const lambda_functor<Arg4>& a4) { 
-  return 
-      lambda_functor_base<
-        forloop_action, 
-        tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-              lambda_functor<Arg3>, lambda_functor<Arg4> >
-      > 
-    ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-            lambda_functor<Arg3>, lambda_functor<Arg4> >(a1, a2, a3, a4)
-    );
-}
-
-// No body case.
-template <class Arg1, class Arg2, class Arg3>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    forloop_no_body_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
-  > 
->
-for_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2, 
-         const lambda_functor<Arg3>& a3) { 
-  return 
-      lambda_functor_base<
-        forloop_no_body_action, 
-        tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-              lambda_functor<Arg3> >
-      > 
-      ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-               lambda_functor<Arg3> >(a1, a2, a3) );
-}
-
-// While loop
-template <class Arg1, class Arg2>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    whileloop_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-  > 
->
-while_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) { 
-  return 
-      lambda_functor_base<
-        whileloop_action, 
-        tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-      > 
-      ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
-}
-
-// No body case.
-template <class Arg1>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    whileloop_no_body_action, 
-    tuple<lambda_functor<Arg1> >
-  > 
->
-while_loop(const lambda_functor<Arg1>& a1) { 
-  return 
-      lambda_functor_base<
-        whileloop_no_body_action, 
-        tuple<lambda_functor<Arg1> >
-      > 
-      ( tuple<lambda_functor<Arg1> >(a1) );
-}
-
-
-// Do While loop
-template <class Arg1, class Arg2>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    dowhileloop_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-  > 
->
-do_while_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) {
-  return 
-      lambda_functor_base<
-        dowhileloop_action, 
-        tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-      > 
-      ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
-}
-
-// No body case.
-template <class Arg1>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    dowhileloop_no_body_action, 
-    tuple<lambda_functor<Arg1> >
-  > 
->
-do_while_loop(const lambda_functor<Arg1>& a1) { 
-  return 
-      lambda_functor_base<
-        dowhileloop_no_body_action, 
-        tuple<lambda_functor<Arg1> >
-      > 
-      ( tuple<lambda_functor<Arg1> >(a1));
-}
-
-
-// If Then
-template <class Arg1, class Arg2>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    ifthen_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-  > 
->
-if_then(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) {
-  return 
-    lambda_functor_base<
-      ifthen_action, 
-      tuple<lambda_functor<Arg1>, lambda_functor<Arg2> > 
-    > 
-    ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2) );
-}
-
-// If then else
-
-template <class Arg1, class Arg2, class Arg3>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    ifthenelse_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
-  > 
->
-if_then_else(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2, 
-             const lambda_functor<Arg3>& a3) {
-  return 
-    lambda_functor_base<
-      ifthenelse_action, 
-      tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
-    > 
-    (tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
-       (a1, a2, a3) );
-}
-
-// Our version of operator?:()
-
-template <class Arg1, class Arg2, class Arg3>
-inline const 
-  lambda_functor<
-    lambda_functor_base<
-      other_action<ifthenelsereturn_action>, 
-      tuple<lambda_functor<Arg1>,
-          typename const_copy_argument<Arg2>::type,
-          typename const_copy_argument<Arg3>::type>
-  > 
->
-if_then_else_return(const lambda_functor<Arg1>& a1, 
-                    const Arg2 & a2, 
-                    const Arg3 & a3) {
-  return 
-      lambda_functor_base<
-        other_action<ifthenelsereturn_action>, 
-        tuple<lambda_functor<Arg1>,
-              typename const_copy_argument<Arg2>::type,
-              typename const_copy_argument<Arg3>::type>
-      > ( tuple<lambda_functor<Arg1>,
-              typename const_copy_argument<Arg2>::type,
-              typename const_copy_argument<Arg3>::type> (a1, a2, a3) );
-}
-
-namespace detail {
-
-// return type specialization for conditional expression begins -----------
-// start reading below and move upwards
-
-// PHASE 6:1 
-// check if A is conbertible to B and B to A
-template<int Phase, bool AtoB, bool BtoA, bool SameType, class A, class B>
-struct return_type_2_ifthenelsereturn;
-
-// if A can be converted to B and vice versa -> ambiguous
-template<int Phase, class A, class B>
-struct return_type_2_ifthenelsereturn<Phase, true, true, false, A, B> {
-  typedef 
-    detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type;
-  // ambiguous type in conditional expression
-};
-// if A can be converted to B and vice versa and are of same type
-template<int Phase, class A, class B>
-struct return_type_2_ifthenelsereturn<Phase, true, true, true, A, B> {
-  typedef A type;
-};
-
-
-// A can be converted to B
-template<int Phase, class A, class B>
-struct return_type_2_ifthenelsereturn<Phase, true, false, false, A, B> {
-  typedef B type;
-};
-
-// B can be converted to A
-template<int Phase, class A, class B>
-struct return_type_2_ifthenelsereturn<Phase, false, true, false, A, B> {
-  typedef A type;
-};
-
-// neither can be converted. Then we drop the potential references, and
-// try again
-template<class A, class B>
-struct return_type_2_ifthenelsereturn<1, false, false, false, A, B> {
-  // it is safe to add const, since the result will be an rvalue and thus
-  // const anyway. The const are needed eg. if the types 
-  // are 'const int*' and 'void *'. The remaining type should be 'const void*'
-  typedef const typename boost::remove_reference<A>::type plainA; 
-  typedef const typename boost::remove_reference<B>::type plainB; 
-  // TODO: Add support for volatile ?
-
-  typedef typename
-       return_type_2_ifthenelsereturn<
-         2,
-         boost::is_convertible<plainA,plainB>::value, 
-         boost::is_convertible<plainB,plainA>::value,
-         boost::is_same<plainA,plainB>::value,
-         plainA, 
-         plainB>::type type;
-};
-
-// PHASE 6:2
-template<class A, class B>
-struct return_type_2_ifthenelsereturn<2, false, false, false, A, B> {
-  typedef 
-    detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type;
-  // types_do_not_match_in_conditional_expression 
-};
-
-
-
-// PHASE 5: now we know that types are not arithmetic.
-template<class A, class B>
-struct non_numeric_types {
-  typedef typename 
-    return_type_2_ifthenelsereturn<
-      1, // phase 1 
-      is_convertible<A,B>::value, 
-      is_convertible<B,A>::value, 
-      is_same<A,B>::value,
-      A, 
-      B>::type type;
-};
-
-// PHASE 4 : 
-// the base case covers arithmetic types with differing promote codes
-// use the type deduction of arithmetic_actions
-template<int CodeA, int CodeB, class A, class B>
-struct arithmetic_or_not {
-  typedef typename
-    return_type_2<arithmetic_action<plus_action>, A, B>::type type; 
-  // plus_action is just a random pick, has to be a concrete instance
-};
-
-// this case covers the case of artihmetic types with the same promote codes. 
-// non numeric deduction is used since e.g. integral promotion is not 
-// performed with operator ?: 
-template<int CodeA, class A, class B>
-struct arithmetic_or_not<CodeA, CodeA, A, B> {
-  typedef typename non_numeric_types<A, B>::type type; 
-};
-
-// if either A or B has promote code -1 it is not an arithmetic type
-template<class A, class B>
-struct arithmetic_or_not <-1, -1, A, B> {
-  typedef typename non_numeric_types<A, B>::type type;
-};
-template<int CodeB, class A, class B>
-struct arithmetic_or_not <-1, CodeB, A, B> {
-  typedef typename non_numeric_types<A, B>::type type;
-};
-template<int CodeA, class A, class B>
-struct arithmetic_or_not <CodeA, -1, A, B> {
-  typedef typename non_numeric_types<A, B>::type type;
-};
-
-
-
-
-// PHASE 3 : Are the types same?
-// No, check if they are arithmetic or not
-template <class A, class B>
-struct same_or_not {
-  typedef typename detail::remove_reference_and_cv<A>::type plainA;
-  typedef typename detail::remove_reference_and_cv<B>::type plainB;
-
-  typedef typename 
-    arithmetic_or_not<
-      detail::promote_code<plainA>::value, 
-      detail::promote_code<plainB>::value, 
-      A, 
-      B>::type type;
-};
-// Yes, clear.
-template <class A> struct same_or_not<A, A> {
-  typedef A type;
-};
-
-} // detail
-
-// PHASE 2 : Perform first the potential array_to_pointer conversion 
-template<class A, class B>
-struct return_type_2<other_action<ifthenelsereturn_action>, A, B> { 
-
-  typedef typename detail::array_to_pointer<A>::type A1;
-  typedef typename detail::array_to_pointer<B>::type B1;
-
-  typedef typename 
-    boost::add_const<typename detail::same_or_not<A1, B1>::type>::type type;
-};
-
-// PHASE 1 : Deduction is based on the second and third operand
-
-
-// return type specialization for conditional expression ends -----------
-
-
-
-
-// Control loop lambda_functor_base specializations.
-
-// Specialization for for_loop.
-template<class Args>
-class 
-lambda_functor_base<forloop_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    for(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); 
-        detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-        detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS))
-      
-      detail::select(boost::tuples::get<3>(args), CALL_ACTUAL_ARGS);
-  }
-};
-
-// No body case
-template<class Args>
-class 
-lambda_functor_base<forloop_no_body_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    for(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); 
-        detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-        detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS)) {}
-   }
-};
-
-
-// Specialization for while_loop.
-template<class Args>
-class 
-lambda_functor_base<whileloop_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    while(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS))
-      
-      detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
-  }
-};
-
-// No body case
-template<class Args> 
-class 
-lambda_functor_base<whileloop_no_body_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-          while(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) {}
-  }
-};
-
-// Specialization for do_while_loop.
-// Note that the first argument is the condition.
-template<class Args>
-class 
-lambda_functor_base<dowhileloop_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    do {
-      detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);      
-    } while (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) );
-  }
-};
-
-// No body case
-template<class Args>
-class 
-lambda_functor_base<dowhileloop_no_body_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-          do {} while (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) );
-  }
-};
-
-
-// Specialization for if_then.
-template<class Args>
-class 
-lambda_functor_base<ifthen_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-  }
-};
-
-// Specialization for if_then_else.
-template<class Args>
-class 
-lambda_functor_base<ifthenelse_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) 
-      detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-    else 
-      detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS);
-  }
-};
-
-// Specialization of lambda_functor_base for if_then_else_return.
-template<class Args>
-class 
-lambda_functor_base<other_action<ifthenelsereturn_action>, Args> {
-public:
-  Args args;
-
-  template <class SigArgs> struct sig {
-  private:
-    typedef typename detail::nth_return_type_sig<1, Args, SigArgs>::type ret1;
-    typedef typename detail::nth_return_type_sig<2, Args, SigArgs>::type ret2;
-  public:
-    typedef typename return_type_2<
-      other_action<ifthenelsereturn_action>, ret1, ret2
-    >::type type;
-  };
-
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) ?
-       detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS) 
-    : 
-       detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS);
-  }
-};
-
-} // lambda
-} // boost
-
-#endif // BOOST_LAMBDA_CONTROL_CONSTRUCTS_HPP
--- a/include/boost/lambda/detail/function_adaptors.hpp
+++ b/include/boost/lambda/detail/function_adaptors.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library -  function_adaptors.hpp ----------------------------
 
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -12,25 +12,167 @@
 #ifndef BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
 #define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP

+#include "boost/mpl/has_xxx.hpp"
+#include "boost/tuple/tuple.hpp"
 #include "boost/type_traits/same_traits.hpp"
+#include "boost/type_traits/remove_reference.hpp"
+#include "boost/utility/result_of.hpp"

 namespace boost { 
 namespace lambda {

+namespace detail {
+
+BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
+
+template<class Tuple>
+struct remove_references_from_elements {
+  typedef typename boost::tuples::cons<
+    typename boost::remove_reference<typename Tuple::head_type>::type,
+    typename remove_references_from_elements<typename Tuple::tail_type>::type
+  > type;
+};
+
+template<>
+struct remove_references_from_elements<boost::tuples::null_type> {
+  typedef boost::tuples::null_type type;
+};
+
+}
+
 template <class Func> struct function_adaptor {

+  typedef typename detail::remove_reference_and_cv<Func>::type plainF;
+
+#if !defined(BOOST_NO_RESULT_OF)
+  // Support functors that use the boost::result_of return type convention.
+  template<class Tuple, int Length, bool HasSig>
+  struct result_converter;
+  template<class Tuple, int Length>
+  struct result_converter<Tuple, Length, true>
+    : plainF::template sig<
+        typename detail::remove_references_from_elements<Tuple>::type
+      >
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 0, false>
+    : result_of<plainF()>
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 1, false>
+    : result_of<plainF(
+        typename tuples::element<1, Tuple>::type)
+      >
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 2, false>
+    : result_of<plainF(
+        typename tuples::element<1, Tuple>::type,
+        typename tuples::element<2, Tuple>::type)
+      >
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 3, false>
+    : result_of<plainF(
+        typename tuples::element<1, Tuple>::type,
+        typename tuples::element<2, Tuple>::type,
+        typename tuples::element<3, Tuple>::type)
+      >
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 4, false>
+    : result_of<plainF(
+        typename tuples::element<1, Tuple>::type,
+        typename tuples::element<2, Tuple>::type,
+        typename tuples::element<3, Tuple>::type,
+        typename tuples::element<4, Tuple>::type)
+      >
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 5, false>
+    : result_of<plainF(
+        typename tuples::element<1, Tuple>::type,
+        typename tuples::element<2, Tuple>::type,
+        typename tuples::element<3, Tuple>::type,
+        typename tuples::element<4, Tuple>::type,
+        typename tuples::element<5, Tuple>::type)
+      >
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 6, false>
+    : result_of<plainF(
+        typename tuples::element<1, Tuple>::type,
+        typename tuples::element<2, Tuple>::type,
+        typename tuples::element<3, Tuple>::type,
+        typename tuples::element<4, Tuple>::type,
+        typename tuples::element<5, Tuple>::type,
+        typename tuples::element<6, Tuple>::type)
+      >
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 7, false>
+    : result_of<plainF(
+        typename tuples::element<1, Tuple>::type,
+        typename tuples::element<2, Tuple>::type,
+        typename tuples::element<3, Tuple>::type,
+        typename tuples::element<4, Tuple>::type,
+        typename tuples::element<5, Tuple>::type,
+        typename tuples::element<6, Tuple>::type,
+        typename tuples::element<7, Tuple>::type)
+      >
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 8, false>
+    : result_of<plainF(
+        typename tuples::element<1, Tuple>::type,
+        typename tuples::element<2, Tuple>::type,
+        typename tuples::element<3, Tuple>::type,
+        typename tuples::element<4, Tuple>::type,
+        typename tuples::element<5, Tuple>::type,
+        typename tuples::element<6, Tuple>::type,
+        typename tuples::element<7, Tuple>::type,
+        typename tuples::element<8, Tuple>::type)
+      >
+  {};
+  template<class Tuple>
+  struct result_converter<Tuple, 9, false>
+    : result_of<plainF(
+        typename tuples::element<1, Tuple>::type,
+        typename tuples::element<2, Tuple>::type,
+        typename tuples::element<3, Tuple>::type,
+        typename tuples::element<4, Tuple>::type,
+        typename tuples::element<5, Tuple>::type,
+        typename tuples::element<6, Tuple>::type,
+        typename tuples::element<7, Tuple>::type,
+        typename tuples::element<8, Tuple>::type,
+        typename tuples::element<9, Tuple>::type)
+      >
+  {};
+
  // we do not know the return type off-hand, we must ask it from Func
-  template <class Args> class sig { 
-    typedef typename Args::head_type F; 
+  // To sig we pass a cons list, where the head is the function object type
+  // itself (potentially cv-qualified)
+  // and the tail contains the types of the actual arguments to be passed
+  // to the function object. The arguments can be cv qualified
+  // as well.
+  template <class Args>
+  struct sig
+    : result_converter<
+        Args
+      , tuples::length<typename Args::tail_type>::value
+      , detail::has_sig<plainF>::value
+      >
+  {};
+#else // BOOST_NO_RESULT_OF
+
+  template <class Args> class sig {
    typedef typename detail::remove_reference_and_cv<Func>::type plainF;
  public:
-    // To sig we pass a cons list, where the head is the function object type
-    // itself (potentially cv-qualified)
-    // and the tail contains the types of the actual arguments to be passed
-    // to the function object. The arguments can be cv qualified
-    // as well.
-    typedef typename plainF::template sig<Args>::type type;
+    typedef typename plainF::template sig<
+      typename detail::remove_references_from_elements<Args>::type
+    >::type type;
  };
+#endif

  template<class RET, class A1>
  static RET apply(A1& a1) {
--- a/include/boost/lambda/detail/is_instance_of.hpp
+++ b/include/boost/lambda/detail/is_instance_of.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library - is_instance_of.hpp ---------------------

-// Copyright (C) 2001 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/lambda_config.hpp
+++ b/include/boost/lambda/detail/lambda_config.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library - lambda_config.hpp ------------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/lambda_functor_base.hpp
+++ b/include/boost/lambda/detail/lambda_functor_base.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library  lambda_functor_base.hpp -----------------------------
 //
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,9 +13,19 @@
 #ifndef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP
 #define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP

+#include "boost/type_traits/add_reference.hpp"
+#include "boost/type_traits/add_const.hpp"
+#include "boost/type_traits/remove_const.hpp"
+#include "boost/lambda/detail/lambda_fwd.hpp"
+#include "boost/lambda/detail/lambda_traits.hpp"
+
 namespace boost { 
 namespace lambda {

+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif

  // for return type deductions we wrap bound argument to this class,
  // which fulfils the base class contract for lambda_functors
@@ -36,12 +46,16 @@ public:
  explicit identity(par_t t) : elem(t) {}

  template <typename SigArgs> 
-  struct sig { typedef element_t type; };
+  struct sig { typedef typename boost::remove_const<element_t>::type type; };

  template<class RET, CALL_TEMPLATE_ARGS>
  RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return elem; }
 };

+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 template <class T> 
 inline lambda_functor<identity<T&> > var(T& t) { return identity<T&>(t); }

@@ -262,6 +276,8 @@ class lambda_functor_base<explicit_return_type_action<RET>, Args>
 public:
  Args args;

+  typedef RET result_type;
+
  explicit lambda_functor_base(const Args& a) : args(a) {}

  template <class SigArgs> struct sig { typedef RET type; };
@@ -337,7 +353,7 @@ class lambda_functor_base<action<0, Act>, Args>
 {  
 public:  
 //  Args args; not needed
-  explicit lambda_functor_base(const Args& a) {}  
+  explicit lambda_functor_base(const Args& /*a*/) {}  
  
  template<class SigArgs> struct sig {  
    typedef typename return_type_N<Act, null_type>::type type;
@@ -367,7 +383,7 @@ public:                                                                \
                                                                       \
  template<class SigArgs> struct sig {                                 \
    typedef typename                                                   \
-    detail::deduce_non_ref_argument_types<Args, SigArgs>::type rets_t; \
+    detail::deduce_argument_types<Args, SigArgs>::type rets_t;         \
  public:                                                              \
    typedef typename                                                   \
      return_type_N_prot<Act, rets_t>::type type;                      \
--- a/include/boost/lambda/detail/lambda_functors.hpp
+++ b/include/boost/lambda/detail/lambda_functors.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library -  lambda_functors.hpp -------------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,6 +13,30 @@
 #ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
 #define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP

+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+
+#include <boost/mpl/or.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_array.hpp>
+
+#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1)\
+  typename lazy_disable_if<is_array<A1>, typename R1 >::type
+#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) \
+  typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2> >, typename R1, R2 >::type
+#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) \
+  typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2>, is_array<A3> >, typename R1, R2, R3 >::type
+
+#else
+
+#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1) typename R1::type
+#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) typename R1, R2::type
+#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) typename R1, R2, R3::type
+
+#endif
+
 namespace boost { 
 namespace lambda {

@@ -105,7 +129,10 @@ typedef const lambda_functor<placeholder<THIRD> >  placeholder3_type;
 // other lambda_functors.
 // -------------------------------------------------------------------

-
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif

 // -- lambda_functor NONE ------------------------------------------------
 template <class T>
@@ -134,6 +161,25 @@ public:
    inherited::template sig<null_type>::type
      nullary_return_type;

+  // Support for boost::result_of.
+  template <class Sig> struct result;
+  template <class F>
+  struct result<F()> {
+    typedef nullary_return_type type;
+  };
+  template <class F, class A>
+  struct result<F(A)> {
+    typedef typename sig<tuple<F, A> >::type type;
+  };
+  template <class F, class A, class B>
+  struct result<F(A, B)> {
+    typedef typename sig<tuple<F, A, B> >::type type;
+  };
+  template <class F, class A, class B, class C>
+  struct result<F(A, B, C)> {
+    typedef typename sig<tuple<F, A, B, C> >::type type;
+  };
+
  nullary_return_type operator()() const { 
    return inherited::template 
      call<nullary_return_type>
@@ -149,7 +195,7 @@ public:
  }

  template<class A>
-  typename inherited::template sig<tuple<A const&> >::type
+  BOOST_LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A const&> >)
  operator()(A const& a) const { 
    return inherited::template call<
      typename inherited::template sig<tuple<A const&> >::type
@@ -165,7 +211,7 @@ public:
  }

  template<class A, class B>
-  typename inherited::template sig<tuple<A const&, B&> >::type
+  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B&> >)
  operator()(A const& a, B& b) const { 
    return inherited::template call<
      typename inherited::template sig<tuple<A const&, B&> >::type
@@ -173,7 +219,7 @@ public:
  }

  template<class A, class B>
-  typename inherited::template sig<tuple<A&, B const&> >::type
+  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A&, B const&> >)
  operator()(A& a, B const& b) const { 
    return inherited::template call<
      typename inherited::template sig<tuple<A&, B const&> >::type
@@ -181,7 +227,7 @@ public:
  }

  template<class A, class B>
-  typename inherited::template sig<tuple<A const&, B const&> >::type
+  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B const&> >)
  operator()(A const& a, B const& b) const { 
    return inherited::template call<
      typename inherited::template sig<tuple<A const&, B const&> >::type
@@ -198,7 +244,7 @@ public:
  }

  template<class A, class B, class C>
-  typename inherited::template sig<tuple<A const&, B const&, C const&> >::type
+  BOOST_LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A const&, B const&, C const&> >)
  operator()(A const& a, B const& b, C const& c) const
  { 
    return inherited::template call<
@@ -244,6 +290,9 @@ public:
  } 
 };

+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif

 } // namespace lambda
 } // namespace boost
--- a/include/boost/lambda/detail/lambda_fwd.hpp
+++ b/include/boost/lambda/detail/lambda_fwd.hpp
@@ -1,6 +1,6 @@
 //  lambda_fwd.hpp - Boost Lambda Library -------------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/lambda_traits.hpp
+++ b/include/boost/lambda/detail/lambda_traits.hpp
@@ -1,6 +1,6 @@
 // - lambda_traits.hpp --- Boost Lambda Library ----------------------------
 //
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -16,6 +16,7 @@
 #include "boost/type_traits/cv_traits.hpp"
 #include "boost/type_traits/function_traits.hpp"
 #include "boost/type_traits/object_traits.hpp"
+#include "boost/tuple/tuple.hpp"

 namespace boost {
 namespace lambda {
@@ -430,6 +431,56 @@ struct bind_traits<const volatile T[n]> {
  typedef const volatile T (&type)[n];
 };

+template<class R>
+struct bind_traits<R()> {
+    typedef R(&type)();
+};
+
+template<class R, class Arg1>
+struct bind_traits<R(Arg1)> {
+    typedef R(&type)(Arg1);
+};
+
+template<class R, class Arg1, class Arg2>
+struct bind_traits<R(Arg1, Arg2)> {
+    typedef R(&type)(Arg1, Arg2);
+};
+
+template<class R, class Arg1, class Arg2, class Arg3>
+struct bind_traits<R(Arg1, Arg2, Arg3)> {
+    typedef R(&type)(Arg1, Arg2, Arg3);
+};
+
+template<class R, class Arg1, class Arg2, class Arg3, class Arg4>
+struct bind_traits<R(Arg1, Arg2, Arg3, Arg4)> {
+    typedef R(&type)(Arg1, Arg2, Arg3, Arg4);
+};
+
+template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
+struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5)> {
+    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5);
+};
+
+template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6>
+struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
+    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6);
+};
+
+template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7>
+struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
+    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7);
+};
+
+template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8>
+struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
+    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8);
+};
+
+template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9>
+struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
+    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9);
+};
+
 template<class T> 
 struct bind_traits<reference_wrapper<T> >{
  typedef T& type;
--- a/include/boost/lambda/detail/member_ptr.hpp
+++ b/include/boost/lambda/detail/member_ptr.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library -- member_ptr.hpp ---------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/include/boost/lambda/detail/operator_actions.hpp
+++ b/include/boost/lambda/detail/operator_actions.hpp
@@ -1,6 +1,6 @@
 // -- operator_actions.hpp - Boost Lambda Library ----------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/operator_lambda_func_base.hpp
+++ b/include/boost/lambda/detail/operator_lambda_func_base.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library  - operator_lambda_func_base.hpp -----------------
 //
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/operator_return_type_traits.hpp
+++ b/include/boost/lambda/detail/operator_return_type_traits.hpp
@@ -1,6 +1,6 @@
 //  operator_return_type_traits.hpp -- Boost Lambda Library ------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -15,6 +15,7 @@
 #include "boost/type_traits/same_traits.hpp"

 #include "boost/indirect_reference.hpp"
+#include "boost/detail/container_fwd.hpp"

 #include <cstddef> // needed for the ptrdiff_t
 #include <iosfwd>  // for istream and ostream
@@ -58,10 +59,6 @@ template <> struct promote_code<long double> { static const int value = 700; };
 } // namespace lambda 
 } // namespace boost

-namespace std {
-  template<class T> class complex;
-}
-
 namespace boost { 
 namespace lambda {
 namespace detail {
@@ -228,34 +225,15 @@ template <> struct contentsof_type<null_type> {


 template <class A> struct contentsof_type<const A> {
-  typedef typename contentsof_type<A>::type type1;
-  // return a reference to the underlying const type
-  // the IF is because the A::reference in the primary template could
-  // be some class type rather than a real reference, hence
-  // we do not want to make it a reference here either
-    typedef typename detail::IF<
-      is_reference<type1>::value, 
-      const typename boost::remove_reference<type1>::type &,
-      const type1
-  >::RET type;
+  typedef typename contentsof_type<A>::type type;
 };

 template <class A> struct contentsof_type<volatile A> {
-  typedef typename contentsof_type<A>::type type1;
-  typedef typename detail::IF<
-    is_reference<type1>::value, 
-    volatile typename boost::remove_reference<type1>::type &,
-    volatile type1
-  >::RET type;
+  typedef typename contentsof_type<A>::type type;
 };

 template <class A> struct contentsof_type<const volatile A> {
-  typedef typename contentsof_type<A>::type type1;
-  typedef typename detail::IF<
-    is_reference<type1>::value, 
-    const volatile typename boost::remove_reference<type1>::type &,
-    const volatile type1
-  >::RET type;
+  typedef typename contentsof_type<A>::type type;
 };

  // standard iterator traits should take care of the pointer types 
@@ -853,44 +831,6 @@ struct return_type_2<other_action<subscript_action>, A, B> {

 };

-
-} // namespace lambda
-} // namespace boost
-
-
-// Forward declarations are incompatible with the libstdc++ debug mode.
-#if BOOST_WORKAROUND(__GNUC__, >= 3) && defined(_GLIBCXX_DEBUG)
-#include <string>
-#include <vector>
-#include <map>
-#include <deque>
-#else
-
-// The GCC 2.95.x uses a non-conformant deque
-#if BOOST_WORKAROUND(__GNUC__, == 2) && __GNUC_MINOR__ <= 96
-#include <deque>
-#else
-
-namespace std {
-  template <class T, class Allocator> class deque;
-}
-
-#endif
-
-namespace std {
- template <class Char, class Traits, class Allocator> class basic_string;
- template <class T, class Allocator> class vector;
- template <class Key, class T, class Cmp, class Allocator> class map;
- template <class Key, class T, class Cmp, class Allocator> class multimap;
-}
-
-#endif
-
-
-
-namespace boost { 
-namespace lambda {
-
 template<class Key, class T, class Cmp, class Allocator, class B> 
 struct plain_return_type_2<other_action<subscript_action>, std::map<Key, T, Cmp, Allocator>, B> { 
  typedef T& type;
@@ -933,6 +873,41 @@ struct plain_return_type_2<other_action<subscript_action>, const std::basic_stri
  typedef typename std::basic_string<Char, Traits, Allocator>::const_reference type;
 };

+template<class Char, class Traits, class Allocator> 
+struct plain_return_type_2<arithmetic_action<plus_action>,
+                           std::basic_string<Char, Traits, Allocator>,
+                           std::basic_string<Char, Traits, Allocator> > { 
+  typedef std::basic_string<Char, Traits, Allocator> type;
+};
+
+template<class Char, class Traits, class Allocator> 
+struct plain_return_type_2<arithmetic_action<plus_action>,
+                           const Char*,
+                           std::basic_string<Char, Traits, Allocator> > { 
+  typedef std::basic_string<Char, Traits, Allocator> type;
+};
+
+template<class Char, class Traits, class Allocator> 
+struct plain_return_type_2<arithmetic_action<plus_action>,
+                           std::basic_string<Char, Traits, Allocator>,
+                           const Char*> { 
+  typedef std::basic_string<Char, Traits, Allocator> type;
+};
+
+template<class Char, class Traits, class Allocator, std::size_t N> 
+struct plain_return_type_2<arithmetic_action<plus_action>,
+                           Char[N],
+                           std::basic_string<Char, Traits, Allocator> > { 
+  typedef std::basic_string<Char, Traits, Allocator> type;
+};
+
+template<class Char, class Traits, class Allocator, std::size_t N> 
+struct plain_return_type_2<arithmetic_action<plus_action>,
+                           std::basic_string<Char, Traits, Allocator>,
+                           Char[N]> { 
+  typedef std::basic_string<Char, Traits, Allocator> type;
+};
+

 } // namespace lambda
 } // namespace boost
--- a/include/boost/lambda/detail/operators.hpp
+++ b/include/boost/lambda/detail/operators.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library - operators.hpp --------------------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -37,16 +37,16 @@ inline const                                                                 \
 lambda_functor<                                                              \
  lambda_functor_base<                                                       \
    ACTION,                                                                  \
-    tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>         \
+    tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>  \
  >                                                                          \
 >                                                                            \
 OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) {                      \
  return                                                                     \
    lambda_functor_base<                                                     \
      ACTION,                                                                \
-      tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>       \
+      tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\
    >                                                                        \
-   (tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>(a, b)); \
+   (tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \
 }


@@ -258,17 +258,17 @@ operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
 #error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E1"
 #endif

-#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)            \
+#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)           \
 template<class Arg, int N, class B>                                         \
 inline const                                                                \
 lambda_functor<                                                             \
-  lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >   \
+  lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >    \
 >                                                                           \
-OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                    \
+OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                     \
 {                                                                           \
-  return lambda_functor<                                                    \
-    lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \
-  >(tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                       \
+  return                                                                    \
+    lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >  \
+  (tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                         \
 }


@@ -276,15 +276,15 @@ OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                    \
 #error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E2"
 #endif

-#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA)             \
-template<int N, class A, class Arg>                                          \
-inline const                                                                 \
-lambda_functor<                                                              \
+#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA)           \
+template<int N, class A, class Arg>                                         \
+inline const                                                                \
+lambda_functor<                                                             \
  lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > >   \
->                                                                            \
+>                                                                           \
 OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b)                     \
-{                                                                            \
-  return                                                                     \
+{                                                                           \
+  return                                                                    \
    lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
    (tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b));                      \
 }
--- a/include/boost/lambda/detail/ret.hpp
+++ b/include/boost/lambda/detail/ret.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library  ret.hpp -----------------------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/return_type_traits.hpp
+++ b/include/boost/lambda/detail/return_type_traits.hpp
@@ -1,6 +1,6 @@
 //  return_type_traits.hpp -- Boost Lambda Library ---------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -216,8 +216,6 @@ typedef typename


  // currently there are no protectable actions with > 2 args
-  // Note, that if there will be, lambda_functor_base will have to be 
-  // changed to not get rid of references in Args elements

 template<class Act, class Args> struct return_type_N_prot {
  typedef typename return_type_N<Act, Args>::type type;
--- a/include/boost/lambda/detail/select_functions.hpp
+++ b/include/boost/lambda/detail/select_functions.hpp
@@ -1,6 +1,6 @@
 // -- select_functions.hpp -- Boost Lambda Library --------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/detail/suppress_unused.hpp
+++ b/include/boost/lambda/detail/suppress_unused.hpp
@@ -0,0 +1,27 @@
+// Boost Lambda Library  suppress_unused.hpp -----------------------------
+//
+// Copyright (C) 2009 Steven Watanabe
+//
+// 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_SUPRESS_UNUSED_HPP
+#define BOOST_LAMBDA_SUPRESS_UNUSED_HPP
+
+namespace boost { 
+namespace lambda {
+namespace detail {
+
+template<class T>
+inline void suppress_unused_variable_warnings(const T&) {}
+
+}
+}
+}
+
+#endif
--- a/include/boost/lambda/exceptions.hpp
+++ b/include/boost/lambda/exceptions.hpp
@@ -1,7 +1,7 @@
 // -- Boost Lambda Library -- exceptions.hpp ----------------
 //
 // Copyright (C) 2000 Gary Powell (gwpowell@hotmail.com)
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -14,6 +14,7 @@
 #if !defined(BOOST_LAMBDA_EXCEPTIONS_HPP)
 #define BOOST_LAMBDA_EXCEPTIONS_HPP

+#include "boost/lambda/core.hpp"
 #include "boost/lambda/detail/control_constructs_common.hpp"

 namespace boost { 
--- a/include/boost/lambda/if.hpp
+++ b/include/boost/lambda/if.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library -- if.hpp ------------------------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000 Gary Powell (powellg@amazon.com)
 // Copyright (C) 2001-2002 Joel de Guzman
 //
--- a/include/boost/lambda/lambda.hpp
+++ b/include/boost/lambda/lambda.hpp
@@ -1,5 +1,5 @@
 // -- lambda.hpp -- Boost Lambda Library -----------------------------------
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/include/boost/lambda/loops.hpp
+++ b/include/boost/lambda/loops.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library -- loops.hpp ----------------------------------------

-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000 Gary Powell (powellg@amazon.com)
 // Copyright (c) 2001-2002 Joel de Guzman
 //
--- a/include/boost/lambda/numeric.hpp
+++ b/include/boost/lambda/numeric.hpp
@@ -1,5 +1,5 @@
 // -- numeric.hpp -- Boost Lambda Library -----------------------------------
-// Copyright (C) 2002 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/include/boost/lambda/switch.hpp
+++ b/include/boost/lambda/switch.hpp
@@ -1,7 +1,7 @@
 // Boost Lambda Library -- switch.hpp -----------------------------------
 //
 // Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -465,12 +465,18 @@ BOOST_LAMBDA_SWITCH( BOOST_PP_INC(N) )
 #define BOOST_LAMBDA_SWITCH_STATEMENT_HELPER(z, N, A) \
 BOOST_LAMBDA_SWITCH_STATEMENT(BOOST_PP_INC(N))

-
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4065)
+#endif

  // up to 9 cases supported (counting default:)
 BOOST_PP_REPEAT_2ND(9,BOOST_LAMBDA_SWITCH_HELPER,FOO)
 BOOST_PP_REPEAT_2ND(9,BOOST_LAMBDA_SWITCH_STATEMENT_HELPER,FOO)

+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif

 } // namespace lambda 
 } // namespace boost
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -11,7 +11,7 @@
 import testing ;

 project 
-  : requirements <library>/boost/test//boost_test_exec_monitor
+  : requirements <toolset>msvc:<asynch-exceptions>on
  ;
          
 test-suite lambda
@@ -30,4 +30,6 @@ test-suite lambda
    [ run operator_tests_simple.cpp ]
    [ run phoenix_control_structures.cpp ]
    [ run switch_construct.cpp ]
+    [ run result_of_tests.cpp ]
+    [ run ret_test.cpp ]
  ;      
--- a/test/algorithm_test.cpp
+++ b/test/algorithm_test.cpp
@@ -1,6 +1,6 @@
 //  bll_and_function.cpp  - The Boost Lambda Library -----------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/test/bind_tests_advanced.cpp
+++ b/test/bind_tests_advanced.cpp
@@ -1,7 +1,8 @@
 //  bind_tests_advanced.cpp  -- The Boost Lambda Library ------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
+// Copyright (C) 2010 Steven Watanabe
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -19,6 +20,9 @@


 #include "boost/any.hpp"
+#include "boost/type_traits/is_reference.hpp"
+#include "boost/mpl/assert.hpp"
+#include "boost/mpl/if.hpp"

 #include <iostream>

@@ -27,7 +31,8 @@
 #include <algorithm>


-using namespace boost::lambda; 
+using namespace boost::lambda;
+namespace bl = boost::lambda;

 int sum_0() { return 0; }
 int sum_1(int a) { return a; }
@@ -91,7 +96,7 @@ int call_with_100(const F& f) {
  // This would result in;
  // bind(_1 + 1, _1)(make_const(100)) , which would be a compile time error

-  return bind(unlambda(f), _1)(make_const(100));
+  return bl::bind(unlambda(f), _1)(make_const(100));

  // for other functors than lambda functors, unlambda has no effect
  // (except for making them const)
@@ -116,11 +121,11 @@ void test_unlambda() {

  BOOST_CHECK(call_with_101(_1 + 1) == 102);

-  BOOST_CHECK(call_with_100(bind(std_functor(std::bind1st(std::plus<int>(), 1)), _1)) == 101);
+  BOOST_CHECK(call_with_100(bl::bind(std_functor(std::bind1st(std::plus<int>(), 1)), _1)) == 101);

  // std_functor insturcts LL that the functor defines a result_type typedef
  // rather than a sig template.
-  bind(std_functor(std::plus<int>()), _1, _2)(i, i);
+  bl::bind(std_functor(std::plus<int>()), _1, _2)(i, i);
 }


@@ -351,6 +356,55 @@ void test_break_const()
  BOOST_CHECK(i == 3);
 }

+template<class T>
+struct func {
+  template<class Args>
+  struct sig {
+    typedef typename boost::tuples::element<1, Args>::type arg1;
+    // If the argument type is not the same as the expected type,
+    // return void, which will cause an error.  Note that we
+    // can't just assert that the types are the same, because
+    // both const and non-const versions can be instantiated
+    // even though only one is ultimately used.
+    typedef typename boost::mpl::if_<boost::is_same<arg1, T>,
+      typename boost::remove_const<arg1>::type,
+      void
+    >::type type;
+  };
+  template<class U>
+  U operator()(const U& arg) const {
+    return arg;
+  }
+};
+
+void test_sig()
+{
+  int i = 1;
+  BOOST_CHECK(bind(func<int>(), 1)() == 1);
+  BOOST_CHECK(bind(func<const int>(), _1)(static_cast<const int&>(i)) == 1);
+  BOOST_CHECK(bind(func<int>(), _1)(i) == 1);
+}
+
+class base {
+public:
+  virtual int foo() = 0;
+};
+
+class derived : public base {
+public:
+  virtual int foo() {
+    return 1;
+  }
+};
+
+void test_abstract()
+{
+  derived d;
+  base& b = d;
+  BOOST_CHECK(bind(&base::foo, var(b))() == 1);
+  BOOST_CHECK(bind(&base::foo, *_1)(&b) == 1);
+}
+
 int test_main(int, char *[]) {

  test_nested_binds();
@@ -360,17 +414,7 @@ int test_main(int, char *[]) {
  test_const_parameters();
  test_rvalue_arguments(); 
  test_break_const(); 
+  test_sig();
+  test_abstract();
  return 0;
 }
-
-
-
-
-
-
-
-
-
-
-
-
--- a/test/bind_tests_simple.cpp
+++ b/test/bind_tests_simple.cpp
@@ -1,6 +1,6 @@
 //  bind_tests_simple.cpp  -- The Boost Lambda Library ------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
@@ -18,9 +18,7 @@

 #include <iostream>

-
-  using namespace std;
-  using namespace boost::lambda;
+using namespace boost::lambda;


 int sum_of_args_0() { return 0; }
--- a/test/bind_tests_simple_f_refs.cpp
+++ b/test/bind_tests_simple_f_refs.cpp
@@ -1,6 +1,6 @@
 //  bind_tests_simple.cpp  -- The Boost Lambda Library ------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
@@ -18,9 +18,7 @@

 #include <iostream>

-
-  using namespace std;
-  using namespace boost::lambda;
+using namespace boost::lambda;


 int sum_of_args_0() { return 0; }
--- a/test/bll_and_function.cpp
+++ b/test/bll_and_function.cpp
@@ -1,6 +1,6 @@
 //  bll_and_function.cpp  - The Boost Lambda Library -----------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/test/cast_test.cpp
+++ b/test/cast_test.cpp
@@ -1,6 +1,6 @@
 //  cast_tests.cpp  -- The Boost Lambda Library ------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
@@ -29,7 +29,7 @@ class base {
 public:
  virtual std::string class_name() const { return "const base"; }
  virtual std::string class_name() { return "base"; }
-
+  virtual ~base() {}
 };

 class derived : public base {
--- a/test/constructor_tests.cpp
+++ b/test/constructor_tests.cpp
@@ -1,6 +1,6 @@
 //  constructor_tests.cpp  -- The Boost Lambda Library ------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
@@ -24,8 +24,12 @@
 #include <algorithm>
 #include <vector>

+#ifdef BOOST_MSVC
+#pragma warning(disable:4512)
+#endif
+
 using namespace boost::lambda;
-using namespace std;
+namespace bl = boost::lambda;

 template<class T>
 bool check_tuple(int n, const T& t) 
@@ -34,7 +38,7 @@ bool check_tuple(int n, const T& t)
 }

 template <>
-bool check_tuple(int n, const null_type& ) { return true; }
+bool check_tuple(int /*n*/, const null_type& ) { return true; }


 void constructor_all_lengths() 
@@ -183,7 +187,7 @@ public:
 void test_destructor ()
 { 
  char space[sizeof(is_destructor_called)];
-  bool flag;
+  bool flag = false;

  is_destructor_called* idc = new(space) is_destructor_called(flag);
  BOOST_CHECK(flag == false);
@@ -208,17 +212,17 @@ int count_deletes::count = 0;
 void test_news_and_deletes ()
 {
  int* i[10];
-  for_each(i, i+10, _1 = bind(new_ptr<int>(), 2));
+  std::for_each(i, i+10, _1 = bind(new_ptr<int>(), 2));
  int count_errors = 0;

-  for_each(i, i+10, (*_1 == 2) || ++var(count_errors));
+  std::for_each(i, i+10, (*_1 == 2) || ++var(count_errors));
  BOOST_CHECK(count_errors == 0);


  count_deletes* ct[10];
-  for_each(ct, ct+10, _1 = bind(new_ptr<count_deletes>()));
+  std::for_each(ct, ct+10, _1 = bind(new_ptr<count_deletes>()));
  count_deletes::count = 0;
-  for_each(ct, ct+10, bind(delete_ptr(), _1));
+  std::for_each(ct, ct+10, bind(delete_ptr(), _1));
  BOOST_CHECK(count_deletes::count == 10);
   
 }
@@ -236,16 +240,16 @@ void test_array_new_and_delete()

 void delayed_construction()
 {
-  vector<int> x(3);
-  vector<int> y(3);
+  std::vector<int> x(3);
+  std::vector<int> y(3);

-  fill(x.begin(), x.end(), 0);
-  fill(y.begin(), y.end(), 1);
+  std::fill(x.begin(), x.end(), 0);
+  std::fill(y.begin(), y.end(), 1);
  
-  vector<pair<int, int> > v;
+  std::vector<std::pair<int, int> > v;

-  transform(x.begin(), x.end(), y.begin(), back_inserter(v),
-            bind(constructor<pair<int, int> >(), _1, _2) );
+  std::transform(x.begin(), x.end(), y.begin(), std::back_inserter(v),
+            bl::bind(constructor<std::pair<int, int> >(), _1, _2) );
 }

 int test_main(int, char *[]) {
--- a/test/control_structures.cpp
+++ b/test/control_structures.cpp
@@ -1,6 +1,6 @@
 // -- control_structures.cpp -- The Boost Lambda Library ------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/test/exception_test.cpp
+++ b/test/exception_test.cpp
@@ -1,6 +1,6 @@
 // -- exception_test.cpp -- The Boost Lambda Library ------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
@@ -29,7 +29,7 @@ using namespace boost::lambda;
 using namespace std;

 // to prevent unused variables warnings
-template <class T> void dummy(const T& t) {}
+template <class T> void dummy(const T&) {}

 void erroneous_exception_related_lambda_expressions() {

@@ -603,7 +603,7 @@ int test_main(int, char *[]) {
    return_type_matching();
    test_empty_catch_blocks();
  }
-  catch (int x)
+  catch (int)
  {
    BOOST_CHECK(false);
  }
--- a/test/extending_rt_traits.cpp
+++ b/test/extending_rt_traits.cpp
@@ -1,6 +1,6 @@
 //  extending_return_type_traits.cpp  -- The Boost Lambda Library --------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
@@ -16,6 +16,7 @@

 #include "boost/lambda/bind.hpp"
 #include "boost/lambda/lambda.hpp"
+#include "boost/lambda/detail/suppress_unused.hpp"

 #include <iostream>

@@ -23,6 +24,8 @@

 #include <algorithm>

+using boost::lambda::detail::suppress_unused_variable_warnings;
+
 class A {};
 class B {};

@@ -81,7 +84,7 @@ struct plain_return_type_1<other_action<contentsof_action>, A> {
 } // lambda
 } // boost

-void ok(B b) {}
+void ok(B /*b*/) {}

 void test_unary_operators() 
 {
@@ -127,7 +130,7 @@ class my_vector {};

 template<class A, class B> 
 my_vector<typename return_type_2<arithmetic_action<plus_action>, A&, B&>::type>
-operator+(const my_vector<A>& a, const my_vector<B>& b)
+operator+(const my_vector<A>& /*a*/, const my_vector<B>& /*b*/)
 {
  typedef typename 
    return_type_2<arithmetic_action<plus_action>, A&, B&>::type res_type;
@@ -175,8 +178,8 @@ Z operator^=( X&, const Y&) { return Z(); }
 // assignment
 class Assign {
 public:
-  void operator=(const Assign& a) {}
-  X operator[](const int& i) { return X(); }
+  void operator=(const Assign& /*a*/) {}
+  X operator[](const int& /*i*/) { return X(); }
 };


@@ -329,9 +332,16 @@ void test_binary_operators() {
  XX dummy3 = (_1 * _2)(vxx, vyy);
  VV dummy4 = (_1 * _2)(cvxx, cvyy);

+  suppress_unused_variable_warnings(dummy1);
+  suppress_unused_variable_warnings(dummy2);
+  suppress_unused_variable_warnings(dummy3);
+  suppress_unused_variable_warnings(dummy4);
+
  my_vector<int> v1; my_vector<double> v2;
  my_vector<double> d = (_1 + _2)(v1, v2);

+  suppress_unused_variable_warnings(d);
+
  // bitwise

  (_1 << _2)(x, y);
--- a/test/is_instance_of_test.cpp
+++ b/test/is_instance_of_test.cpp
@@ -1,6 +1,6 @@
 // is_instance_of_test.cpp -- The Boost Lambda Library ------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/test/member_pointer_test.cpp
+++ b/test/member_pointer_test.cpp
@@ -1,6 +1,6 @@
 //  member_pointer_test.cpp  -- The Boost Lambda Library ------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
@@ -118,11 +118,11 @@ class C {};
 class D {};

 // ->* can be overloaded to do anything
-bool operator->*(A a, B b) {
+bool operator->*(A /*a*/, B /*b*/) {
  return false; 
 }

-bool operator->*(B b, A a) {
+bool operator->*(B /*b*/, A /*a*/) {
  return true; 
 }

--- a/test/operator_tests_simple.cpp
+++ b/test/operator_tests_simple.cpp
@@ -1,6 +1,6 @@
 //  operator_tests_simple.cpp  -- The Boost Lambda Library ---------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
@@ -17,6 +17,10 @@

 #include "boost/lambda/lambda.hpp"

+#include "boost/lambda/detail/suppress_unused.hpp"
+
+#include <boost/shared_ptr.hpp>
+
 #include <vector>
 #include <map>
 #include <set>
@@ -96,6 +100,8 @@ void arithmetic_operators() {
  // test that unary plus really does something
  unary_plus_tester u;
  unary_plus_tester up = (+_1)(u);
+
+  boost::lambda::detail::suppress_unused_variable_warnings(up);
 }

 void bitwise_operators() {
@@ -229,6 +235,22 @@ void compound_operators() {
  (_1 %= 2)(i);
  BOOST_CHECK(i == 1);
  
+  // lambda expression as a left operand with rvalue on RHS
+  (_1 += (0 + 1))(i);
+  BOOST_CHECK(i == 2);
+
+  (_1 -= (0 + 1))(i);
+  BOOST_CHECK(i == 1);
+
+  (_1 *= (0 + 10))(i);
+  BOOST_CHECK(i == 10);
+
+  (_1 /= (0 + 2))(i);
+  BOOST_CHECK(i == 5);
+
+  (_1 %= (0 + 2))(i);
+  BOOST_CHECK(i == 1);
+  
  // shifts
  unsigned int ui = 2;
  (_1 <<= 1)(ui);
@@ -319,8 +341,18 @@ void address_of_and_dereference() {
  
  (*_1 = 7)(it);
  BOOST_CHECK(vi[0] == 7); 
+  const std::vector<int>::iterator cit(it);
+  (*_1 = 8)(cit);
+  BOOST_CHECK(vi[0] == 8);

  // TODO: Add tests for more complex iterator types
+
+  boost::shared_ptr<int> ptr(new int(0));
+  (*_1 = 7)(ptr);
+  BOOST_CHECK(*ptr == 7);
+  const boost::shared_ptr<int> cptr(ptr);
+  (*_1 = 8)(cptr);
+  BOOST_CHECK(*ptr == 8);
 }


--- a/test/phoenix_control_structures.cpp
+++ b/test/phoenix_control_structures.cpp
@@ -1,6 +1,6 @@
 //  phoenix_style_control_structures.cpp  -- The Boost Lambda Library ------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
--- a/test/result_of_tests.cpp
+++ b/test/result_of_tests.cpp
@@ -0,0 +1,314 @@
+//  result_of_tests.cpp  -- The Boost Lambda Library ------------------
+//
+// Copyright (C) 2010 Steven Watanabe
+//
+// 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
+
+// -----------------------------------------------------------------------
+
+
+#include <boost/test/minimal.hpp>    // see "Header Implementation Option"
+#include <boost/lambda/bind.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+struct with_result_type {
+    typedef int result_type;
+    int operator()() const { return 0; }
+    int operator()(int) const { return 1; }
+    int operator()(int, int) const { return 2; }
+    int operator()(int, int, int) const { return 3; }
+    int operator()(int, int, int, int) const { return 4; }
+    int operator()(int, int, int, int, int) const { return 5; }
+    int operator()(int, int, int, int, int, int) const { return 6; }
+    int operator()(int, int, int, int, int, int, int) const { return 7; }
+    int operator()(int, int, int, int, int, int, int, int) const { return 8; }
+    int operator()(int, int, int, int, int, int, int, int, int) const { return 9; }
+};
+
+struct with_result_template_value {
+    template<class Sig>
+    struct result;
+    template<class This>
+    struct result<This()> {
+        typedef int type;
+    };
+    template<class This, class A1>
+    struct result<This(A1)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2>
+    struct result<This(A1, A2)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3>
+    struct result<This(A1, A2, A3)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4>
+    struct result<This(A1, A2, A3, A4)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5>
+    struct result<This(A1, A2, A3, A4, A5)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5, class A6>
+    struct result<This(A1, A2, A3, A4, A5, A6)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A6, int>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    struct result<This(A1, A2, A3, A4, A5, A6, A7)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A6, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A7, int>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    struct result<This(A1, A2, A3, A4, A5, A6, A7, A8)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A6, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A7, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A8, int>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    struct result<This(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A6, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A7, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A8, int>));
+        BOOST_MPL_ASSERT((boost::is_same<A9, int>));
+        typedef int type;
+    };
+
+    int operator()() const { return 0; }
+    int operator()(int) const { return 1; }
+    int operator()(int, int) const { return 2; }
+    int operator()(int, int, int) const { return 3; }
+    int operator()(int, int, int, int) const { return 4; }
+    int operator()(int, int, int, int, int) const { return 5; }
+    int operator()(int, int, int, int, int, int) const { return 6; }
+    int operator()(int, int, int, int, int, int, int) const { return 7; }
+    int operator()(int, int, int, int, int, int, int, int) const { return 8; }
+    int operator()(int, int, int, int, int, int, int, int, int) const { return 9; }
+};
+
+struct with_result_template_reference {
+    template<class Sig>
+    struct result;
+    template<class This>
+    struct result<This()> {
+        typedef int type;
+    };
+    template<class This, class A1>
+    struct result<This(A1)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int&>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2>
+    struct result<This(A1, A2)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int&>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3>
+    struct result<This(A1, A2, A3)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int&>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4>
+    struct result<This(A1, A2, A3, A4)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int&>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5>
+    struct result<This(A1, A2, A3, A4, A5)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int&>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5, class A6>
+    struct result<This(A1, A2, A3, A4, A5, A6)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A6, int&>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    struct result<This(A1, A2, A3, A4, A5, A6, A7)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A6, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A7, int&>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    struct result<This(A1, A2, A3, A4, A5, A6, A7, A8)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A6, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A7, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A8, int&>));
+        typedef int type;
+    };
+    template<class This, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    struct result<This(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
+        BOOST_MPL_ASSERT((boost::is_same<A1, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A2, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A3, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A4, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A5, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A6, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A7, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A8, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<A9, int&>));
+        typedef int type;
+    };
+
+    int operator()() const { return 0; }
+    int operator()(int) const { return 1; }
+    int operator()(int, int) const { return 2; }
+    int operator()(int, int, int) const { return 3; }
+    int operator()(int, int, int, int) const { return 4; }
+    int operator()(int, int, int, int, int) const { return 5; }
+    int operator()(int, int, int, int, int, int) const { return 6; }
+    int operator()(int, int, int, int, int, int, int) const { return 7; }
+    int operator()(int, int, int, int, int, int, int, int) const { return 8; }
+    int operator()(int, int, int, int, int, int, int, int, int) const { return 9; }
+};
+
+template<class F>
+typename boost::result_of<F()>::type apply0(F f) {
+    return f();
+}
+template<class A, class F>
+typename boost::result_of<F(A)>::type apply1(F f, A a) {
+    return f(a);
+}
+template<class A, class B, class F>
+typename boost::result_of<F(A, B)>::type apply2(F f, A a, B b) {
+    return f(a, b);
+}
+template<class A, class B, class C, class F>
+typename boost::result_of<F(A, B, C)>::type apply3(F f, A a, B b, C c) {
+    return f(a, b, c);
+}
+
+using namespace boost::lambda;
+
+int test_main(int, char *[]) {
+    BOOST_CHECK(boost::lambda::bind(with_result_type())() == 0);
+    BOOST_CHECK(boost::lambda::bind(with_result_type(), 1)() == 1);
+    BOOST_CHECK(boost::lambda::bind(with_result_type(), 1, 2)() == 2);
+    BOOST_CHECK(boost::lambda::bind(with_result_type(), 1, 2, 3)() == 3);
+    BOOST_CHECK(boost::lambda::bind(with_result_type(), 1, 2, 3, 4)() == 4);
+    BOOST_CHECK(boost::lambda::bind(with_result_type(), 1, 2, 3, 4, 5)() == 5);
+    BOOST_CHECK(boost::lambda::bind(with_result_type(), 1, 2, 3, 4, 5, 6)() == 6);
+    BOOST_CHECK(boost::lambda::bind(with_result_type(), 1, 2, 3, 4, 5, 6, 7)() == 7);
+    BOOST_CHECK(boost::lambda::bind(with_result_type(), 1, 2, 3, 4, 5, 6, 7, 8)() == 8);
+    BOOST_CHECK(boost::lambda::bind(with_result_type(), 1, 2, 3, 4, 5, 6, 7, 8, 9)() == 9);
+    
+    // Nullary result_of fails
+    //BOOST_CHECK(boost::lambda::bind(with_result_template_value())() == 0);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_value(), 1)() == 1);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_value(), 1, 2)() == 2);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_value(), 1, 2, 3)() == 3);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_value(), 1, 2, 3, 4)() == 4);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_value(), 1, 2, 3, 4, 5)() == 5);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_value(), 1, 2, 3, 4, 5, 6)() == 6);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_value(), 1, 2, 3, 4, 5, 6, 7)() == 7);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_value(), 1, 2, 3, 4, 5, 6, 7, 8)() == 8);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_value(), 1, 2, 3, 4, 5, 6, 7, 8, 9)() == 9);
+
+    int one = 1,
+        two = 2,
+        three = 3,
+        four = 4,
+        five = 5,
+        six = 6,
+        seven = 7,
+        eight = 8,
+        nine = 9;
+
+    // Nullary result_of fails
+    //BOOST_CHECK(boost::lambda::bind(with_result_template_reference())() == 0);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_reference(), var(one))() == 1);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_reference(), var(one), var(two))() == 2);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_reference(), var(one), var(two), var(three))() == 3);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_reference(), var(one), var(two), var(three), var(four))() == 4);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_reference(), var(one), var(two), var(three), var(four), var(five))() == 5);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_reference(), var(one), var(two), var(three), var(four), var(five), var(six))() == 6);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_reference(), var(one), var(two), var(three), var(four), var(five), var(six), var(seven))() == 7);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_reference(), var(one), var(two), var(three), var(four), var(five), var(six), var(seven), var(eight))() == 8);
+    BOOST_CHECK(boost::lambda::bind(with_result_template_reference(), var(one), var(two), var(three), var(four), var(five), var(six), var(seven), var(eight), var(nine))() == 9);
+
+    // Check using result_of with lambda functors
+    //BOOST_CHECK(apply0(constant(0)) == 0);
+    BOOST_CHECK(apply1<int>(_1, one) == 1);
+    BOOST_CHECK(apply1<int&>(_1, one) == 1);
+    BOOST_CHECK(apply1<const int&>(_1, one) == 1);
+    BOOST_CHECK((apply2<int, int>(_1 + _2, one, two) == 3));
+    BOOST_CHECK((apply2<int&, int&>(_1 + _2, one, two) == 3));
+    BOOST_CHECK((apply2<const int&, const int&>(_1 + _2, one, two) == 3));
+    BOOST_CHECK((apply3<int, int, int>(_1 + _2 + _3, one, two, three) == 6));
+    BOOST_CHECK((apply3<int&, int&, int&>(_1 + _2 + _3, one, two, three) == 6));
+    BOOST_CHECK((apply3<const int&, const int&, const int&>(_1 + _2 + _3, one, two, three) == 6));
+
+    return 0;
+}
--- a/test/ret_test.cpp
+++ b/test/ret_test.cpp
@@ -0,0 +1,53 @@
+//  ret_test.cpp  - The Boost Lambda Library -----------------------
+//
+// Copyright (C) 2009 Steven Watanabe
+//
+// 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
+
+#include <boost/test/minimal.hpp>
+
+#include <boost/lambda/lambda.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+template<class R, class F>
+void test_ret(R r, F f) {
+    typename F::result_type x = f();
+    BOOST_MPL_ASSERT((boost::is_same<R, typename F::result_type>));
+    BOOST_CHECK(x == r);
+}
+
+template<class R, class F, class T1>
+void test_ret(R r, F f, T1& t1) {
+    typename F::result_type x = f(t1);
+    BOOST_MPL_ASSERT((boost::is_same<R, typename F::result_type>));
+    BOOST_CHECK(x == r);
+}
+
+class add_result {
+public:
+    add_result(int i = 0) : value(i) {}
+    friend bool operator==(const add_result& lhs, const add_result& rhs) {
+        return(lhs.value == rhs.value);
+    }
+private:
+    int value;
+};
+
+class addable {};
+add_result operator+(addable, addable) {
+    return add_result(7);
+}
+
+int test_main(int, char*[]) {
+    addable test;
+    test_ret(add_result(7), boost::lambda::ret<add_result>(boost::lambda::_1 + test), test);
+    test_ret(8.0, boost::lambda::ret<double>(boost::lambda::constant(7) + 1));
+
+    return 0;
+}
--- a/test/switch_construct.cpp
+++ b/test/switch_construct.cpp
@@ -1,6 +1,6 @@
 //  switch_test.cpp  -- The Boost Lambda Library --------------------------
 //
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
Author	SHA1	Message	Date
Beman Dawes	bb05b4954f	Release 1.45.0 [SVN r66646]	2010-11-19 15:17:53 +00:00
Daniel Walker	2c14c3a13b	merged changeset 63726 from trunk [SVN r63907]	2010-07-12 01:36:38 +00:00
Steven Watanabe	0d0f71272e	Merge lambda from the trunk [SVN r63555]	2010-07-03 19:05:15 +00:00
Daniel James	08b3f6336c	Merge documentation fixes. * Use `doc/src/.css` instead of `doc/html/.css`. * Remove wiki and people directories. * Some documentation fixes. * Left out `minimal.css` changes and boostbook changes because of clashes. [SVN r63347]	2010-06-26 12:30:09 +00:00
Troy D. Straszheim	e368877636	rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release. [SVN r56941]	2009-10-17 01:10:45 +00:00
Troy D. Straszheim	22bc52b7c4	Add basic copyright/license to keep cmake out of the inspection report [SVN r55095]	2009-07-22 21:51:01 +00:00
Steven Watanabe	8a943f6510	Merge [43113], [45097], [53261], [53343], [53648], [53649], and [53651] from the trunk [SVN r53875]	2009-06-13 21:18:10 +00:00
Steven Watanabe	d69f83d074	Merge [53061] and [53233] from the trunk [SVN r53266]	2009-05-26 00:59:17 +00:00
Steven Watanabe	7648a7adf1	Merge [51448] from the trunk. [SVN r51617]	2009-03-05 03:52:26 +00:00
John Maddock	48e6f45d92	Merge PDF build changes from Trunk. [SVN r51417]	2009-02-23 18:39:32 +00:00
Steven Watanabe	927a04351e	Merge [50516] and [50999] from the trunk. These are the fixes for #781 and #2446 respectively [SVN r51368]	2009-02-21 18:10:20 +00:00
Troy D. Straszheim	b5b41af8f4	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
Marshall Clow	1f6ca994e6	Merged revisions 50413 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r50413 \| marshall \| 2008-12-30 10:27:43 -0800 (Tue, 30 Dec 2008) \| 1 line Typo: fixes bug #2583 ........ [SVN r50602]	2009-01-15 03:46:14 +00:00
Beman Dawes	4a254c4161	With his kind permission, change Jaakko "Järvi" to "Jarvi" [SVN r46809]	2008-06-28 13:57:20 +00:00
Beman Dawes	e67976c740	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41370]	2007-11-25 18:38:02 +00:00
Beman Dawes	a0cd34c938	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41369]	2007-11-25 18:07:19 +00:00
Beman Dawes	672c8e10d4	Starting point for releases [SVN r39706]	2007-10-05 14:25:06 +00:00
nobody	87dd3997e7	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Daniel James	b112fb9254	Fix a link. [SVN r36651]	2007-01-07 22:42:25 +00:00
Jaakko Järvi	13ec0c5bbc	fixed omission [SVN r36201]	2006-11-29 19:28:48 +00:00
Jaakko Järvi	29ab5a2814	fixed bug 1444052 [SVN r36200]	2006-11-29 19:21:46 +00:00
Beman Dawes	a0cfe43611	Merged copyright and license addition [SVN r35907]	2006-11-07 19:27:00 +00:00
Rene Rivera	fe858cf734	Remove obsolete Boost.Build v1 files. [SVN r35880]	2006-11-06 17:10:46 +00:00
nobody	b3120233dc	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r33417]	2006-03-21 02:26:31 +00:00