diff --git a/include/momo/HashMultiMap.h b/include/momo/HashMultiMap.h
index c9e154fe..15a0fc7c 100644
--- a/include/momo/HashMultiMap.h
+++ b/include/momo/HashMultiMap.h
@@ -370,10 +370,10 @@ namespace internal
 			MOMO_STATIC_ASSERT(std::is_same<ValueArg, Value>::value);
 
 		private:
-			typedef typename ValueManager::template Creator<ValueArg> BaseCreator;
+			typedef typename ValueManager::template Creator<ValueArg> CreatorBase;
 
 		public:
-			using BaseCreator::BaseCreator;
+			using CreatorBase::CreatorBase;
 		};
 
 	public:
diff --git a/include/momo/stdish/map.h b/include/momo/stdish/map.h
index 7164fc20..ecb20518 100644
--- a/include/momo/stdish/map.h
+++ b/include/momo/stdish/map.h
@@ -836,24 +836,24 @@ template<typename TKey, typename TMapped,
 class map : public internal::map_base<TKey, TMapped, TLessFunc, TAllocator, TTreeMap>
 {
 private:
-	typedef internal::map_base<TKey, TMapped, TLessFunc, TAllocator, TTreeMap> BaseMap;
+	typedef internal::map_base<TKey, TMapped, TLessFunc, TAllocator, TTreeMap> MapBase;
 	typedef TTreeMap TreeMap;
 
 public:
-	using typename BaseMap::key_type;
-	using typename BaseMap::mapped_type;
-	using typename BaseMap::size_type;
-	using typename BaseMap::value_type;
-	using typename BaseMap::const_reference;
-	using typename BaseMap::const_iterator;
-	using typename BaseMap::iterator;
+	using typename MapBase::key_type;
+	using typename MapBase::mapped_type;
+	using typename MapBase::size_type;
+	using typename MapBase::value_type;
+	using typename MapBase::const_reference;
+	using typename MapBase::const_iterator;
+	using typename MapBase::iterator;
 
 public:
-	using BaseMap::BaseMap;
+	using MapBase::MapBase;
 
 	map& operator=(std::initializer_list<value_type> values)
 	{
-		BaseMap::ptAssign(values);
+		MapBase::ptAssign(values);
 		return *this;
 	}
 
@@ -864,26 +864,26 @@ class map : public internal::map_base<TKey, TMapped, TLessFunc, TAllocator, TTre
 
 	typename TreeMap::ValueReferenceRKey operator[](key_type&& key)
 	{
-		return BaseMap::get_nested_container()[std::move(key)];
+		return MapBase::get_nested_container()[std::move(key)];
 	}
 
 	typename TreeMap::ValueReferenceCKey operator[](const key_type& key)
 	{
-		return BaseMap::get_nested_container()[key];
+		return MapBase::get_nested_container()[key];
 	}
 
 	const mapped_type& at(const key_type& key) const
 	{
-		const_iterator iter = BaseMap::find(key);
-		if (iter == BaseMap::end())
+		const_iterator iter = MapBase::find(key);
+		if (iter == MapBase::end())
 			throw std::out_of_range("invalid map key");
 		return iter->second;
 	}
 
 	mapped_type& at(const key_type& key)
 	{
-		iterator iter = BaseMap::find(key);
-		if (iter == BaseMap::end())
+		iterator iter = MapBase::find(key);
+		if (iter == MapBase::end())
 			throw std::out_of_range("invalid map key");
 		return iter->second;
 	}
@@ -891,28 +891,28 @@ class map : public internal::map_base<TKey, TMapped, TLessFunc, TAllocator, TTre
 	template<typename... MappedArgs>
 	std::pair<iterator, bool> try_emplace(key_type&& key, MappedArgs&&... mappedArgs)
 	{
-		return BaseMap::ptEmplace(nullptr, std::forward_as_tuple(std::move(key)),
+		return MapBase::ptEmplace(nullptr, std::forward_as_tuple(std::move(key)),
 			std::forward_as_tuple(std::forward<MappedArgs>(mappedArgs)...));
 	}
 
 	template<typename... MappedArgs>
 	iterator try_emplace(const_iterator hint, key_type&& key, MappedArgs&&... mappedArgs)
 	{
-		return BaseMap::ptEmplace(hint, std::forward_as_tuple(std::move(key)),
+		return MapBase::ptEmplace(hint, std::forward_as_tuple(std::move(key)),
 			std::forward_as_tuple(std::forward<MappedArgs>(mappedArgs)...)).first;
 	}
 
 	template<typename... MappedArgs>
 	std::pair<iterator, bool> try_emplace(const key_type& key, MappedArgs&&... mappedArgs)
 	{
-		return BaseMap::ptEmplace(nullptr, std::forward_as_tuple(key),
+		return MapBase::ptEmplace(nullptr, std::forward_as_tuple(key),
 			std::forward_as_tuple(std::forward<MappedArgs>(mappedArgs)...));
 	}
 
 	template<typename... MappedArgs>
 	iterator try_emplace(const_iterator hint, const key_type& key, MappedArgs&&... mappedArgs)
 	{
-		return BaseMap::ptEmplace(hint, std::forward_as_tuple(key),
+		return MapBase::ptEmplace(hint, std::forward_as_tuple(key),
 			std::forward_as_tuple(std::forward<MappedArgs>(mappedArgs)...)).first;
 	}
 
@@ -952,7 +952,7 @@ class map : public internal::map_base<TKey, TMapped, TLessFunc, TAllocator, TTre
 	template<typename Hint, typename RKey, typename MappedArg>
 	std::pair<iterator, bool> pvInsertOrAssign(Hint hint, RKey&& key, MappedArg&& mappedArg)
 	{
-		std::pair<iterator, bool> res = BaseMap::ptEmplace(hint,
+		std::pair<iterator, bool> res = MapBase::ptEmplace(hint,
 			std::forward_as_tuple(std::forward<RKey>(key)),
 			std::forward_as_tuple(std::forward<MappedArg>(mappedArg)));
 		if (!res.second)
@@ -977,26 +977,26 @@ template<typename TKey, typename TMapped,
 class multimap : public internal::map_base<TKey, TMapped, TLessFunc, TAllocator, TTreeMap>
 {
 private:
-	typedef internal::map_base<TKey, TMapped, TLessFunc, TAllocator, TTreeMap> BaseMap;
+	typedef internal::map_base<TKey, TMapped, TLessFunc, TAllocator, TTreeMap> MapBase;
 
 public:
-	using typename BaseMap::key_type;
-	using typename BaseMap::mapped_type;
-	using typename BaseMap::size_type;
-	using typename BaseMap::value_type;
-	using typename BaseMap::iterator;
-	using typename BaseMap::const_reference;
-	using typename BaseMap::const_iterator;
-	using typename BaseMap::node_type;
+	using typename MapBase::key_type;
+	using typename MapBase::mapped_type;
+	using typename MapBase::size_type;
+	using typename MapBase::value_type;
+	using typename MapBase::iterator;
+	using typename MapBase::const_reference;
+	using typename MapBase::const_iterator;
+	using typename MapBase::node_type;
 
 	typedef iterator insert_return_type;
 
 public:
-	using BaseMap::BaseMap;
+	using MapBase::MapBase;
 
 	multimap& operator=(std::initializer_list<value_type> values)
 	{
-		BaseMap::ptAssign(values);
+		MapBase::ptAssign(values);
 		return *this;
 	}
 
@@ -1005,47 +1005,47 @@ class multimap : public internal::map_base<TKey, TMapped, TLessFunc, TAllocator,
 		left.swap(right);
 	}
 
-	//using BaseMap::insert;	// gcc 5 & 6
+	//using MapBase::insert;	// gcc 5 & 6
 
 	template<typename ValueArg = std::pair<key_type, mapped_type>>
 	momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
 	iterator> insert(ValueArg&& valueArg)
 	{
-		return BaseMap::insert(std::forward<ValueArg>(valueArg)).first;
+		return MapBase::insert(std::forward<ValueArg>(valueArg)).first;
 	}
 
 	template<typename ValueArg = std::pair<key_type, mapped_type>>
 	momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
 	iterator> insert(const_iterator hint, ValueArg&& valueArg)
 	{
-		return BaseMap::insert(hint, std::forward<ValueArg>(valueArg));
+		return MapBase::insert(hint, std::forward<ValueArg>(valueArg));
 	}
 
 	iterator insert(node_type&& node)
 	{
-		return BaseMap::insert(std::move(node)).position;
+		return MapBase::insert(std::move(node)).position;
 	}
 
 	iterator insert(const_iterator hint, node_type&& node)
 	{
-		return BaseMap::insert(hint, std::move(node));
+		return MapBase::insert(hint, std::move(node));
 	}
 
 	template<typename Iterator>
 	void insert(Iterator first, Iterator last)
 	{
-		BaseMap::insert(first, last);
+		MapBase::insert(first, last);
 	}
 
 	void insert(std::initializer_list<value_type> values)
 	{
-		BaseMap::insert(values);
+		MapBase::insert(values);
 	}
 
 	template<typename... ValueArgs>
 	iterator emplace(ValueArgs&&... valueArgs)
 	{
-		return BaseMap::emplace(std::forward<ValueArgs>(valueArgs)...).first;
+		return MapBase::emplace(std::forward<ValueArgs>(valueArgs)...).first;
 	}
 
 	template<typename ValueFilter>