Release 1.37.0

[SVN r49549]

doc/Jamfile.v2

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

doc/lambda.xml

@@ -44,7 +44,7 @@
     <para>
 
       The Boost Lambda Library (BLL in the sequel) is a C++ template
-      library, which implements a form of <emphasis>lambda abstractions</emphasis> for C++.
+      library, which implements form of <emphasis>lambda abstractions</emphasis> for C++.
 The term originates from functional programming and lambda calculus, where a lambda abstraction defines an unnamed function.
       The primary motivation for the BLL is to provide flexible and
       convenient means to define unnamed function objects for STL algorithms.
@@ -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>
@@ -3191,7 +3191,7 @@ to extend the library with new features.
 
 
 
-<section>
+<appendix>
 <title>Rationale for some of the design decisions</title>
 
 <section id="lambda.why_weak_arity">
@@ -3256,7 +3256,7 @@ was dropped.
 
 </section>
 
-</section>
+</appendix>
 
 
 

include/boost/lambda/casts.hpp

@@ -14,8 +14,6 @@
 #if !defined(BOOST_LAMBDA_CASTS_HPP)
 #define BOOST_LAMBDA_CASTS_HPP
 
-#include "boost/lambda/detail/suppress_unused.hpp"
-
 #include <typeinfo>
 
 namespace boost { 
@@ -66,12 +64,11 @@ public:
   }
 };
 
-// typeid action
+  // typedid action
 class typeid_action {
 public:
   template<class RET, class Arg1>
   static RET apply(Arg1 &a1) {
-    detail::suppress_unused_variable_warnings(a1);
     return typeid(a1);
   }
 };

include/boost/lambda/detail/lambda_functor_base.hpp

@@ -16,10 +16,6 @@
 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
@@ -40,16 +36,12 @@ 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; }
 };
 
-#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); }
 
@@ -270,8 +262,6 @@ 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; };
@@ -347,7 +337,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;

include/boost/lambda/detail/lambda_functors.hpp

@@ -13,30 +13,6 @@
 #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 {
 
@@ -129,10 +105,7 @@ 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>
@@ -176,7 +149,7 @@ public:
   }
 
   template<class A>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A const&> >)
+  typename inherited::template sig<tuple<A const&> >::type
   operator()(A const& a) const { 
     return inherited::template call<
       typename inherited::template sig<tuple<A const&> >::type
@@ -192,7 +165,7 @@ public:
   }
 
   template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B&> >)
+  typename inherited::template sig<tuple<A const&, B&> >::type
   operator()(A const& a, B& b) const { 
     return inherited::template call<
       typename inherited::template sig<tuple<A const&, B&> >::type
@@ -200,7 +173,7 @@ public:
   }
 
   template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A&, B const&> >)
+  typename inherited::template sig<tuple<A&, B const&> >::type
   operator()(A& a, B const& b) const { 
     return inherited::template call<
       typename inherited::template sig<tuple<A&, B const&> >::type
@@ -208,7 +181,7 @@ public:
   }
 
   template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B const&> >)
+  typename inherited::template sig<tuple<A const&, B const&> >::type
   operator()(A const& a, B const& b) const { 
     return inherited::template call<
       typename inherited::template sig<tuple<A const&, B const&> >::type
@@ -225,7 +198,7 @@ public:
   }
 
   template<class A, class B, class C>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A const&, B const&, C const&> >)
+  typename inherited::template sig<tuple<A const&, B const&, C const&> >::type
   operator()(A const& a, B const& b, C const& c) const
   { 
     return inherited::template call<
@@ -271,9 +244,6 @@ public:
   } 
 };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
 
 } // namespace lambda
 } // namespace boost

include/boost/lambda/detail/lambda_traits.hpp

@@ -430,56 +430,6 @@ 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;

include/boost/lambda/detail/operator_return_type_traits.hpp

@@ -15,7 +15,6 @@
 #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
@@ -59,6 +58,10 @@ 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 {
@@ -225,15 +228,34 @@ template <> struct contentsof_type<null_type> {
 
 
 template <class A> struct contentsof_type<const A> {
-  typedef typename contentsof_type<A>::type type;
+  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;
 };
 
 template <class A> struct contentsof_type<volatile A> {
-  typedef typename contentsof_type<A>::type type;
+  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;
 };
 
 template <class A> struct contentsof_type<const volatile A> {
-  typedef typename contentsof_type<A>::type type;
+  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;
 };
 
   // standard iterator traits should take care of the pointer types 
@@ -831,6 +853,44 @@ 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;
@@ -873,41 +933,6 @@ 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

include/boost/lambda/detail/operators.hpp

@@ -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_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >  \
-  (tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                         \
+  return lambda_functor<                                                    \
+    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));                      \
 }

include/boost/lambda/detail/suppress_unused.hpp

@@ -1,27 +0,0 @@
-// 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

include/boost/lambda/switch.hpp

@@ -465,18 +465,12 @@ 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

test/Jamfile

@@ -11,7 +11,7 @@
 import testing ;
 
 project 
-  : requirements <toolset>msvc:<asynch-exceptions>on
+  : requirements <library>/boost/test//boost_test_exec_monitor
   ;
           
 test-suite lambda
@@ -30,5 +30,4 @@ test-suite lambda
     [ run operator_tests_simple.cpp ]
     [ run phoenix_control_structures.cpp ]
     [ run switch_construct.cpp ]
-    [ run ret_test.cpp ]
   ;      

test/bind_tests_advanced.cpp

@@ -27,8 +27,7 @@
 #include <algorithm>
 
 
