diff --git a/src/QuikGraph/Algorithms/ShortestPath/YenShortestPathsAlgorithm.cs b/src/QuikGraph/Algorithms/ShortestPath/YenShortestPathsAlgorithm.cs
index b2c30b51f..dbff2129f 100644
--- a/src/QuikGraph/Algorithms/ShortestPath/YenShortestPathsAlgorithm.cs
+++ b/src/QuikGraph/Algorithms/ShortestPath/YenShortestPathsAlgorithm.cs
@@ -14,20 +14,21 @@ namespace QuikGraph.Algorithms.ShortestPath
     /// with non negative edge cost.
     /// </summary>
     /// <typeparam name="TVertex">Vertex type.</typeparam>
-    public class YenShortestPathsAlgorithm<TVertex>
+    /// <typeparam name="TEdge">Edge type.</typeparam>
+    public class YenShortestPathsAlgorithm<TVertex, TEdge> where TEdge : IEdge<TVertex>
     {
         /// <summary>
         /// Class representing a sorted path.
         /// </summary>
-        public struct SortedPath : IEnumerable<EquatableTaggedEdge<TVertex, double>>, IEquatable<SortedPath>
+        public struct SortedPath : IEnumerable<TEdge>, IEquatable<SortedPath>
         {
             [NotNull, ItemNotNull]
-            private readonly List<EquatableTaggedEdge<TVertex, double>> _edges;
+            private readonly List<TEdge> _edges;
 
             /// <summary>
             /// Initializes a new instance of the <see cref="SortedPath"/> struct.
             /// </summary>
-            public SortedPath([NotNull, ItemNotNull] IEnumerable<EquatableTaggedEdge<TVertex, double>> edges)
+            public SortedPath([NotNull, ItemNotNull] IEnumerable<TEdge> edges)
             {
                 _edges = edges.ToList();
             }
@@ -48,7 +49,7 @@ internal TVertex GetVertex(int i)
 
             [Pure]
             [NotNull]
-            internal EquatableTaggedEdge<TVertex, double> GetEdge(int i)
+            internal TEdge GetEdge(int i)
             {
                 Debug.Assert(i >= 0 && i < _edges.Count);
 
@@ -57,7 +58,7 @@ internal EquatableTaggedEdge<TVertex, double> GetEdge(int i)
 
             [Pure]
             [NotNull, ItemNotNull]
-            internal EquatableTaggedEdge<TVertex, double>[] GetEdges(int count)
+            internal TEdge[] GetEdges(int count)
             {
                 if (count > _edges.Count)
                 {
@@ -88,7 +89,7 @@ public override int GetHashCode()
             }
 
             /// <inheritdoc />
-            public IEnumerator<EquatableTaggedEdge<TVertex, double>> GetEnumerator()
+            public IEnumerator<TEdge> GetEnumerator()
             {
                 return _edges.GetEnumerator();
             }
@@ -104,7 +105,7 @@ IEnumerator IEnumerable.GetEnumerator()
         private readonly TVertex _targetVertex;
 
         [NotNull]
-        private readonly Func<EquatableTaggedEdge<TVertex, double>, double> _weights;
+        private readonly Func<TEdge, double> _weights;
 
         [NotNull]
         private readonly Func<IEnumerable<SortedPath>, IEnumerable<SortedPath>> _filter;
@@ -113,10 +114,10 @@ IEnumerator IEnumerable.GetEnumerator()
         private readonly int _k;
 
         [NotNull]
-        private readonly IMutableVertexAndEdgeListGraph<TVertex, EquatableTaggedEdge<TVertex, double>> _graph;
+        private readonly IMutableVertexAndEdgeListGraph<TVertex, TEdge> _graph;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="YenShortestPathsAlgorithm{TVertex}"/> class.
+        /// Initializes a new instance of the <see cref="YenShortestPathsAlgorithm{TVertex,TEdge}"/> class.
         /// </summary>
         /// <remarks>
         /// <see cref="T:System.Double"/> for tag type (edge) which comes from Dijkstra’s algorithm, which is used to get one shortest path.
@@ -134,11 +135,11 @@ IEnumerator IEnumerable.GetEnumerator()
         /// <exception cref="T:System.ArgumentException"><paramref name="target"/> is not part of <paramref name="graph"/>.</exception>
         /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="k"/> is lower than 1.</exception>
         public YenShortestPathsAlgorithm(
-            [NotNull] AdjacencyGraph<TVertex, EquatableTaggedEdge<TVertex, double>> graph,
+            [NotNull] AdjacencyGraph<TVertex, TEdge> graph,
             [NotNull] TVertex source,
             [NotNull] TVertex target,
             int k,
-            [CanBeNull] Func<EquatableTaggedEdge<TVertex, double>, double> edgeWeights = null,
+            [CanBeNull] Func<TEdge, double> edgeWeights,
             [CanBeNull] Func<IEnumerable<SortedPath>, IEnumerable<SortedPath>> filter = null)
         {
             if (graph is null)
@@ -153,12 +154,14 @@ public YenShortestPathsAlgorithm(
                 throw new ArgumentException("Target must be in the graph", nameof(source));
             if (k < 1)
                 throw new ArgumentOutOfRangeException(nameof(k), "Value must be positive.");
+            if (edgeWeights == null)
+                throw new ArgumentNullException(nameof(edgeWeights));
 
             _sourceVertex = source;
             _targetVertex = target;
             _k = k;
             _graph = graph.Clone();
-            _weights = edgeWeights ?? DefaultGetWeights;
+            _weights = edgeWeights;
             _filter = filter ?? DefaultFilter;
         }
 
@@ -169,12 +172,6 @@ private static IEnumerable<SortedPath> DefaultFilter([NotNull] IEnumerable<Sorte
             return paths;
         }
 
-        [Pure]
-        private static double DefaultGetWeights([NotNull] EquatableTaggedEdge<TVertex, double> edge)
-        {
-            return edge.Tag;
-        }
-
         [Pure]
         private double GetPathDistance([ItemNotNull] SortedPath edges)
         {
@@ -196,7 +193,7 @@ private SortedPath GetInitialShortestPath()
         [Pure]
         [CanBeNull]
         private SortedPath? GetShortestPathInGraph(
-            [NotNull] IVertexListGraph<TVertex, EquatableTaggedEdge<TVertex, double>> graph,
+            [NotNull] IVertexListGraph<TVertex, TEdge> graph,
             [NotNull] TVertex source,
             [NotNull] TVertex target)
         {
@@ -205,8 +202,8 @@ private SortedPath GetInitialShortestPath()
             Debug.Assert(target != null);
 
             // Compute distances between the start vertex and other
-            var algorithm = new DijkstraShortestPathAlgorithm<TVertex, EquatableTaggedEdge<TVertex, double>>(graph, _weights);
-            var recorder = new VertexPredecessorRecorderObserver<TVertex, EquatableTaggedEdge<TVertex, double>>();
+            var algorithm = new DijkstraShortestPathAlgorithm<TVertex, TEdge>(graph, _weights);
+            var recorder = new VertexPredecessorRecorderObserver<TVertex, TEdge>();
 
             using (recorder.Attach(algorithm))
             {
@@ -214,7 +211,7 @@ private SortedPath GetInitialShortestPath()
             }
 
             // Get shortest path from start (source) vertex to target
-            return recorder.TryGetPath(target, out IEnumerable<EquatableTaggedEdge<TVertex, double>> path)
+            return recorder.TryGetPath(target, out IEnumerable<TEdge> path)
                 ? new SortedPath(path)
                 : (SortedPath?)null;
         }
@@ -258,12 +255,12 @@ private bool SearchAndAddKthShortestPath(
                 TVertex spurVertex = previousPath.GetVertex(i);
 
                 // The sequence of nodes from the source to the spur node of the previous k-shortest path
-                EquatableTaggedEdge<TVertex, double>[] rootPath = previousPath.GetEdges(i);
+                TEdge[] rootPath = previousPath.GetEdges(i);
 
                 foreach (SortedPath path in shortestPaths.Where(path => rootPath.SequenceEqual(path.GetEdges(i))))
                 {
                     // Remove the links that are part of the previous shortest paths which share the same root path
-                    EquatableTaggedEdge<TVertex, double> edgeToRemove = path.GetEdge(i);
+                    TEdge edgeToRemove = path.GetEdge(i);
                     _edgesToRestore.Add(edgeToRemove);
                     _graph.RemoveEdge(edgeToRemove);
                 }
@@ -343,10 +340,10 @@ public IEnumerable<SortedPath> Execute()
         }
 
         [NotNull, ItemNotNull]
-        private readonly List<EquatableTaggedEdge<TVertex, double>> _edgesToRestore =
-            new List<EquatableTaggedEdge<TVertex, double>>();
+        private readonly List<TEdge> _edgesToRestore =
+            new List<TEdge>();
 
-        private void OnGraphEdgeRemoved([NotNull] EquatableTaggedEdge<TVertex, double> edge)
+        private void OnGraphEdgeRemoved([NotNull] TEdge edge)
         {
             _edgesToRestore.Add(edge);
         }
diff --git a/tests/QuikGraph.Tests/Algorithms/ShortestPath/YenShortestPathsAlgorithmTests.cs b/tests/QuikGraph.Tests/Algorithms/ShortestPath/YenShortestPathsAlgorithmTests.cs
index 895df5296..4c18f2731 100644
--- a/tests/QuikGraph.Tests/Algorithms/ShortestPath/YenShortestPathsAlgorithmTests.cs
+++ b/tests/QuikGraph.Tests/Algorithms/ShortestPath/YenShortestPathsAlgorithmTests.cs
@@ -6,7 +6,7 @@
 namespace QuikGraph.Tests.Algorithms.ShortestPath
 {
     /// <summary>
-    /// Tests for <see cref="YenShortestPathsAlgorithm{TVertex}"/>.
+    /// Tests for <see cref="YenShortestPathsAlgorithm{TVertex,TEdge}"/>.
     /// </summary>
     [TestFixture]
     internal sealed class YenShortestPathsAlgorithmTests
@@ -14,21 +14,23 @@ internal sealed class YenShortestPathsAlgorithmTests
         [Test]
         public void Constructor()
         {
-            Func<EquatableTaggedEdge<int, double>, double> Weights = _ => 1.0;
+            Func<EquatableTaggedEdge<int, double>, double> weights = edge => edge.Tag;
 
             var graph = new AdjacencyGraph<int, EquatableTaggedEdge<int, double>>();
             graph.AddVertexRange(new[] { 1, 2 });
             // ReSharper disable ObjectCreationAsStatement
-            Assert.DoesNotThrow(() => new YenShortestPathsAlgorithm<int>(graph, 1, 2, int.MaxValue));
-            Assert.DoesNotThrow(() => new YenShortestPathsAlgorithm<int>(graph, 1, 2, 10));
+            Assert.DoesNotThrow(() => new YenShortestPathsAlgorithm<int, EquatableTaggedEdge<int, double>>(graph, 1, 2, int.MaxValue, weights));
+            Assert.DoesNotThrow(() => new YenShortestPathsAlgorithm<int, EquatableTaggedEdge<int, double>>(graph, 1, 2, 10, weights));
 
-            Assert.DoesNotThrow(() => new YenShortestPathsAlgorithm<int>(graph, 1, 2, int.MaxValue, Weights, paths => paths.Where(path => path.Count() > 2)));
+            Assert.DoesNotThrow(() => new YenShortestPathsAlgorithm<int, EquatableTaggedEdge<int, double>>(graph, 1, 2, int.MaxValue, weights, paths => paths.Where(path => path.Count() > 2)));
             // ReSharper restore ObjectCreationAsStatement
         }
 
         [Test]
         public void Constructor_Throws()
         {
+            Func<EquatableTaggedEdge<TestVertex, double>, double> weights = edge => edge.Tag;
+
             // ReSharper disable ObjectCreationAsStatement
             // ReSharper disable AssignNullToNotNullAttribute
             var vertex1 = new TestVertex("1");
@@ -36,41 +38,41 @@ public void Constructor_Throws()
 
             var graph = new AdjacencyGraph<TestVertex, EquatableTaggedEdge<TestVertex, double>>();
             Assert.Throws<ArgumentException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(graph, vertex1, vertex2, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(graph, vertex1, vertex2, int.MaxValue, weights));
 
             graph = new AdjacencyGraph<TestVertex, EquatableTaggedEdge<TestVertex, double>>();
             graph.AddVertex(vertex1);
             Assert.Throws<ArgumentException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(graph, vertex1, vertex2, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(graph, vertex1, vertex2, int.MaxValue, weights));
 
             graph = new AdjacencyGraph<TestVertex, EquatableTaggedEdge<TestVertex, double>>();
             graph.AddVertex(vertex2);
             Assert.Throws<ArgumentException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(graph, vertex1, vertex2, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(graph, vertex1, vertex2, int.MaxValue, weights));
 
             graph = new AdjacencyGraph<TestVertex, EquatableTaggedEdge<TestVertex, double>>();
             graph.AddVertexRange(new[] { vertex1, vertex2 });
 
             Assert.Throws<ArgumentNullException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(null, vertex1, vertex2, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(null, vertex1, vertex2, int.MaxValue, weights));
             Assert.Throws<ArgumentNullException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(graph, null, vertex2, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(graph, null, vertex2, int.MaxValue, weights));
             Assert.Throws<ArgumentNullException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(graph, vertex1, null, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(graph, vertex1, null, int.MaxValue, weights));
             Assert.Throws<ArgumentNullException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(null, null, vertex2, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(null, null, vertex2, int.MaxValue, weights));
             Assert.Throws<ArgumentNullException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(null, vertex1, null, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(null, vertex1, null, int.MaxValue, weights));
             Assert.Throws<ArgumentNullException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(graph, null, null, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(graph, null, null, int.MaxValue, weights));
             Assert.Throws<ArgumentNullException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(null, null, null, int.MaxValue));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(null, null, null, int.MaxValue, weights));
             // ReSharper restore AssignNullToNotNullAttribute
 
             Assert.Throws<ArgumentOutOfRangeException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(graph, vertex1, vertex2, 0));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(graph, vertex1, vertex2, 0, weights));
             Assert.Throws<ArgumentOutOfRangeException>(
-                () => new YenShortestPathsAlgorithm<TestVertex>(graph, vertex1, vertex2, -1));
+                () => new YenShortestPathsAlgorithm<TestVertex, EquatableTaggedEdge<TestVertex, double>>(graph, vertex1, vertex2, -1, weights));
             // ReSharper restore ObjectCreationAsStatement
         }
 
@@ -85,11 +87,12 @@ public void SimpleNoPathGraph()
             graph.AddVertex('1');
 
             // ReSharper disable ReturnValueOfPureMethodIsNotUsed
-            var algorithm = new YenShortestPathsAlgorithm<char>(graph, '1', '1', 10);
+            Func<EquatableTaggedEdge<char, double>, double> weights = edge => edge.Tag;
+            var algorithm = new YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>(graph, '1', '1', 10, weights);
             Assert.Throws<NoPathFoundException>(() => algorithm.Execute());
 
             graph.AddVertex('2');
-            algorithm = new YenShortestPathsAlgorithm<char>(graph, '1', '2', 10);
+            algorithm = new YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>(graph, '1', '2', 10, weights);
             Assert.Throws<NoPathFoundException>(() => algorithm.Execute());
             // ReSharper restore ReturnValueOfPureMethodIsNotUsed
         }
@@ -104,7 +107,8 @@ public void LoopGraph()
             var graph = new AdjacencyGraph<char, EquatableTaggedEdge<char, double>>(true);
             graph.AddVertexRange("1");
 
-            var algorithm = new YenShortestPathsAlgorithm<char>(graph, '1', '1', 10);
+            Func<EquatableTaggedEdge<char, double>, double> weights = edge => edge.Tag;
+            var algorithm = new YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>(graph, '1', '1', 10, weights);
             graph.AddEdge(new EquatableTaggedEdge<char, double>('1', '1', 7));
             // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             Assert.Throws<NoPathFoundException>(() => algorithm.Execute());
@@ -127,8 +131,9 @@ public void GraphWithCycle()
             };
             graph.AddEdgeRange(edges);
 
