[libsigcplusplus] Remove _A_ prefixes from method arguments.

[Murray Cumming <murrayc src gnome org>]

commit 7c69bb093cbb741728f6e54f5b52a9ff0882b4e8
Author: Murray Cumming <murrayc murrayc com>
Date:   Tue Apr 19 20:42:33 2016 +0200

    Remove _A_ prefixes from method arguments.
    
    Leading underscores are reserved in C++, and the A is just odd.

 sigc++/adaptors/adaptor_trait.h   |   18 +++---
 sigc++/adaptors/adapts.h          |   18 +++---
 sigc++/adaptors/bind.h            |   70 +++++++++++++-------------
 sigc++/adaptors/bind_return.h     |   32 ++++++------
 sigc++/adaptors/bound_argument.h  |   24 ++++----
 sigc++/adaptors/compose.h         |   72 +++++++++++++-------------
 sigc++/adaptors/exception_catch.h |   20 ++++----
 sigc++/adaptors/hide.h            |   30 +++++-----
 sigc++/adaptors/retype.h          |   28 +++++-----
 sigc++/adaptors/retype_return.h   |   36 +++++++-------
 sigc++/adaptors/track_obj.h       |   34 ++++++------
 sigc++/functors/mem_fun.h         |  102 ++++++++++++++++++------------------
 sigc++/functors/ptr_fun.h         |   18 +++---
 sigc++/functors/slot.h            |   32 ++++++------
 sigc++/limit_reference.h          |   16 +++---
 sigc++/signal.h                   |   68 ++++++++++++------------
 sigc++/visit_each.h               |   34 ++++++------
 tests/test_visit_each.cc          |   28 +++++-----
 18 files changed, 340 insertions(+), 340 deletions(-)
---
diff --git a/sigc++/adaptors/adaptor_trait.h b/sigc++/adaptors/adaptor_trait.h
index 8fa0885..e2847a2 100644
--- a/sigc++/adaptors/adaptor_trait.h
+++ b/sigc++/adaptors/adaptor_trait.h
@@ -71,29 +71,29 @@ struct adaptor_functor : public adaptor_base
   decltype(auto) operator()() const { return functor_(); }
 
   /** Invokes the wrapped functor passing on the arguments.
-   * @param _A_arg... Arguments to be passed on to the functor.
+   * @param arg... Arguments to be passed on to the functor.
    * @return The return value of the functor invocation.
    */
   template <typename... T_arg>
-  decltype(auto) operator()(T_arg&&... _A_arg) const
+  decltype(auto) operator()(T_arg&&... arg) const
   {
-    return functor_(std::forward<T_arg>(_A_arg)...);
+    return functor_(std::forward<T_arg>(arg)...);
   }
 
   /// Constructs an invalid functor.
   adaptor_functor() = default;
 
   /** Constructs an adaptor_functor object that wraps the passed functor.
-   * @param _A_functor Functor to invoke from operator()().
+   * @param functor Functor to invoke from operator()().
    */
-  explicit adaptor_functor(const T_functor& _A_functor) : functor_(_A_functor) {}
+  explicit adaptor_functor(const T_functor& functor) : functor_(functor) {}
 
   /** Constructs an adaptor_functor object that wraps the passed (member)
    * function pointer.
-   * @param _A_type Pointer to function or class method to invoke from operator()().
+   * @param type Pointer to function or class method to invoke from operator()().
    */
   template <typename T_type>
-  explicit adaptor_functor(const T_type& _A_type) : functor_(_A_type)
+  explicit adaptor_functor(const T_type& type) : functor_(type)
   {
   }
 
@@ -113,9 +113,9 @@ template <typename T_functor>
 struct visitor<adaptor_functor<T_functor>>
 {
   template <typename T_action>
-  static void do_visit_each(const T_action& _A_action, const adaptor_functor<T_functor>& _A_target)
+  static void do_visit_each(const T_action& action, const adaptor_functor<T_functor>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
+    sigc::visit_each(action, target.functor_);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
diff --git a/sigc++/adaptors/adapts.h b/sigc++/adaptors/adapts.h
index 7cb26f5..bdb0746 100644
--- a/sigc++/adaptors/adapts.h
+++ b/sigc++/adaptors/adapts.h
@@ -33,16 +33,16 @@ namespace sigc
  *   //
  *   template <typename T_arg1>
  *   decltype(auto)
- *   operator()(T_arg1 _A_arg1) const;
+ *   operator()(T_arg1 arg1) const;
  *   //
  *   template <typename T_arg1, typename T_arg2>
  *   decltype(auto)
- *   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const;
+ *   operator()(T_arg1 arg1, T_arg2 arg2) const;
  *   //
  *   // Constructs a my_adaptor object that wraps the passed functor.
  *   // Initializes adapts<T_functor>::functor_, which is invoked from operator()().
- *   explicit my_adaptor(const T_functor& _A_functor)
- *     : sigc::adapts<T_functor>(_A_functor) {}
+ *   explicit my_adaptor(const T_functor& functor)
+ *     : sigc::adapts<T_functor>(functor) {}
  * };
  * } // end namespace my_ns
  * //
@@ -53,10 +53,10 @@ namespace sigc
  * struct visitor<my_ns::my_adaptor<T_functor> >
  * {
  *   template <typename T_action>
- *   static void do_visit_each(const T_action& _A_action,
- *                             const my_ns::my_adaptor<T_functor>& _A_target)
+ *   static void do_visit_each(const T_action& action,
+ *                             const my_ns::my_adaptor<T_functor>& target)
  *   {
- *     sigc::visit_each(_A_action, _A_target.functor_);
+ *     sigc::visit_each(action, target.functor_);
  *   }
  * };
  * } // end namespace sigc
@@ -80,9 +80,9 @@ private:
 
 public:
   /** Constructs an adaptor that wraps the passed functor.
-   * @param _A_functor Functor to invoke from operator()().
+   * @param functor Functor to invoke from operator()().
    */
-  explicit adapts(const T_functor& _A_functor) : functor_(_A_functor) {}
+  explicit adapts(const T_functor& functor) : functor_(functor) {}
 
   /// Adaptor that is invoked from operator()().
   mutable adaptor_type functor_;
diff --git a/sigc++/adaptors/bind.h b/sigc++/adaptors/bind.h
index 623af7f..7e370f4 100644
--- a/sigc++/adaptors/bind.h
+++ b/sigc++/adaptors/bind.h
@@ -110,17 +110,17 @@ struct bind_functor : public adapts<T_functor>
 {
   /** Invokes the wrapped functor passing on the arguments.
    * bound_ is passed as the next argument.
-   * @param _A_arg Arguments to be passed on to the functor.
+   * @param arg Arguments to be passed on to the functor.
    * @return The return value of the functor invocation.
    */
   template <typename... T_arg>
-  decltype(auto) operator()(T_arg&&... _A_arg)
+  decltype(auto) operator()(T_arg&&... arg)
   {
-    // For instance, if I_location is 1, and _A_arg has 4 arguments,
-    // we would want to call operator() with (_A_arg0, bound, _A_arg1, _A_arg2).
+    // For instance, if I_location is 1, and arg has 4 arguments,
+    // we would want to call operator() with (arg0, bound, arg1, arg2).
 
     using tuple_type_args = std::tuple<type_trait_pass_t<T_arg>...>;
-    const auto t_args = std::tuple<T_arg...>(std::forward<T_arg>(_A_arg)...);
+    const auto t_args = std::tuple<T_arg...>(std::forward<T_arg>(arg)...);
     constexpr auto t_args_size = std::tuple_size<tuple_type_args>::value;
 
     // Prevent calling tuple_start<> with values that will cause a compilation error.
@@ -138,11 +138,11 @@ struct bind_functor : public adapts<T_functor>
   }
 
   /** Constructs a bind_functor object that binds an argument to the passed functor.
-   * @param _A_func Functor to invoke from operator()().
-   * @param _A_bound Argument to bind to the functor.
+   * @param func Functor to invoke from operator()().
+   * @param bound Argument to bind to the functor.
    */
-  bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound>... _A_bound)
-  : adapts<T_functor>(_A_func), bound_(_A_bound...)
+  bind_functor(type_trait_take_t<T_functor> func, type_trait_take_t<T_bound>... bound)
+  : adapts<T_functor>(func), bound_(bound...)
   {
   }
 
@@ -168,16 +168,16 @@ struct bind_functor<-1, T_functor, T_type...> : public adapts<T_functor>
 public:
   /** Invokes the wrapped functor passing on the arguments.
    * bound_ is passed as the next argument.
-   * @param _A_arg Arguments to be passed on to the functor.
+   * @param arg Arguments to be passed on to the functor.
    * @return The return value of the functor invocation.
    */
   template <typename... T_arg>
