gras: added comments and renamed tmpl args

9 files changed, 405 insertions, 396 deletions

diff --git a/include/gras/callable.hpp b/include/gras/callable.hpp
index 015f965..b5003c1 100644
--- a/include/gras/callable.hpp
+++ b/include/gras/callable.hpp
@@ -62,65 +62,65 @@ protected:
     template <typename ClassType>
     void register_call(const std::string &name, void(ClassType::*fcn)());
 
-    template <typename ClassType, typename ReturnType, typename Arg0>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &));
+    template <typename ClassType, typename ReturnType, typename A0>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &));
 
-    template <typename ClassType, typename Arg0>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &));
+    template <typename ClassType, typename A0>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &));
 
-    template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &));
+    template <typename ClassType, typename ReturnType, typename A0, typename A1>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &));
 
-    template <typename ClassType, typename Arg0, typename Arg1>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &));
+    template <typename ClassType, typename A0, typename A1>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &));
 
-    template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &));
+    template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &));
 
-    template <typename ClassType, typename Arg0, typename Arg1, typename Arg2>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &));
+    template <typename ClassType, typename A0, typename A1, typename A2>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &));
 
-    template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &));
+    template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &));
 
-    template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &));
+    template <typename ClassType, typename A0, typename A1, typename A2, typename A3>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &));
 
-    template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &));
+    template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &));
 
-    template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &));
+    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &));
 
-    template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &));
+    template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &));
 
-    template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &));
+    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &));
 
-    template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &));
+    template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &));
 
-    template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &));
+    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &));
 
-    template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &));
+    template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &));
 
-    template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &));
+    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &));
 
-    template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &));
+    template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &));
 
-    template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &));
+    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &));
 
-    template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &));
+    template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &));
 