-            var algorithm = new YenShortestPathsAlgorithm<char>(graph, '1', '5', 10);
-            YenShortestPathsAlgorithm<char>.SortedPath[] paths = algorithm.Execute().ToArray();
+            Func<EquatableTaggedEdge<char, double>, double> weights = edge => edge.Tag;
+            var algorithm = new YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>(graph, '1', '5', 10, weights);
+            YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>.SortedPath[] paths = algorithm.Execute().ToArray();
 
             // Expecting to get 2 paths:
             // 1 => 1-2-3-5
@@ -161,8 +166,9 @@ public void GraphWithMultiplePaths()
             };
             graph.AddEdgeRange(edges);
 
-            var algorithm = new YenShortestPathsAlgorithm<string>(graph, "A", "D", 5);
-            YenShortestPathsAlgorithm<string>.SortedPath[] paths = algorithm.Execute().ToArray();
+            Func<EquatableTaggedEdge<string, double>, double> weights = edge => edge.Tag;
+            var algorithm = new YenShortestPathsAlgorithm<string, EquatableTaggedEdge<string, double>>(graph, "A", "D", 5, weights);
+            YenShortestPathsAlgorithm<string, EquatableTaggedEdge<string, double>>.SortedPath[] paths = algorithm.Execute().ToArray();
 
             // Expecting to get 3 paths:
             // 1 => A-B-D