-  decltype(auto) operator()(T_arg&&... _A_arg)
+  decltype(auto) operator()(T_arg&&... arg)
   {
-    // For instance, if _A_arg has 4 arguments,
-    // we would want to call operator() with (_A_arg0, _A_arg1, _A_arg2, bound).
+    // For instance, if arg has 4 arguments,
+    // we would want to call operator() with (arg0, arg1, arg2, bound).
 
-    const auto t_args = std::tuple<T_arg...>(std::forward<T_arg>(_A_arg)...);
+    const auto t_args = std::tuple<T_arg...>(std::forward<T_arg>(arg)...);
     const auto t_bound = internal::tuple_transform_each<internal::TransformEachInvoker>(bound_);
     const auto t_with_bound = std::tuple_cat(t_args, t_bound);
 
@@ -186,11 +186,11 @@ public:
   }
 
   /** Constructs a bind_functor object that binds an argument to the passed functor.
-   * @param _A_func Functor to invoke from operator()().
-   * @param _A_bound Arguments to bind to the functor.
+   * @param func Functor to invoke from operator()().
+   * @param bound Arguments to bind to the functor.
    */
-  bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type>... _A_bound)
-  : adapts<T_functor>(_A_func), bound_(_A_bound...)
+  bind_functor(type_trait_take_t<T_functor> func, type_trait_take_t<T_type>... bound)
+  : adapts<T_functor>(func), bound_(bound...)
   {
   }
 
@@ -218,10 +218,10 @@ struct visitor<bind_functor<T_loc, T_functor, T_bound...>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const bind_functor<T_loc, T_functor, T_bound...>& _A_target)
+    const T_action& action, const bind_functor<T_loc, T_functor, T_bound...>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
-    sigc::visit_each(_A_action, std::get<0>(_A_target.bound_));
+    sigc::visit_each(action, target.functor_);
+    sigc::visit_each(action, std::get<0>(target.bound_));
   }
 };
 
@@ -237,11 +237,11 @@ struct visitor<bind_functor<-1, T_functor, T_type...>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const bind_functor<-1, T_functor, T_type...>& _A_target)
+    const T_action& action, const bind_functor<-1, T_functor, T_type...>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
+    sigc::visit_each(action, target.functor_);
 
-    sigc::internal::tuple_for_each<internal::TupleVisitorVisitEach>(_A_target.bound_, _A_action);
+    sigc::internal::tuple_for_each<internal::TupleVisitorVisitEach>(target.bound_, action);
   }
 };
 
@@ -252,34 +252,34 @@ struct visitor<bind_functor<-1, T_functor, T_type...>>
  * The optional template argument @e I_location specifies the zero-based
  * position of the argument to be fixed (@p -1 stands for the last argument).
  *
- * @param _A_func Functor that should be wrapped.
- * @param _A_b1 Argument to bind to @e _A_func.
- * @return Adaptor that executes @e _A_func with the bound argument on invokation.
+ * @param func Functor that should be wrapped.
+ * @param b1 Argument to bind to @e func.
+ * @return Adaptor that executes @e func with the bound argument on invokation.
  *
  * @ingroup bind
  */
 template <int I_location, typename T_functor, origin::Copy_constructible... T_bound>
 inline decltype(auto)
-bind(const T_functor& _A_func, T_bound... _A_b)
+bind(const T_functor& func, T_bound... b)
 {
-  return bind_functor<I_location, T_functor, T_bound...>(_A_func, _A_b...);
+  return bind_functor<I_location, T_functor, T_bound...>(func, b...);
 }
 
 /** Creates an adaptor of type sigc::bind_functor which fixes the last arguments of the passed
  * functor.
- * This function overload fixes the last arguments of @e _A_func.
+ * This function overload fixes the last arguments of @e func.
  *
- * @param _A_func Functor that should be wrapped.
- * @param _A_b Arguments to bind to @e _A_func.
- * @return Adaptor that executes _A_func with the bound argument on invokation.
+ * @param func Functor that should be wrapped.
+ * @param b Arguments to bind to @e func.
+ * @return Adaptor that executes func with the bound argument on invokation.
  *
  * @ingroup bind
  */
 template <typename T_functor, origin::Copy_constructible... T_type>
 inline decltype(auto)
-bind(const T_functor& _A_func, T_type... _A_b)
+bind(const T_functor& func, T_type... b)
 {
-  return bind_functor<-1, T_functor, T_type...>(_A_func, _A_b...);
+  return bind_functor<-1, T_functor, T_type...>(func, b...);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/adaptors/bind_return.h b/sigc++/adaptors/bind_return.h
index cbe432c..908e035 100644
--- a/sigc++/adaptors/bind_return.h
+++ b/sigc++/adaptors/bind_return.h
@@ -25,23 +25,23 @@ struct bind_return_functor : public adapts<T_functor>
   typename unwrap_reference<T_return>::type operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
-   * @param _A_a... Arguments to be passed on to the functor.
+   * @param a... Arguments to be passed on to the functor.
    * @return The fixed return value.
    */
   template <typename... T_arg>
-  inline typename unwrap_reference<T_return>::type operator()(T_arg... _A_a)
+  inline typename unwrap_reference<T_return>::type operator()(T_arg... a)
   {
-    this->functor_.template operator()<type_trait_pass_t<T_arg>...>(_A_a...);
+    this->functor_.template operator()<type_trait_pass_t<T_arg>...>(a...);
     return ret_value_.invoke();
   }
 
-  /** Constructs a bind_return_functor object that fixes the return value to @p _A_ret_value.
-   * @param _A_functor Functor to invoke from operator()().
-   * @param _A_ret_value Value to return from operator()().
+  /** Constructs a bind_return_functor object that fixes the return value to @p ret_value.
+   * @param functor Functor to invoke from operator()().
+   * @param ret_value Value to return from operator()().
    */
   bind_return_functor(
-    type_trait_take_t<T_functor> _A_functor, type_trait_take_t<T_return> _A_ret_value)
-  : adapts<T_functor>(_A_functor), ret_value_(_A_ret_value)
+    type_trait_take_t<T_functor> functor, type_trait_take_t<T_return> ret_value)
+  : adapts<T_functor>(functor), ret_value_(ret_value)
   {
   }
 