-    template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-    void register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &));
+    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+    void register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &));
 
     /*******************************************************************
      * Call API - don't look here, template magic, not helpful
@@ -132,65 +132,65 @@ public:
     inline
     void x(const std::string &name);
 
-    template <typename ReturnType, typename Arg0>
-    ReturnType x(const std::string &name, const Arg0 &);
+    template <typename ReturnType, typename A0>
+    ReturnType x(const std::string &name, const A0 &);
 
-    template <typename Arg0>
-    void x(const std::string &name, const Arg0 &);
+    template <typename A0>
+    void x(const std::string &name, const A0 &);
 
-    template <typename ReturnType, typename Arg0, typename Arg1>
-    ReturnType x(const std::string &name, const Arg0 &, const Arg1 &);
+    template <typename ReturnType, typename A0, typename A1>
+    ReturnType x(const std::string &name, const A0 &, const A1 &);
 
-    template <typename Arg0, typename Arg1>
-    void x(const std::string &name, const Arg0 &, const Arg1 &);
+    template <typename A0, typename A1>
+    void x(const std::string &name, const A0 &, const A1 &);
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2>
-    ReturnType x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &);
+    template <typename ReturnType, typename A0, typename A1, typename A2>
+    ReturnType x(const std::string &name, const A0 &, const A1 &, const A2 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2>
-    void x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &);
+    template <typename A0, typename A1, typename A2>
+    void x(const std::string &name, const A0 &, const A1 &, const A2 &);
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-    ReturnType x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &);
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3>
+    ReturnType x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-    void x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &);
+    template <typename A0, typename A1, typename A2, typename A3>
+    void x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &);
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-    ReturnType x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &);
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
+    ReturnType x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-    void x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4>
+    void x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &);
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-    ReturnType x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &);
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+    ReturnType x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-    void x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+    void x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &);
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-    ReturnType x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &);
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+    ReturnType x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-    void x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+    void x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &);
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-    ReturnType x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &);
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+    ReturnType x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-    void x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+    void x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &);
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-    ReturnType x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &);
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+    ReturnType x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-    void x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+    void x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &);
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-    ReturnType x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &);
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+    ReturnType x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-    void x(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+    void x(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &);
 
     /*******************************************************************
      * Private registration hooks
diff --git a/include/gras/detail/callable.hpp b/include/gras/detail/callable.hpp
index 7a82a45..68766fe 100644
--- a/include/gras/detail/callable.hpp
+++ b/include/gras/detail/callable.hpp
@@ -70,490 +70,490 @@ void Callable::register_call(const std::string &name, void(ClassType::*fcn)())
 /***********************************************************************
  * Registration for return with 1 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0>
+template <typename ClassType, typename ReturnType, typename A0>
 struct CallableRegistryEntryImpl1 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &);
     CallableRegistryEntryImpl1(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 1) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &))
+template <typename ClassType, typename ReturnType, typename A0>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl1<ClassType, ReturnType, Arg0>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl1<ClassType, ReturnType, A0>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0>
+template <typename ClassType, typename A0>
 struct CallableRegistryEntryImplVoid1 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &);
+    typedef void(ClassType::*Fcn)(const A0 &);
     CallableRegistryEntryImplVoid1(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 1) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &))
+template <typename ClassType, typename A0>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid1<ClassType, Arg0>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid1<ClassType, A0>(obj, fcn);
     _register_call(name, fr);
 }
 
 /***********************************************************************
  * Registration for return with 2 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1>
+template <typename ClassType, typename ReturnType, typename A0, typename A1>
 struct CallableRegistryEntryImpl2 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &, const Arg1 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &, const A1 &);
     CallableRegistryEntryImpl2(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 2) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &))
+template <typename ClassType, typename ReturnType, typename A0, typename A1>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl2<ClassType, ReturnType, Arg0, Arg1>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl2<ClassType, ReturnType, A0, A1>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0, typename Arg1>
+template <typename ClassType, typename A0, typename A1>
 struct CallableRegistryEntryImplVoid2 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &, const Arg1 &);
+    typedef void(ClassType::*Fcn)(const A0 &, const A1 &);
     CallableRegistryEntryImplVoid2(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 2) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0, typename Arg1>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &))
+template <typename ClassType, typename A0, typename A1>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid2<ClassType, Arg0, Arg1>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid2<ClassType, A0, A1>(obj, fcn);
     _register_call(name, fr);
 }
 
 /***********************************************************************
  * Registration for return with 3 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2>
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2>
 struct CallableRegistryEntryImpl3 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &);
     CallableRegistryEntryImpl3(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 3) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &))
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl3<ClassType, ReturnType, Arg0, Arg1, Arg2>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl3<ClassType, ReturnType, A0, A1, A2>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2>
+template <typename ClassType, typename A0, typename A1, typename A2>
 struct CallableRegistryEntryImplVoid3 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &);
+    typedef void(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &);
     CallableRegistryEntryImplVoid3(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 3) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &))
+template <typename ClassType, typename A0, typename A1, typename A2>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid3<ClassType, Arg0, Arg1, Arg2>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid3<ClassType, A0, A1, A2>(obj, fcn);
     _register_call(name, fr);
 }
 
 /***********************************************************************
  * Registration for return with 4 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3>
 struct CallableRegistryEntryImpl4 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &);
     CallableRegistryEntryImpl4(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 4) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &))
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl4<ClassType, ReturnType, Arg0, Arg1, Arg2, Arg3>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl4<ClassType, ReturnType, A0, A1, A2, A3>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3>
 struct CallableRegistryEntryImplVoid4 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &);
+    typedef void(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &);
     CallableRegistryEntryImplVoid4(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 4) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &))
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid4<ClassType, Arg0, Arg1, Arg2, Arg3>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid4<ClassType, A0, A1, A2, A3>(obj, fcn);
     _register_call(name, fr);
 }
 
 /***********************************************************************
  * Registration for return with 5 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
 struct CallableRegistryEntryImpl5 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &);
     CallableRegistryEntryImpl5(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 5) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &))
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl5<ClassType, ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl5<ClassType, ReturnType, A0, A1, A2, A3, A4>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4>
 struct CallableRegistryEntryImplVoid5 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &);
+    typedef void(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &);
     CallableRegistryEntryImplVoid5(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 5) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &))
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid5<ClassType, Arg0, Arg1, Arg2, Arg3, Arg4>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid5<ClassType, A0, A1, A2, A3, A4>(obj, fcn);
     _register_call(name, fr);
 }
 
 /***********************************************************************
  * Registration for return with 6 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
 struct CallableRegistryEntryImpl6 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &);
     CallableRegistryEntryImpl6(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 6) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &))
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl6<ClassType, ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl6<ClassType, ReturnType, A0, A1, A2, A3, A4, A5>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
 struct CallableRegistryEntryImplVoid6 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &);
+    typedef void(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &);
     CallableRegistryEntryImplVoid6(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 6) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &))
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid6<ClassType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid6<ClassType, A0, A1, A2, A3, A4, A5>(obj, fcn);
     _register_call(name, fr);
 }
 
 /***********************************************************************
  * Registration for return with 7 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
 struct CallableRegistryEntryImpl7 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &);
     CallableRegistryEntryImpl7(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 7) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &))
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl7<ClassType, ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl7<ClassType, ReturnType, A0, A1, A2, A3, A4, A5, A6>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
 struct CallableRegistryEntryImplVoid7 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &);
+    typedef void(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &);
     CallableRegistryEntryImplVoid7(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 7) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &))
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid7<ClassType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid7<ClassType, A0, A1, A2, A3, A4, A5, A6>(obj, fcn);
     _register_call(name, fr);
 }
 
 /***********************************************************************
  * Registration for return with 8 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
 struct CallableRegistryEntryImpl8 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &);
     CallableRegistryEntryImpl8(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 8) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>(), a[7].safe_as<Arg7>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>(), a[7].safe_as<A7>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &))
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl8<ClassType, ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl8<ClassType, ReturnType, A0, A1, A2, A3, A4, A5, A6, A7>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
 struct CallableRegistryEntryImplVoid8 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &);
+    typedef void(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &);
     CallableRegistryEntryImplVoid8(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 8) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>(), a[7].safe_as<Arg7>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>(), a[7].safe_as<A7>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &))
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid8<ClassType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid8<ClassType, A0, A1, A2, A3, A4, A5, A6, A7>(obj, fcn);
     _register_call(name, fr);
 }
 
 /***********************************************************************
  * Registration for return with 9 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
 struct CallableRegistryEntryImpl9 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &);
     CallableRegistryEntryImpl9(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 9) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>(), a[7].safe_as<Arg7>(), a[8].safe_as<Arg8>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>(), a[7].safe_as<A7>(), a[8].safe_as<A8>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &))
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl9<ClassType, ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl9<ClassType, ReturnType, A0, A1, A2, A3, A4, A5, A6, A7, A8>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
 struct CallableRegistryEntryImplVoid9 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &);
+    typedef void(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &);
     CallableRegistryEntryImplVoid9(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 9) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>(), a[7].safe_as<Arg7>(), a[8].safe_as<Arg8>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>(), a[7].safe_as<A7>(), a[8].safe_as<A8>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &))
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid9<ClassType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid9<ClassType, A0, A1, A2, A3, A4, A5, A6, A7, A8>(obj, fcn);
     _register_call(name, fr);
 }
 
 /***********************************************************************
  * Registration for return with 10 args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
 struct CallableRegistryEntryImpl10 : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &);
+    typedef ReturnType(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &);
     CallableRegistryEntryImpl10(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 10) throw a;
-        return PMC_M((_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>(), a[7].safe_as<Arg7>(), a[8].safe_as<Arg8>(), a[9].safe_as<Arg9>()));
+        return PMC_M((_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>(), a[7].safe_as<A7>(), a[8].safe_as<A8>(), a[9].safe_as<A9>()));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &))
+template <typename ClassType, typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl10<ClassType, ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl10<ClassType, ReturnType, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
 struct CallableRegistryEntryImplVoid10 : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &);
+    typedef void(ClassType::*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &);
     CallableRegistryEntryImplVoid10(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 10) throw a;
-        (_obj->*_fcn)(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>(), a[7].safe_as<Arg7>(), a[8].safe_as<Arg8>(), a[9].safe_as<Arg9>()); return PMCC();
+        (_obj->*_fcn)(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>(), a[7].safe_as<A7>(), a[8].safe_as<A8>(), a[9].safe_as<A9>()); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &))
+template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid10<ClassType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid10<ClassType, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(obj, fcn);
     _register_call(name, fr);
 }
 
@@ -578,8 +578,8 @@ void Callable::x(const std::string &name)
 /***********************************************************************
  * Call implementations with 1 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0)
+template <typename ReturnType, typename A0>
+ReturnType Callable::x(const std::string &name, const A0 &a0)
 {
     PMCList args(1);
     args[0] = PMC_M(a0);
@@ -587,8 +587,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0)
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0>
-void Callable::x(const std::string &name, const Arg0 &a0)
+template <typename A0>
+void Callable::x(const std::string &name, const A0 &a0)
 {
     PMCList args(1);
     args[0] = PMC_M(a0);
@@ -598,8 +598,8 @@ void Callable::x(const std::string &name, const Arg0 &a0)
 /***********************************************************************
  * Call implementations with 2 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1)
+template <typename ReturnType, typename A0, typename A1>
+ReturnType Callable::x(const std::string &name, const A0 &a0, const A1 &a1)
 {
     PMCList args(2);
     args[0] = PMC_M(a0);
@@ -608,8 +608,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1)
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0, typename Arg1>
-void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1)
+template <typename A0, typename A1>
+void Callable::x(const std::string &name, const A0 &a0, const A1 &a1)
 {
     PMCList args(2);
     args[0] = PMC_M(a0);
@@ -620,8 +620,8 @@ void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1)
 /***********************************************************************
  * Call implementations with 3 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2)
+template <typename ReturnType, typename A0, typename A1, typename A2>
+ReturnType Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2)
 {
     PMCList args(3);
     args[0] = PMC_M(a0);
@@ -631,8 +631,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0, typename Arg1, typename Arg2>
-void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2)
+template <typename A0, typename A1, typename A2>
+void Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2)
 {
     PMCList args(3);
     args[0] = PMC_M(a0);
@@ -644,8 +644,8 @@ void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const
 /***********************************************************************
  * Call implementations with 4 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3)
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3>
+ReturnType Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3)
 {
     PMCList args(4);
     args[0] = PMC_M(a0);
@@ -656,8 +656,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3)
+template <typename A0, typename A1, typename A2, typename A3>
+void Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3)
 {
     PMCList args(4);
     args[0] = PMC_M(a0);
@@ -670,8 +670,8 @@ void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const
 /***********************************************************************
  * Call implementations with 5 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4)
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
+ReturnType Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
 {
     PMCList args(5);
     args[0] = PMC_M(a0);
@@ -683,8 +683,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4)
+template <typename A0, typename A1, typename A2, typename A3, typename A4>
+void Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
 {
     PMCList args(5);
     args[0] = PMC_M(a0);
@@ -698,8 +698,8 @@ void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const
 /***********************************************************************
  * Call implementations with 6 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5)
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+ReturnType Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
 {
     PMCList args(6);
     args[0] = PMC_M(a0);
@@ -712,8 +712,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+void Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
 {
     PMCList args(6);
     args[0] = PMC_M(a0);
@@ -728,8 +728,8 @@ void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const
 /***********************************************************************
  * Call implementations with 7 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6)
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+ReturnType Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
 {
     PMCList args(7);
     args[0] = PMC_M(a0);
@@ -743,8 +743,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+void Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
 {
     PMCList args(7);
     args[0] = PMC_M(a0);
@@ -760,8 +760,8 @@ void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const
 /***********************************************************************
  * Call implementations with 8 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6, const Arg7 &a7)
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+ReturnType Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
 {
     PMCList args(8);
     args[0] = PMC_M(a0);
@@ -776,8 +776,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6, const Arg7 &a7)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+void Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
 {
     PMCList args(8);
     args[0] = PMC_M(a0);
@@ -794,8 +794,8 @@ void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const
 /***********************************************************************
  * Call implementations with 9 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6, const Arg7 &a7, const Arg8 &a8)
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+ReturnType Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
 {
     PMCList args(9);
     args[0] = PMC_M(a0);
@@ -811,8 +811,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6, const Arg7 &a7, const Arg8 &a8)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+void Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
 {
     PMCList args(9);
     args[0] = PMC_M(a0);
@@ -830,8 +830,8 @@ void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const
 /***********************************************************************
  * Call implementations with 10 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6, const Arg7 &a7, const Arg8 &a8, const Arg9 &a9)
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+ReturnType Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)
 {
     PMCList args(10);
     args[0] = PMC_M(a0);
@@ -848,8 +848,8 @@ ReturnType Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return r.safe_as<ReturnType>();
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-void Callable::x(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6, const Arg7 &a7, const Arg8 &a8, const Arg9 &a9)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+void Callable::x(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)
 {
     PMCList args(10);
     args[0] = PMC_M(a0);
diff --git a/include/gras/detail/factory.hpp b/include/gras/detail/factory.hpp
index 6570da4..a2de116 100644
--- a/include/gras/detail/factory.hpp
+++ b/include/gras/detail/factory.hpp
@@ -45,240 +45,240 @@ void Factory::register_make(const std::string &name, ReturnType(*fcn)())
 /***********************************************************************
  * Templated registration - 1 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0>
+template <typename ReturnType, typename A0>
 struct FactoryRegistryEntryImpl1 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &);
+    typedef ReturnType(*Fcn)(const A0 &);
     FactoryRegistryEntryImpl1(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 1) throw a;
-        return _fcn(a[0].safe_as<Arg0>());
+        return _fcn(a[0].safe_as<A0>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &))
+template <typename ReturnType, typename A0>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &))
 {
-    void *r = new FactoryRegistryEntryImpl1<ReturnType, Arg0>(fcn);
+    void *r = new FactoryRegistryEntryImpl1<ReturnType, A0>(fcn);
     Factory::_register_make(name, r);
 }
 
 /***********************************************************************
  * Templated registration - 2 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1>
+template <typename ReturnType, typename A0, typename A1>
 struct FactoryRegistryEntryImpl2 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &, const Arg1 &);
+    typedef ReturnType(*Fcn)(const A0 &, const A1 &);
     FactoryRegistryEntryImpl2(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 2) throw a;
-        return _fcn(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>());
+        return _fcn(a[0].safe_as<A0>(), a[1].safe_as<A1>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0, typename Arg1>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &))
+template <typename ReturnType, typename A0, typename A1>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &))
 {
-    void *r = new FactoryRegistryEntryImpl2<ReturnType, Arg0, Arg1>(fcn);
+    void *r = new FactoryRegistryEntryImpl2<ReturnType, A0, A1>(fcn);
     Factory::_register_make(name, r);
 }
 
 /***********************************************************************
  * Templated registration - 3 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2>
+template <typename ReturnType, typename A0, typename A1, typename A2>
 struct FactoryRegistryEntryImpl3 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &);
+    typedef ReturnType(*Fcn)(const A0 &, const A1 &, const A2 &);
     FactoryRegistryEntryImpl3(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 3) throw a;
-        return _fcn(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>());
+        return _fcn(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &))
+template <typename ReturnType, typename A0, typename A1, typename A2>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &))
 {
-    void *r = new FactoryRegistryEntryImpl3<ReturnType, Arg0, Arg1, Arg2>(fcn);
+    void *r = new FactoryRegistryEntryImpl3<ReturnType, A0, A1, A2>(fcn);
     Factory::_register_make(name, r);
 }
 
 /***********************************************************************
  * Templated registration - 4 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3>
 struct FactoryRegistryEntryImpl4 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &);
+    typedef ReturnType(*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &);
     FactoryRegistryEntryImpl4(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 4) throw a;
-        return _fcn(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>());
+        return _fcn(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &))
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &))
 {
-    void *r = new FactoryRegistryEntryImpl4<ReturnType, Arg0, Arg1, Arg2, Arg3>(fcn);
+    void *r = new FactoryRegistryEntryImpl4<ReturnType, A0, A1, A2, A3>(fcn);
     Factory::_register_make(name, r);
 }
 
 /***********************************************************************
  * Templated registration - 5 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
 struct FactoryRegistryEntryImpl5 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &);
+    typedef ReturnType(*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &);
     FactoryRegistryEntryImpl5(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 5) throw a;
-        return _fcn(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>());
+        return _fcn(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &))
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &))
 {
-    void *r = new FactoryRegistryEntryImpl5<ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4>(fcn);
+    void *r = new FactoryRegistryEntryImpl5<ReturnType, A0, A1, A2, A3, A4>(fcn);
     Factory::_register_make(name, r);
 }
 
 /***********************************************************************
  * Templated registration - 6 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
 struct FactoryRegistryEntryImpl6 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &);
+    typedef ReturnType(*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &);
     FactoryRegistryEntryImpl6(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 6) throw a;
-        return _fcn(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>());
+        return _fcn(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &))
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &))
 {
-    void *r = new FactoryRegistryEntryImpl6<ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5>(fcn);
+    void *r = new FactoryRegistryEntryImpl6<ReturnType, A0, A1, A2, A3, A4, A5>(fcn);
     Factory::_register_make(name, r);
 }
 
 /***********************************************************************
  * Templated registration - 7 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
 struct FactoryRegistryEntryImpl7 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &);
+    typedef ReturnType(*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &);
     FactoryRegistryEntryImpl7(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 7) throw a;
-        return _fcn(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>());
+        return _fcn(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &))
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &))
 {
-    void *r = new FactoryRegistryEntryImpl7<ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(fcn);
+    void *r = new FactoryRegistryEntryImpl7<ReturnType, A0, A1, A2, A3, A4, A5, A6>(fcn);
     Factory::_register_make(name, r);
 }
 
 /***********************************************************************
  * Templated registration - 8 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
 struct FactoryRegistryEntryImpl8 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &);
+    typedef ReturnType(*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &);
     FactoryRegistryEntryImpl8(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 8) throw a;
-        return _fcn(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>(), a[7].safe_as<Arg7>());
+        return _fcn(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>(), a[7].safe_as<A7>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &))
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &))
 {
-    void *r = new FactoryRegistryEntryImpl8<ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>(fcn);
+    void *r = new FactoryRegistryEntryImpl8<ReturnType, A0, A1, A2, A3, A4, A5, A6, A7>(fcn);
     Factory::_register_make(name, r);
 }
 
 /***********************************************************************
  * Templated registration - 9 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
 struct FactoryRegistryEntryImpl9 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &);
+    typedef ReturnType(*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &);
     FactoryRegistryEntryImpl9(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 9) throw a;
-        return _fcn(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>(), a[7].safe_as<Arg7>(), a[8].safe_as<Arg8>());
+        return _fcn(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>(), a[7].safe_as<A7>(), a[8].safe_as<A8>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &))
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &))
 {
-    void *r = new FactoryRegistryEntryImpl9<ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8>(fcn);
+    void *r = new FactoryRegistryEntryImpl9<ReturnType, A0, A1, A2, A3, A4, A5, A6, A7, A8>(fcn);
     Factory::_register_make(name, r);
 }
 
 /***********************************************************************
  * Templated registration - 10 args
  **********************************************************************/
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
 struct FactoryRegistryEntryImpl10 : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &);
