Release 1.41.0

[SVN r57747]

doc/Jamfile.v2

@@ -1,4 +1,4 @@
-project lambda/doc ;
+project boost/doc ;
 import boostbook : boostbook ;
 
 # Are these really the correct images??
@@ -6,16 +6,6 @@ path-constant images : ../../spirit/phoenix/doc/html ;
 
 boostbook lambda-doc : lambda.xml 
 :
-   <xsl:param>boost.root=../../../..
    <format>pdf:<xsl:param>img.src.path=$(images)/
 ;
 
-###############################################################################
-alias boostdoc
-    : lambda.xml
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;

doc/detail/lambda_doc.xml

@@ -3435,7 +3435,7 @@ was dropped.
 <firstname>Brian</firstname>
 <surname>McNamara</surname>
 </author>
-<bibliomisc><ulink url="http://yanniss.github.io/fc++/">yanniss.github.io/fc++/ </ulink>
+<bibliomisc><ulink url="http://www.cc.gatech.edu/~yannis/fc++/">www.cc.gatech.edu/~yannis/fc++/</ulink>
 </bibliomisc>
 <pubdate>2002</pubdate>
 </biblioentry>

doc/lambda.xml

@@ -3440,7 +3440,7 @@ was dropped.
 <firstname>Brian</firstname>
 <surname>McNamara</surname>
 </author>
-<bibliomisc><ulink url="http://yanniss.github.io/fc++/">yanniss.github.io/fc++/ </ulink>
+<bibliomisc><ulink url="http://www.cc.gatech.edu/~yannis/fc++/">www.cc.gatech.edu/~yannis/fc++/</ulink>
 </bibliomisc>
 <pubdate>2002</pubdate>
 </biblioentry>

include/boost/lambda/casts.hpp

@@ -15,16 +15,12 @@
 #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;

include/boost/lambda/closures.hpp

@@ -251,7 +251,7 @@ private:
     closure& operator=(closure const&); // no assign
 
     template <int N, typename ClosureT>
-    friend class closure_member;
+    friend struct closure_member;
 
     template <typename ClosureT>
     friend class closure_frame;

include/boost/lambda/construct.hpp

@@ -14,9 +14,6 @@
 #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 {
 

include/boost/lambda/control_structures.hpp

@@ -17,7 +17,6 @@
 #include "boost/lambda/detail/operator_actions.hpp"
 #include "boost/lambda/detail/operator_return_type_traits.hpp"
 
-#include "boost/lambda/if.hpp"
-#include "boost/lambda/loops.hpp"
+#include "boost/lambda/detail/control_structures_impl.hpp"
 
 #endif

include/boost/lambda/detail/control_structures_impl.hpp

@@ -0,0 +1,550 @@
+// Boost Lambda Library -- control_structures_impl.hpp ---------------------
+
+// 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
+// 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

include/boost/lambda/detail/function_adaptors.hpp

@@ -12,170 +12,25 @@
 #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/type_traits/remove_cv.hpp"
-#include "boost/type_traits/add_const.hpp"
-#include "boost/type_traits/add_volatile.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
-  // 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 {
+  template <class Args> class sig { 
+    typedef typename Args::head_type F; 
     typedef typename detail::remove_reference_and_cv<Func>::type plainF;
   public:
-    typedef typename plainF::template sig<
-      typename detail::remove_references_from_elements<Args>::type
-    >::type type;
+    // 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;
   };