@@ -70,10 +70,10 @@ struct visitor<bind_return_functor<T_return, T_functor>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const bind_return_functor<T_return, T_functor>& _A_target)
+    const T_action& action, const bind_return_functor<T_return, T_functor>& target)
   {
-    sigc::visit_each(_A_action, _A_target.ret_value_);
-    sigc::visit_each(_A_action, _A_target.functor_);
+    sigc::visit_each(action, target.ret_value_);
+    sigc::visit_each(action, target.functor_);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
@@ -81,17 +81,17 @@ struct visitor<bind_return_functor<T_return, T_functor>>
 /** Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed
  * functor to the passed argument.
  *
- * @param _A_functor Functor that should be wrapped.
- * @param _A_ret_value Argument to fix the return value of @e _A_functor to.
- * @return Adaptor that executes @e _A_functor on invokation and returns @e _A_ret_value.
+ * @param functor Functor that should be wrapped.
+ * @param ret_value Argument to fix the return value of @e functor to.
+ * @return Adaptor that executes @e functor on invokation and returns @e ret_value.
  *
  * @ingroup bind
  */
 template <typename T_return, typename T_functor>
 inline bind_return_functor<T_return, T_functor>
-bind_return(const T_functor& _A_functor, T_return _A_ret_value)
+bind_return(const T_functor& functor, T_return ret_value)
 {
-  return bind_return_functor<T_return, T_functor>(_A_functor, _A_ret_value);
+  return bind_return_functor<T_return, T_functor>(functor, ret_value);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/adaptors/bound_argument.h b/sigc++/adaptors/bound_argument.h
index a14a35e..39d51e4 100644
--- a/sigc++/adaptors/bound_argument.h
+++ b/sigc++/adaptors/bound_argument.h
@@ -51,9 +51,9 @@ class bound_argument
 {
 public:
   /** Constructor.
-   * @param _A_argument The argument to bind.
+   * @param arg The argument to bind.
    */
-  bound_argument(const T_type& _A_argument) : visited_(_A_argument) {}
+  bound_argument(const T_type& arg) : visited_(arg) {}
 
   /** Retrieve the entity to visit in visit_each().
    * @return The bound argument.
@@ -81,10 +81,10 @@ class bound_argument<std::reference_wrapper<T_wrapped>>
 {
 public:
   /** Constructor.
-   * @param _A_argument The argument to bind.
+   * @param arg The argument to bind.
    */
-  bound_argument(const std::reference_wrapper<T_wrapped>& _A_argument)
-  : visited_(unwrap(_A_argument))
+  bound_argument(const std::reference_wrapper<T_wrapped>& arg)
+  : visited_(unwrap(arg))
   {
   }
 
@@ -113,10 +113,10 @@ class bound_argument<std::reference_wrapper<const T_wrapped>>
 {
 public:
   /** Constructor.
-   * @param _A_argument The argument to bind.
+   * @param arg The argument to bind.
    */
-  bound_argument(const std::reference_wrapper<const T_wrapped>& _A_argument)
-  : visited_(unwrap(_A_argument))
+  bound_argument(const std::reference_wrapper<const T_wrapped>& arg)
+  : visited_(unwrap(arg))
   {
   }
 
@@ -142,16 +142,16 @@ private:
  * method.
  * @tparam T_type The type of bound_argument.
  * @tparam T_action The type of functor to invoke.
- * @param _A_action The functor to invoke.
- * @param _A_argument The visited instance.
+ * @param action The functor to invoke.
+ * @param arg The visited instance.
  */
 template <typename T_type>
 struct visitor<bound_argument<T_type>>
 {
   template <typename T_action>
-  static void do_visit_each(const T_action& _A_action, const bound_argument<T_type>& _A_argument)
+  static void do_visit_each(const T_action& action, const bound_argument<T_type>& arg)
   {
-    sigc::visit_each(_A_action, _A_argument.visit());
+    sigc::visit_each(action, arg.visit());
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
diff --git a/sigc++/adaptors/compose.h b/sigc++/adaptors/compose.h
index 8339b2a..49b38e8 100644
--- a/sigc++/adaptors/compose.h
+++ b/sigc++/adaptors/compose.h
@@ -46,18 +46,18 @@ struct compose1_functor : public adapts<T_setter>
   decltype(auto) operator()() { return this->functor_(get_()); }
 
   template <typename... T_arg>
-  decltype(auto) operator()(T_arg&&... _A_a)
+  decltype(auto) operator()(T_arg&&... a)
   {
-    return this->functor_(get_(std::forward<T_arg>(_A_a)...));
+    return this->functor_(get_(std::forward<T_arg>(a)...));
   }
 
   /** Constructs a compose1_functor object that combines the passed functors.
-   * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and
-   * @e _A_getter2.
-   * @param _A_getter Functor to invoke from operator()().
+   * @param setter Functor that receives the return values of the invokation of @e getter1 and
+   * @e getter2.
+   * @param getter Functor to invoke from operator()().
    */
-  compose1_functor(const T_setter& _A_setter, const T_getter& _A_getter)
-  : adapts<T_setter>(_A_setter), get_(_A_getter)
+  compose1_functor(const T_setter& setter, const T_getter& getter)
+  : adapts<T_setter>(setter), get_(getter)
   {
   }
 
@@ -80,20 +80,20 @@ struct compose2_functor : public adapts<T_setter>
   decltype(auto) operator()() { return this->functor_(get1_(), get2_()); }
 
   template <typename... T_arg>
-  decltype(auto) operator()(T_arg... _A_a)
+  decltype(auto) operator()(T_arg... a)
   {
-    return this->functor_(get1_(_A_a...), get2_(_A_a...));
+    return this->functor_(get1_(a...), get2_(a...));
   }
 
   /** Constructs a compose2_functor object that combines the passed functors.
-   * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and
-   * @e _A_getter2.
-   * @param _A_getter1 Functor to invoke from operator()().
-   * @param _A_getter2 Functor to invoke from operator()().
+   * @param setter Functor that receives the return values of the invokation of @e getter1 and
+   * @e getter2.
+   * @param getter1 Functor to invoke from operator()().
+   * @param getter2 Functor to invoke from operator()().
    */
   compose2_functor(
-    const T_setter& _A_setter, const T_getter1& _A_getter1, const T_getter2& _A_getter2)
-  : adapts<T_setter>(_A_setter), get1_(_A_getter1), get2_(_A_getter2)
+    const T_setter& setter, const T_getter1& getter1, const T_getter2& getter2)
+  : adapts<T_setter>(setter), get1_(getter1), get2_(getter2)
   {
   }
 
@@ -114,10 +114,10 @@ struct visitor<compose1_functor<T_setter, T_getter>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const compose1_functor<T_setter, T_getter>& _A_target)
+    const T_action& action, const compose1_functor<T_setter, T_getter>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
-    sigc::visit_each(_A_action, _A_target.get_);
+    sigc::visit_each(action, target.functor_);
+    sigc::visit_each(action, target.get_);
   }
 };
 
@@ -133,47 +133,47 @@ struct visitor<compose2_functor<T_setter, T_getter1, T_getter2>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const compose2_functor<T_setter, T_getter1, T_getter2>& _A_target)
+    const T_action& action, const compose2_functor<T_setter, T_getter1, T_getter2>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
-    sigc::visit_each(_A_action, _A_target.get1_);
-    sigc::visit_each(_A_action, _A_target.get2_);
+    sigc::visit_each(action, target.functor_);
+    sigc::visit_each(action, target.get1_);
+    sigc::visit_each(action, target.get2_);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
 /** Creates an adaptor of type sigc::compose1_functor which combines two functors.
  *
- * @param _A_setter Functor that receives the return value of the invokation of @e _A_getter.
- * @param _A_getter Functor to invoke from operator()().
- * @return Adaptor that executes @e _A_setter with the value returned from invokation of @e
- * _A_getter.
+ * @param setter Functor that receives the return value of the invokation of @e getter.
+ * @param getter Functor to invoke from operator()().
+ * @return Adaptor that executes @e setter with the value returned from invokation of @e
+ * getter.
  *
  * @ingroup compose
  */
 template <typename T_setter, typename T_getter>
 inline compose1_functor<T_setter, T_getter>
-compose(const T_setter& _A_setter, const T_getter& _A_getter)
+compose(const T_setter& setter, const T_getter& getter)
 {
-  return compose1_functor<T_setter, T_getter>(_A_setter, _A_getter);
+  return compose1_functor<T_setter, T_getter>(setter, getter);
 }
 
 /** Creates an adaptor of type sigc::compose2_functor which combines three functors.
  *
- * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and
- * @e _A_getter2.
- * @param _A_getter1 Functor to invoke from operator()().
- * @param _A_getter2 Functor to invoke from operator()().
- * @return Adaptor that executes @e _A_setter with the values return from invokation of @e
- * _A_getter1 and @e _A_getter2.
+ * @param setter Functor that receives the return values of the invokation of @e getter1 and
+ * @e getter2.
+ * @param getter1 Functor to invoke from operator()().
+ * @param getter2 Functor to invoke from operator()().
+ * @return Adaptor that executes @e setter with the values return from invokation of @e
+ * getter1 and @e getter2.
  *
  * @ingroup compose
  */
 template <typename T_setter, typename T_getter1, typename T_getter2>
 inline compose2_functor<T_setter, T_getter1, T_getter2>
-compose(const T_setter& _A_setter, const T_getter1& _A_getter1, const T_getter2& _A_getter2)
+compose(const T_setter& setter, const T_getter1& getter1, const T_getter2& getter2)
 {
-  return compose2_functor<T_setter, T_getter1, T_getter2>(_A_setter, _A_getter1, _A_getter2);
+  return compose2_functor<T_setter, T_getter1, T_getter2>(setter, getter1, getter2);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/adaptors/exception_catch.h b/sigc++/adaptors/exception_catch.h
index 6812615..a79c9d0 100644
--- a/sigc++/adaptors/exception_catch.h
+++ b/sigc++/adaptors/exception_catch.h
@@ -71,11 +71,11 @@ struct exception_catch_functor : public adapts<T_functor>
   }
 
   template <typename... T_arg>
-  decltype(auto) operator()(T_arg... _A_a)
+  decltype(auto) operator()(T_arg... a)
   {
     try
     {
-      return this->functor_.template operator()<type_trait_pass_t<T_arg>...>(_A_a...);
+      return this->functor_.template operator()<type_trait_pass_t<T_arg>...>(a...);
     }
     catch (...)
     {
@@ -83,8 +83,8 @@ struct exception_catch_functor : public adapts<T_functor>
     }
   }
 
-  exception_catch_functor(const T_functor& _A_func, const T_catcher& _A_catcher)
-  : adapts<T_functor>(_A_func), catcher_(_A_catcher)
+  exception_catch_functor(const T_functor& func, const T_catcher& catcher)
+  : adapts<T_functor>(func), catcher_(catcher)
   {
   }
 
@@ -97,20 +97,20 @@ template <typename T_functor, typename T_catcher>
 struct visitor<exception_catch_functor<T_functor, T_catcher>>
 {
   template <typename T_action>
-  static void do_visit_each(const T_action& _A_action,
-    const exception_catch_functor<T_functor, T_catcher>& _A_target)
+  static void do_visit_each(const T_action& action,
+    const exception_catch_functor<T_functor, T_catcher>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
-    sigc::visit_each(_A_action, _A_target.catcher_);
+    sigc::visit_each(action, target.functor_);
+    sigc::visit_each(action, target.catcher_);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
 template <typename T_functor, typename T_catcher>
 inline decltype(auto)
-exception_catch(const T_functor& _A_func, const T_catcher& _A_catcher)
+exception_catch(const T_functor& func, const T_catcher& catcher)
 {
-  return exception_catch_functor<T_functor, T_catcher>(_A_func, _A_catcher);
+  return exception_catch_functor<T_functor, T_catcher>(func, catcher);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/adaptors/hide.h b/sigc++/adaptors/hide.h
index ef0149f..e4fa416 100644
--- a/sigc++/adaptors/hide.h
+++ b/sigc++/adaptors/hide.h
@@ -70,15 +70,15 @@ template <int I_location, typename T_functor>
 struct hide_functor : public adapts<T_functor>
 {
   /** Invokes the wrapped functor, ignoring the argument at index @e I_location (0-indexed).
-   * @param _A_a Arguments to be passed on to the functor, apart from the ignored argument.
+   * @param a Arguments to be passed on to the functor, apart from the ignored argument.
    * @return The return value of the functor invocation.
    */
   template <typename... T_arg>
-  decltype(auto) operator()(T_arg&&... _A_a)
+  decltype(auto) operator()(T_arg&&... a)
   {
     constexpr auto size = sizeof...(T_arg);
     constexpr auto index_ignore = (I_location == -1 ? size - 1 : I_location);
-    const auto t = std::tuple<T_arg...>(std::forward<T_arg>(_A_a)...);
+    const auto t = std::tuple<T_arg...>(std::forward<T_arg>(a)...);
 
     const auto t_start = internal::tuple_start<index_ignore>(t);
     const auto t_end = internal::tuple_end<size - index_ignore - 1>(t);
@@ -94,9 +94,9 @@ struct hide_functor : public adapts<T_functor>
   }
 
   /** Constructs a hide_functor object that adds a dummy parameter to the passed functor.
-   * @param _A_func Functor to invoke from operator()().
+   * @param func Functor to invoke from operator()().
    */
-  explicit hide_functor(const T_functor& _A_func) : adapts<T_functor>(_A_func) {}
+  explicit hide_functor(const T_functor& func) : adapts<T_functor>(func) {}
 
 private:
   // TODO_variadic: Replace this with std::experimental::apply() if that becomes standard
@@ -121,9 +121,9 @@ struct visitor<hide_functor<I_location, T_functor>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const hide_functor<I_location, T_functor>& _A_target)
+    const T_action& action, const hide_functor<I_location, T_functor>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
+    sigc::visit_each(action, target.functor_);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
@@ -133,32 +133,32 @@ struct visitor<hide_functor<I_location, T_functor>>
  * The optional template argument @e I_location specifies the zero-based
  * position of the dummy parameter in the returned functor (@p -1 stands for the last parameter).
  *
- * @param _A_func Functor that should be wrapped.
- * @return Adaptor that executes @e _A_func, ignoring the value of the dummy parameter.
+ * @param func Functor that should be wrapped.
+ * @return Adaptor that executes @e func, ignoring the value of the dummy parameter.
  *
  * @ingroup hide
  */
 template <int I_location, typename T_functor>
 inline decltype(auto)
-hide(const T_functor& _A_func)
+hide(const T_functor& func)
 {
-  return hide_functor<I_location, T_functor>(_A_func);
+  return hide_functor<I_location, T_functor>(func);
 }
 
 /** Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed
  * functor.
  * This overload adds a dummy parameter at the back of the functor's parameter list.
  *
- * @param _A_func Functor that should be wrapped.
- * @return Adaptor that executes @e _A_func, ignoring the value of the last parameter.
+ * @param func Functor that should be wrapped.
+ * @return Adaptor that executes @e func, ignoring the value of the last parameter.
  *
  * @ingroup hide
  */
 template <typename T_functor>
 inline decltype(auto)
-hide(const T_functor& _A_func)
+hide(const T_functor& func)
 {
-  return hide_functor<-1, T_functor>(_A_func);
+  return hide_functor<-1, T_functor>(func);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/adaptors/retype.h b/sigc++/adaptors/retype.h
index cac00d3..51ca7bc 100644
--- a/sigc++/adaptors/retype.h
+++ b/sigc++/adaptors/retype.h
@@ -62,17 +62,17 @@ template <typename T_functor, typename... T_type>
 struct retype_functor : public adapts<T_functor>
 {
   template <typename... T_arg>
-  decltype(auto) operator()(T_arg... _A_a)
+  decltype(auto) operator()(T_arg... a)
   {
     return this->functor_.template operator()<type_trait_take_t<T_type>...>(
-      static_cast<T_type>(_A_a)...);
+      static_cast<T_type>(a)...);
   }
 
   /** Constructs a retype_functor object that performs C-style casts on the parameters passed on to
    * the functor.
-   * @param _A_functor Functor to invoke from operator()().
+   * @param functor Functor to invoke from operator()().
    */
-  explicit retype_functor(type_trait_take_t<T_functor> _A_functor) : adapts<T_functor>(_A_functor)
+  explicit retype_functor(type_trait_take_t<T_functor> functor) : adapts<T_functor>(functor)
   {
   }
 };
@@ -90,9 +90,9 @@ struct visitor<retype_functor<T_functor, T_type...>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const retype_functor<T_functor, T_type...>& _A_target)
+    const T_action& action, const retype_functor<T_functor, T_type...>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
+    sigc::visit_each(action, target.functor_);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
@@ -101,32 +101,32 @@ struct visitor<retype_functor<T_functor, T_type...>>
 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters
  * passed on to the functor.
  *
- * @param _A_functor Functor that should be wrapped.
- * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ * @param functor Functor that should be wrapped.
+ * @return Adaptor that executes @e functor performing C-style casts on the paramters passed on.
  *
  * @ingroup retype
  */
 template <template <typename T_func, typename... T_arg> class T_functor, typename T_func, typename... T_arg>
 inline decltype(auto)
-retype(const T_functor<T_func, T_arg...>& _A_functor)
+retype(const T_functor<T_func, T_arg...>& functor)
 {
-  return retype_functor<T_functor<T_func, T_arg...>, T_arg...>(_A_functor);
+  return retype_functor<T_functor<T_func, T_arg...>, T_arg...>(functor);
 }
 
 // This one takes, for instance, a pointer_functor or slot:
 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters
  * passed on to the functor.
  *
- * @param _A_functor Functor that should be wrapped.
- * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ * @param functor Functor that should be wrapped.
+ * @return Adaptor that executes @e functor performing C-style casts on the paramters passed on.
  *
  * @ingroup retype
  */
 template <template <typename T_return, typename... T_arg> class T_functor, typename T_return, typename... 
T_arg>
 inline decltype(auto)
-retype(const T_functor<T_return(T_arg...)>& _A_functor)
+retype(const T_functor<T_return(T_arg...)>& functor)
 {
-  return retype_functor<T_functor<T_return(T_arg...)>, T_arg...>(_A_functor);
+  return retype_functor<T_functor<T_return(T_arg...)>, T_arg...>(functor);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/adaptors/retype_return.h b/sigc++/adaptors/retype_return.h
index 7749abb..98917b3 100644
--- a/sigc++/adaptors/retype_return.h
+++ b/sigc++/adaptors/retype_return.h
@@ -21,19 +21,19 @@ struct retype_return_functor : public adapts<T_functor>
   T_return operator()();
 
   template <typename... T_arg>
-  inline T_return operator()(T_arg&&... _A_a)
+  inline T_return operator()(T_arg&&... a)
   {
-    return T_return(this->functor_.template operator() < T_arg... > (std::forward<T_arg>(_A_a)...));
+    return T_return(this->functor_.template operator() < T_arg... > (std::forward<T_arg>(a)...));
   }
 
   retype_return_functor() = default;
 
   /** Constructs a retype_return_functor object that perform a C-style cast on the return value of
    * the passed functor.
-   * @param _A_functor Functor to invoke from operator()().
+   * @param functor Functor to invoke from operator()().
    */
-  explicit retype_return_functor(type_trait_take_t<T_functor> _A_functor)
-  : adapts<T_functor>(_A_functor)
+  explicit retype_return_functor(type_trait_take_t<T_functor> functor)
+  : adapts<T_functor>(functor)
   {
   }
 };
@@ -61,13 +61,13 @@ struct retype_return_functor<void, T_functor> : public adapts<T_functor>
   void operator()();
 
   template <typename... T_arg>
-  inline void operator()(T_arg... _A_a)
+  inline void operator()(T_arg... a)
   {
-    this->functor_.template operator()<T_arg...>(_A_a...);
+    this->functor_.template operator()<T_arg...>(a...);
   }
 
   retype_return_functor() = default;
-  retype_return_functor(type_trait_take_t<T_functor> _A_functor) : adapts<T_functor>(_A_functor) {}
+  retype_return_functor(type_trait_take_t<T_functor> functor) : adapts<T_functor>(functor) {}
 };
 
 template <typename T_functor>
@@ -90,9 +90,9 @@ struct visitor<retype_return_functor<T_return, T_functor>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const retype_return_functor<T_return, T_functor>& _A_target)
+    const T_action& action, const retype_return_functor<T_return, T_functor>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
+    sigc::visit_each(action, target.functor_);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
@@ -101,31 +101,31 @@ struct visitor<retype_return_functor<T_return, T_functor>>
  * return value of the passed functor.
  * The template argument @e T_return specifies the target type of the cast.
  *
- * @param _A_functor Functor that should be wrapped.
- * @return Adaptor that executes @e _A_functor performing a C-style cast on the return value.
+ * @param functor Functor that should be wrapped.
+ * @return Adaptor that executes @e functor performing a C-style cast on the return value.
  *
  * @ingroup retype
  */
 template <typename T_return, typename T_functor>
 inline retype_return_functor<T_return, T_functor>
-retype_return(const T_functor& _A_functor)
+retype_return(const T_functor& functor)
 {
-  return retype_return_functor<T_return, T_functor>(_A_functor);
+  return retype_return_functor<T_return, T_functor>(functor);
 }
 
 /** Creates an adaptor of type sigc::retype_return_functor which drops the return value of the
  * passed functor.
  *
- * @param _A_functor Functor that should be wrapped.
- * @return Adaptor that executes @e _A_functor dropping its return value.
+ * @param functor Functor that should be wrapped.
+ * @return Adaptor that executes @e functor dropping its return value.
  *
  * @ingroup hide
  */
 template <typename T_functor>
 inline retype_return_functor<void, T_functor>
-hide_return(const T_functor& _A_functor)
+hide_return(const T_functor& functor)
 {
-  return retype_return_functor<void, T_functor>(_A_functor);
+  return retype_return_functor<void, T_functor>(functor);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/adaptors/track_obj.h b/sigc++/adaptors/track_obj.h
index 730133c..8de46ec 100644
--- a/sigc++/adaptors/track_obj.h
+++ b/sigc++/adaptors/track_obj.h
@@ -54,11 +54,11 @@ class track_obj_functor : public adapts<T_functor>
 public:
   /** Constructs a track_obj_functor object that wraps the passed functor and
    * stores a reference to the passed trackable objects.
-   * @param _A_func Functor.
-   * @param _A_obj Trackable objects.
+   * @param func Functor.
+   * @param obj Trackable objects.
    */
-  track_obj_functor(const T_functor& _A_func, const T_obj&... _A_obj)
-  : adapts<T_functor>(_A_func), obj_(_A_obj...)
+  track_obj_functor(const T_functor& func, const T_obj&... obj)
+  : adapts<T_functor>(func), obj_(obj...)
   {
   }
 
@@ -68,14 +68,14 @@ public:
   decltype(auto) operator()() { return this->functor_(); }
 
   /** Invokes the wrapped functor passing on the arguments.
-   * @param _A_arg... Arguments to be passed on to the functor.
+   * @param arg... Arguments to be passed on to the functor.
    * @return The return value of the functor invocation.
    */
   template <typename... T_arg>
-  decltype(auto) operator()(T_arg&&... _A_arg)
+  decltype(auto) operator()(T_arg&&... arg)
   {
     return this->functor_.template operator()<type_trait_pass_t<T_arg>...>(
-      std::forward<T_arg>(_A_arg)...);
+      std::forward<T_arg>(arg)...);
   }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -102,21 +102,21 @@ struct visitor<track_obj_functor<T_functor, T_obj...>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const track_obj_functor<T_functor, T_obj...>& _A_target)