+    typedef ReturnType(*Fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &);
     FactoryRegistryEntryImpl10(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < 10) throw a;
-        return _fcn(a[0].safe_as<Arg0>(), a[1].safe_as<Arg1>(), a[2].safe_as<Arg2>(), a[3].safe_as<Arg3>(), a[4].safe_as<Arg4>(), a[5].safe_as<Arg5>(), a[6].safe_as<Arg6>(), a[7].safe_as<Arg7>(), a[8].safe_as<Arg8>(), a[9].safe_as<Arg9>());
+        return _fcn(a[0].safe_as<A0>(), a[1].safe_as<A1>(), a[2].safe_as<A2>(), a[3].safe_as<A3>(), a[4].safe_as<A4>(), a[5].safe_as<A5>(), a[6].safe_as<A6>(), a[7].safe_as<A7>(), a[8].safe_as<A8>(), a[9].safe_as<A9>());
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &))
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &))
 {
-    void *r = new FactoryRegistryEntryImpl10<ReturnType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9>(fcn);
+    void *r = new FactoryRegistryEntryImpl10<ReturnType, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(fcn);
     Factory::_register_make(name, r);
 }
 
@@ -292,16 +292,16 @@ Element *Factory::make(const std::string &name)
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0>
-Element *Factory::make(const std::string &name, const Arg0 &a0)
+template <typename A0>
+Element *Factory::make(const std::string &name, const A0 &a0)
 {
     PMCList args(1);
     args[0] = PMC_M(a0);
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0, typename Arg1>
-Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1)
+template <typename A0, typename A1>
+Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1)
 {
     PMCList args(2);
     args[0] = PMC_M(a0);
@@ -309,8 +309,8 @@ Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1)
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0, typename Arg1, typename Arg2>
-Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2)
+template <typename A0, typename A1, typename A2>
+Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2)
 {
     PMCList args(3);
     args[0] = PMC_M(a0);
@@ -319,8 +319,8 @@ Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3)
+template <typename A0, typename A1, typename A2, typename A3>
+Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3)
 {
     PMCList args(4);
     args[0] = PMC_M(a0);
@@ -330,8 +330,8 @@ Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4)
+template <typename A0, typename A1, typename A2, typename A3, typename A4>
+Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
 {
     PMCList args(5);
     args[0] = PMC_M(a0);
@@ -342,8 +342,8 @@ Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
 {
     PMCList args(6);
     args[0] = PMC_M(a0);
@@ -355,8 +355,8 @@ Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
 {
     PMCList args(7);
     args[0] = PMC_M(a0);
@@ -369,8 +369,8 @@ Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6, const Arg7 &a7)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
 {
     PMCList args(8);
     args[0] = PMC_M(a0);
@@ -384,8 +384,8 @@ Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6, const Arg7 &a7, const Arg8 &a8)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
 {
     PMCList args(9);
     args[0] = PMC_M(a0);
@@ -400,8 +400,8 @@ Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1,
     return Factory::_handle_make(name, PMC_M(args));
 }
 
-template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-Element *Factory::make(const std::string &name, const Arg0 &a0, const Arg1 &a1, const Arg2 &a2, const Arg3 &a3, const Arg4 &a4, const Arg5 &a5, const Arg6 &a6, const Arg7 &a7, const Arg8 &a8, const Arg9 &a9)
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)
 {
     PMCList args(10);
     args[0] = PMC_M(a0);
diff --git a/include/gras/factory.hpp b/include/gras/factory.hpp
index b60b1e7..cffd4b1 100644
--- a/include/gras/factory.hpp
+++ b/include/gras/factory.hpp
@@ -39,35 +39,35 @@ struct GRAS_API Factory
     template <typename ReturnType>
     static void register_make(const std::string &name, ReturnType(*fcn)());
 
-    template <typename ReturnType, typename Arg0>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &));
+    template <typename ReturnType, typename A0>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &));
 
