diff --git a/generator/routing_index_generator.cpp b/generator/routing_index_generator.cpp
index 42383c6625..fd69d76fd2 100644
--- a/generator/routing_index_generator.cpp
+++ b/generator/routing_index_generator.cpp
@@ -151,27 +151,27 @@ class DijkstraWrapper final
 {
 public:
   // AStarAlgorithm types aliases:
-  using TVertexType = Segment;
-  using TEdgeType = SegmentEdge;
-  using TWeightType = RouteWeight;
+  using Vertex = Segment;
+  using Edge = SegmentEdge;
+  using Weight = RouteWeight;
 
   explicit DijkstraWrapper(IndexGraph & graph) : m_graph(graph) {}
 
-  void GetOutgoingEdgesList(TVertexType const & vertex, vector<TEdgeType> & edges)
+  void GetOutgoingEdgesList(Vertex const & vertex, vector<Edge> & edges)
   {
     edges.clear();
     m_graph.GetEdgeList(vertex, true /* isOutgoing */, edges);
   }
 
-  void GetIngoingEdgesList(TVertexType const & vertex, vector<TEdgeType> & edges)
+  void GetIngoingEdgesList(Vertex const & vertex, vector<Edge> & edges)
   {
     edges.clear();
     m_graph.GetEdgeList(vertex, false /* isOutgoing */, edges);
   }
 
-  TWeightType HeuristicCostEstimate(TVertexType const & /* from */, TVertexType const & /* to */)
+  Weight HeuristicCostEstimate(Vertex const & /* from */, Vertex const & /* to */)
   {
-    return GetAStarWeightZero<TWeightType>();
+    return GetAStarWeightZero<Weight>();
   }
 
 private:
diff --git a/routing/base/astar_algorithm.hpp b/routing/base/astar_algorithm.hpp
index 9ebd2b7e3e..914f85f6a5 100644
--- a/routing/base/astar_algorithm.hpp
+++ b/routing/base/astar_algorithm.hpp
@@ -15,14 +15,13 @@
 
 namespace routing
 {
-template <typename TGraph>
+template <typename Graph>
 class AStarAlgorithm
 {
 public:
-  using TGraphType = TGraph;
-  using TVertexType = typename TGraphType::TVertexType;
-  using TEdgeType = typename TGraphType::TEdgeType;
-  using TWeightType = typename TGraphType::TWeightType;
+  using Vertex = typename Graph::Vertex;
+  using Edge = typename Graph::Edge;
+  using Weight = typename Graph::Weight;
 
   enum class Result
   {
@@ -48,11 +47,11 @@ public:
     return os;
   }
 
-  using OnVisitedVertexCallback = std::function<void(TVertexType const &, TVertexType const &)>;
+  using OnVisitedVertexCallback = std::function<void(Vertex const &, Vertex const &)>;
   // Callback used to check path length from start/finish to the edge (including the edge itself)
   // before adding the edge to AStar queue.
   // Can be used to clip some path which does not meet restrictions.
-  using CheckLengthCallback = std::function<bool(TWeightType const &)>;
+  using CheckLengthCallback = std::function<bool(Weight const &)>;
 
   class Context final
   {
@@ -63,12 +62,12 @@ public:
       m_parents.clear();
     }
 
-    bool HasDistance(TVertexType const & vertex) const
+    bool HasDistance(Vertex const & vertex) const
     {
       return m_distanceMap.find(vertex) != m_distanceMap.cend();
     }
 
-    TWeightType GetDistance(TVertexType const & vertex) const
+    Weight GetDistance(Vertex const & vertex) const
     {
       auto const & it = m_distanceMap.find(vertex);
       if (it == m_distanceMap.cend())
@@ -77,52 +76,48 @@ public:
       return it->second;
     }
 
-    void SetDistance(TVertexType const & vertex, TWeightType const & distance)
+    void SetDistance(Vertex const & vertex, Weight const & distance)
     {
       m_distanceMap[vertex] = distance;
     }
 
-    void SetParent(TVertexType const & parent, TVertexType const & child)
-    {
-      m_parents[parent] = child;
-    }
+    void SetParent(Vertex const & parent, Vertex const & child) { m_parents[parent] = child; }
 
-    void ReconstructPath(TVertexType const & v, std::vector<TVertexType> & path) const;
+    void ReconstructPath(Vertex const & v, std::vector<Vertex> & path) const;
 
   private:
-    std::map<TVertexType, TWeightType> m_distanceMap;
-    std::map<TVertexType, TVertexType> m_parents;
+    std::map<Vertex, Weight> m_distanceMap;
+    std::map<Vertex, Vertex> m_parents;
   };
 
   // VisitVertex returns true: wave will continue
   // VisitVertex returns false: wave will stop
   template <typename VisitVertex, typename AdjustEdgeWeight, typename FilterStates>
-  void PropagateWave(TGraphType & graph, TVertexType const & startVertex,
-                     VisitVertex && visitVertex, AdjustEdgeWeight && adjustEdgeWeight,
-                     FilterStates && filterStates, Context & context) const;
+  void PropagateWave(Graph & graph, Vertex const & startVertex, VisitVertex && visitVertex,
+                     AdjustEdgeWeight && adjustEdgeWeight, FilterStates && filterStates,
+                     Context & context) const;
 
   template <typename VisitVertex>
-  void PropagateWave(TGraphType & graph, TVertexType const & startVertex,
-                     VisitVertex && visitVertex, Context & context) const;
+  void PropagateWave(Graph & graph, Vertex const & startVertex, VisitVertex && visitVertex,
+                     Context & context) const;
 
-  Result FindPath(TGraphType & graph, TVertexType const & startVertex,
-                  TVertexType const & finalVertex, RoutingResult<TVertexType, TWeightType> & result,
+  Result FindPath(Graph & graph, Vertex const & startVertex, Vertex const & finalVertex,
+                  RoutingResult<Vertex, Weight> & result,
                   my::Cancellable const & cancellable = my::Cancellable(),
                   OnVisitedVertexCallback onVisitedVertexCallback = {},
                   CheckLengthCallback checkLengthCallback = {}) const;
 
-  Result FindPathBidirectional(TGraphType & graph, TVertexType const & startVertex,
-                               TVertexType const & finalVertex,
-                               RoutingResult<TVertexType, TWeightType> & result,
+  Result FindPathBidirectional(Graph & graph, Vertex const & startVertex,
+                               Vertex const & finalVertex, RoutingResult<Vertex, Weight> & result,
                                my::Cancellable const & cancellable = my::Cancellable(),
                                OnVisitedVertexCallback onVisitedVertexCallback = {},
                                CheckLengthCallback checkLengthCallback = {}) const;
 
   // Adjust route to the previous one.
   // Expects |checkLengthCallback| to check wave propagation limit.
-  typename AStarAlgorithm<TGraph>::Result AdjustRoute(
-      TGraphType & graph, TVertexType const & startVertex, std::vector<TEdgeType> const & prevRoute,
-      RoutingResult<TVertexType, TWeightType> & result, my::Cancellable const & cancellable,
+  typename AStarAlgorithm<Graph>::Result AdjustRoute(
+      Graph & graph, Vertex const & startVertex, std::vector<Edge> const & prevRoute,
+      RoutingResult<Vertex, Weight> & result, my::Cancellable const & cancellable,
       OnVisitedVertexCallback onVisitedVertexCallback,
       CheckLengthCallback checkLengthCallback) const;
 
@@ -131,9 +126,9 @@ private:
   static uint32_t constexpr kQueueSwitchPeriod = 128;
 
   // Precision of comparison weights.
-  static TWeightType constexpr kEpsilon = GetAStarWeightEpsilon<TWeightType>();
-  static TWeightType constexpr kZeroDistance = GetAStarWeightZero<TWeightType>();
-  static TWeightType constexpr kInfiniteDistance = GetAStarWeightMax<TWeightType>();
+  static Weight constexpr kEpsilon = GetAStarWeightEpsilon<Weight>();
+  static Weight constexpr kZeroDistance = GetAStarWeightZero<Weight>();
+  static Weight constexpr kInfiniteDistance = GetAStarWeightMax<Weight>();
 
   class PeriodicPollCancellable final
   {
@@ -156,15 +151,12 @@ private:
   // comment for FindPath for more information.
   struct State
   {
-    State(TVertexType const & vertex, TWeightType const & distance)
-      : vertex(vertex), distance(distance)
-    {
-    }
+    State(Vertex const & vertex, Weight const & distance) : vertex(vertex), distance(distance) {}
 
     inline bool operator>(State const & rhs) const { return distance > rhs.distance; }
 
-    TVertexType vertex;
-    TWeightType distance;
+    Vertex vertex;
+    Weight distance;
   };
 
   // BidirectionalStepContext keeps all the information that is needed to
@@ -172,17 +164,20 @@ private:
   // purpose is to make the code that changes directions more readable.
   struct BidirectionalStepContext
   {
-    BidirectionalStepContext(bool forward, TVertexType const & startVertex,
-                             TVertexType const & finalVertex, TGraphType & graph)
-        : forward(forward), startVertex(startVertex), finalVertex(finalVertex), graph(graph)
-        , m_piRT(graph.HeuristicCostEstimate(finalVertex, startVertex))
-        , m_piFS(graph.HeuristicCostEstimate(startVertex, finalVertex))
+    BidirectionalStepContext(bool forward, Vertex const & startVertex, Vertex const & finalVertex,
+                             Graph & graph)
+      : forward(forward)
+      , startVertex(startVertex)
+      , finalVertex(finalVertex)
+      , graph(graph)
+      , m_piRT(graph.HeuristicCostEstimate(finalVertex, startVertex))
+      , m_piFS(graph.HeuristicCostEstimate(startVertex, finalVertex))
     {
       bestVertex = forward ? startVertex : finalVertex;
       pS = ConsistentHeuristic(bestVertex);
     }
 
-    TWeightType TopDistance() const
+    Weight TopDistance() const
     {
       ASSERT(!queue.empty(), ());
       return bestDistance.at(queue.top().vertex);
@@ -191,7 +186,7 @@ private:
     // p_f(v) = 0.5*(π_f(v) - π_r(v)) + 0.5*π_r(t)
     // p_r(v) = 0.5*(π_r(v) - π_f(v)) + 0.5*π_f(s)
     // p_r(v) + p_f(v) = const. Note: this condition is called consistence.
-    TWeightType ConsistentHeuristic(TVertexType const & v) const
+    Weight ConsistentHeuristic(Vertex const & v) const
     {
       auto const piF = graph.HeuristicCostEstimate(v, finalVertex);
       auto const piR = graph.HeuristicCostEstimate(v, startVertex);
@@ -209,7 +204,7 @@ private:
       }
     }
 
-    void GetAdjacencyList(TVertexType const & v, std::vector<TEdgeType> & adj)
+    void GetAdjacencyList(Vertex const & v, std::vector<Edge> & adj)
     {
       if (forward)
         graph.GetOutgoingEdgesList(v, adj);
@@ -218,43 +213,42 @@ private:
     }
 
     bool const forward;
-    TVertexType const & startVertex;
-    TVertexType const & finalVertex;
-    TGraph & graph;
-    TWeightType const m_piRT;
-    TWeightType const m_piFS;
+    Vertex const & startVertex;
+    Vertex const & finalVertex;
+    Graph & graph;
+    Weight const m_piRT;
+    Weight const m_piFS;
 
     std::priority_queue<State, std::vector<State>, std::greater<State>> queue;
-    std::map<TVertexType, TWeightType> bestDistance;
-    std::map<TVertexType, TVertexType> parent;
-    TVertexType bestVertex;
+    std::map<Vertex, Weight> bestDistance;
+    std::map<Vertex, Vertex> parent;
+    Vertex bestVertex;
 
-    TWeightType pS;
+    Weight pS;
   };
 
-  static void ReconstructPath(TVertexType const & v,
-                              std::map<TVertexType, TVertexType> const & parent,
-                              std::vector<TVertexType> & path);
-  static void ReconstructPathBidirectional(TVertexType const & v, TVertexType const & w,
-                                           std::map<TVertexType, TVertexType> const & parentV,
-                                           std::map<TVertexType, TVertexType> const & parentW,
-                                           std::vector<TVertexType> & path);
+  static void ReconstructPath(Vertex const & v, std::map<Vertex, Vertex> const & parent,
+                              std::vector<Vertex> & path);
+  static void ReconstructPathBidirectional(Vertex const & v, Vertex const & w,
+                                           std::map<Vertex, Vertex> const & parentV,
+                                           std::map<Vertex, Vertex> const & parentW,
+                                           std::vector<Vertex> & path);
 };
 
-template <typename TGraph>
-constexpr typename TGraph::TWeightType AStarAlgorithm<TGraph>::kEpsilon;
-template <typename TGraph>
-constexpr typename TGraph::TWeightType AStarAlgorithm<TGraph>::kInfiniteDistance;
-template <typename TGraph>
-constexpr typename TGraph::TWeightType AStarAlgorithm<TGraph>::kZeroDistance;
+template <typename Graph>
+constexpr typename Graph::Weight AStarAlgorithm<Graph>::kEpsilon;
+template <typename Graph>
+constexpr typename Graph::Weight AStarAlgorithm<Graph>::kInfiniteDistance;
+template <typename Graph>
+constexpr typename Graph::Weight AStarAlgorithm<Graph>::kZeroDistance;
 
-template <typename TGraph>
+template <typename Graph>
 template <typename VisitVertex, typename AdjustEdgeWeight, typename FilterStates>
-void AStarAlgorithm<TGraph>::PropagateWave(TGraphType & graph, TVertexType const & startVertex,
-                                           VisitVertex && visitVertex,
-                                           AdjustEdgeWeight && adjustEdgeWeight,
-                                           FilterStates && filterStates,
-                                           AStarAlgorithm<TGraph>::Context & context) const
+void AStarAlgorithm<Graph>::PropagateWave(Graph & graph, Vertex const & startVertex,
+                                          VisitVertex && visitVertex,
+                                          AdjustEdgeWeight && adjustEdgeWeight,
+                                          FilterStates && filterStates,
+                                          AStarAlgorithm<Graph>::Context & context) const
 {
   context.Clear();
 
@@ -263,7 +257,7 @@ void AStarAlgorithm<TGraph>::PropagateWave(TGraphType & graph, TVertexType const
   context.SetDistance(startVertex, kZeroDistance);
   queue.push(State(startVertex, kZeroDistance));
 
-  std::vector<TEdgeType> adj;
+  std::vector<Edge> adj;
 
   while (!queue.empty())
   {
@@ -301,13 +295,13 @@ void AStarAlgorithm<TGraph>::PropagateWave(TGraphType & graph, TVertexType const
   }
 }
 
-template <typename TGraph>
+template <typename Graph>
 template <typename VisitVertex>
-void AStarAlgorithm<TGraph>::PropagateWave(TGraphType & graph, TVertexType const & startVertex,
-                                           VisitVertex && visitVertex,
-                                           AStarAlgorithm<TGraph>::Context & context) const
+void AStarAlgorithm<Graph>::PropagateWave(Graph & graph, Vertex const & startVertex,
+                                          VisitVertex && visitVertex,
+                                          AStarAlgorithm<Graph>::Context & context) const
 {
-  auto const adjustEdgeWeight = [](TVertexType const & /* vertex */, TEdgeType const & edge) {
+  auto const adjustEdgeWeight = [](Vertex const & /* vertex */, Edge const & edge) {
     return edge.GetWeight();
   };
   auto const filterStates = [](State const & /* state */) { return true; };
@@ -325,39 +319,39 @@ void AStarAlgorithm<TGraph>::PropagateWave(TGraphType & graph, TVertexType const
 // http://research.microsoft.com/pubs/154937/soda05.pdf
 // http://www.cs.princeton.edu/courses/archive/spr06/cos423/Handouts/EPP%20shortest%20path%20algorithms.pdf
 
-template <typename TGraph>
-typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::FindPath(
-    TGraphType & graph, TVertexType const & startVertex, TVertexType const & finalVertex,
-    RoutingResult<TVertexType, TWeightType> & result, my::Cancellable const & cancellable,
+template <typename Graph>
+typename AStarAlgorithm<Graph>::Result AStarAlgorithm<Graph>::FindPath(
+    Graph & graph, Vertex const & startVertex, Vertex const & finalVertex,
+    RoutingResult<Vertex, Weight> & result, my::Cancellable const & cancellable,
     OnVisitedVertexCallback onVisitedVertexCallback, CheckLengthCallback checkLengthCallback) const
 {
   result.Clear();
   if (onVisitedVertexCallback == nullptr)
-    onVisitedVertexCallback = [](TVertexType const &, TVertexType const &) {};
+    onVisitedVertexCallback = [](Vertex const &, Vertex const &) {};
 
   if (checkLengthCallback == nullptr)
-    checkLengthCallback = [](TWeightType const & /* weight */) { return true; };
+    checkLengthCallback = [](Weight const & /* weight */) { return true; };
 
   Context context;
   PeriodicPollCancellable periodicCancellable(cancellable);
   Result resultCode = Result::NoPath;
 
-  auto const heuristicDiff = [&](TVertexType const & vertexFrom, TVertexType const & vertexTo) {
+  auto const heuristicDiff = [&](Vertex const & vertexFrom, Vertex const & vertexTo) {
     return graph.HeuristicCostEstimate(vertexFrom, finalVertex) -
            graph.HeuristicCostEstimate(vertexTo, finalVertex);
   };
 
-  auto const fullToReducedLength = [&](TVertexType const & vertexFrom, TVertexType const & vertexTo,
-                                       TWeightType const length) {
+  auto const fullToReducedLength = [&](Vertex const & vertexFrom, Vertex const & vertexTo,
+                                       Weight const length) {
     return length - heuristicDiff(vertexFrom, vertexTo);
   };
 
-  auto const reducedToFullLength = [&](TVertexType const & vertexFrom, TVertexType const & vertexTo,
-                                       TWeightType const reducedLength) {
+  auto const reducedToFullLength = [&](Vertex const & vertexFrom, Vertex const & vertexTo,
+                                       Weight const reducedLength) {
     return reducedLength + heuristicDiff(vertexFrom, vertexTo);
   };
 
-  auto visitVertex = [&](TVertexType const & vertex) {
+  auto visitVertex = [&](Vertex const & vertex) {
     if (periodicCancellable.IsCancelled())
     {
       resultCode = Result::Cancelled;
@@ -375,7 +369,7 @@ typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::FindPath(
     return true;
   };
 
-  auto const adjustEdgeWeight = [&](TVertexType const & vertexV, TEdgeType const & edge) {
+  auto const adjustEdgeWeight = [&](Vertex const & vertexV, Edge const & edge) {
     auto const reducedWeight = fullToReducedLength(vertexV, edge.GetTarget(), edge.GetWeight());
 
     CHECK_GREATER_OR_EQUAL(reducedWeight, -kEpsilon, ("Invariant violated."));
@@ -402,17 +396,17 @@ typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::FindPath(
   return resultCode;
 }
 
-template <typename TGraph>
-typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::FindPathBidirectional(
-    TGraphType & graph, TVertexType const & startVertex, TVertexType const & finalVertex,
-    RoutingResult<TVertexType, TWeightType> & result, my::Cancellable const & cancellable,
+template <typename Graph>
+typename AStarAlgorithm<Graph>::Result AStarAlgorithm<Graph>::FindPathBidirectional(
+    Graph & graph, Vertex const & startVertex, Vertex const & finalVertex,
+    RoutingResult<Vertex, Weight> & result, my::Cancellable const & cancellable,
     OnVisitedVertexCallback onVisitedVertexCallback, CheckLengthCallback checkLengthCallback) const
 {
   if (onVisitedVertexCallback == nullptr)
-    onVisitedVertexCallback = [](TVertexType const &, TVertexType const &){};
+    onVisitedVertexCallback = [](Vertex const &, Vertex const &) {};
 
   if (checkLengthCallback == nullptr)
-    checkLengthCallback = [](TWeightType const & /* weight */) { return true; };
+    checkLengthCallback = [](Weight const & /* weight */) { return true; };
 
   BidirectionalStepContext forward(true /* forward */, startVertex, finalVertex, graph);
   BidirectionalStepContext backward(false /* forward */, startVertex, finalVertex, graph);
@@ -434,7 +428,7 @@ typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::FindPathBidirect
   BidirectionalStepContext * cur = &forward;
   BidirectionalStepContext * nxt = &backward;
 
-  std::vector<TEdgeType> adj;
+  std::vector<Edge> adj;
 
   // It is not necessary to check emptiness for both queues here
   // because if we have not found a path by the time one of the
@@ -546,10 +540,10 @@ typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::FindPathBidirect
   return Result::NoPath;
 }
 
-template <typename TGraph>
-typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::AdjustRoute(
-    TGraphType & graph, TVertexType const & startVertex, std::vector<TEdgeType> const & prevRoute,
-    RoutingResult<TVertexType, TWeightType> & result, my::Cancellable const & cancellable,
+template <typename Graph>
+typename AStarAlgorithm<Graph>::Result AStarAlgorithm<Graph>::AdjustRoute(
+    Graph & graph, Vertex const & startVertex, std::vector<Edge> const & prevRoute,
+    RoutingResult<Vertex, Weight> & result, my::Cancellable const & cancellable,
     OnVisitedVertexCallback onVisitedVertexCallback, CheckLengthCallback checkLengthCallback) const
 {
   CHECK(!prevRoute.empty(), ());
@@ -559,13 +553,13 @@ typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::AdjustRoute(
 
   result.Clear();
   if (onVisitedVertexCallback == nullptr)
-    onVisitedVertexCallback = [](TVertexType const &, TVertexType const &) {};
+    onVisitedVertexCallback = [](Vertex const &, Vertex const &) {};
 
   bool wasCancelled = false;
   auto minDistance = kInfiniteDistance;
-  TVertexType returnVertex;
+  Vertex returnVertex;
 
-  std::map<TVertexType, TWeightType> remainingDistances;
+  std::map<Vertex, Weight> remainingDistances;
   auto remainingDistance = kZeroDistance;
 
   for (auto it = prevRoute.crbegin(); it != prevRoute.crend(); ++it)
@@ -577,7 +571,7 @@ typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::AdjustRoute(
   Context context;
   PeriodicPollCancellable periodicCancellable(cancellable);
 
-  auto visitVertex = [&](TVertexType const & vertex) {
+  auto visitVertex = [&](Vertex const & vertex) {
 
     if (periodicCancellable.IsCancelled())
     {
@@ -601,7 +595,7 @@ typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::AdjustRoute(
     return true;
   };
 
-  auto const adjustEdgeWeight = [](TVertexType const & /* vertex */, TEdgeType const & edge) {
+  auto const adjustEdgeWeight = [](Vertex const & /* vertex */, Edge const & edge) {
     return edge.GetWeight();
   };
 
@@ -642,13 +636,13 @@ typename AStarAlgorithm<TGraph>::Result AStarAlgorithm<TGraph>::AdjustRoute(
 }
 
 // static
-template <typename TGraph>
-void AStarAlgorithm<TGraph>::ReconstructPath(TVertexType const & v,
-                                             std::map<TVertexType, TVertexType> const & parent,
-                                             std::vector<TVertexType> & path)
+template <typename Graph>
+void AStarAlgorithm<Graph>::ReconstructPath(Vertex const & v,
+                                            std::map<Vertex, Vertex> const & parent,
+                                            std::vector<Vertex> & path)
 {
   path.clear();
-  TVertexType cur = v;
+  Vertex cur = v;
   while (true)
   {
     path.push_back(cur);
@@ -661,15 +655,15 @@ void AStarAlgorithm<TGraph>::ReconstructPath(TVertexType const & v,
 }
 
 // static
-template <typename TGraph>
-void AStarAlgorithm<TGraph>::ReconstructPathBidirectional(
-    TVertexType const & v, TVertexType const & w,
-    std::map<TVertexType, TVertexType> const & parentV,
-    std::map<TVertexType, TVertexType> const & parentW, std::vector<TVertexType> & path)
+template <typename Graph>
+void AStarAlgorithm<Graph>::ReconstructPathBidirectional(Vertex const & v, Vertex const & w,
+                                                         std::map<Vertex, Vertex> const & parentV,
+                                                         std::map<Vertex, Vertex> const & parentW,
+                                                         std::vector<Vertex> & path)
 {
-  std::vector<TVertexType> pathV;
+  std::vector<Vertex> pathV;
   ReconstructPath(v, parentV, pathV);
-  std::vector<TVertexType> pathW;
+  std::vector<Vertex> pathW;
   ReconstructPath(w, parentW, pathW);
   path.clear();
   path.reserve(pathV.size() + pathW.size());
@@ -677,10 +671,10 @@ void AStarAlgorithm<TGraph>::ReconstructPathBidirectional(
   path.insert(path.end(), pathW.rbegin(), pathW.rend());
 }
 
-template <typename TGraph>
-void AStarAlgorithm<TGraph>::Context::ReconstructPath(TVertexType const & v,
-                                                      std::vector<TVertexType> & path) const
+template <typename Graph>
+void AStarAlgorithm<Graph>::Context::ReconstructPath(Vertex const & v,
+                                                     std::vector<Vertex> & path) const
 {
-  AStarAlgorithm<TGraph>::ReconstructPath(v, m_parents, path);
+  AStarAlgorithm<Graph>::ReconstructPath(v, m_parents, path);
 }
 }  // namespace routing
diff --git a/routing/base/astar_weight.hpp b/routing/base/astar_weight.hpp
index 2d8c725462..8779a59b3f 100644
--- a/routing/base/astar_weight.hpp
+++ b/routing/base/astar_weight.hpp
@@ -4,8 +4,8 @@
 
 namespace routing
 {
-template <typename WeightType>
-constexpr WeightType GetAStarWeightZero();
+template <typename Weight>
+constexpr Weight GetAStarWeightZero();
 
 template <>
 constexpr double GetAStarWeightZero<double>()
@@ -14,8 +14,8 @@ constexpr double GetAStarWeightZero<double>()
 }
 
 // Precision of comparison weights.
-template <typename WeightType>
-constexpr WeightType GetAStarWeightEpsilon();
+template <typename Weight>
+constexpr Weight GetAStarWeightEpsilon();
 
 template <>
 constexpr double GetAStarWeightEpsilon<double>()
@@ -23,8 +23,8 @@ constexpr double GetAStarWeightEpsilon<double>()
   return 1e-6;
 }
 
-template <typename WeightType>
-constexpr WeightType GetAStarWeightMax();
+template <typename Weight>
+constexpr Weight GetAStarWeightMax();
 
 template <>
 constexpr double GetAStarWeightMax<double>()
diff --git a/routing/base/routing_result.hpp b/routing/base/routing_result.hpp
index 0cdcadb696..164afdaa33 100644
--- a/routing/base/routing_result.hpp
+++ b/routing/base/routing_result.hpp
@@ -6,18 +6,18 @@
 
 namespace routing
 {
-template <typename VertexType, typename WeightType>
+template <typename Vertex, typename Weight>
 struct RoutingResult final
 {
-  RoutingResult() : m_distance(GetAStarWeightZero<WeightType>()) {}
+  RoutingResult() : m_distance(GetAStarWeightZero<Weight>()) {}
 
   void Clear()
   {
     m_path.clear();
-    m_distance = GetAStarWeightZero<WeightType>();
+    m_distance = GetAStarWeightZero<Weight>();
   }
 
-  std::vector<VertexType> m_path;
-  WeightType m_distance;
+  std::vector<Vertex> m_path;
+  Weight m_distance;
 };
 }  // namespace routing
diff --git a/routing/cross_mwm_road_graph.cpp b/routing/cross_mwm_road_graph.cpp
index 762bee4d76..26be45db2d 100644
--- a/routing/cross_mwm_road_graph.cpp
+++ b/routing/cross_mwm_road_graph.cpp
@@ -124,7 +124,7 @@ bool FindCrossNode(CrossRoutingContextReader const & currentContext, CrossNode c
 template <class Fn>
 vector<BorderCross> const & ConstructBorderCrossImpl(
     TWrittenNodeId nodeId, TRoutingMappingPtr const & currentMapping,
-    unordered_map<CrossMwmRoadGraph::TCachingKey, vector<BorderCross>,
+    unordered_map<CrossMwmRoadGraph::CachingKey, vector<BorderCross>,
                   CrossMwmRoadGraph::Hash> const & cachedNextNodes,
     Fn && borderCrossConstructor)
 {
diff --git a/routing/cross_mwm_road_graph.hpp b/routing/cross_mwm_road_graph.hpp
index 271fddc943..0b9d3bd741 100644
--- a/routing/cross_mwm_road_graph.hpp
+++ b/routing/cross_mwm_road_graph.hpp
@@ -123,14 +123,14 @@ private:
 class CrossMwmRoadGraph final
 {
 public:
-  using TCachingKey = pair<TWrittenNodeId, Index::MwmId>;
-  using TVertexType = BorderCross;
-  using TEdgeType = CrossWeightedEdge;
-  using TWeightType = double;
+  using CachingKey = pair<TWrittenNodeId, Index::MwmId>;
+  using Vertex = BorderCross;
+  using Edge = CrossWeightedEdge;
+  using Weight = double;
 
   struct Hash
   {
-    size_t operator()(TCachingKey const & p) const
+    size_t operator()(CachingKey const & p) const
     {
       return hash<TWrittenNodeId>()(p.first) ^ hash<string>()(p.second.GetInfo()->GetCountryName());
     }
@@ -181,8 +181,8 @@ private:
   mutable RoutingIndexManager m_indexManager;
 
   // @TODO(bykoianko) Consider removing key work mutable.
-  mutable unordered_map<TCachingKey, vector<BorderCross>, Hash> m_cachedNextNodesByIngoing;
-  mutable unordered_map<TCachingKey, vector<BorderCross>, Hash> m_cachedNextNodesByOutgoing;
+  mutable unordered_map<CachingKey, vector<BorderCross>, Hash> m_cachedNextNodesByIngoing;
+  mutable unordered_map<CachingKey, vector<BorderCross>, Hash> m_cachedNextNodesByOutgoing;
 };
 
 //--------------------------------------------------------------------------------------------------
diff --git a/routing/cross_mwm_router.cpp b/routing/cross_mwm_router.cpp
index 5fbfd9a5eb..8a28033d77 100644
--- a/routing/cross_mwm_router.cpp
+++ b/routing/cross_mwm_router.cpp
@@ -14,7 +14,7 @@ namespace
 /// Function to run AStar Algorithm from the base.
 IRouter::ResultCode CalculateRoute(BorderCross const & startPos, BorderCross const & finalPos,
                                    CrossMwmRoadGraph & roadGraph, RouterDelegate const & delegate,
-                                   RoutingResult<BorderCross, double /* WeightType */> & route)
+                                   RoutingResult<BorderCross, double /* Weight */> & route)
 {
   using TAlgorithm = AStarAlgorithm<CrossMwmRoadGraph>;
 
@@ -91,7 +91,7 @@ IRouter::ResultCode CalculateCrossMwmPath(TRoutingNodes const & startGraphNodes,
     return IRouter::EndPointNotFound;
 
   // Finding path through maps.
-  RoutingResult<BorderCross, double /* WeightType */> tempRoad;
+  RoutingResult<BorderCross, double /* Weight */> tempRoad;
   code = CalculateRoute({startNode, startNode}, {finalNode, finalNode}, roadGraph, delegate, tempRoad);
   cost = tempRoad.m_distance;
   if (code != IRouter::NoError)
diff --git a/routing/index_graph.hpp b/routing/index_graph.hpp
index 7d65f5ee70..a448d1659e 100644
--- a/routing/index_graph.hpp
+++ b/routing/index_graph.hpp
@@ -24,9 +24,9 @@ class IndexGraph final
 {
 public:
   // AStarAlgorithm types aliases:
-  using TVertexType = Segment;
-  using TEdgeType = SegmentEdge;
-  using TWeightType = RouteWeight;
+  using Vertex = Segment;
+  using Edge = SegmentEdge;
+  using Weight = RouteWeight;
 
   IndexGraph() = default;
   explicit IndexGraph(unique_ptr<GeometryLoader> loader, shared_ptr<EdgeEstimator> estimator);
diff --git a/routing/index_graph_starter.hpp b/routing/index_graph_starter.hpp
index d874eca965..e849b619a2 100644
--- a/routing/index_graph_starter.hpp
+++ b/routing/index_graph_starter.hpp
@@ -30,9 +30,9 @@ class IndexGraphStarter final
 {
 public:
   // AStarAlgorithm types aliases:
-  using TVertexType = IndexGraph::TVertexType;
-  using TEdgeType = IndexGraph::TEdgeType;
-  using TWeightType = IndexGraph::TWeightType;
+  using Vertex = IndexGraph::Vertex;
+  using Edge = IndexGraph::Edge;
+  using Weight = IndexGraph::Weight;
 
   friend class FakeEdgesContainer;
 
@@ -81,17 +81,17 @@ public:
   void GetEdgesList(Segment const & segment, bool isOutgoing,
                     std::vector<SegmentEdge> & edges) const;
 
-  void GetOutgoingEdgesList(TVertexType const & segment, std::vector<TEdgeType> & edges) const
+  void GetOutgoingEdgesList(Vertex const & segment, std::vector<Edge> & edges) const
   {
     GetEdgesList(segment, true /* isOutgoing */, edges);
   }
 
-  void GetIngoingEdgesList(TVertexType const & segment, std::vector<TEdgeType> & edges) const
+  void GetIngoingEdgesList(Vertex const & segment, std::vector<Edge> & edges) const
   {
     GetEdgesList(segment, false /* isOutgoing */, edges);
   }
 
-  RouteWeight HeuristicCostEstimate(TVertexType const & from, TVertexType const & to) const
+  RouteWeight HeuristicCostEstimate(Vertex const & from, Vertex const & to) const
   {
     return m_graph.HeuristicCostEstimate(GetPoint(from, true /* front */),
                                          GetPoint(to, true /* front */));
diff --git a/routing/index_router.cpp b/routing/index_router.cpp
index 358c48c94c..055ad7a152 100644
--- a/routing/index_router.cpp
+++ b/routing/index_router.cpp
@@ -136,11 +136,11 @@ IRouter::ResultCode ConvertResult(typename AStarAlgorithm<Graph>::Result result)
 
 template <typename Graph>
 IRouter::ResultCode FindPath(
-    typename Graph::TVertexType const & start, typename Graph::TVertexType const & finish,
+    typename Graph::Vertex const & start, typename Graph::Vertex const & finish,
     RouterDelegate const & delegate, Graph & graph,
     typename AStarAlgorithm<Graph>::OnVisitedVertexCallback const & onVisitedVertexCallback,
     typename AStarAlgorithm<Graph>::CheckLengthCallback const & checkLengthCallback,
-    RoutingResult<typename Graph::TVertexType, typename Graph::TWeightType> & routingResult)
+    RoutingResult<typename Graph::Vertex, typename Graph::Weight> & routingResult)
 {
   AStarAlgorithm<Graph> algorithm;
   return ConvertResult<Graph>(algorithm.FindPathBidirectional(
diff --git a/routing/road_graph_router.cpp b/routing/road_graph_router.cpp
index 16b640b24d..d5ce2fbed4 100644
--- a/routing/road_graph_router.cpp
+++ b/routing/road_graph_router.cpp
@@ -193,7 +193,7 @@ IRouter::ResultCode RoadGraphRouter::CalculateRoute(Checkpoints const & checkpoi
   m_roadGraph->AddFakeEdges(startPos, startVicinity);
   m_roadGraph->AddFakeEdges(finalPos, finalVicinity);
 
-  RoutingResult<Junction, double /* WeightType */> result;
+  RoutingResult<Junction, double /* Weight */> result;
   IRoutingAlgorithm::Result const resultCode =
       m_algorithm->CalculateRoute(*m_roadGraph, startPos, finalPos, delegate, result);
 
diff --git a/routing/routing_algorithm.cpp b/routing/routing_algorithm.cpp
index 3323122289..7458b94b68 100644
--- a/routing/routing_algorithm.cpp
+++ b/routing/routing_algorithm.cpp
@@ -49,9 +49,9 @@ private:
 class RoadGraph
 {
 public:
-  using TVertexType = Junction;
-  using TEdgeType = WeightedEdge;
-  using TWeightType = double;
+  using Vertex = Junction;
+  using Edge = WeightedEdge;
+  using Weight = double;
 
   RoadGraph(IRoadGraph const & roadGraph)
     : m_roadGraph(roadGraph)
diff --git a/routing/routing_tests/astar_algorithm_test.cpp b/routing/routing_tests/astar_algorithm_test.cpp
index 99bace87e1..b3012c98bc 100644
--- a/routing/routing_tests/astar_algorithm_test.cpp
+++ b/routing/routing_tests/astar_algorithm_test.cpp
@@ -26,9 +26,9 @@ struct Edge
 class UndirectedGraph
 {
 public:
-  using TVertexType = unsigned;
-  using TEdgeType = Edge;
-  using TWeightType = double;
+  using Vertex = unsigned;
+  using Edge = Edge;
+  using Weight = double;
 
   void AddEdge(unsigned u, unsigned v, unsigned w)
   {
@@ -66,7 +66,7 @@ void TestAStar(UndirectedGraph & graph, vector<unsigned> const & expectedRoute,
 {
   TAlgorithm algo;
 
-  RoutingResult<unsigned /* VertexType */, double /* WeightType */> actualRoute;
+  RoutingResult<unsigned /* Vertex */, double /* Weight */> actualRoute;
   TEST_EQUAL(TAlgorithm::Result::OK, algo.FindPath(graph, 0u, 4u, actualRoute), ());
   TEST_EQUAL(expectedRoute, actualRoute.m_path, ());
   TEST_ALMOST_EQUAL_ULPS(expectedDistance, actualRoute.m_distance, ());
@@ -105,7 +105,7 @@ UNIT_TEST(AStarAlgorithm_CheckLength)
   graph.AddEdge(3, 4, 3);
 
   TAlgorithm algo;
-  RoutingResult<unsigned /* VertexType */, double /* WeightType */> routingResult;
+  RoutingResult<unsigned /* Vertex */, double /* Weight */> routingResult;
   TAlgorithm::Result result =
       algo.FindPath(graph, 0u, 4u, routingResult, {} /* cancellable */,
                     {} /* onVisitedVertexCallback */, [](double weight) { return weight < 23; });
@@ -135,7 +135,7 @@ UNIT_TEST(AdjustRoute)
   vector<Edge> const prevRoute = {{0, 0}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}};
 
   TAlgorithm algo;
-  RoutingResult<unsigned /* VertexType */, double /* WeightType */> result;
+  RoutingResult<unsigned /* Vertex */, double /* Weight */> result;
   auto code = algo.AdjustRoute(graph, 6 /* start */, prevRoute, result,
                                my::Cancellable(), nullptr /* onVisitedVertexCallback */,
                                [](double weight){ return weight <= 1.0; });
@@ -157,7 +157,7 @@ UNIT_TEST(AdjustRouteNoPath)
   vector<Edge> const prevRoute = {{0, 0}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}};
 
   TAlgorithm algo;
-  RoutingResult<unsigned /* VertexType */, double /* WeightType */> result;
+  RoutingResult<unsigned /* Vertex */, double /* Weight */> result;
   auto code = algo.AdjustRoute(graph, 6 /* start */, prevRoute, result,
                                my::Cancellable(), nullptr /* onVisitedVertexCallback */,
                                [](double weight){ return weight <= 1.0; });
@@ -179,7 +179,7 @@ UNIT_TEST(AdjustRouteOutOfLimit)
   vector<Edge> const prevRoute = {{0, 0}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}};
 
   TAlgorithm algo;
-  RoutingResult<unsigned /* VertexType */, double /* WeightType */> result;
+  RoutingResult<unsigned /* Vertex */, double /* Weight */> result;
   auto code = algo.AdjustRoute(graph, 6 /* start */, prevRoute, result,
                                my::Cancellable(), nullptr /* onVisitedVertexCallback */,
                                [](double weight){ return weight <= 1.0; });
diff --git a/routing/routing_tests/astar_router_test.cpp b/routing/routing_tests/astar_router_test.cpp
index 0127a0485e..1b41e723e0 100644
--- a/routing/routing_tests/astar_router_test.cpp
+++ b/routing/routing_tests/astar_router_test.cpp
@@ -30,7 +30,7 @@ void TestAStarRouterMock(Junction const & startPos, Junction const & finalPos,
   InitRoadGraphMockSourceWithTest2(graph);
 
   RouterDelegate delegate;
-  RoutingResult<Junction, double /* WeightType */> result;
+  RoutingResult<Junction, double /* Weight */> result;
   TRoutingAlgorithm algorithm;
   TEST_EQUAL(TRoutingAlgorithm::Result::OK,
              algorithm.CalculateRoute(graph, startPos, finalPos, delegate, result), ());
@@ -98,7 +98,7 @@ UNIT_TEST(AStarRouter_SimpleGraph_RouteIsFound)
       MakeJunctionForTesting(m2::PointD(0, 60)), MakeJunctionForTesting(m2::PointD(40, 100))};
 
   RouterDelegate delegate;
-  RoutingResult<Junction, double /* WeightType */> result;
+  RoutingResult<Junction, double /* Weight */> result;
   TRoutingAlgorithm algorithm;
   TEST_EQUAL(TRoutingAlgorithm::Result::OK,
              algorithm.CalculateRoute(graph, startPos, finalPos, delegate, result), ());
@@ -167,7 +167,7 @@ UNIT_TEST(AStarRouter_SimpleGraph_RoutesInConnectedComponents)
     {
       RouterDelegate delegate;
       Junction const finalPos = roadInfo_2[j].m_junctions[0];
-      RoutingResult<Junction, double /* WeightType */> result;
+      RoutingResult<Junction, double /* Weight */> result;
       TEST_EQUAL(TRoutingAlgorithm::Result::NoPath,
                  algorithm.CalculateRoute(graph, startPos, finalPos, delegate, result), ());
       TEST_EQUAL(TRoutingAlgorithm::Result::NoPath,
@@ -183,7 +183,7 @@ UNIT_TEST(AStarRouter_SimpleGraph_RoutesInConnectedComponents)
     {
       RouterDelegate delegate;
       Junction const finalPos = roadInfo_1[j].m_junctions[0];
-      RoutingResult<Junction, double /* WeightType */> result;
+      RoutingResult<Junction, double /* Weight */> result;
       TEST_EQUAL(TRoutingAlgorithm::Result::OK,
                  algorithm.CalculateRoute(graph, startPos, finalPos, delegate, result), ());
       TEST_EQUAL(TRoutingAlgorithm::Result::OK,
@@ -199,7 +199,7 @@ UNIT_TEST(AStarRouter_SimpleGraph_RoutesInConnectedComponents)
     {
       RouterDelegate delegate;
       Junction const finalPos = roadInfo_2[j].m_junctions[0];
-      RoutingResult<Junction, double /* WeightType */> result;
+      RoutingResult<Junction, double /* Weight */> result;
       TEST_EQUAL(TRoutingAlgorithm::Result::OK,
                  algorithm.CalculateRoute(graph, startPos, finalPos, delegate, result), ());
       TEST_EQUAL(TRoutingAlgorithm::Result::OK,
@@ -227,7 +227,7 @@ UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad1)
   // path3 = 1/5 + 8/4 + 1/5 = 2.4
 
   RouterDelegate delegate;
-  RoutingResult<Junction, double /* WeightType */> result;
+  RoutingResult<Junction, double /* Weight */> result;
   TRoutingAlgorithm algorithm;
   TEST_EQUAL(TRoutingAlgorithm::Result::OK,
              algorithm.CalculateRoute(graph, MakeJunctionForTesting(m2::PointD(2, 2)),
@@ -262,7 +262,7 @@ UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad2)
   // path3 = 1/5 + 8/4.4 + 1/5 = 2.2
 
   RouterDelegate delegate;
-  RoutingResult<Junction, double /* WeightType */> result;
+  RoutingResult<Junction, double /* Weight */> result;
   TRoutingAlgorithm algorithm;
   TEST_EQUAL(TRoutingAlgorithm::Result::OK,
              algorithm.CalculateRoute(graph, MakeJunctionForTesting(m2::PointD(2, 2)),
@@ -294,7 +294,7 @@ UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad3)
   // path3 = 1/5 + 8/4.9 + 1/5 = 2.03
 
   RouterDelegate delegate;
-  RoutingResult<Junction, double /* WeightType */> result;
+  RoutingResult<Junction, double /* Weight */> result;
   TRoutingAlgorithm algorithm;
   TEST_EQUAL(TRoutingAlgorithm::Result::OK,
              algorithm.CalculateRoute(graph, MakeJunctionForTesting(m2::PointD(2, 2)),
diff --git a/routing/world_graph.hpp b/routing/world_graph.hpp
index c6959f6a56..6f301befd8 100644
--- a/routing/world_graph.hpp
+++ b/routing/world_graph.hpp
@@ -19,14 +19,10 @@ namespace routing
 class WorldGraph
 {
 public:
-  // AStarAlgorithm types aliases:
-  using TVertexType = IndexGraph::TVertexType;
-  using TEdgeType = IndexGraph::TEdgeType;
-  using TWeightType = IndexGraph::TWeightType;
-
-  // CheckGraphConnectivity() types aliases:
-  using Vertex = TVertexType;
-  using Edge = TEdgeType;
+  // AStarAlgorithm and CheckGraphConnectivity() types aliases:
+  using Vertex = IndexGraph::Vertex;
+  using Edge = IndexGraph::Edge;
+  using Weight = IndexGraph::Weight;
 
   enum class Mode
   {