-#endif
 
   template<class RET, class A1>
   static RET apply(A1& a1) {
@@ -240,26 +95,22 @@ struct function_adaptor<T Object::*> {
   // the data member is accessed is const, and finally adding a reference
   template<class Args> class sig { 
     typedef typename boost::tuples::element<1, Args>::type argument_type;
-    typedef typename boost::remove_reference<
-      argument_type
-    >::type unref_type;
 
-    typedef typename detail::IF<boost::is_const<unref_type>::value,
+    typedef typename detail::IF<boost::is_const<argument_type>::value,
       typename boost::add_const<T>::type,
       T
     >::RET properly_consted_return_type;
 
-    typedef typename detail::IF<boost::is_volatile<unref_type>::value,
+    typedef typename detail::IF<
+        boost::is_volatile<properly_consted_return_type>::value,
       typename boost::add_volatile<properly_consted_return_type>::type,
       properly_consted_return_type
     >::RET properly_cvd_return_type;
 
 
   public:
-    typedef typename detail::IF<boost::is_reference<argument_type>::value,
-      typename boost::add_reference<properly_cvd_return_type>::type,
-      typename boost::remove_cv<T>::type
-    >::RET type;
+    typedef typename 
+      boost::add_reference<properly_cvd_return_type>::type type;
   };
 
   template <class RET>

include/boost/lambda/detail/lambda_config.hpp

@@ -22,6 +22,13 @@
 #     define BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 #     define BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
 #   endif
+#   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
+#     define BOOST_NO_TEMPLATED_STREAMS
+#     define BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
+#   endif
+#   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 95) 
+#     define BOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER
+#   endif
 # endif  // __GNUC__
  
 

include/boost/lambda/detail/lambda_functor_base.hpp

@@ -13,12 +13,6 @@
 #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 {
 
@@ -46,7 +40,7 @@ public:
   explicit identity(par_t t) : elem(t) {}
 
   template <typename SigArgs> 
-  struct sig { typedef typename boost::remove_const<element_t>::type type; };
+  struct sig { typedef element_t type; };
 
   template<class RET, CALL_TEMPLATE_ARGS>
   RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return elem; }
@@ -383,7 +377,7 @@ public:                                                                \
                                                                        \
   template<class SigArgs> struct sig {                                 \
     typedef typename                                                   \
-    detail::deduce_argument_types<Args, SigArgs>::type rets_t;         \
+    detail::deduce_non_ref_argument_types<Args, SigArgs>::type rets_t; \
   public:                                                              \
     typedef typename                                                   \
       return_type_N_prot<Act, rets_t>::type type;                      \

include/boost/lambda/detail/lambda_functors.hpp

@@ -15,7 +15,6 @@
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/utility/result_of.hpp>
 
 #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
 
@@ -162,25 +161,6 @@ 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>
@@ -298,38 +278,6 @@ public:
 } // namespace lambda
 } // namespace boost
 
-namespace boost {
-
-#if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_CXX11_DECLTYPE)
-
-template<class T>
-struct result_of<boost::lambda::lambda_functor<T>()>
-{
-    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
-};
-
-template<class T>
-struct result_of<const boost::lambda::lambda_functor<T>()>
-{
-    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
-};
-
-#endif
-
-template<class T>
-struct tr1_result_of<boost::lambda::lambda_functor<T>()>
-{
-    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
-};
-
-template<class T>
-struct tr1_result_of<const boost::lambda::lambda_functor<T>()>
-{
-    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
-};
-
-}
-
 // is_placeholder
 
 #include <boost/is_placeholder.hpp>

include/boost/lambda/detail/lambda_traits.hpp

@@ -16,7 +16,6 @@
 #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 {
@@ -282,11 +281,6 @@ struct const_copy_argument<void> {
   typedef void type;
 };
 
-template<>
-struct const_copy_argument<void const> {
-  typedef void type;
-};
-
 
 // Does the same as const_copy_argument, but passes references through as such
 template<class T>

include/boost/lambda/detail/operator_return_type_traits.hpp

@@ -12,13 +12,7 @@
 #define BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP
 
 #include "boost/lambda/detail/is_instance_of.hpp"
-#include "boost/type_traits/is_same.hpp"
-#include "boost/type_traits/is_pointer.hpp"
-#include "boost/type_traits/is_float.hpp"
-#include "boost/type_traits/is_convertible.hpp"
-#include "boost/type_traits/remove_pointer.hpp"
-#include "boost/type_traits/remove_const.hpp"
-#include "boost/type_traits/remove_reference.hpp"
+#include "boost/type_traits/same_traits.hpp"
 
 #include "boost/indirect_reference.hpp"
 #include "boost/detail/container_fwd.hpp"
@@ -542,6 +536,36 @@ struct return_type_2<bitwise_action<Act>, A, B>
 
 namespace detail {
 
+#ifdef BOOST_NO_TEMPLATED_STREAMS
+
+template<class A, class B>
+struct leftshift_type {
+
+  typedef typename detail::IF<
+    boost::is_convertible<
+      typename boost::remove_reference<A>::type*,
+      std::ostream*
+    >::value,
+    std::ostream&, 
+    typename detail::remove_reference_and_cv<A>::type
+  >::RET type;
+};
+
+template<class A, class B>
+struct rightshift_type {
+
+  typedef typename detail::IF<
+
+    boost::is_convertible<
+      typename boost::remove_reference<A>::type*,
+      std::istream*
+    >::value, 
+    std::istream&,
+    typename detail::remove_reference_and_cv<A>::type
+  >::RET type;
+};
+
+#else
 
 template <class T> struct get_ostream_type {
   typedef std::basic_ostream<typename T::char_type, 
@@ -578,6 +602,7 @@ public:
 };
 
 
+#endif
 
 } // end detail
 

include/boost/lambda/detail/operators.hpp

