diff --git a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
index 3e9e1530e32be00bde29939c4987bc2d60c34799..202f6f3d15cb1d8d64478422171ca5d377a9d423 100644
--- a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
+++ b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
@@ -641,11 +641,6 @@ bool PLANAR(GraphWrapper &G, bool embed, HopcroftTarjan::Result &res)
 	return true;
 }
 
-HopcroftTarjan::Result HopcroftTarjan::hopcrofttarjan(const Graph &graph)
-{
-	return dispatch(graph.getData());
-}
-
 HopcroftTarjan::Result HopcroftTarjan::hopcrofttarjan(const DirectedGraph &graph)
 {
 	AdjacencyListDirectedGraph copy(graph);
diff --git a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h
index dd044613b33f6974d027a0892e3db2058314ed24..30d6fa0aae4176d229f2e579673c2c40684e829d 100644
--- a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h
+++ b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h
@@ -8,24 +8,17 @@
 #ifndef GRAPH_HOPCROFT_TARJAN_H_
 #define GRAPH_HOPCROFT_TARJAN_H_
 
-#include <core/multipleDispatch.hpp>
-
 #include <graph/GraphClasses.h>
 
-namespace graph
-{
+namespace graph {
 
-namespace embedding
-{
+namespace embedding {
 
 // Computes combinatorial embedding of bidirected biconnected simple planar graph
-class HopcroftTarjan : public alib::SingleDispatch<HopcroftTarjan, ext::unordered_map<Node, ext::vector<Node>>, const graph::GraphBase &>
-{
+class HopcroftTarjan {
 public:
 	typedef ext::unordered_map<Node, ext::vector<Node>> Result;
 
-	static Result hopcrofttarjan(const Graph &graph);
-
 	static Result hopcrofttarjan(const DirectedGraph &graph);
 	static Result hopcrofttarjan(const UndirectedGraph &graph);
 };
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.h b/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.h
index bf427fcd52e635b1b6b1cb396f6540866b247c0c..0eb92a9a0967f2471bd0cd895fa79fb9d3bc9577 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.h
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.h
@@ -12,14 +12,11 @@
 
 #include <graph/GraphClasses.h>
 
-namespace graph
-{
+namespace graph {
 
-namespace isomorphism
-{
+namespace isomorphism {
 
-namespace hopcroft
-{
+namespace hopcroft {
 
 class Vertex;
 class EdgeEnd;
@@ -30,8 +27,7 @@ enum Direction {
 	CounterClockWise
 };
 
-class Graph
-{
+class Graph {
 public:
 	explicit Graph(const UndirectedGraph &graph);
 	~Graph();
@@ -63,8 +59,7 @@ private:
 	void init(const UndirectedGraph &graph);
 };
 
-class Vertex
-{
+class Vertex {
 public:
 	explicit Vertex();
 
@@ -95,8 +90,7 @@ public:
 	std::string out;
 };
 
-class EdgeEnd
-{
+class EdgeEnd {
 public:
 	explicit EdgeEnd();
 
@@ -116,8 +110,7 @@ public:
 	std::string dump() const;
 };
 
-class Face
-{
+class Face {
 public:
 	explicit Face();
 
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h b/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h
index 225e7c86f450eb7654281312ecad3363d32addc8..9a283628b5882fecca3d0121072c8fefed5fe0a0 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h
@@ -14,17 +14,13 @@
 
 #include "HopcroftGraph.h"
 
-namespace graph
-{
+namespace graph {
 
-namespace isomorphism
-{
+namespace isomorphism {
 
-namespace hopcroft
-{
+namespace hopcroft {
 
-class HopcroftImpl
-{
+class HopcroftImpl {
 public:
 	explicit HopcroftImpl(Graph *g1, Graph *g2);
 
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.cpp b/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.cpp
index 6dc99279e9c6dcbdc91a2638f6c1fd834fdb527f..fdaaa4aaf69398ffcef3fa34e69df07410ef05f4 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.cpp
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.cpp
@@ -17,11 +17,6 @@ namespace graph
 namespace isomorphism
 {
 
-bool HopcroftWong::hopcroftwong(const Graph &first, const Graph &second)
-{
-	return dispatch(first.getData(), second.getData());
-}
-
 bool HopcroftWong::hopcroftwong(const UndirectedGraph &first, const UndirectedGraph &second)
 {
 	hopcroft::Graph g1(first);
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.h b/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.h
index c2b8405161f2f30d4049a161ceb3b0aa8b0baf8f..e34bf1ede650931198b0c2b0a9118b64b65d3ee5 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.h
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.h
@@ -8,22 +8,15 @@
 #ifndef GRAPH_HOPCROFT_WONG_H_
 #define GRAPH_HOPCROFT_WONG_H_
 
-#include <core/multipleDispatch.hpp>
-
 #include <graph/GraphClasses.h>
 
-namespace graph
-{
+namespace graph {
 
-namespace isomorphism
-{
+namespace isomorphism {
 
 // Decides isomorphism of triconnected planar graphs
-class HopcroftWong : public alib::DoubleDispatch<HopcroftWong, bool, const graph::GraphBase&, const graph::GraphBase &>
-{
+class HopcroftWong {
 public:
-	static bool hopcroftwong(const Graph &first, const Graph &second);
-
 	static bool hopcroftwong(const UndirectedGraph &first, const UndirectedGraph &second);
 
 };
diff --git a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp
index 9590fb396f7b5515c31ec50ea935cefdf49b8aad..39509bb057c53bf5092389d472dedbbc866ad500 100644
--- a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp
+++ b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp
@@ -111,11 +111,6 @@ static bool impl(const T &first, const T &second)
 	return impl_r(first, second, n1, n2, mapping);
 }
 
-bool Isomorphism::isomorphism(const Graph &first, const Graph &second)
-{
-	return dispatch(first.getData(), second.getData());
-}
-
 bool Isomorphism::isomorphism(const DirectedGraph &first, const DirectedGraph &second)
 {
 	return impl(first, second);
diff --git a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.h b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.h
index 65dabc2806ff9da6270ad74a724e1b641aebbb45..6581fc71fb6799214d5772ea404aaf036a7475b6 100644
--- a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.h
+++ b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.h
@@ -8,21 +8,14 @@
 #ifndef GRAPH_ISOMORPHISM_H_
 #define GRAPH_ISOMORPHISM_H_
 
-#include <core/multipleDispatch.hpp>
-
 #include <graph/GraphClasses.h>
 
-namespace graph
-{
+namespace graph {
 
-namespace isomorphism
-{
+namespace isomorphism {
 
-class Isomorphism : public alib::DoubleDispatch<Isomorphism, bool, const graph::GraphBase &, const graph::GraphBase &>
-{
+class Isomorphism {
 public:
-	static bool isomorphism(const Graph &first, const Graph &second);
-
 	static bool isomorphism(const DirectedGraph &first, const DirectedGraph &second);
 	static bool isomorphism(const UndirectedGraph &first, const UndirectedGraph &second);
 };
diff --git a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
index 067dce1b63b8ad03016af932dbb04533140c51f6..26ab8ccb59d24f836d7aff767dec27bf8eb01040 100644
--- a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
+++ b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
@@ -225,11 +225,6 @@ static Flow fordfulkerson_impl_undir( const UndirectedGraph & ugraph, Node sourc
 	return ctx.flow;
 }
 
-Flow FordFulkerson::fordfulkerson( const Graph & graph, Node source, Node sink )
-{
-	return dispatch( graph.getData(), source, sink );
-}
-
 Flow FordFulkerson::fordfulkerson( const DirectedGraph & graph, Node source, Node sink )
 {
 	return fordfulkerson_impl_dir( graph, source, sink );
diff --git a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h
index 1f998128bfa537d01edab0125bc7310bb48d4bb6..4a40f8b4f38b2cad539b1da0c9339da08d764d25 100644
--- a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h
+++ b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h
@@ -10,7 +10,6 @@
 
 #include <unordered_map>
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
@@ -20,12 +19,8 @@ namespace maximumflow {
 typedef ext::unordered_map< Node, ext::unordered_map< Node, int > > Capacity;
 typedef ext::unordered_map< Node, ext::unordered_map< Node, int > > Flow;
 
-class FordFulkerson : public alib::SingleDispatch< FordFulkerson, Flow, const graph::GraphBase &, Node, Node > {
-
- public:
-
-	static Flow fordfulkerson( const Graph & graph, Node source, Node sink );
-
+class FordFulkerson {
+public:
 	static Flow fordfulkerson( const DirectedGraph & graph, Node source, Node sink );
 
 	static Flow fordfulkerson( const UndirectedGraph & graph, Node source, Node sink );
diff --git a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
index 4313c2c8b7153d3751d9ade3e8b60b49548357eb..bf5c723188c11afc6a117b6b9f5733a3956e8bf9 100644
--- a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
+++ b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
@@ -155,11 +155,6 @@ static Cut fordfulkerson_impl_undir( const UndirectedGraph & ugraph, Node source
 	return cut;
 }
 
-Cut FordFulkerson::fordfulkerson( const Graph & graph, Node source, Node sink )
-{
-	return dispatch( graph.getData(), source, sink );
-}
-
 Cut FordFulkerson::fordfulkerson( const DirectedGraph & graph, Node source, Node sink )
 {
 	return fordfulkerson_impl_dir( graph, source, sink );
diff --git a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.h b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.h
index c517a134fcb58996ed80b5b9ad10fc2c6048128e..f51f7021639b13f549193cd229b035a3fccc84a1 100644
--- a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.h
+++ b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.h
@@ -10,10 +10,8 @@
 
 #include <unordered_set>
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
-
 namespace std {
 	template<>
 	struct hash< std::pair< graph::Node, graph::Node > > {
@@ -30,11 +28,8 @@ namespace minimumcut {
 
 typedef std::unordered_set< std::pair< Node, Node > > Cut;
 
-class FordFulkerson : public alib::SingleDispatch < FordFulkerson, Cut, const graph::GraphBase &, Node, Node > {
+class FordFulkerson {
 public:
-
-	static Cut fordfulkerson( const Graph & graph, Node source, Node sink );
-
 	static Cut fordfulkerson( const DirectedGraph & graph, Node source, Node sink );
 
 	static Cut fordfulkerson( const UndirectedGraph & graph, Node source, Node sink );
diff --git a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
index 7192a3416895a4ca04c545f269ea05b1cd049bce..034e30b94f5080e14afb15c151d947ccd943c511 100644
--- a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
@@ -110,24 +110,19 @@ static BellmanFord::Result bellmanford_impl(const UndirectedGraph &graph, const
 	return d;
 }
 
-BellmanFord::Result BellmanFord::bellmanford(const Graph &graph, const Node &start)
-{
-	return dispatch(graph.getData(), start);
-}
-
 BellmanFord::Result BellmanFord::bellmanford(const DirectedGraph &graph, const Node &start)
 {
 	return bellmanford_impl(graph, start);
 }
 
-auto BellmanFordDirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::DirectedGraph> ( BellmanFord::bellmanford );
+// auto BellmanFordDirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::DirectedGraph> ( BellmanFord::bellmanford );
 
 BellmanFord::Result BellmanFord::bellmanford(const UndirectedGraph &graph, const Node &start)
 {
 	return bellmanford_impl(graph, start);
 }
 
-auto BellmanFordUndirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::UndirectedGraph> ( BellmanFord::bellmanford );
+// auto BellmanFordUndirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::UndirectedGraph> ( BellmanFord::bellmanford );
 
 } // namespace shortestpath
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h
index fc2db83f5279881567206af16a668f19652b0769..8ae2affeffbcaba7dab02868951d0eb1f03375ab 100644
--- a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h
+++ b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_BELLMAN_FORD_H_
 #define GRAPH_BELLMAN_FORD_H_
 
-#include <core/multipleDispatch.hpp>
 #include <unordered_map>
 
 #include <graph/GraphClasses.h>
@@ -22,12 +21,10 @@ namespace shortestpath {
 //
 // note: negative-weight undirected edge = negative-weight cycle
 
-class BellmanFord : public alib::SingleDispatch<BellmanFord, ext::unordered_map<Node, int>, const graph::GraphBase &, const Node&> {
+class BellmanFord {
 public:
 	typedef ext::unordered_map<Node, int> Result;
 
-	static Result bellmanford(const Graph &graph, const Node &start);
-
 	static Result bellmanford(const DirectedGraph &graph, const Node &start);
 	static Result bellmanford(const UndirectedGraph &graph, const Node &start);
 };
diff --git a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
index 58ac9a62b4b06bdcf00c98e2b63e13be48f077c3..8d84e6cc6b1bf5c238db59ef2c920c117f250335 100644
--- a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
@@ -126,24 +126,19 @@ static Dijkstra::Result dijkstra_impl(const T &graph, const Node &start)
 	return d;
 }
 
-Dijkstra::Result Dijkstra::dijkstra(const Graph &graph, const Node &start)
-{
-	return dispatch(graph.getData(), start);
-}
-
 Dijkstra::Result Dijkstra::dijkstra(const DirectedGraph &graph, const Node &start)
 {
 	return dijkstra_impl(graph, start);
 }
 
-auto DijkstraDirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::DirectedGraph> ( Dijkstra::dijkstra );
+// auto DijkstraDirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::DirectedGraph> ( Dijkstra::dijkstra );
 
 Dijkstra::Result Dijkstra::dijkstra(const UndirectedGraph &graph, const Node &start)
 {
 	return dijkstra_impl(graph, start);
 }
 
-auto DijkstraUndirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::UndirectedGraph> ( Dijkstra::dijkstra );
+// auto DijkstraUndirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::UndirectedGraph> ( Dijkstra::dijkstra );
 
 } // namespace shortestpath
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h
index c5321845668d5d355b4ddda8a0b71285ad050522..14b154013929cc1761157c66c3bfc1d1a16ba2fb 100644
--- a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h
+++ b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_DIJKSTRA_H_
 #define GRAPH_DIJKSTRA_H_
 
-#include <core/multipleDispatch.hpp>
 #include <unordered_map>
 
 #include <graph/GraphClasses.h>
@@ -19,12 +18,10 @@ namespace shortestpath {
 
 // Dijkstra only works on graphs without negative-weight edges (>= 0)
 
-class Dijkstra : public alib::SingleDispatch < Dijkstra, ext::unordered_map<Node, int>, const graph::GraphBase &, const Node&> {
+class Dijkstra {
 public:
 	typedef ext::unordered_map<Node, int> Result;
 
-	static Result dijkstra(const Graph &graph, const Node &start);
-
 	static Result dijkstra(const DirectedGraph &graph, const Node &start);
 	static Result dijkstra(const UndirectedGraph &graph, const Node &start);
 };
diff --git a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp
index 6c9708640b223af69e9f9dccfee2b9a2c7ac7150..2a98323a76f4ca8b246b69ff7c7a9bf0ce48627e 100644
--- a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp
@@ -65,24 +65,19 @@ static FloydWarshall::Result floydwarshall_impl(const T &graph)
 	return d;
 }
 
-FloydWarshall::Result FloydWarshall::floydwarshall(const Graph &graph)
-{
-	return dispatch(graph.getData());
-}
-
 FloydWarshall::Result FloydWarshall::floydwarshall(const DirectedGraph &graph)
 {
 	return floydwarshall_impl(graph);
 }
 
-auto FloydWarshallDirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::DirectedGraph> ( FloydWarshall::floydwarshall );
+// auto FloydWarshallDirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::DirectedGraph> ( FloydWarshall::floydwarshall );
 
 FloydWarshall::Result FloydWarshall::floydwarshall(const UndirectedGraph &graph)
 {
 	return floydwarshall_impl(graph);
 }
 
-auto FloydWarshallUndirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::UndirectedGraph> ( FloydWarshall::floydwarshall );
+// auto FloydWarshallUndirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::UndirectedGraph> ( FloydWarshall::floydwarshall );
 
 } // namespace shortestpath
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h
index 131680323a017dae6b7bd2040875e12973794797..240f76350cec25f740a0d44ded943e73cf649f97 100644
--- a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h
+++ b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_FLOYD_WARSHALL_FORD_H_
 #define GRAPH_FLOYD_WARSHALL_FORD_H_
 
-#include <core/multipleDispatch.hpp>
 #include <unordered_map>
 
 #include <graph/GraphClasses.h>
@@ -23,12 +22,10 @@ namespace shortestpath {
 // note: negative-weight undirected edge = negative-weight cycle
 // note: std::numeric_limits<int>::max() is used as infinity
 
-class FloydWarshall : public alib::SingleDispatch<FloydWarshall, ext::unordered_map<Node, ext::unordered_map<Node, int>>, const graph::GraphBase & > {
+class FloydWarshall {
 public:
 	typedef ext::unordered_map<Node, ext::unordered_map<Node, int>> Result;
 
-	static Result floydwarshall(const Graph &graph);
-
 	static Result floydwarshall(const DirectedGraph &graph);
 	static Result floydwarshall(const UndirectedGraph &graph);
 };
diff --git a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
index 69633bbc113193f39a4241347b114bc7b72cb6ee..2657a7c5ab761e8e6fffe2d0f8fcd920bf89419b 100644
--- a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
+++ b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
@@ -31,15 +31,11 @@ static TopologicalSort::Result topsort_impl(const DirectedGraph &graph) {
 	return s;
 }
 
-TopologicalSort::Result TopologicalSort::topologicalsort(const Graph &graph) {
-	return dispatch(graph.getData());
-}
-
 TopologicalSort::Result TopologicalSort::topologicalsort(const DirectedGraph &graph) {
 	return topsort_impl(graph);
 }
 
-auto TopologicalSortDirectedGraph = registration::OverloadRegister < TopologicalSort, TopologicalSort::Result, graph::DirectedGraph> ( TopologicalSort::topologicalsort );
+// auto TopologicalSortDirectedGraph = registration::OverloadRegister < TopologicalSort, TopologicalSort::Result, graph::DirectedGraph> ( TopologicalSort::topologicalsort );
 
 } // namespace sort
 
diff --git a/alib2algo_experimental/src/graph/sort/TopologicalSort.h b/alib2algo_experimental/src/graph/sort/TopologicalSort.h
index cb3cc793d63e14488e7330c6379f612baf5f0fb6..b1ccd2fc9a8c8cc40d70bd12b5c86c5d147ce5bf 100644
--- a/alib2algo_experimental/src/graph/sort/TopologicalSort.h
+++ b/alib2algo_experimental/src/graph/sort/TopologicalSort.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_TOPOLOGICAL_SORT_H_
 #define GRAPH_TOPOLOGICAL_SORT_H_
 
-#include <core/multipleDispatch.hpp>
 #include <list>
 
 #include <graph/GraphClasses.h>
@@ -17,12 +16,10 @@ namespace graph {
 
 namespace sort {
 
-class TopologicalSort : public alib::SingleDispatch<TopologicalSort, ext::list<Node>, const graph::GraphBase & > {
+class TopologicalSort {
 public:
 	typedef ext::list<Node> Result;
 
-	static Result topologicalsort(const Graph &graph);
-
 	static Result topologicalsort(const DirectedGraph &graph);
 };
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
index cddcd4fa57c0fb3d463ccd9f046598b8e015da1c..b84ac36ee2392d0604053342a6e018a3e1931980 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
@@ -236,17 +236,12 @@ static AdjacencyListDirectedGraph edmonds_impl( const DirectedGraph & graph )
 	return spanningTree;
 }
 
-Graph Edmonds::edmonds( const Graph & graph )
-{
-	return dispatch( graph.getData() );
-}
-
 AdjacencyListDirectedGraph Edmonds::edmonds( const DirectedGraph & graph )
 {
 	return edmonds_impl( graph );
 }
 
-auto EdmondsDirectedGraph = registration::OverloadRegister < Edmonds,  graph::AdjacencyListDirectedGraph, graph::DirectedGraph > ( Edmonds::edmonds );
+// auto EdmondsDirectedGraph = registration::OverloadRegister < Edmonds,  graph::AdjacencyListDirectedGraph, graph::DirectedGraph > ( Edmonds::edmonds );
 
 } // spanningtree
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/Edmonds.h b/alib2algo_experimental/src/graph/spanningtree/Edmonds.h
index c7e9f8746fce8f21bf6d68d61ef871fd3f1c4f52..737587c2fa1378c1545b8e2f8c02bba61b67bf0d 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Edmonds.h
+++ b/alib2algo_experimental/src/graph/spanningtree/Edmonds.h
@@ -8,25 +8,16 @@
 #ifndef GRAPH_EDMONDS
 #define GRAPH_EDMONDS
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
 
 namespace spanningtree {
 
-class Edmonds : public alib::SingleDispatch< Edmonds, graph::Graph, const graph::GraphBase & > {
+class Edmonds {
 public:
-
-	static Graph edmonds( const Graph & graph );
-
 	static AdjacencyListDirectedGraph edmonds( const DirectedGraph & graph );
 
-	static Edmonds & getInstance() {
-		static Edmonds res;
-		return res;
-	}
-
 };
 
 } // spanningtree
diff --git a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
index 838b1184b8b44ea22043fea06f2e27fb15cdc49e..e6e61812c7f55b51289d5c10ef228675b4bdc7ae 100644
--- a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
@@ -101,15 +101,11 @@ static AdjacencyListUndirectedGraph jarnikprim_impl(const UndirectedGraph &graph
 	return res;
 }
 
-Graph JarnikPrim::jarnikprim(const Graph &graph, const Node &start) {
-	return dispatch(graph.getData(), start);
-}
-
 AdjacencyListUndirectedGraph JarnikPrim::jarnikprim(const UndirectedGraph &graph, const Node &start) {
 	return jarnikprim_impl(graph, start);
 }
 
-auto JarnikPrimUndirectedGraph = registration::OverloadRegister < JarnikPrim, graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph> ( JarnikPrim::jarnikprim );
+// auto JarnikPrimUndirectedGraph = registration::OverloadRegister < JarnikPrim, graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph> ( JarnikPrim::jarnikprim );
 
 } // namespace spanningtree
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.h b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.h
index bae920684cdb232c94e574ce189789e1d9446f7b..a03f6214128df66c850dfd01c5f08723bc4336bb 100644
--- a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.h
+++ b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.h
@@ -8,17 +8,14 @@
 #ifndef GRAPH_JARNIK_PRIM_H_
 #define GRAPH_JARNIK_PRIM_H_
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
 
 namespace spanningtree {
 
-class JarnikPrim : public alib::SingleDispatch < JarnikPrim, graph::Graph, const graph::GraphBase &, const Node&> {
+class JarnikPrim {
 public:
-	static Graph jarnikprim(const Graph &graph, const Node &start);
-
 	static AdjacencyListUndirectedGraph jarnikprim(const UndirectedGraph &graph, const Node &start);
 
 };
diff --git a/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp b/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
index f0a060e87f567add7304b00a01887b0b005976f6..b6c263db7aee4791cf4087d1ba63eb5a55b8c6bf 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
@@ -75,17 +75,12 @@ static AdjacencyListUndirectedGraph kruskal_impl( const UndirectedGraph & graph
 	return res;
 }
 
-Graph Kruskal::kruskal( const Graph & graph )
-{
-	return dispatch( graph.getData() );
-}
-
 AdjacencyListUndirectedGraph Kruskal::kruskal( const UndirectedGraph & graph )
 {
 	return kruskal_impl( graph );
 }
 
-auto KruskalUndirectedGraph = registration::OverloadRegister < Kruskal,  graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph > ( Kruskal::kruskal );
+// auto KruskalUndirectedGraph = registration::OverloadRegister < Kruskal,  graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph > ( Kruskal::kruskal );
 
 } // namespace spanningtree
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/Kruskal.h b/alib2algo_experimental/src/graph/spanningtree/Kruskal.h
index ecdec6096a26c18dd70141af12dd253f18ac4ce4..8158beb679839046cd1ef59e76e7abad63e9e10c 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Kruskal.h
+++ b/alib2algo_experimental/src/graph/spanningtree/Kruskal.h
@@ -8,25 +8,16 @@
 #ifndef GRAPH_KRUSKAL
 #define GRAPH_KRUSKAL
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
 
 namespace spanningtree {
 
-class Kruskal : public alib::SingleDispatch< Kruskal, graph::Graph, const graph::GraphBase & > {
+class Kruskal {
 public:
-
-	static Graph kruskal( const Graph & graph );
-
 	static AdjacencyListUndirectedGraph kruskal( const UndirectedGraph & graph );
 
-	static Kruskal & getInstance() {
-		static Kruskal res;
-		return res;
-	}
-
 };
 
 } // namespace spanningtree
diff --git a/alib2algo_experimental/src/graph/traverse/Bfs.cpp b/alib2algo_experimental/src/graph/traverse/Bfs.cpp
index 3ae4c0e37e0f15620317f6b374abe41d9cdb0225..628cba2225ce65e114428f9b770850674ba4c961 100644
--- a/alib2algo_experimental/src/graph/traverse/Bfs.cpp
+++ b/alib2algo_experimental/src/graph/traverse/Bfs.cpp
@@ -66,37 +66,29 @@ static void bfs2_impl(const T &graph, const Node &start, Bfs::FunctionExt func)
 	}
 }
 
-void Bfs::bfs(const Graph &graph, const Node &start, Bfs::Function func) {
-	dispatch(graph.getData(), start, func);
-}
-
-void Bfs::bfs(const Graph &graph, const Node &start, Bfs::FunctionExt func) {
-	dispatch(graph.getData(), start, func);
-}
-
 void Bfs::bfs(const DirectedGraph &graph, const Node &start, Bfs::Function func) {
 	bfs_impl(graph, start, func);
 }
 
-auto BfsDirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::DirectedGraph> ( Bfs::bfs );
+// auto BfsDirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::DirectedGraph> ( Bfs::bfs );
 
 void Bfs::bfs(const DirectedGraph &graph, const Node &start, Bfs::FunctionExt func) {
 	bfs2_impl(graph, start, func);
 }
 
-auto BfsDirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::DirectedGraph> ( Bfs::bfs );
+// auto BfsDirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::DirectedGraph> ( Bfs::bfs );
 
 void Bfs::bfs(const UndirectedGraph &graph, const Node &start, Bfs::Function func) {
 	bfs_impl(graph, start, func);
 }
 
-auto BfsUndirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::UndirectedGraph> ( Bfs::bfs );
+// auto BfsUndirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::UndirectedGraph> ( Bfs::bfs );
 
 void Bfs::bfs(const UndirectedGraph &graph, const Node &start, Bfs::FunctionExt func) {
 	bfs2_impl(graph, start, func);
 }
 
-auto BfsUndirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::UndirectedGraph> ( Bfs::bfs );
+// auto BfsUndirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::UndirectedGraph> ( Bfs::bfs );
 
 } // namespace traverse
 
diff --git a/alib2algo_experimental/src/graph/traverse/Bfs.h b/alib2algo_experimental/src/graph/traverse/Bfs.h
index f532682c4b5bce5e895a563dd394182c2ef1bab2..493fb869bb17314f85812eb20bab6de84cf6221d 100644
--- a/alib2algo_experimental/src/graph/traverse/Bfs.h
+++ b/alib2algo_experimental/src/graph/traverse/Bfs.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_BFS_H_
 #define GRAPH_BFS_H_
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
@@ -20,17 +19,11 @@ namespace traverse {
 // bool Function(const Node &visitedNode);
 // bool FunctionExt(const Node &visitedNode, const Node &predecessor, int distanceFromStart);
 
-class Bfs : public alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&)>>, public alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&, const Node&, int)>> {
+class Bfs {
 public:
-	using alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&)>>::dispatch;
-	using alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&, const Node&, int)>>::dispatch;
-
 	typedef std::function<bool(const Node&)> Function;
 	typedef std::function<bool(const Node&, const Node&, int)> FunctionExt;
 
-	static void bfs(const Graph &graph, const Node &start, Function func);
-	static void bfs(const Graph &graph, const Node &start, FunctionExt func);
-
 	static void bfs(const DirectedGraph &graph, const Node &start, Function func);
 	static void bfs(const DirectedGraph &graph, const Node &start, FunctionExt func);
 	static void bfs(const UndirectedGraph &graph, const Node &start, Function func);
diff --git a/alib2algo_experimental/src/graph/traverse/Dfs.cpp b/alib2algo_experimental/src/graph/traverse/Dfs.cpp
index d0f892f6c42cc14aa8d04e6224ff522f1fd971da..95ae205f090b2a86a346320d8eb6bebc562b983d 100644
--- a/alib2algo_experimental/src/graph/traverse/Dfs.cpp
+++ b/alib2algo_experimental/src/graph/traverse/Dfs.cpp
@@ -55,19 +55,11 @@ static bool dfs2_impl(const T &graph, const Node &n, const Node &p, ext::unorder
 	return func(n, p, opened, ++time);
 }
 
-void Dfs::dfs(const Graph &graph, const Node &start, Dfs::Function func) {
-	dispatch(graph.getData(), start, func);
-}
-
-void Dfs::dfs(const Graph &graph, const Node &start, Dfs::FunctionExt func) {
-	dispatch(graph.getData(), start, func);
-}
-
 void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::Function func) {
 	dfs_impl(graph, start, func);
 }
 
-auto DfsDirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::DirectedGraph> ( Dfs::dfs );
+// auto DfsDirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::DirectedGraph> ( Dfs::dfs );
 
 void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::FunctionExt func) {
 	int time = 0;
@@ -75,13 +67,13 @@ void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::FunctionExt fu
 	dfs2_impl(graph, start, start, visited, time, func);
 }
 
-auto DfsDirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::DirectedGraph> ( Dfs::dfs );
+// auto DfsDirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::DirectedGraph> ( Dfs::dfs );
 
 void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::Function func) {
 	dfs_impl(graph, start, func);
 }
 
-auto DfsUndirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::UndirectedGraph> ( Dfs::dfs );
+// auto DfsUndirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::UndirectedGraph> ( Dfs::dfs );
 
 void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::FunctionExt func) {
 	int time = 0;
@@ -89,7 +81,7 @@ void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::FunctionExt
 	dfs2_impl(graph, start, start, visited, time, func);
 }
 
-auto DfsUndirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::UndirectedGraph> ( Dfs::dfs );
+// auto DfsUndirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::UndirectedGraph> ( Dfs::dfs );
 
 } // namespace traverse
 
diff --git a/alib2algo_experimental/src/graph/traverse/Dfs.h b/alib2algo_experimental/src/graph/traverse/Dfs.h
index 67007552db168862261c86a420c32834591b8d8c..cb8bf68d9b93c99efca55e6393171234ffdd25ab 100644
--- a/alib2algo_experimental/src/graph/traverse/Dfs.h
+++ b/alib2algo_experimental/src/graph/traverse/Dfs.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_DFS_H_
 #define GRAPH_DFS_H_
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
@@ -20,17 +19,11 @@ namespace traverse {
 // bool Function(const Node &node);
 // bool FunctionExt(const Node &node, const Node &predecessor, int openTime, int closeTime);
 
-class Dfs : public alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&)>>, public alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&, const Node&, int, int)>> {
+class Dfs {
 public:
-	using alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&)>>::dispatch;
-	using alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&, const Node&, int, int)>>::dispatch;
-
 	typedef std::function<bool(const Node&)> Function;
 	typedef std::function<bool(const Node&, const Node&, int, int)> FunctionExt;
 
-	static void dfs(const Graph &graph, const Node &start, Function func);
-	static void dfs(const Graph &graph, const Node &start, FunctionExt func);
-
 	static void dfs(const DirectedGraph &graph, const Node &start, Function func);
 	static void dfs(const DirectedGraph &graph, const Node &start, FunctionExt func);
 	static void dfs(const UndirectedGraph &graph, const Node &start, Function func);
diff --git a/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp b/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp
index 238e6e3ec62ab75467b7598ab85d733fdca58118..95863eecc3a6153871e0ed2cdf48b1b89063951d 100644
--- a/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp
+++ b/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp
@@ -216,9 +216,7 @@ void GraphBfsTest::testBfs2()
 	distances.clear();
 	predecessors.clear();
 
-	graph::Graph g(dg);
-
-	graph::traverse::Bfs::bfs(g, n1, [&](const graph::Node &n, const graph::Node &p, int d) {
+	graph::traverse::Bfs::bfs(dg, n1, [&](const graph::Node &n, const graph::Node &p, int d) {
 		distances[n] = d;
 		predecessors.insert(std::make_pair(n, p));
 		return true;
@@ -251,9 +249,7 @@ void GraphBfsTest::testBfs2()
 	distances.clear();
 	predecessors.clear();
 
-	graph::Graph g2(ug);
-
-	graph::traverse::Bfs::bfs(g2, n1, [&](const graph::Node &n, const graph::Node &p, int d) {
+	graph::traverse::Bfs::bfs(ug, n1, [&](const graph::Node &n, const graph::Node &p, int d) {
 		distances[n] = d;
 		predecessors.insert(std::make_pair(n, p));
 		return true;
diff --git a/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp b/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp
index 2ea20a3d3e4886df73d6ddb50934bff5e183ea34..f11210060d7940cfc4e18d0edb2c87debdb851be 100644
--- a/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp
+++ b/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp
@@ -218,9 +218,7 @@ void GraphDfsTest::testDfs2()
 	closed.clear();
 	predecessors.clear();
 
-	graph::Graph g(dg);
-
-	graph::traverse::Dfs::dfs(g, n1, [&](const graph::Node &n, const graph::Node &p, int o, int c) {
+	graph::traverse::Dfs::dfs(dg, n1, [&](const graph::Node &n, const graph::Node &p, int o, int c) {
 		counter++;
 		opened[n] = o;
 		closed[n] = c;
@@ -254,9 +252,7 @@ void GraphDfsTest::testDfs2()
 	closed.clear();
 	predecessors.clear();
 
-	graph::Graph g2(ug);
-
-	graph::traverse::Dfs::dfs(g2, n1, [&](const graph::Node &n, const graph::Node &p, int o, int c) {
+	graph::traverse::Dfs::dfs(ug, n1, [&](const graph::Node &n, const graph::Node &p, int o, int c) {
 		counter++;
 		opened[n] = o;
 		closed[n] = c;