-    template <typename ReturnType, typename Arg0, typename Arg1>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &));
+    template <typename ReturnType, typename A0, typename A1>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &));
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &));
+    template <typename ReturnType, typename A0, typename A1, typename A2>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &));
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &));
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &));
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &));
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &));
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &));
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &));
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &));
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &));
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &));
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &));
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &));
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &));
 
-    template <typename ReturnType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &));
+    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &));
 
     /*******************************************************************
      * Make API - don't look here, template magic, not helpful
@@ -75,35 +75,35 @@ struct GRAS_API Factory
     inline
     static Element *make(const std::string &name);
 
-    template <typename Arg0>
-    static Element *make(const std::string &name, const Arg0 &);
+    template <typename A0>
+    static Element *make(const std::string &name, const A0 &);
 
-    template <typename Arg0, typename Arg1>
-    static Element *make(const std::string &name, const Arg0 &, const Arg1 &);
+    template <typename A0, typename A1>
+    static Element *make(const std::string &name, const A0 &, const A1 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2>
-    static Element *make(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &);
+    template <typename A0, typename A1, typename A2>
+    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3>
-    static Element *make(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &);
+    template <typename A0, typename A1, typename A2, typename A3>
+    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-    static Element *make(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4>
+    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-    static Element *make(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
-    static Element *make(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
-    static Element *make(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8>
-    static Element *make(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &);
 
-    template <typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
-    static Element *make(const std::string &name, const Arg0 &, const Arg1 &, const Arg2 &, const Arg3 &, const Arg4 &, const Arg5 &, const Arg6 &, const Arg7 &, const Arg8 &, const Arg9 &);
+    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &);
 
     /*******************************************************************
      * Private registration hooks
diff --git a/tmpl/callable.tmpl.hpp b/tmpl/callable.tmpl.hpp
index 1c73910..900bae4 100644
--- a/tmpl/callable.tmpl.hpp
+++ b/tmpl/callable.tmpl.hpp
@@ -57,11 +57,11 @@ protected:
      ******************************************************************/
 protected:
     #for $NARGS in range($MAX_ARGS)
