Add DijkstraResult return type instead of unnamed tuple

tests/dijkstra.rs

@@ -6,24 +6,24 @@ use grapherity::traits::GraphTopology;
 fn dijkstra_single_vertex() {
     let mut graph = AppendGraph::new();
     let v1 = graph.add_vertex();
-    let (distances, predecessors) = algorithms::dijkstra(&graph, v1);
+    let result = algorithms::dijkstra(&graph, v1);
     assert_eq!(
-        distances.len(),
+        result.distances.len(),
         1,
         "distances count must equal vertex count"
     );
     assert_eq!(
-        predecessors.len(),
+        result.predecessors.len(),
         1,
         "predecessors count must equal vertex count"
     );
     assert_eq!(
-        distances[0],
+        result.distances[0],
         Some(0),
         "unexpected distance of source vertex"
     );
     assert_eq!(
-        predecessors[0], None,
+        result.predecessors[0], None,
         "unexpected predecessor of source vertex",
     );
 }
@@ -33,23 +33,23 @@ fn dijkstra_disconnected() {
     let mut graph = AppendGraph::new();
     let v1 = graph.add_vertex();
     graph.add_vertex();
-    let (distances, predecessors) = algorithms::dijkstra(&graph, v1);
+    let result = algorithms::dijkstra(&graph, v1);
     assert_eq!(
-        distances.len(),
+        result.distances.len(),
         2,
         "distances count must equal vertex count"
     );
     assert_eq!(
-        predecessors.len(),
+        result.predecessors.len(),
         2,
         "predecessors count must equal vertex count"
     );
     assert_eq!(
-        distances[1], None,
+        result.distances[1], None,
         "unexpected distance of disconnected vertex"
     );
     assert_eq!(
-        predecessors[0], None,
+        result.predecessors[0], None,
         "unexpected predecessor of disconnected vertex",
     );
 }
@@ -57,7 +57,7 @@ fn dijkstra_disconnected() {
 #[test]
 fn dijkstra() {
     let (graph, vertices) = make_test_graph();
-    let (distances, predecessors) = algorithms::dijkstra(&graph, vertices[0]);
+    let result = algorithms::dijkstra(&graph, vertices[0]);
     let expected_distances_from_v0 = [
         Some(0),
         Some(1),
@@ -83,25 +83,25 @@ fn dijkstra() {
         vec![Some(vertices[5]), Some(vertices[6]), Some(vertices[7])],
     ];
     assert_eq!(
-        distances.len(),
+        result.distances.len(),
         graph.vertex_count(),
         "distances count must equal vertex count"
     );
     assert_eq!(
-        predecessors.len(),
+        result.predecessors.len(),
         graph.vertex_count(),
         "predecessors count must equal vertex count"
     );
     for i in 0..graph.vertex_count() {
         assert_eq!(
-            distances[i], expected_distances_from_v0[i],
+            result.distances[i], expected_distances_from_v0[i],
             "unexpected distance from {:?} to {:?}",
             vertices[0], vertices[i]
         );
         assert!(
-            expected_predecessors_from_v0[i].contains(&predecessors[i]),
+            expected_predecessors_from_v0[i].contains(&result.predecessors[i]),
             "unexpected predecessor {:?} of {:?}",
-            predecessors[i],
+            result.predecessors[i],
             vertices[i]
         );
     }