gl: impl tags -> repr tags

Author: SpectraL519

docs/gl/architecture.md

@@ -23,17 +23,17 @@ The [**gl::graph_traits**](../cpp-gl/structgl_1_1graph__traits.md) struct config
 1. **Directionality**: Directed vs. Undirected.
 2. **Vertex Properties**: The data payload attached to each vertex.
 3. **Edge Properties**: The data payload attached to each edge.
-4. **Implementation Tag**: The underlying memory layout (e.g., Adjacency List).
+4. **Representation Tag**: The underlying memory layout (e.g., Adjacency List).
 5. **ID Type**: The integer type used for internal indexing (defaults to `std::uint32_t`).
 
 To reduce boilerplate, the library provides several generic type aliases for the most common configurations:
 
 - Based on the directional tag:
 
-    - [**gl::directed_graph<VP, EP, Impl, IdType>**](../cpp-gl/group__GL-Core.md#typedef-directed_graph)
-    - [**gl::undirected_graph<VP, EP, Impl, IdType>**](../cpp-gl/group__GL-Core.md#typedef-undirected_graph)
+    - [**gl::directed_graph<VP, EP, ReprTag, IdType>**](../cpp-gl/group__GL-Core.md#typedef-directed_graph)
+    - [**gl::undirected_graph<VP, EP, ReprTag, IdType>**](../cpp-gl/group__GL-Core.md#typedef-undirected_graph)
 
-- Based on the implementation tag:
+- Based on the representation tag:
 
     - [**gl::list_graph<Dir, VP, EP, IdType>**](../cpp-gl/group__GL-Core.md#typedef-list_graph)
     - [**gl::flat_list_graph<Dir, VP, EP, IdType>**](../cpp-gl/group__GL-Core.md#typedef-flat_list_graph)
@@ -139,7 +139,7 @@ for (auto neighbor_id : graph.neighbor_ids(source_id)) { // (3)!
 
 ## Graph Representation Models
 
-Choosing the correct memory layout is critical for algorithmic performance. CPP-GL abstracts this choice entirely behind the `ImplTag`, allowing you to swap layouts without altering a single line of traversal code.
+Choosing the correct memory layout is critical for algorithmic performance. CPP-GL abstracts this choice entirely behind the `ReprTag`, allowing you to swap layouts without altering a single line of traversal code.
 
 ### Fundamental Representations
 
@@ -161,21 +161,21 @@ Consider the following graph:
 
 CPP-GL currently categorizes its memory layouts into two primary families based on their underlying memory allocation strategy.
 
-> [!NOTE] All representation model tag types are defined in the `gl::impl` namespace.
+> [!NOTE] All representation model tag types are defined in the `gl::repr` namespace.
 
 #### Standard Models
 
 Heap-allocated, nested structures that prioritize flexibility and dynamic structural modification.
 
-- [**list_t**](../cpp-gl/structgl_1_1impl_1_1list__t.md): A standard Adjacency List model implemented using traditional nested containers (e.g., `std::vector<std::vector<T>>`).
-- [**matrix_t**](../cpp-gl/structgl_1_1impl_1_1matrix__t.md): A standard Adjacency Matrix model implemented using traditional nested containers.
+- [**list_t**](../cpp-gl/structgl_1_1repr_1_1list__t.md): A standard Adjacency List model implemented using traditional nested containers (e.g., `std::vector<std::vector<T>>`).
+- [**matrix_t**](../cpp-gl/structgl_1_1repr_1_1matrix__t.md): A standard Adjacency Matrix model implemented using traditional nested containers.
 
 ### Flat Models
 
 Contiguous 1D memory blocks that prioritize cache locality and maximum traversal speed over modification speed.
 
-- [**flat_list_t**](../cpp-gl/structgl_1_1impl_1_1flat__list__t.md): A flattened Adjacency List model implemented using the generic [**flat_jagged_vector**](../cpp-gl/classgl_1_1flat__jagged__vector.md) data structure.
-- [**flat_matrix_t**](../cpp-gl/structgl_1_1impl_1_1flat__matrix__t.md): A flattened Adjacency Matrix model implemented using the generic [**flat_matrix**](../cpp-gl/classgl_1_1flat__matrix.md) data structure.
+- [**flat_list_t**](../cpp-gl/structgl_1_1repr_1_1flat__list__t.md): A flattened Adjacency List model implemented using the generic [**flat_jagged_vector**](../cpp-gl/classgl_1_1flat__jagged__vector.md) data structure.
+- [**flat_matrix_t**](../cpp-gl/structgl_1_1repr_1_1flat__matrix__t.md): A flattened Adjacency Matrix model implemented using the generic [**flat_matrix**](../cpp-gl/classgl_1_1flat__matrix.md) data structure.
 
 ### Topology Support: Simple Graphs and Multigraphs
 
@@ -204,7 +204,7 @@ Being "edge-aware" means that the internal representation stores the specific `e
 
 #### Standard Memory Models
 
-The standard implementations utilize traditional, nested 2D containers (e.g., `std::vector<std::vector<T>>`).
+The standard model implementations utilize traditional, nested 2D containers (e.g., `std::vector<std::vector<T>>`).
 
 These models are highly flexible. Because the inner containers can grow independently, they handle structural modifications, like adding vertices or edges, gracefully. The trade-off is that the memory is fragmented across the heap, which can lead to cache misses during heavy graph traversals.
 
@@ -250,11 +250,11 @@ Depending on the chosen representation model, the computational complexity of st
 
 ### Choosing the Layout
 
-Selecting the right `ImplTag` is a balance of your specific operational needs - use:
+Selecting the right `ReprTag` is a balance of your specific operational needs - use:
 
-- [**list_t**](../cpp-gl/structgl_1_1impl_1_1list__t.md) for highly dynamic, sparse graphs where the topology changes frequently.
-- [**flat_list_t**](../cpp-gl/structgl_1_1impl_1_1flat__list__t.md) for static, sparse graphs where traversal speed and cache locality are paramount.
-- [**matrix_t**](../cpp-gl/structgl_1_1impl_1_1matrix__t.md) (or [**flat_matrix_t**](../cpp-gl/structgl_1_1impl_1_1flat__matrix__t.md) if structure is entirely static) for highly dense graphs (where $\vert E \vert \approx \vert V \vert^2$) when instant $O(1)$ edge lookups are strictly required and memory footprint is not a bottleneck.
+- [**list_t**](../cpp-gl/structgl_1_1repr_1_1list__t.md) for highly dynamic, sparse graphs where the topology changes frequently.
+- [**flat_list_t**](../cpp-gl/structgl_1_1repr_1_1flat__list__t.md) for static, sparse graphs where traversal speed and cache locality are paramount.
+- [**matrix_t**](../cpp-gl/structgl_1_1repr_1_1matrix__t.md) (or [**flat_matrix_t**](../cpp-gl/structgl_1_1repr_1_1flat__matrix__t.md) if structure is entirely static) for highly dense graphs (where $\vert E \vert \approx \vert V \vert^2$) when instant $O(1)$ edge lookups are strictly required and memory footprint is not a bottleneck.
 
 ---
 

docs/gl/quick_start.md

@@ -23,7 +23,7 @@ int main() {
         gl::directed_t,
         gl::empty_properties,
         gl::weight_property<int>,
-        gl::impl::list_t>;
+        gl::repr::list_t>;
 
     gl::graph<traits_t> graph(5); // (3)!
 

include/gl/algorithm/pathfinding/dijkstra.hpp

@@ -105,9 +105,9 @@ struct dijkstra_search_node {
 /// >
 /// > The time complexity depends on the underlying representation of `GraphType` and the priority queue overhead:
 /// > - **Adjacency List Representations**: \f$O((|V| + |E|) \log |V|)\f$
-/// >   - *Includes:* @ref gl::impl::list_t "list_t" and @ref gl::impl::flat_list_t "flat_list_t".
+/// >   - *Includes:* @ref gl::repr::list_t "list_t" and @ref gl::repr::flat_list_t "flat_list_t".
 /// > - **Adjacency Matrix Representations**: \f$O(|V|^2 + |E| \log |V|)\f$
-/// >   - *Includes:* @ref gl::impl::matrix_t "matrix_t" and @ref gl::impl::flat_matrix_t "flat_matrix_t".
+/// >   - *Includes:* @ref gl::repr::matrix_t "matrix_t" and @ref gl::repr::flat_matrix_t "flat_matrix_t".
 /// >   - *Note:* Iterating over adjacent vertices requires scanning the entire \f$|V|\f$-length matrix row.
 ///
 /// ### Template Parameters

include/gl/algorithm/spanning_tree/prim_mst.hpp

@@ -59,10 +59,10 @@ struct mst_descriptor {
 /// >
 /// > The time complexity depends on the underlying representation of `GraphType` and the queue overhead:
 /// > - **Adjacency List Representations**: \f$O(|E| \log |E|)\f$
-/// >   - *Includes:* @ref gl::impl::list_t "list_t" and @ref gl::impl::flat_list_t "flat_list_t".
+/// >   - *Includes:* @ref gl::repr::list_t "list_t" and @ref gl::repr::flat_list_t "flat_list_t".
 /// >   - *Note:* In simple graphs, this simplifies to \f$O(|E| \log |V|)\f$. However, because list models allow multigraphs, the queue size and operations scale strictly with \f$|E|\f$.
 /// > - **Adjacency Matrix Representations**: \f$O(|V|^2 + |E| \log |V|)\f$
-/// >   - *Includes:* @ref gl::impl::matrix_t "matrix_t" and @ref gl::impl::flat_matrix_t "flat_matrix_t".
+/// >   - *Includes:* @ref gl::repr::matrix_t "matrix_t" and @ref gl::repr::flat_matrix_t "flat_matrix_t".
 /// >   - *Note:* Iterating over incident edges requires scanning the entire \f$|V|\f$-length matrix row. Since matrices represent simple graphs, the heap operations safely simplify to \f$O(\log |V|)\f$.
 ///
 /// ### Template Parameters

include/gl/algorithm/topology/coloring.hpp

@@ -40,9 +40,9 @@ using bicoloring_type = std::vector<binary_color>;
 /// >
 /// > The time complexity depends entirely on the underlying representation of `GraphType`:
 /// > - **Adjacency List Representations**: \f$O(|V| + |E|)\f$
-/// >   - *Includes:* @ref gl::impl::list_t "list_t" and @ref gl::impl::flat_list_t "flat_list_t".
+/// >   - *Includes:* @ref gl::repr::list_t "list_t" and @ref gl::repr::flat_list_t "flat_list_t".
 /// > - **Adjacency Matrix Representations**: \f$O(|V|^2)\f$
-/// >   - *Includes:* @ref gl::impl::matrix_t "matrix_t" and @ref gl::impl::flat_matrix_t "flat_matrix_t".
+/// >   - *Includes:* @ref gl::repr::matrix_t "matrix_t" and @ref gl::repr::flat_matrix_t "flat_matrix_t".
 /// >   - *Note:* Iterating over adjacent vertices requires scanning the entire \f$|V|\f$-length matrix row.
 ///
 /// ### Template Parameters

include/gl/algorithm/topology/topological_sort.hpp

@@ -42,9 +42,9 @@ namespace gl::algorithm {
 /// >
 /// > The time complexity depends entirely on the underlying representation of `GraphType`:
 /// > - **Adjacency List Representations**: \f$O(|V| + |E|)\f$
-/// >   - *Includes:* @ref gl::impl::list_t "list_t" and @ref gl::impl::flat_list_t "flat_list_t".
+/// >   - *Includes:* @ref gl::repr::list_t "list_t" and @ref gl::repr::flat_list_t "flat_list_t".
 /// > - **Adjacency Matrix Representations**: \f$O(|V|^2)\f$
-/// >   - *Includes:* @ref gl::impl::matrix_t "matrix_t" and @ref gl::impl::flat_matrix_t "flat_matrix_t".
+/// >   - *Includes:* @ref gl::repr::matrix_t "matrix_t" and @ref gl::repr::flat_matrix_t "flat_matrix_t".
 /// >   - *Note:* Iterating over adjacent vertices requires scanning the entire \f$|V|\f$-length matrix row.
 ///
 /// ### Template Parameters

include/gl/algorithm/traversal/breadth_first_search.hpp

@@ -48,9 +48,9 @@ namespace gl::algorithm {
 /// >
 /// > The time complexity depends entirely on the underlying representation of `GraphType`:
 /// > - **Adjacency List Representations**: \f$O(|V| + |E|)\f$
-/// >   - *Includes:* @ref gl::impl::list_t "list_t" and @ref gl::impl::flat_list_t "flat_list_t".
+/// >   - *Includes:* @ref gl::repr::list_t "list_t" and @ref gl::repr::flat_list_t "flat_list_t".
 /// > - **Adjacency Matrix Representations**: \f$O(|V|^2)\f$
-/// >   - *Includes:* @ref gl::impl::matrix_t "matrix_t" and @ref gl::impl::flat_matrix_t "flat_matrix_t".
+/// >   - *Includes:* @ref gl::repr::matrix_t "matrix_t" and @ref gl::repr::flat_matrix_t "flat_matrix_t".
 /// >   - *Note:* Iterating over adjacent vertices requires scanning the entire \f$|V|\f$-length matrix row.
 ///
 /// ### Template Parameters

include/gl/algorithm/traversal/depth_first_search.hpp

@@ -56,9 +56,9 @@ namespace gl::algorithm {
 /// >
 /// > The time complexity depends entirely on the underlying representation of `GraphType`:
 /// > - **Adjacency List Representations**: \f$O(|V| + |E|)\f$
-/// >   - *Includes:* @ref gl::impl::list_t "list_t" and @ref gl::impl::flat_list_t "flat_list_t".
+/// >   - *Includes:* @ref gl::repr::list_t "list_t" and @ref gl::repr::flat_list_t "flat_list_t".
 /// > - **Adjacency Matrix Representations**: \f$O(|V|^2)\f$
-/// >   - *Includes:* @ref gl::impl::matrix_t "matrix_t" and @ref gl::impl::flat_matrix_t "flat_matrix_t".
+/// >   - *Includes:* @ref gl::repr::matrix_t "matrix_t" and @ref gl::repr::flat_matrix_t "flat_matrix_t".
 /// >   - *Note:* Iterating over adjacent vertices requires scanning the entire \f$|V|\f$-length matrix row.
 ///
 /// ### Template Parameters
@@ -156,9 +156,9 @@ result_type<Result, predecessors_map<G>> depth_first_search(
 /// >
 /// > The time complexity depends entirely on the underlying representation of `GraphType`:
 /// > - **Adjacency List Representations**: \f$O(|V| + |E|)\f$
-/// >   - *Includes:* @ref gl::impl::list_t "list_t" and @ref gl::impl::flat_list_t "flat_list_t".
+/// >   - *Includes:* @ref gl::repr::list_t "list_t" and @ref gl::repr::flat_list_t "flat_list_t".
 /// > - **Adjacency Matrix Representations**: \f$O(|V|^2)\f$
-/// >   - *Includes:* @ref gl::impl::matrix_t "matrix_t" and @ref gl::impl::flat_matrix_t "flat_matrix_t".
+/// >   - *Includes:* @ref gl::repr::matrix_t "matrix_t" and @ref gl::repr::flat_matrix_t "flat_matrix_t".
 /// >   - *Note:* Iterating over adjacent vertices requires scanning the entire \f$|V|\f$-length matrix row.
 ///
 /// ### Template Parameters