-    template <typename ClassType, typename ReturnType, $expand('typename Arg%d', $NARGS)>
-    void register_call(const std::string &name, ReturnType(ClassType::*fcn)($expand('const Arg%d &', $NARGS)));
+    template <typename ClassType, typename ReturnType, $expand('typename A%d', $NARGS)>
+    void register_call(const std::string &name, ReturnType(ClassType::*fcn)($expand('const A%d &', $NARGS)));
 
-    template <typename ClassType, $expand('typename Arg%d', $NARGS)>
-    void register_call(const std::string &name, void(ClassType::*fcn)($expand('const Arg%d &', $NARGS)));
+    template <typename ClassType, $expand('typename A%d', $NARGS)>
+    void register_call(const std::string &name, void(ClassType::*fcn)($expand('const A%d &', $NARGS)));
 
     #end for
     /*******************************************************************
@@ -69,11 +69,11 @@ protected:
      ******************************************************************/
 public:
     #for $NARGS in range($MAX_ARGS)
-    template <typename ReturnType, $expand('typename Arg%d', $NARGS)>
-    ReturnType x(const std::string &name, $expand('const Arg%d &', $NARGS));
+    template <typename ReturnType, $expand('typename A%d', $NARGS)>
+    ReturnType x(const std::string &name, $expand('const A%d &', $NARGS));
 