+    const T_action& action, const track_obj_functor<T_functor, T_obj...>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
+    sigc::visit_each(action, target.functor_);
 
-    // Call sigc::visit_each(_A_action, element) on each element in the
-    //_A_target.obj_ tuple:
-    sigc::internal::tuple_for_each<internal::TupleVisitorVisitEach>(_A_target.obj_, _A_action);
+    // Call sigc::visit_each(action, element) on each element in the
+    //target.obj_ tuple:
+    sigc::internal::tuple_for_each<internal::TupleVisitorVisitEach>(target.obj_, action);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
 /** Creates an adaptor of type sigc::track_obj_functor which wraps a functor.
- * @param _A_func Functor that shall be wrapped.
- * @param _A_obj Trackable objects.
- * @return Adaptor that executes _A_func() on invocation.
+ * @param func Functor that shall be wrapped.
+ * @param obj Trackable objects.
+ * @return Adaptor that executes func() on invocation.
  *
  * @newin{2,4}
  *
@@ -124,9 +124,9 @@ struct visitor<track_obj_functor<T_functor, T_obj...>>
  */
 template <typename T_functor, typename... T_obj>
 inline decltype(auto)
-track_obj(const T_functor& _A_func, const T_obj&... _A_obj)
+track_obj(const T_functor& func, const T_obj&... obj)
 {
-  return track_obj_functor<T_functor, T_obj...>(_A_func, _A_obj...);
+  return track_obj_functor<T_functor, T_obj...>(func, obj...);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/functors/mem_fun.h b/sigc++/functors/mem_fun.h
index eeb8493..4f1cbb5 100644
--- a/sigc++/functors/mem_fun.h
+++ b/sigc++/functors/mem_fun.h
@@ -84,18 +84,18 @@ public:
   mem_functor() : func_ptr_(nullptr) {}
 
   /** Constructs a mem_functor object that wraps the passed method.
-   * @param _A_func Pointer to method will be invoked from operator()().
+   * @param func Pointer to method will be invoked from operator()().
    */
-  explicit mem_functor(function_type _A_func) : func_ptr_(_A_func) {}
+  explicit mem_functor(function_type func) : func_ptr_(func) {}
 
   /** Execute the wrapped method operating on the passed instance.
-   * @param _A_obj Reference to instance the method should operate on.
-   * @param _A_a... Argument to be passed on to the method.
+   * @param obj Reference to instance the method should operate on.
+   * @param a... Argument to be passed on to the method.
    * @return The return value of the method invocation.
    */
-  decltype(auto) operator()(obj_type_with_modifier& _A_obj, type_trait_take_t<T_arg>... _A_a) const
+  decltype(auto) operator()(obj_type_with_modifier& obj, type_trait_take_t<T_arg>... a) const
   {
-    return (_A_obj.*func_ptr_)(_A_a...);
+    return (obj.*func_ptr_)(a...);
   }
 
 protected:
@@ -120,21 +120,21 @@ public:
       limit_reference<const object_type>, limit_reference<object_type>>;
 
   /** Constructs a bound_mem_functor object that wraps the passed method.
-   * @param _A_obj Reference to instance the method will operate on.
-   * @param _A_func Pointer to method will be invoked from operator()().
+   * @param obj Reference to instance the method will operate on.
+   * @param func Pointer to method will be invoked from operator()().
    */
-  bound_mem_functor(obj_type_with_modifier& _A_obj, function_type _A_func)
-  : base_type(_A_func), obj_(_A_obj)
+  bound_mem_functor(obj_type_with_modifier& obj, function_type func)
+  : base_type(func), obj_(obj)
   {
   }
 
   /** Execute the wrapped method operating on the stored instance.
-   * @param _A_a... Argument to be passed on to the method.
+   * @param a... Argument to be passed on to the method.
    * @return The return value of the method invocation.
    */
-  decltype(auto) operator()(type_trait_take_t<T_arg>... _A_a) const
+  decltype(auto) operator()(type_trait_take_t<T_arg>... a) const
   {
-    return (obj_.invoke().*(this->func_ptr_))(_A_a...);
+    return (obj_.invoke().*(this->func_ptr_))(a...);
   }
 
   // protected:
@@ -156,123 +156,123 @@ struct visitor<bound_mem_functor<T_func, T_arg...>>
 {
   template <typename T_action>
   static void do_visit_each(
-    const T_action& _A_action, const bound_mem_functor<T_func, T_arg...>& _A_target)
+    const T_action& action, const bound_mem_functor<T_func, T_arg...>& target)
   {
-    sigc::visit_each(_A_action, _A_target.obj_);
+    sigc::visit_each(action, target.obj_);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
 /** Creates a functor of type sigc::mem_functor which wraps a  method.
- * @param _A_func Pointer to method that should be wrapped.
- * @return Functor that executes _A_func on invokation.
+ * @param func Pointer to method that should be wrapped.
+ * @return Functor that executes func on invokation.
  *
  * @ingroup mem_fun
  */
 template <typename T_return, typename T_obj, typename... T_arg>
 inline decltype(auto)
-mem_fun(T_return (T_obj::*_A_func)(T_arg...))
+mem_fun(T_return (T_obj::*func)(T_arg...))
 {
-  return mem_functor<T_return (T_obj::*)(T_arg...), T_arg...>(_A_func);
+  return mem_functor<T_return (T_obj::*)(T_arg...), T_arg...>(func);
 }
 
 /** Creates a functor of type sigc::const_mem_functor which wraps a const method.
- * @param _A_func Pointer to method that should be wrapped.
- * @return Functor that executes _A_func on invokation.
+ * @param func Pointer to method that should be wrapped.
+ * @return Functor that executes func on invokation.
  *
  * @ingroup mem_fun
  */
 template <typename T_return, typename T_obj, typename... T_arg>
 inline decltype(auto)
-mem_fun(T_return (T_obj::*_A_func)(T_arg...) const)
+mem_fun(T_return (T_obj::*func)(T_arg...) const)
 {
-  return mem_functor<T_return (T_obj::*)(T_arg...) const, T_arg...>(_A_func);
+  return mem_functor<T_return (T_obj::*)(T_arg...) const, T_arg...>(func);
 }
 
 /** Creates a functor of type sigc::volatile_mem_functor which wraps a volatile method.
- * @param _A_func Pointer to method that should be wrapped.
- * @return Functor that executes _A_func on invokation.
+ * @param func Pointer to method that should be wrapped.
+ * @return Functor that executes func on invokation.
  *
  * @ingroup mem_fun
  */
 template <typename T_return, typename T_obj, typename... T_arg>
 inline decltype(auto)
-mem_fun(T_return (T_obj::*_A_func)(T_arg...) volatile)
+mem_fun(T_return (T_obj::*func)(T_arg...) volatile)
 {
-  return mem_functor<T_return (T_obj::*)(T_arg...) volatile, T_arg...>(_A_func);
+  return mem_functor<T_return (T_obj::*)(T_arg...) volatile, T_arg...>(func);
 }
 
 /** Creates a functor of type sigc::const_volatile_mem_functor which wraps a const volatile method.
- * @param _A_func Pointer to method that should be wrapped.
- * @return Functor that executes _A_func on invokation.
+ * @param func Pointer to method that should be wrapped.
+ * @return Functor that executes func on invokation.
  *
  * @ingroup mem_fun
  */
 template <typename T_return, typename T_obj, typename... T_arg>
 inline decltype(auto)
-mem_fun(T_return (T_obj::*_A_func)(T_arg...) const volatile)
+mem_fun(T_return (T_obj::*func)(T_arg...) const volatile)
 {
-  return mem_functor<T_return (T_obj::*)(T_arg...) const volatile, T_arg...>(_A_func);
+  return mem_functor<T_return (T_obj::*)(T_arg...) const volatile, T_arg...>(func);
 }
 
 /** Creates a functor of type sigc::bound_mem_functor which encapsulates a method and an object
  * instance.
- * @param _A_obj Reference to object instance the functor should operate on.
- * @param _A_func Pointer to method that should be wrapped.
- * @return Functor that executes @e _A_func on invokation.
+ * @param obj Reference to object instance the functor should operate on.
+ * @param func Pointer to method that should be wrapped.
+ * @return Functor that executes @e func on invokation.
  *
  * @ingroup mem_fun
  */
 template <typename T_return, typename T_obj, typename T_obj2, typename... T_arg>
 inline decltype(auto)
-mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg...))
+mem_fun(/**/ T_obj& obj, T_return (T_obj2::*func)(T_arg...))
 {
-  return bound_mem_functor<T_return (T_obj::*)(T_arg...), T_arg...>(_A_obj, _A_func);
+  return bound_mem_functor<T_return (T_obj::*)(T_arg...), T_arg...>(obj, func);
 }
 
 /** Creates a functor of type sigc::bound_const_mem_functor which encapsulates a method and an
  * object instance.
- * @param _A_obj Reference to object instance the functor should operate on.
- * @param _A_func Pointer to method that should be wrapped.
- * @return Functor that executes @e _A_func on invokation.
+ * @param obj Reference to object instance the functor should operate on.
+ * @param func Pointer to method that should be wrapped.
+ * @return Functor that executes @e func on invokation.
  *
  * @ingroup mem_fun
  */
 template <typename T_return, typename T_obj, typename T_obj2, typename... T_arg>
 inline decltype(auto)
-mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg...) const)
+mem_fun(/*const*/ T_obj& obj, T_return (T_obj2::*func)(T_arg...) const)
 {
-  return bound_mem_functor<T_return (T_obj::*)(T_arg...) const, T_arg...>(_A_obj, _A_func);
+  return bound_mem_functor<T_return (T_obj::*)(T_arg...) const, T_arg...>(obj, func);
 }
 
 /** Creates a functor of type sigc::bound_volatile_mem_functor which encapsulates a method and an
  * object instance.
- * @param _A_obj Reference to object instance the functor should operate on.
- * @param _A_func Pointer to method that should be wrapped.
- * @return Functor that executes @e _A_func on invokation.
+ * @param obj Reference to object instance the functor should operate on.
+ * @param func Pointer to method that should be wrapped.
+ * @return Functor that executes @e func on invokation.
  *
  * @ingroup mem_fun
  */
 template <typename T_return, typename T_obj, typename T_obj2, typename... T_arg>
 inline decltype(auto)
-mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg...) volatile)
+mem_fun(/**/ T_obj& obj, T_return (T_obj2::*func)(T_arg...) volatile)
 {
-  return bound_mem_functor<T_return (T_obj::*)(T_arg...) volatile, T_arg...>(_A_obj, _A_func);
+  return bound_mem_functor<T_return (T_obj::*)(T_arg...) volatile, T_arg...>(obj, func);
 }
 
 /** Creates a functor of type sigc::bound_const_volatile_mem_functor which encapsulates a method and
  * an object instance.
- * @param _A_obj Reference to object instance the functor should operate on.
- * @param _A_func Pointer to method that should be wrapped.
- * @return Functor that executes @e _A_func on invokation.
+ * @param obj Reference to object instance the functor should operate on.
+ * @param func Pointer to method that should be wrapped.
+ * @return Functor that executes @e func on invokation.
  *
  * @ingroup mem_fun
  */
 template <typename T_return, typename T_obj, typename T_obj2, typename... T_arg>
 inline decltype(auto)
-mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg...) const volatile)
+mem_fun(/*const*/ T_obj& obj, T_return (T_obj2::*func)(T_arg...) const volatile)
 {
-  return bound_mem_functor<T_return (T_obj::*)(T_arg...) const volatile, T_arg...>(_A_obj, _A_func);
+  return bound_mem_functor<T_return (T_obj::*)(T_arg...) const volatile, T_arg...>(obj, func);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/functors/ptr_fun.h b/sigc++/functors/ptr_fun.h
index faec0ca..239aedb 100644
--- a/sigc++/functors/ptr_fun.h
+++ b/sigc++/functors/ptr_fun.h
@@ -66,28 +66,28 @@ public:
   pointer_functor() = default;
 
   /** Constructs a pointer_functor2 object that wraps an existing function.
-   * @param _A_func Pointer to function that will be invoked from operator()().
+   * @param func Pointer to function that will be invoked from operator()().
    */
-  explicit pointer_functor(function_type _A_func) : func_ptr_(_A_func) {}
+  explicit pointer_functor(function_type func) : func_ptr_(func) {}
 
   /** Execute the wrapped function.
-   * @param _A_a1 Argument to be passed on to the function.
-   * @param _A_a2 Argument to be passed on to the function.
+   * @param a1 Argument to be passed on to the function.
+   * @param a2 Argument to be passed on to the function.
    * @return The return value of the function invocation.
    */
-  T_return operator()(type_trait_take_t<T_args>... _A_a) const { return func_ptr_(_A_a...); }
+  T_return operator()(type_trait_take_t<T_args>... a) const { return func_ptr_(a...); }
 };
 
 /** Creates a functor of type sigc::pointer_functor which wraps an existing non-member function.
- * @param _A_func Pointer to function that should be wrapped.
- * @return Functor that executes @e _A_func on invokation.
+ * @param func Pointer to function that should be wrapped.
+ * @return Functor that executes @e func on invokation.
  *
  * @ingroup ptr_fun
  */
 template <typename T_return, typename... T_args>
-inline decltype(auto) ptr_fun(T_return (*_A_func)(T_args...))
+inline decltype(auto) ptr_fun(T_return (*func)(T_args...))
 {
-  return pointer_functor<T_return(T_args...)>(_A_func);
+  return pointer_functor<T_return(T_args...)>(func);
 }
 
 } /* namespace sigc */
diff --git a/sigc++/functors/slot.h b/sigc++/functors/slot.h
index b9de448..d9217b5 100644
--- a/sigc++/functors/slot.h
+++ b/sigc++/functors/slot.h
@@ -102,7 +102,7 @@ struct slot_call
 {
   /** Invokes a functor of type @p T_functor.
    * @param rep slot_rep object that holds a functor of type @p T_functor.
-   * @param _A_a Arguments to be passed on to the functor.
+   * @param a Arguments to be passed on to the functor.
    * @return The return values of the functor invocation.
    */
   static T_return call_it(slot_rep* rep, type_trait_take_t<T_arg>... a_)
@@ -166,23 +166,23 @@ public:
 #endif
 
   /** Invoke the contained functor unless slot is in blocking state.
-   * @param _A_a Arguments to be passed on to the functor.
+   * @param a Arguments to be passed on to the functor.
    * @return The return value of the functor invocation.
    */
-  inline T_return operator()(type_trait_take_t<T_arg>... _A_a) const
+  inline T_return operator()(type_trait_take_t<T_arg>... a) const
   {
     if (!empty() && !blocked())
-      return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a...);
+      return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, a...);
     return T_return();
   }
 
   inline slot() = default;
 
   /** Constructs a slot from an arbitrary functor.
-   * @param _A_func The desired functor the new slot should be assigned to.
+   * @param func The desired functor the new slot should be assigned to.
    */
   template <typename T_functor>
-  slot(const T_functor& _A_func) : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
+  slot(const T_functor& func) : slot_base(new internal::typed_slot_rep<T_functor>(func))
   {
     // The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
     slot_base::rep_->call_ = internal::slot_call<T_functor, T_return, T_arg...>::address();
@@ -245,25 +245,25 @@ template <typename T_return, typename... T_arg>
 struct visitor<slot<T_return, T_arg...>>
 {
   static void do_visit_each(
-    const internal::limit_trackable_target<internal::slot_do_bind>& _A_action,
-    const slot<T_return, T_arg...>& _A_target)
+    const internal::limit_trackable_target<internal::slot_do_bind>& action,
+    const slot<T_return, T_arg...>& target)
   {
-    if (_A_target.rep_ && _A_target.rep_->parent_ == nullptr)
-      _A_target.rep_->set_parent(_A_action.action_.rep_, &internal::slot_rep::notify);
+    if (target.rep_ && target.rep_->parent_ == nullptr)
+      target.rep_->set_parent(action.action_.rep_, &internal::slot_rep::notify);
   }
 
   static void do_visit_each(
-    const internal::limit_trackable_target<internal::slot_do_unbind>& _A_action,
-    const slot<T_return, T_arg...>& _A_target)
+    const internal::limit_trackable_target<internal::slot_do_unbind>& action,
+    const slot<T_return, T_arg...>& target)
   {
-    if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
-      _A_target.rep_->set_parent(nullptr, nullptr);
+    if (target.rep_ && target.rep_->parent_ == action.action_.rep_)
+      target.rep_->set_parent(nullptr, nullptr);
   }
 
   template <typename T_action>
