diff --git a/src/name-assignment/assignment-func.hpp b/src/name-assignment/assignment-func.hpp
index 7f35fcf..f08e50c 100644
--- a/src/name-assignment/assignment-func.hpp
+++ b/src/name-assignment/assignment-func.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2017-2021, Regents of the University of California.
+ * Copyright (c) 2017-2022, Regents of the University of California.
  *
  * This file is part of ndncert, a certificate management system based on NDN.
  *
@@ -30,10 +30,12 @@
 class NameAssignmentFunc : boost::noncopyable
 {
 protected:
-  explicit NameAssignmentFunc(const std::string& format = "");
+  explicit
+  NameAssignmentFunc(const std::string& format = "");
 
 public:
-  virtual ~NameAssignmentFunc() = default;
+  virtual
+  ~NameAssignmentFunc() = default;
 
   /**
    * @brief The name assignment function provided by the CA operator to generate available
@@ -48,40 +50,40 @@
   virtual std::vector<ndn::PartialName>
   assignName(const std::multimap<std::string, std::string>& params) = 0;
 
-public:
-  template <class AssignmentType>
+public: // factory
+  template<class AssignmentType>
   static void
-  registerNameAssignmentFunc(const std::string& typeName)
+  registerNameAssignmentFunc(const std::string& type)
   {
-    CurriedFuncFactory& factory = getFactory();
-    BOOST_ASSERT(factory.count(typeName) == 0);
-    factory[typeName] = [](const std::string& format) { return std::make_unique<AssignmentType>(format); };
+    auto& factory = getFactory();
+    BOOST_ASSERT(factory.count(type) == 0);
+    factory[type] = [] (const std::string& format) { return std::make_unique<AssignmentType>(format); };
   }
 
   static std::unique_ptr<NameAssignmentFunc>
-  createNameAssignmentFunc(const std::string& challengeType, const std::string& format = "");
+  createNameAssignmentFunc(const std::string& type, const std::string& format = "");
 
 NDNCERT_PUBLIC_WITH_TESTS_ELSE_PROTECTED:
   std::vector<std::string> m_nameFormat;
 
 private:
-  typedef std::function<std::unique_ptr<NameAssignmentFunc>(const std::string&)> FactoryCreateFunc;
-  typedef std::map<std::string, FactoryCreateFunc> CurriedFuncFactory;
+  using CreateFunc = std::function<std::unique_ptr<NameAssignmentFunc>(const std::string &)>;
+  using FuncFactory = std::map<std::string, CreateFunc>;
 
-  static CurriedFuncFactory&
+  static FuncFactory&
   getFactory();
 };
 
-#define NDNCERT_REGISTER_FUNCFACTORY(C, T)                                        \
-  static class NdnCert##C##FuncFactoryRegistrationClass                           \
-  {                                                                               \
-  public:                                                                         \
-    NdnCert##C##FuncFactoryRegistrationClass()                                    \
-    {                                                                             \
-      ::ndncert::NameAssignmentFunc::registerNameAssignmentFunc<C>(T);            \
-    }                                                                             \
-  } g_NdnCert##C##ChallengeRegistrationVariable
-
 } // namespace ndncert
 
+#define NDNCERT_REGISTER_NAME_ASSIGNMENT_FUNC(C, T)                           \
+static class NdnCert##C##NameAssignmentRegistrationClass                      \
+{                                                                             \
+public:                                                                       \
+  NdnCert##C##NameAssignmentRegistrationClass()                               \
+  {                                                                           \
+    ::ndncert::NameAssignmentFunc::registerNameAssignmentFunc<C>(T);          \
+  }                                                                           \
+} g_NdnCert##C##NameAssignmentRegistrationVariable
+
 #endif // NDNCERT_ASSIGNMENT_FUNC_HPP