-    template <$expand('typename Arg%d', $NARGS)>
-    void x(const std::string &name, $expand('const Arg%d &', $NARGS));
+    template <$expand('typename A%d', $NARGS)>
+    void x(const std::string &name, $expand('const A%d &', $NARGS));
 
     #end for
     /*******************************************************************
diff --git a/tmpl/callable_detail.tmpl.hpp b/tmpl/callable_detail.tmpl.hpp
index ee11815..65750e7 100644
--- a/tmpl/callable_detail.tmpl.hpp
+++ b/tmpl/callable_detail.tmpl.hpp
@@ -22,49 +22,49 @@ struct GRAS_API CallableRegistryEntry
 /***********************************************************************
  * Registration for return with $NARGS args
  **********************************************************************/
-template <typename ClassType, typename ReturnType, $expand('typename Arg%d', $NARGS)>
+template <typename ClassType, typename ReturnType, $expand('typename A%d', $NARGS)>
 struct CallableRegistryEntryImpl$(NARGS) : CallableRegistryEntry
 {
-    typedef ReturnType(ClassType::*Fcn)($expand('const Arg%d &', $NARGS));
+    typedef ReturnType(ClassType::*Fcn)($expand('const A%d &', $NARGS));
     CallableRegistryEntryImpl$(NARGS)(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < $NARGS) throw a;
-        return PMC_M((_obj->*_fcn)($expand('a[%d].safe_as<Arg%d>()', $NARGS)));
+        return PMC_M((_obj->*_fcn)($expand('a[%d].safe_as<A%d>()', $NARGS)));
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, typename ReturnType, $expand('typename Arg%d', $NARGS)>
-void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)($expand('const Arg%d &', $NARGS)))
+template <typename ClassType, typename ReturnType, $expand('typename A%d', $NARGS)>
+void Callable::register_call(const std::string &name, ReturnType(ClassType::*fcn)($expand('const A%d &', $NARGS)))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImpl$(NARGS)<ClassType, ReturnType, $expand('Arg%d', $NARGS)>(obj, fcn);
+    void *fr = new CallableRegistryEntryImpl$(NARGS)<ClassType, ReturnType, $expand('A%d', $NARGS)>(obj, fcn);
     _register_call(name, fr);
 }
 