-  static void do_visit_each(const T_action& _A_action, const slot<T_return, T_arg...>& _A_target)
+  static void do_visit_each(const T_action& action, const slot<T_return, T_arg...>& target)
   {
-    _A_action(_A_target);
+    action(target);
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
diff --git a/sigc++/limit_reference.h b/sigc++/limit_reference.h
index d581b84..5284ca9 100644
--- a/sigc++/limit_reference.h
+++ b/sigc++/limit_reference.h
@@ -36,9 +36,9 @@ public:
   using reference_type = typename std::remove_volatile_t<T_type>;
 
   /** Constructor.
-   * @param _A_target The reference to limit.
+   * @param target The reference to limit.
    */
-  limit_reference(reference_type& _A_target) : visited(_A_target) {}
+  limit_reference(reference_type& target) : visited(target) {}
 
   /** Retrieve the entity to visit for visit_each().
    * Depending on the template specialization, this is either a derived reference, or
@@ -69,9 +69,9 @@ public:
   using reference_type = typename std::remove_volatile_t<T_type>;
 
   /** Constructor.
-   * @param _A_target The reference to limit.
+   * @param target The reference to limit.
    */
-  limit_reference(reference_type& _A_target) : visited(_A_target), invoked(_A_target) {}
+  limit_reference(reference_type& target) : visited(target), invoked(target) {}
 
   /** Retrieve the entity to visit for visit_each().
    * Depending on the template specialization, this is either a derived reference, or
@@ -105,16 +105,16 @@ private:
  * visit() method.
  * @tparam T_type The type of the reference
  * @tparam T_action The type of functor to invoke.
- * @param _A_action The functor to invoke.
- * @param _A_target The visited instance.
+ * @param action The functor to invoke.
+ * @param target The visited instance.
  */
 template <typename T_type>
 struct visitor<limit_reference<T_type>>
 {
   template <typename T_action>
-  static void do_visit_each(const T_action& _A_action, const limit_reference<T_type>& _A_target)
+  static void do_visit_each(const T_action& action, const limit_reference<T_type>& target)
   {
-    sigc::visit_each(_A_action, _A_target.visit());
+    sigc::visit_each(action, target.visit());
   }
 };
 #endif // DOXYGEN_SHOULD_SKIP_THIS
diff --git a/sigc++/signal.h b/sigc++/signal.h
index 70fe47e..e572f3d 100644
--- a/sigc++/signal.h
+++ b/sigc++/signal.h
@@ -606,24 +606,24 @@ struct signal_emit
    * The parameters are stored in member variables. operator()() passes
    * the values on to some slot.
    */
-  signal_emit(type_trait_take_t<T_arg>... _A_a) : _A_a_(_A_a...) {}
+  signal_emit(type_trait_take_t<T_arg>... a) : a_(a...) {}
 
   /** Invokes a slot using the buffered parameter values.
-   * @param _A_slot Some slot to invoke.
+   * @param slot Some slot to invoke.
    * @return The slot's return value.
    */
-  T_return operator()(const slot_type& _A_slot) const
+  T_return operator()(const slot_type& slot) const
   {
-    const auto seq = std::make_index_sequence<std::tuple_size<decltype(_A_a_)>::value>();
-    return call_call_type_operator_parentheses_with_tuple(_A_slot, _A_a_, seq);
+    const auto seq = std::make_index_sequence<std::tuple_size<decltype(a_)>::value>();
+    return call_call_type_operator_parentheses_with_tuple(slot, a_, seq);
   }
 
   /** Executes a list of slots using an accumulator of type @e T_accumulator.
    * The arguments are buffered in a temporary instance of signal_emit.
-   * @param _A_a Arguments to be passed on to the slots.
+   * @param a Arguments to be passed on to the slots.
    * @return The accumulated return values of the slot invocations as processed by the accumulator.
    */
-  static decltype(auto) emit(signal_impl* impl, type_trait_take_t<T_arg>... _A_a)
+  static decltype(auto) emit(signal_impl* impl, type_trait_take_t<T_arg>... a)
   {
     T_accumulator accumulator;
 
@@ -633,17 +633,17 @@ struct signal_emit
     signal_exec exec(impl);
     temp_slot_list slots(impl->slots_);
 
-    self_type self(_A_a...);
+    self_type self(a...);
     return accumulator(
       slot_iterator_buf_type(slots.begin(), &self), slot_iterator_buf_type(slots.end(), &self));
   }
 
   /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.   *
    * The arguments are buffered in a temporary instance of signal_emit.
-   * @param _A_a Arguments to be passed on to the slots.
+   * @param a Arguments to be passed on to the slots.
    * @return The accumulated return values of the slot invocations as processed by the accumulator.
    */
-  static decltype(auto) emit_reverse(signal_impl* impl, type_trait_take_t<T_arg>... _A_a)
+  static decltype(auto) emit_reverse(signal_impl* impl, type_trait_take_t<T_arg>... a)
   {
     T_accumulator accumulator;
 
@@ -653,21 +653,21 @@ struct signal_emit
     signal_exec exec(impl);
     temp_slot_list slots(impl->slots_);
 
-    self_type self(_A_a...);
+    self_type self(a...);
     return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
       slot_reverse_iterator_buf_type(slots.begin(), &self));
   }
 
-  std::tuple<type_trait_take_t<T_arg>...> _A_a_;
+  std::tuple<type_trait_take_t<T_arg>...> a_;
 
 private:
   // TODO_variadic: Replace this with std::experimental::apply() if that becomes standard
   // C++, or add our own implementation, to avoid code duplication.
   template <std::size_t... Is>
   decltype(auto) call_call_type_operator_parentheses_with_tuple(
-    const slot_type& _A_slot, const std::tuple<T_arg...>& tuple, std::index_sequence<Is...>) const
+    const slot_type& slot, const std::tuple<T_arg...>& tuple, std::index_sequence<Is...>) const
   {
-    return (_A_slot)(std::get<Is>(tuple)...);
+    return (slot)(std::get<Is>(tuple)...);
   }
 };
 
@@ -688,11 +688,11 @@ public:
    * The arguments are passed directly on to the slots.
    * The return value of the last slot invoked is returned.
    * @param first An iterator pointing to the first slot in the list.
-   * @param last An iterator pointing to the last slot in the list.   * @param _A_a Arguments to be
+   * @param last An iterator pointing to the last slot in the list.   * @param a Arguments to be
    * passed on to the slots.
    * @return The return value of the last slot invoked.
    */
-  static decltype(auto) emit(signal_impl* impl, type_trait_take_t<T_arg>... _A_a)
+  static decltype(auto) emit(signal_impl* impl, type_trait_take_t<T_arg>... a)
   {
     if (!impl || impl->slots_.empty())
       return T_return();
@@ -718,12 +718,12 @@ public:
         return T_return();
       }
 
-      r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a...);
+      r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, a...);
       for (++it; it != slots.end(); ++it)
       {
         if (it->empty() || it->blocked())
           continue;
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a...);
+        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, a...);
       }
     }
 
@@ -732,10 +732,10 @@ public:
 
   /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
    * The arguments are passed directly on to the slots.
-   * @param _A_a%1 Argument to be passed on to the slots.
+   * @param a%1 Argument to be passed on to the slots.
    * @return The return value of the last slot invoked.
    */
-  static decltype(auto) emit_reverse(signal_impl* impl, type_trait_take_t<T_arg>... _A_a)
+  static decltype(auto) emit_reverse(signal_impl* impl, type_trait_take_t<T_arg>... a)
   {
     if (!impl || impl->slots_.empty())
       return T_return();
@@ -763,12 +763,12 @@ public:
         return T_return();
       }
 
-      r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a...);
+      r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, a...);
       for (++it; it != reverse_iterator_type(slots.begin()); ++it)
       {
         if (it->empty() || it->blocked())
           continue;
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a...);
+        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, a...);
       }
     }
 
@@ -792,9 +792,9 @@ public:
 
   /** Executes a list of slots using an accumulator of type @e T_accumulator.   * The arguments are
    * passed directly on to the slots.
-   * @param _A_a Arguments to be passed on to the slots.
+   * @param a Arguments to be passed on to the slots.
    */
-  static decltype(auto) emit(signal_impl* impl, type_trait_take_t<T_arg>... _A_a)
+  static decltype(auto) emit(signal_impl* impl, type_trait_take_t<T_arg>... a)
   {
     if (!impl || impl->slots_.empty())
       return;
@@ -806,17 +806,17 @@ public:
       if (slot.empty() || slot.blocked())
         continue;
 
-      (reinterpret_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a...);
+      (reinterpret_cast<call_type>(slot.rep_->call_))(slot.rep_, a...);
     }
   }
 
   /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.   *
    * The arguments are passed directly on to the slots.
    * @param first An iterator pointing to the first slot in the list.