@@ -37,16 +37,16 @@ inline const                                                                 \
 lambda_functor<                                                              \
   lambda_functor_base<                                                       \
     ACTION,                                                                  \
-    tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>  \
+    tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>         \
   >                                                                          \
 >                                                                            \
 OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) {                      \
   return                                                                     \
     lambda_functor_base<                                                     \
       ACTION,                                                                \
-      tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\
+      tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>       \
     >                                                                        \
-   (tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \
+   (tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>(a, b)); \
 }
 
 
@@ -161,6 +161,23 @@ namespace detail {
 
 // Note that the overloading is const vs. non-const first argument
 
+#ifdef BOOST_NO_TEMPLATED_STREAMS
+template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
+  typedef typename detail::IF<
+                       boost::is_convertible<T*, std::ostream*>::value,
+                       T&,
+                       typename const_copy_argument <T>::type
+                     >::RET type;
+};
+
+template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
+  typedef typename detail::IF<
+                       boost::is_convertible<T*, std::istream*>::value,
+                       T&,
+                       typename const_copy_argument <T>::type
+                     >::RET type;
+};
+#else
 
 template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
   typedef typename detail::IF<
@@ -181,6 +198,7 @@ template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
                        typename const_copy_argument <T>::type
                      >::RET type;
 };
+#endif
 
 } // detail
 

include/boost/lambda/detail/ret.hpp

@@ -284,7 +284,7 @@ inline const
 lambda_functor<
   lambda_functor_base<do_nothing_action, null_type> 
 > 
