1 files changed, 1 insertions, 1 deletions
diff --git a/3rdParty/Boost/src/boost/lambda/detail/ret.hpp b/3rdParty/Boost/src/boost/lambda/detail/ret.hpp
index fbd8b3a..96f5fc1 100644
--- a/3rdParty/Boost/src/boost/lambda/detail/ret.hpp
+++ b/3rdParty/Boost/src/boost/lambda/detail/ret.hpp
@@ -252,71 +252,71 @@ const_parameters(const lambda_functor<Arg>& lf)
 // the wrapped lambda functor is evaluated, but we just don't do anything
 // with the result.
 struct voidifier_action {
   template<class Ret, class A> static void apply(A&) {}
 };
 
 template<class Args> struct return_type_N<voidifier_action, Args> {
   typedef void type;
 };
 
 template<class Arg1>
 inline const 
 lambda_functor<
   lambda_functor_base<
     action<1, voidifier_action>,
     tuple<lambda_functor<Arg1> >
   > 
 > 
 make_void(const lambda_functor<Arg1>& a1) { 
 return 
     lambda_functor_base<
       action<1, voidifier_action>,
       tuple<lambda_functor<Arg1> >
     > 
   (tuple<lambda_functor<Arg1> > (a1));
 }
 
 // for non-lambda functors, make_void does nothing 
 // (the argument gets evaluated immediately)
 
 template<class Arg1>
 inline const 
 lambda_functor<
   lambda_functor_base<do_nothing_action, null_type> 
 > 
-make_void(const Arg1& a1) { 
+make_void(const Arg1&) { 
 return 
     lambda_functor_base<do_nothing_action, null_type>();
 }
 
 // std_functor -----------------------------------------------------
 
 //  The STL uses the result_type typedef as the convention to let binders know
 //  the return type of a function object. 
 //  LL uses the sig template.
 //  To let LL know that the function object has the result_type typedef 
 //  defined, it can be wrapped with the std_functor function.
 
 
 // Just inherit form the template parameter (the standard functor), 
 // and provide a sig template. So we have a class which is still the
 // same functor + the sig template.
 
 template<class T>
 struct result_type_to_sig : public T {
   template<class Args> struct sig { typedef typename T::result_type type; };
   result_type_to_sig(const T& t) : T(t) {}
 };
 
 template<class F>
 inline result_type_to_sig<F> std_functor(const F& f) { return f; }
 
 
 } // namespace lambda 
 } // namespace boost
 
 #endif