-   * @param last An iterator pointing to the last slot in the list.   * @param _A_a Arguments to be
+   * @param last An iterator pointing to the last slot in the list.   * @param a Arguments to be
    * passed on to the slots.
    */
-  static decltype(auto) emit_reverse(signal_impl* impl, type_trait_take_t<T_arg>... _A_a)
+  static decltype(auto) emit_reverse(signal_impl* impl, type_trait_take_t<T_arg>... a)
   {
     if (!impl || impl->slots_.empty())
       return;
@@ -830,7 +830,7 @@ public:
     {
       if (it->empty() || it->blocked())
         continue;
-      (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a...);
+      (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, a...);
     }
   }
 };
@@ -920,22 +920,22 @@ public:
    * If @e T_accumulated is not @p void, an accumulator of this type
    * is used to process the return values of the slot invocations.
    * Otherwise, the return value of the last slot invoked is returned.
-   * @param _A_a Arguments to be passed on to the slots.
+   * @param a Arguments to be passed on to the slots.
    * @return The accumulated return values of the slot invocations.
    */
-  decltype(auto) emit(type_trait_take_t<T_arg>... _A_a) const
+  decltype(auto) emit(type_trait_take_t<T_arg>... a) const
   {
-    return emitter_type::emit(impl_, _A_a...);
+    return emitter_type::emit(impl_, a...);
   }
 
   /** Triggers the emission of the signal in reverse order (see emit()). */
-  decltype(auto) emit_reverse(type_trait_take_t<T_arg>... _A_a) const
+  decltype(auto) emit_reverse(type_trait_take_t<T_arg>... a) const
   {
-    return emitter_type::emit_reverse(impl_, _A_a...);
+    return emitter_type::emit_reverse(impl_, a...);
   }
 
   /** Triggers the emission of the signal (see emit()). */
-  decltype(auto) operator()(type_trait_take_t<T_arg>... _A_a) const { return emit(_A_a...); }
+  decltype(auto) operator()(type_trait_take_t<T_arg>... a) const { return emit(a...); }
 
   /** Creates a functor that calls emit() on this signal.
    * @code
diff --git a/sigc++/visit_each.h b/sigc++/visit_each.h
index cffd703..066ccd3 100644
--- a/sigc++/visit_each.h
+++ b/sigc++/visit_each.h
@@ -40,15 +40,15 @@ template <typename T_action>
 struct limit_trackable_target
 {
   template <typename T_type>
-  void operator()(T_type&& _A_type) const
+  void operator()(T_type&& type) const
   {
     using T_self = limit_trackable_target<T_action>;
 
     //Only call action_() if T_Type derives from trackable.
-    with_type<T_type, T_self>::execute_(std::forward<T_type>(_A_type), *this);
+    with_type<T_type, T_self>::execute_(std::forward<T_type>(type), *this);
   }
 
-  explicit limit_trackable_target(const T_action& _A_action) : action_(_A_action) {}
+  explicit limit_trackable_target(const T_action& action) : action_(action) {}
 
   limit_trackable_target(const limit_trackable_target& src) = delete;
   limit_trackable_target& operator=(const limit_trackable_target& src) = delete;
@@ -72,9 +72,9 @@ private:
   template <typename T_type, typename T_limit>
   struct with_type<T_type, T_limit, true>
   {
-    static void execute_(const T_type& _A_type, const T_limit& _A_action)
+    static void execute_(const T_type& type, const T_limit& action)
     {
-      _A_action.action_(_A_type);
+      action.action_(type);
     }
   };
 };
@@ -91,7 +91,7 @@ private:
 
 /** sigc::visitor<T_functor>::do_visit_each() performs a functor on each of the targets of a
  * functor.
- * All unknown types just call @a _A_action on them.
+ * All unknown types just call @a action on them.
  * Add specializations that specialize the @a T_functor argument for your own
  * functor types, so that subobjects get visited. This is needed to enable
  * auto-disconnection support for your functor types.
@@ -114,11 +114,11 @@ private:
  *     struct visitor<some_ns::some_functor>
  *     {
  *       template <typename T_action>
- *       static void do_visit_each(const T_action& _A_action,
- *                                 const some_ns::some_functor& _A_target)
+ *       static void do_visit_each(const T_action& action,
+ *                                 const some_ns::some_functor& target)
  *       {
- *         sigc::visit_each(_A_action, _A_target.some_data_member);
- *         sigc::visit_each(_A_action, _A_target.some_other_functor);
+ *         sigc::visit_each(action, target.some_data_member);
+ *         sigc::visit_each(action, target.some_other_functor);
  *       }
  *     };
  *   }
@@ -130,9 +130,9 @@ template <typename T_functor>
 struct visitor
 {
   template <typename T_action>
-  static void do_visit_each(const T_action& _A_action, const T_functor& _A_functor)
+  static void do_visit_each(const T_action& action, const T_functor& functor)
   {
-    _A_action(_A_functor);
+    action(functor);
   }
 };
 
@@ -142,9 +142,9 @@ struct visitor
  */
 template <typename T_action, typename T_functor>
 void
-visit_each(const T_action& _A_action, const T_functor& _A_functor)
+visit_each(const T_action& action, const T_functor& functor)
 {
-  sigc::visitor<T_functor>::do_visit_each(_A_action, _A_functor);
+  sigc::visitor<T_functor>::do_visit_each(action, functor);
 }
 
 /** This function performs a functor on each of the targets
@@ -164,11 +164,11 @@ visit_each(const T_action& _A_action, const T_functor& _A_functor)
  */
 template <typename T_action, typename T_functor>
 void
-visit_each_trackable(const T_action& _A_action, const T_functor& _A_functor)
+visit_each_trackable(const T_action& action, const T_functor& functor)
 {
-  internal::limit_trackable_target<T_action> limited_action(_A_action);
+  internal::limit_trackable_target<T_action> limited_action(action);
 
-  sigc::visit_each(limited_action, _A_functor);
+  sigc::visit_each(limited_action, functor);
 }
 
 } /* namespace sigc */
diff --git a/tests/test_visit_each.cc b/tests/test_visit_each.cc
index 90e2838..39b471d 100644
--- a/tests/test_visit_each.cc
+++ b/tests/test_visit_each.cc
@@ -91,36 +91,36 @@ struct MyAdaptor1 : public sigc::adapts<T_functor>
   }
 
   template <typename T_arg1>
-  decltype(auto) operator()(T_arg1 _A_arg1) const
+  decltype(auto) operator()(T_arg1 arg1) const
   {
-    result_stream << "MyAdaptor1()(_A_arg1) ";
-    return this->functor_(_A_arg1);
+    result_stream << "MyAdaptor1()(arg1) ";
+    return this->functor_(arg1);
   }
 
   template <typename T_arg1, typename T_arg2>
-  decltype(auto) operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const
+  decltype(auto) operator()(T_arg1 arg1, T_arg2 arg2) const
   {
-    result_stream << "MyAdaptor1()(_A_arg1, _A_arg2) ";
-    return this->functor_(_A_arg1, _A_arg2);
+    result_stream << "MyAdaptor1()(arg1, arg2) ";
+    return this->functor_(arg1, arg2);
   }
 
   // Constructs a MyAdaptor1 object that wraps the passed functor.
   // Initializes adapts<T_functor>::functor_, which is invoked from operator()().
-  explicit MyAdaptor1(const T_functor& _A_functor) : sigc::adapts<T_functor>(_A_functor) {}
+  explicit MyAdaptor1(const T_functor& functor) : sigc::adapts<T_functor>(functor) {}
 };
 
 template <typename T_action, typename T_functor>
 void
-visit_each(const T_action& _A_action, const MyAdaptor1<T_functor>& _A_target)
+visit_each(const T_action& action, const MyAdaptor1<T_functor>& target)
 {
-  visit_each(_A_action, _A_target.functor_);
+  visit_each(action, target.functor_);
 }
 
 template <typename T_functor>
 inline MyAdaptor1<T_functor>
-my_adaptor1(const T_functor& _A_func)
+my_adaptor1(const T_functor& func)
 {
-  return MyAdaptor1<T_functor>(_A_func);
+  return MyAdaptor1<T_functor>(func);
 }
 
 } // end namespace ns1
@@ -133,9 +133,9 @@ template <typename T_functor>
 struct visitor<ns1::MyAdaptor1<T_functor>>
 {
   template <typename T_action>
-  static void do_visit_each(const T_action& _A_action, const ns1::MyAdaptor1<T_functor>& _A_target)
+  static void do_visit_each(const T_action& action, const ns1::MyAdaptor1<T_functor>& target)
   {
-    sigc::visit_each(_A_action, _A_target.functor_);
+    sigc::visit_each(action, target.functor_);
   }
 };
 } // end namespace sigc
@@ -179,7 +179,7 @@ main(int argc, char* argv[])
     MyClass1 my_class3("a=");
     sl1 = ns1::my_adaptor1(sigc::mem_fun(my_class3, &MyClass1::execute));
     sl1(42);
-    util->check_result(result_stream, "MyAdaptor1()(_A_arg1) a=42");
+    util->check_result(result_stream, "MyAdaptor1()(arg1) a=42");
 
   } // auto-disconnect sl1