resolved comments

Author: SpectraL519

docs/additional_functionality.md

@@ -1,6 +1,7 @@
 # Additional functionality
 
 - [Force inlining](#force-inlining)
+- [Ranges utility](#ranges-utility)
 
 <br />
 
@@ -16,3 +17,44 @@ To enable the force inlining functionality you have to add the following in your
 
 > [!NOTE]
 > Force inlining is supported only for the GNU G++ and CLang++ compilers.
+
+<br />
+<br />
+
+## Ranges utility
+
+Small helpers for working with C++20 ranges.
+
+> [!NOTE]
+> - Header: [gl/util/ranges.hpp](/include/gl/util/ranges.hpp)
+> - Namespace: `gl::util`
+
+### View adapters
+
+- **`deref_view`**
+	- *Description*: A transform view that dereferences pointer-like elements in a range. Useful for turning a range of pointers or smart pointers into a range of references.
+	- *Usage*: `range | gl::util::deref_view`
+	- *Works with*: `T*`, `std::unique_ptr<T>`, `std::shared_ptr<T>`, and generally pointer-like objects supporting unary `*`.
+	- *Return type*: A lazy transformed view whose reference type is `decltype(*p)` of the underlying elements.
+	- *Example*:
+		```cpp
+		std::vector<std::unique_ptr<int>> v; /* ... */
+		for (int& x : v | gl::util::deref_view) {
+				// use x as an int&
+		}
+		```
+
+### Functions
+
+- **`range_size(r)`**
+	- *Template parameters*:
+		- `R: std::ranges::range`
+	- *Description*: Returns the size of a range. If `R` models `std::ranges::sized_range`, it forwards to `std::ranges::size(r)` in O(1). Otherwise, it computes `std::ranges::distance(std::begin(r), std::end(r))` in O(n).
+	- *Parameters*:
+		- `r: R&&` – the input range.
+	- *Return type*: Same type as produced by `std::ranges::size(r)` for sized ranges or `std::ranges::distance(...)` otherwise.
+	- *Complexity*: O(1) for sized ranges; O(n) otherwise.
+	- *Exceptions*: No specific exceptions; propagates iterator operations if they throw.
+
+> [!CAUTION]
+> For non-sized, single-pass/input ranges `range_size` will consume the range when computing distance.

docs/algorithms.md

@@ -62,17 +62,6 @@ This section covers the specific types and type traits used for the algorithm im
     - `id: types::id_type` - the ID of the vertex.
     - `source_id: types::id_type` - the ID of the source vertex, typically used during algorithms.
 
-- `edge_info`
-  - *Description*: Holds information about an edge, including the edge itself and its source vertex's ID.
-  - *Template parameters*:
-    - `EdgeType: type_traits::c_instantiation_of<edge_descriptor>` - the type of the edge.
-  - *Constructors*:
-    - `vertex_info(types::id_type id)` - initializes the object with the same value for `id` and `source_id` representing a starting vertex
-    - `vertex_info(types::id_type id, types::id_type source_id)`
-  - *Member variables*:
-    - `edge: types::const_ref_wrap<EdgeType>` - a constant reference wrapper for the edge.
-    - `source_id: types::id_type` - the ID of the source vertex of the held edge.
-
 - `predicate_result`
   - *Description*: Represents the result of a predicate evaluation.
   - *Type definitions*:
@@ -383,7 +372,7 @@ This section covers the specific types and type traits used for the algorithm im
 > - *Constructors*:
 >   - `mst_descriptor(types::size_type n_vertices)` - Initializes an empty `edges` list with the capacity of $\text{n-vertices} - 1$ and the total weight is set to $0$.
 > - *Member variables*:
->   - `edges: std::vector<types::const_ref_wrap<edge_type>>` - A list of constant edge references representing the edges of the spanning tree.
+>   - `edges: std::vector<edge_type>` - A list of edges of the spanning tree.
 >   - `weight: weight_type` - The total weight of all edges of the spanning tree.
 
 <br />

include/gl/algorithm/mst.hpp

@@ -34,19 +34,18 @@ template <type_traits::c_undirected_graph GraphType>
 
     using vertex_type = typename GraphType::vertex_type;
     using edge_type = typename GraphType::edge_type;
-    using edge_info_type = algorithm::edge_info<edge_type>;
     using distance_type = types::vertex_distance_type<GraphType>;
 
-    struct edge_info_comparator {
+    struct edge_comparator {
         [[nodiscard]] gl_attr_force_inline bool operator()(
-            const edge_info_type& lhs, const edge_info_type& rhs
+            const edge_type& lhs, const edge_type& rhs
         ) const {
-            return get_weight<GraphType>(lhs.edge) > get_weight<GraphType>(rhs.edge);
+            return get_weight<GraphType>(lhs) > get_weight<GraphType>(rhs);
         }
     };
 
     using queue_type =
-        std::priority_queue<edge_info_type, std::vector<edge_info_type>, edge_info_comparator>;
+        std::priority_queue<edge_type, std::vector<edge_type>, edge_comparator>;
 
     // prepare the necessary utility
     const auto n_vertices = graph.n_vertices();
@@ -58,35 +57,31 @@ template <type_traits::c_undirected_graph GraphType>
     const types::id_type root_id = root_id_opt.value_or(constants::zero);
 
     for (const auto& edge : graph.adjacent_edges(root_id))
-        edge_queue.emplace(edge, root_id);
+        edge_queue.emplace(edge);
 
     // mark the root vertex as visited
     visited[root_id] = true;
     types::size_type n_vertices_in_mst = constants::one;
 
     // find the mst
     while (n_vertices_in_mst < n_vertices) {
-        const auto min_edge_info = edge_queue.top();
+        const auto min_edge = edge_queue.top();
         edge_queue.pop();
 
-        const auto& min_edge = min_edge_info.edge;
-        const auto min_weight = get_weight<GraphType>(min_edge);
-
-        const auto& target_id = min_edge.incident_vertex(min_edge_info.source_id);
-        if (visited[target_id])
+        if (visited[min_edge.target()])
             continue;
 
         // add the minimum weight edge to the mst
         mst.edges.emplace_back(min_edge);
-        mst.weight += min_weight;
+        mst.weight += get_weight<GraphType>(min_edge);
 
-        visited[target_id] = true;
+        visited[min_edge.target()] = true;
         ++n_vertices_in_mst;
 
         // enqueue all edges adjacent to the `target` vertex if they lead to unvisited verties
-        for (const auto& edge : graph.adjacent_edges(target_id))
-            if (not visited[edge.incident_vertex(target_id)])
-                edge_queue.emplace(edge, target_id);
+        for (const auto& edge : graph.adjacent_edges(min_edge.target()))
+            if (not visited[edge.incident_vertex(min_edge.target())])
+                edge_queue.emplace(edge);
     }
 
     return mst;

include/gl/algorithm/types.hpp

@@ -27,14 +27,6 @@ struct vertex_info {
     types::id_type pred_id;
 };
 
-template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
-struct edge_info {
-    using edge_type = EdgeType;
-
-    edge_type edge;
-    types::id_type source_id;
-};
-
 struct predicate_result {
     enum class eval : std::uint8_t { ok, not_ok, unknown };
     using enum eval;