-make_void(const Arg1&) { 
+make_void(const Arg1& a1) { 
 return 
     lambda_functor_base<do_nothing_action, null_type>();
 }

include/boost/lambda/detail/return_type_traits.hpp

@@ -19,6 +19,10 @@
 namespace boost { 
 namespace lambda {
 
+using ::boost::type_traits::ice_and;
+using ::boost::type_traits::ice_or;
+using ::boost::type_traits::ice_not;
+
 // Much of the type deduction code for standard arithmetic types 
 // from Gary Powell
 
@@ -73,7 +77,8 @@ template <class Act, class A> struct return_type_1_prot {
 public:
   typedef typename 
     detail::IF<
-      is_protectable<Act>::value && is_lambda_functor<A>::value,
+  //      is_protectable<Act>::value && is_lambda_functor<A>::value,
+      ice_and<is_protectable<Act>::value, is_lambda_functor<A>::value>::value,
       lambda_functor<
         lambda_functor_base< 
           Act, 
@@ -107,7 +112,9 @@ namespace detail {
   // add const to rvalues, so that all rvalues are stored as const in 
   // the args tuple
     typedef typename detail::IF_type<
-      boost::is_reference<T>::value && !boost::is_const<non_ref_T>::value,
+//      boost::is_reference<T>::value && !boost::is_const<non_ref_T>::value,
+      ice_and<boost::is_reference<T>::value,
+              ice_not<boost::is_const<non_ref_T>::value>::value>::value,
       detail::identity_mapping<T>,
       const_copy_argument<non_ref_T> // handles funtion and array 
     >::type type;                      // types correctly
@@ -141,8 +148,11 @@ template <class Act, class A, class B> struct return_type_2_prot {
 
 typedef typename 
   detail::IF<
-    is_protectable<Act>::value &&
-      (is_lambda_functor<A>::value || is_lambda_functor<B>::value),
+//    is_protectable<Act>::value &&
+//      (is_lambda_functor<A>::value || is_lambda_functor<B>::value),
+    ice_and<is_protectable<Act>::value,
+            ice_or<is_lambda_functor<A>::value, 
+                   is_lambda_functor<B>::value>::value>::value,
     lambda_functor<
       lambda_functor_base< 
         Act, 
@@ -177,8 +187,11 @@ struct return_type_2_comma
 
 typedef typename 
   detail::IF<
-    is_protectable<other_action<comma_action> >::value && // it is protectable
-    (is_lambda_functor<A>::value || is_lambda_functor<B>::value),
+//  is_protectable<other_action<comma_action> >::value && // it is protectable
+//  (is_lambda_functor<A>::value || is_lambda_functor<B>::value),
+    ice_and<is_protectable<other_action<comma_action> >::value, // it is protectable
+            ice_or<is_lambda_functor<A>::value, 
+                   is_lambda_functor<B>::value>::value>::value,
     lambda_functor<
       lambda_functor_base< 
         other_action<comma_action>, 
@@ -203,6 +216,8 @@ 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;

include/boost/lambda/detail/suppress_unused.hpp

@@ -10,8 +10,8 @@
 
 // ------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_SUPPRESS_UNUSED_HPP
-#define BOOST_LAMBDA_SUPPRESS_UNUSED_HPP
+#ifndef BOOST_LAMBDA_SUPRESS_UNUSED_HPP
+#define BOOST_LAMBDA_SUPRESS_UNUSED_HPP
 
 namespace boost { 
 namespace lambda {

include/boost/lambda/exceptions.hpp

@@ -14,7 +14,6 @@
 #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 { 

include/boost/lambda/if.hpp

@@ -345,7 +345,7 @@ public:
 //      is true, the true_statement (again an lambda_functor) is executed
 //      otherwise, the false_statement (another lambda_functor) is executed. The
 //      result type of this is void. Note the trailing underscore after
-//      if_ and the leading dot and the trailing underscore before
+//      if_ and the the leading dot and the trailing underscore before
 //      and after .else_.
 //
 ///////////////////////////////////////////////////////////////////////////////

include/boost/lambda/lambda.hpp

@@ -24,6 +24,11 @@
 
 
 #include "boost/lambda/detail/operators.hpp"
+
+#ifndef BOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER
+// sorry, member ptr does not work with gcc2.95
 #include "boost/lambda/detail/member_ptr.hpp"
+#endif
+
 
 #endif

include/boost/lambda/loops.hpp

@@ -348,7 +348,7 @@ while_(CondT const& cond)
 //      While the condition (an lambda_functor) evaluates to true, statement
 //      (another lambda_functor) is executed. The statement is executed at least
 //      once. The result type of this is void. Note the trailing
-//      underscore after do_ and the leading dot and the trailing
+//      underscore after do_ and the the leading dot and the trailing
 //      underscore before and after .while_.
 //
 ///////////////////////////////////////////////////////////////////////////////

meta/libraries.json

@@ -1,15 +0,0 @@
-{
-    "key": "lambda",
-    "name": "Lambda",
-    "authors": [
-        "Jaakko Järvi",
-        "Gary Powell"
-    ],
-    "description": "Define small unnamed function objects at the actual call site, and more.",
-    "category": [
-        "Function-objects"
-    ],
-    "maintainers": [
-        "Jaakko Jarvi <jarvi -at- cs.tamu.edu>"
-    ]
-}

test/Jamfile

@@ -30,6 +30,5 @@ 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 ]
   ;      

test/bind_tests_advanced.cpp

@@ -2,7 +2,6 @@
 //
 // 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
@@ -20,9 +19,6 @@
 
 
 #include "boost/any.hpp"
-#include "boost/type_traits/is_reference.hpp"
-#include "boost/mpl/assert.hpp"
-#include "boost/mpl/if.hpp"
 
 #include <iostream>
 
@@ -121,16 +117,8 @@ void test_unlambda() {
 
   BOOST_CHECK(call_with_101(_1 + 1) == 102);
 
-#if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
-
   BOOST_CHECK(call_with_100(bl::bind(std_functor(std::bind1st(std::plus<int>(), 1)), _1)) == 101);
 
-#else
-
-  BOOST_CHECK(call_with_100(bl::bind(std_functor(std::bind(std::plus<int>(), 1, std::placeholders::_1)), _1)) == 101);
-
-#endif
-
   // std_functor insturcts LL that the functor defines a result_type typedef
   // rather than a sig template.
   bl::bind(std_functor(std::plus<int>()), _1, _2)(i, i);
@@ -364,55 +352,6 @@ 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();
@@ -422,7 +361,17 @@ int test_main(int, char *[]) {
   test_const_parameters();
   test_rvalue_arguments(); 
   test_break_const(); 
-  test_sig();
-  test_abstract();
   return 0;
 }
+
+
+
+
+
+
+
+
+
+
+
+

test/bind_tests_simple.cpp

@@ -80,23 +80,6 @@ void test_member_functions()
   // bind(&A::add, a, _1); 
 }
 
-struct B {
-  B(int n) : i(n) {};
-  int i;
-};
-
-void test_data_members()
-{
-  using boost::ref;
-  B b(10);
-  BOOST_CHECK(bind(&B::i, ref(b))() == 10);
-  BOOST_CHECK(bind(&B::i, b)() == 10);
-  BOOST_CHECK(bind(&B::i, _1)(b) == 10);
-  BOOST_CHECK(bind(&B::i, _1)(B(11)) == 11);
-  bind(&B::i, ref(b))() = 1;
-  BOOST_CHECK(b.i == 1);
-}
-
 int test_main(int, char *[]) {
 
   int i = 1; int j = 2; int k = 3;

test/cast_test.cpp

@@ -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 {

test/operator_tests_simple.cpp

@@ -235,22 +235,6 @@ 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);

test/result_of_tests.cpp

@@ -1,314 +0,0 @@
-//  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;
-}