-template <typename ClassType, $expand('typename Arg%d', $NARGS)>
+template <typename ClassType, $expand('typename A%d', $NARGS)>
 struct CallableRegistryEntryImplVoid$(NARGS) : CallableRegistryEntry
 {
-    typedef void(ClassType::*Fcn)($expand('const Arg%d &', $NARGS));
+    typedef void(ClassType::*Fcn)($expand('const A%d &', $NARGS));
     CallableRegistryEntryImplVoid$(NARGS)(ClassType *obj, Fcn fcn):
     _obj(obj), _fcn(fcn){}
     PMCC call(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < $NARGS) throw a;
-        (_obj->*_fcn)($expand('a[%d].safe_as<Arg%d>()', $NARGS)); return PMCC();
+        (_obj->*_fcn)($expand('a[%d].safe_as<A%d>()', $NARGS)); return PMCC();
     }
     ClassType *_obj; Fcn _fcn;
 };
 
-template <typename ClassType, $expand('typename Arg%d', $NARGS)>
-void Callable::register_call(const std::string &name, void(ClassType::*fcn)($expand('const Arg%d &', $NARGS)))
+template <typename ClassType, $expand('typename A%d', $NARGS)>
+void Callable::register_call(const std::string &name, void(ClassType::*fcn)($expand('const A%d &', $NARGS)))
 {
     ClassType *obj = dynamic_cast<ClassType *>(this);
-    void *fr = new CallableRegistryEntryImplVoid$(NARGS)<ClassType, $expand('Arg%d', $NARGS)>(obj, fcn);
+    void *fr = new CallableRegistryEntryImplVoid$(NARGS)<ClassType, $expand('A%d', $NARGS)>(obj, fcn);
     _register_call(name, fr);
 }
 