@@ -205,8 +211,9 @@ public void GraphWithMultiplePaths_KShortest()
             graph.AddEdgeRange(edges);
 
             // K = 5
-            var algorithmK5 = new YenShortestPathsAlgorithm<char>(graph, 'C', 'H', 5);
-            YenShortestPathsAlgorithm<char>.SortedPath[] paths = algorithmK5.Execute().ToArray();
+            Func<EquatableTaggedEdge<char, double>, double> weights = edge => edge.Tag;
+            var algorithmK5 = new YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>(graph, 'C', 'H', 5, weights);
+            YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>.SortedPath[] paths = algorithmK5.Execute().ToArray();
 
             // Expecting to get 5 paths:
             // 1 => C-E-F-H
@@ -220,7 +227,7 @@ public void GraphWithMultiplePaths_KShortest()
 
 
             // K = 50
-            var algorithmK50 = new YenShortestPathsAlgorithm<char>(graph, 'C', 'H', 50);
+            var algorithmK50 = new YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>(graph, 'C', 'H', 50, weights);
             paths = algorithmK50.Execute().ToArray();
 
             // Expecting to get 7 paths:
@@ -250,7 +257,7 @@ public void GraphWithMultiplePaths_KShortest()
 
             #region Local function
 
-            void CheckFiveFirstPaths(YenShortestPathsAlgorithm<char>.SortedPath[] ps)
+            void CheckFiveFirstPaths(YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>.SortedPath[] ps)
             {
                 // 1
                 EquatableTaggedEdge<char, double>[] path0 = ps[0].ToArray();
@@ -287,23 +294,16 @@ void CheckFiveFirstPaths(YenShortestPathsAlgorithm<char>.SortedPath[] ps)
         [Test]
         public void MultipleRunMethods()
         {
+            Func<EquatableTaggedEdge<char, double>, double> weights = edge => edge.Tag;
             AdjacencyGraph<char, EquatableTaggedEdge<char, double>> graph = GenerateGraph(
                 out EquatableTaggedEdge<char, double>[] graphEdges);
 
-            // Default weight function and default filter function case
-            var algorithm = new YenShortestPathsAlgorithm<char>(graph, '1', '5', 10);
-            RunYenAndCheck(algorithm);
-
-            // Custom weight function and default filter function case
-            algorithm = new YenShortestPathsAlgorithm<char>(graph, '1', '5', 10, e => e.Tag);
-            RunYenAndCheck(algorithm);
-
-            // Default weight function and custom filter function case
-            algorithm = new YenShortestPathsAlgorithm<char>(graph, '1', '5', 10, null, e => e);
+            // Default filter function case
+            var algorithm = new YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>(graph, '1', '5', 10, weights);
             RunYenAndCheck(algorithm);
 
-            // Custom weight function and custom filter function case
-            algorithm = new YenShortestPathsAlgorithm<char>(graph, '1', '5', 10, e => e.Tag, e => e);
+            // Custom filter function case
+            algorithm = new YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>(graph, '1', '5', 10, weights, e => e);
             RunYenAndCheck(algorithm);
 
             #region Local functions
@@ -331,12 +331,12 @@ AdjacencyGraph<char, EquatableTaggedEdge<char, double>> GenerateGraph(
                 return g;
             }
 
-            void RunYenAndCheck(YenShortestPathsAlgorithm<char> yen)
+            void RunYenAndCheck(YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>> yen)
             {
                 // Generate simple graph
                 // like this https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
                 // but with directed edges input graph
-                YenShortestPathsAlgorithm<char>.SortedPath[] paths = yen.Execute().ToArray();
+                YenShortestPathsAlgorithm<char, EquatableTaggedEdge<char, double>>.SortedPath[] paths = yen.Execute().ToArray();
 
                 // Expecting to get 3 paths:
                 // 1 => 1-3-4-5
@@ -374,10 +374,10 @@ public void SortedPathHashCode()
                 new EquatableTaggedEdge<int, double>(2, 3, 1.0),
                 new EquatableTaggedEdge<int, double>(3, 4, 1.0)
             };
-            var path1 = new YenShortestPathsAlgorithm<int>.SortedPath(edges);
-            var path2 = new YenShortestPathsAlgorithm<int>.SortedPath(edges);
+            var path1 = new YenShortestPathsAlgorithm<int, EquatableTaggedEdge<int, double>>.SortedPath(edges);
+            var path2 = new YenShortestPathsAlgorithm<int, EquatableTaggedEdge<int, double>>.SortedPath(edges);
 
-            var path3 = new YenShortestPathsAlgorithm<int>.SortedPath(new[]
+            var path3 = new YenShortestPathsAlgorithm<int, EquatableTaggedEdge<int, double>>.SortedPath(new[]
             {
                 new EquatableTaggedEdge<int, double>(1, 2, 1.0),
                 new EquatableTaggedEdge<int, double>(2, 3, 1.0),
@@ -400,11 +400,11 @@ public void SortedPathEnumeration()
                 new EquatableTaggedEdge<int, double>(3, 4, 1.0)
             };
 
-            var path = new YenShortestPathsAlgorithm<int>.SortedPath(edges);
+            var path = new YenShortestPathsAlgorithm<int, EquatableTaggedEdge<int, double>>.SortedPath(edges);
             CollectionAssert.AreEqual(edges, path);
 
             CollectionAssert.IsEmpty(
-                new YenShortestPathsAlgorithm<int>.SortedPath(
+                new YenShortestPathsAlgorithm<int, EquatableTaggedEdge<int, double>>.SortedPath(
                     Enumerable.Empty<EquatableTaggedEdge<int, double>>()));
         }
     }