-using namespace boost::lambda;
-namespace bl = boost::lambda;
+using namespace boost::lambda; 
 
 int sum_0() { return 0; }
 int sum_1(int a) { return a; }
@@ -92,7 +91,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 bl::bind(unlambda(f), _1)(make_const(100));
+  return bind(unlambda(f), _1)(make_const(100));
 
   // for other functors than lambda functors, unlambda has no effect
   // (except for making them const)
@@ -117,11 +116,11 @@ void test_unlambda() {
 
   BOOST_CHECK(call_with_101(_1 + 1) == 102);
 
-  BOOST_CHECK(call_with_100(bl::bind(std_functor(std::bind1st(std::plus<int>(), 1)), _1)) == 101);
+  BOOST_CHECK(call_with_100(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.
-  bl::bind(std_functor(std::plus<int>()), _1, _2)(i, i);
+  bind(std_functor(std::plus<int>()), _1, _2)(i, i);
 }
 
 

test/bind_tests_simple.cpp

@@ -18,7 +18,9 @@
 
 #include <iostream>
 
-using namespace boost::lambda;
+
+  using namespace std;
+  using namespace boost::lambda;
 
 
 int sum_of_args_0() { return 0; }

test/bind_tests_simple_f_refs.cpp

@@ -18,7 +18,9 @@
 
 #include <iostream>
 
-using namespace boost::lambda;
+
+  using namespace std;
+  using namespace boost::lambda;
 
 
 int sum_of_args_0() { return 0; }

test/constructor_tests.cpp

@@ -24,12 +24,8 @@
 #include <algorithm>
 #include <vector>
 
-#ifdef BOOST_MSVC
-#pragma warning(disable:4512)
-#endif
-
 using namespace boost::lambda;
-namespace bl = boost::lambda;
+using namespace std;
 
 template<class T>
 bool check_tuple(int n, const T& t) 
@@ -38,7 +34,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() 
@@ -187,7 +183,7 @@ public:
 void test_destructor ()
 { 
   char space[sizeof(is_destructor_called)];
-  bool flag = false;
+  bool flag;
 
   is_destructor_called* idc = new(space) is_destructor_called(flag);
   BOOST_CHECK(flag == false);
@@ -212,17 +208,17 @@ int count_deletes::count = 0;
 void test_news_and_deletes ()
 {
   int* i[10];
-  std::for_each(i, i+10, _1 = bind(new_ptr<int>(), 2));
+  for_each(i, i+10, _1 = bind(new_ptr<int>(), 2));
   int count_errors = 0;
 
-  std::for_each(i, i+10, (*_1 == 2) || ++var(count_errors));
+  for_each(i, i+10, (*_1 == 2) || ++var(count_errors));
   BOOST_CHECK(count_errors == 0);
 
 
   count_deletes* ct[10];
-  std::for_each(ct, ct+10, _1 = bind(new_ptr<count_deletes>()));
+  for_each(ct, ct+10, _1 = bind(new_ptr<count_deletes>()));
   count_deletes::count = 0;
-  std::for_each(ct, ct+10, bind(delete_ptr(), _1));
+  for_each(ct, ct+10, bind(delete_ptr(), _1));
   BOOST_CHECK(count_deletes::count == 10);
    
 }
@@ -240,16 +236,16 @@ void test_array_new_and_delete()
 
 void delayed_construction()
 {
-  std::vector<int> x(3);
-  std::vector<int> y(3);
+  vector<int> x(3);
+  vector<int> y(3);
 
-  std::fill(x.begin(), x.end(), 0);
-  std::fill(y.begin(), y.end(), 1);
+  fill(x.begin(), x.end(), 0);
+  fill(y.begin(), y.end(), 1);
   
-  std::vector<std::pair<int, int> > v;
+  vector<pair<int, int> > v;
 
-  std::transform(x.begin(), x.end(), y.begin(), std::back_inserter(v),
-            bl::bind(constructor<std::pair<int, int> >(), _1, _2) );
+  transform(x.begin(), x.end(), y.begin(), back_inserter(v),
+            bind(constructor<pair<int, int> >(), _1, _2) );
 }
 
 int test_main(int, char *[]) {

test/exception_test.cpp

@@ -29,7 +29,7 @@ using namespace boost::lambda;
 using namespace std;
 
 // to prevent unused variables warnings
-template <class T> void dummy(const T&) {}
+template <class T> void dummy(const T& 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)
+  catch (int x)
   {
     BOOST_CHECK(false);
   }

test/extending_rt_traits.cpp

@@ -16,7 +16,6 @@
 
 #include "boost/lambda/bind.hpp"
 #include "boost/lambda/lambda.hpp"
-#include "boost/lambda/detail/suppress_unused.hpp"
 
 #include <iostream>
 
@@ -24,8 +23,6 @@
 
 #include <algorithm>
 
-using boost::lambda::detail::suppress_unused_variable_warnings;
-
 class A {};
 class B {};
 
@@ -84,7 +81,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() 
 {
@@ -130,7 +127,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;
@@ -178,8 +175,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(); }
 };
 
 
@@ -332,16 +329,9 @@ 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);

test/member_pointer_test.cpp

@@ -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; 
 }
 

test/operator_tests_simple.cpp

@@ -17,10 +17,6 @@
 
 #include "boost/lambda/lambda.hpp"
 
-#include "boost/lambda/detail/suppress_unused.hpp"
-
-#include <boost/shared_ptr.hpp>
-
 #include <vector>
 #include <map>
 #include <set>
@@ -100,8 +96,6 @@ 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() {
@@ -325,18 +319,8 @@ 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);
 }
 
 

test/ret_test.cpp

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