@@ -73,8 +73,8 @@ void Callable::register_call(const std::string &name, void(ClassType::*fcn)($exp
 /***********************************************************************
  * Call implementations with $NARGS args
  **********************************************************************/
-template <typename ReturnType, $expand('typename Arg%d', $NARGS)>
-ReturnType Callable::x(const std::string &name, $expand('const Arg%d &a%d', $NARGS))
+template <typename ReturnType, $expand('typename A%d', $NARGS)>
+ReturnType Callable::x(const std::string &name, $expand('const A%d &a%d', $NARGS))
 {
     PMCList args($NARGS);
     #for $i in range($NARGS):
@@ -84,8 +84,8 @@ ReturnType Callable::x(const std::string &name, $expand('const Arg%d &a%d', $NAR
     return r.safe_as<ReturnType>();
 }
 
-template <$expand('typename Arg%d', $NARGS)>
-void Callable::x(const std::string &name, $expand('const Arg%d &a%d', $NARGS))
+template <$expand('typename A%d', $NARGS)>
+void Callable::x(const std::string &name, $expand('const A%d &a%d', $NARGS))
 {
     PMCList args($NARGS);
     #for $i in range($NARGS):
diff --git a/tmpl/factory.tmpl.hpp b/tmpl/factory.tmpl.hpp
index 66f3e3e..a9c9820 100644
--- a/tmpl/factory.tmpl.hpp
+++ b/tmpl/factory.tmpl.hpp
@@ -37,16 +37,16 @@ struct GRAS_API Factory
      * Register API - don't look here, template magic, not helpful
      ******************************************************************/
     #for $NARGS in range($MAX_ARGS)
-    template <typename ReturnType, $expand('typename Arg%d', $NARGS)>
-    static void register_make(const std::string &name, ReturnType(*fcn)($expand('const Arg%d &', $NARGS)));
+    template <typename ReturnType, $expand('typename A%d', $NARGS)>
+    static void register_make(const std::string &name, ReturnType(*fcn)($expand('const A%d &', $NARGS)));
 
     #end for
     /*******************************************************************
      * Make API - don't look here, template magic, not helpful
      ******************************************************************/;
     #for $NARGS in range($MAX_ARGS)
-    template <$expand('typename Arg%d', $NARGS)>
-    static Element *make(const std::string &name, $expand('const Arg%d &', $NARGS));
+    template <$expand('typename A%d', $NARGS)>
+    static Element *make(const std::string &name, $expand('const A%d &', $NARGS));
 
     #end for
     /*******************************************************************
diff --git a/tmpl/factory_detail.tmpl.hpp b/tmpl/factory_detail.tmpl.hpp
index 1238c38..87a0756 100644
--- a/tmpl/factory_detail.tmpl.hpp
+++ b/tmpl/factory_detail.tmpl.hpp
@@ -22,24 +22,24 @@ struct GRAS_API FactoryRegistryEntry
 /***********************************************************************
  * Templated registration - $NARGS args
  **********************************************************************/
-template <typename ReturnType, $expand('typename Arg%d', $NARGS)>
+template <typename ReturnType, $expand('typename A%d', $NARGS)>
 struct FactoryRegistryEntryImpl$(NARGS) : FactoryRegistryEntry
 {
-    typedef ReturnType(*Fcn)($expand('const Arg%d &', $NARGS));
+    typedef ReturnType(*Fcn)($expand('const A%d &', $NARGS));
     FactoryRegistryEntryImpl$(NARGS)(Fcn fcn):_fcn(fcn){}
     Element *make(const PMCC &args)
     {
         const PMCList &a = args.as<PMCList>();
         if (a.size() < $NARGS) throw a;
-        return _fcn($expand('a[%d].safe_as<Arg%d>()', $NARGS));
+        return _fcn($expand('a[%d].safe_as<A%d>()', $NARGS));
     }
     Fcn _fcn;
 };
 
-template <typename ReturnType, $expand('typename Arg%d', $NARGS)>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)($expand('const Arg%d &', $NARGS)))
+template <typename ReturnType, $expand('typename A%d', $NARGS)>
+void Factory::register_make(const std::string &name, ReturnType(*fcn)($expand('const A%d &', $NARGS)))
 {
-    void *r = new FactoryRegistryEntryImpl$(NARGS)<ReturnType, $expand('Arg%d', $NARGS)>(fcn);
+    void *r = new FactoryRegistryEntryImpl$(NARGS)<ReturnType, $expand('A%d', $NARGS)>(fcn);
     Factory::_register_make(name, r);
 }
 
@@ -48,8 +48,8 @@ void Factory::register_make(const std::string &name, ReturnType(*fcn)($expand('c
  * Templated make implementations
  **********************************************************************/
 #for $NARGS in range($MAX_ARGS)
-template <$expand('typename Arg%d', $NARGS)>
-Element *Factory::make(const std::string &name, $expand('const Arg%d &a%d', $NARGS))
+template <$expand('typename A%d', $NARGS)>
+Element *Factory::make(const std::string &name, $expand('const A%d &a%d', $NARGS))
 {
     PMCList args($NARGS);
     #for $i in range($NARGS):
diff --git a/tmpl/regen_all.sh b/tmpl/regen_all.sh
index f9f4c95..53886c9 100644..100755
--- a/tmpl/regen_all.sh
+++ b/tmpl/regen_all.sh
@@ -1,5 +1,14 @@
 #!/bin/bash
 
+# This script generates the multi-argument template code
+# for the callable and factory interfaces.
+# This is the magic that makes the API calls
+# so natural to call into as a C++ client app.
+# This script is manually run when the source tmpl files are changed.
+# And the generated sources are checked in.
+# This way, the build system does not generate public headers.
+# And the build system does not depend on Cheetah templates.
+
 SCRIPT="`readlink -e $0`"
 SCRIPTPATH="`dirname $SCRIPT`"
 DEST=${SCRIPTPATH}/../include/gras