AddEdge should add an edge between the vertices with the given source and target hashes. If either vertex doesn't exit, ErrVertexNotFound should be r

AddVertex should add the given vertex with the given hash value and vertex properties to the graph. If the vertex already exists, it is up to you whet

New creates a new graph with vertices of type T, identified by hash values of type K. These hash values will be obtained using the provided hash funct

Directed creates a directed graph. This has implications on graph traversal and the order of arguments of the Edge and AddEdge functions.

EdgeWeight returns a function that sets the weight of an edge to the given weight. This is a functional option for the [graph.Graph.Edge] and [graph.G

AdjacencyMap computes an adjacency map with all vertices in the graph. There is an entry for each vertex. Each of those entries is another map whose

Traits returns the graph's traits. Those traits must be set when creating a graph using New.

Vertex should return the vertex and vertex properties with the given hash value. If the vertex doesn't exist, ErrVertexNotFound should be returned.

copyEdge returns an argument list suitable for the Graph.AddEdge method. This argument list is derived from the given edge, hence the name copyEdge.

Edge should return the edge joining the vertices with the given hash values. It should exclusively look for an edge between the source and the target

RemoveEdge should remove the edge between the vertices with the given source and target hashes. If either vertex doesn't exist, it is up to you wheth

RemoveVertex should remove the vertex with the given hash value. If the vertex doesn't exist, ErrVertexNotFound should be returned. If the vertex has

VertexWithProperties returns the vertex with the given hash along with its properties or ErrVertexNotFound if it doesn't exist.

EdgeData returns a function that sets the data of an edge to the given value. This is a functional option for the [graph.Graph.Edge] and [graph.Graph.

PredecessorMap computes a predecessor map with all vertices in the graph. It has the same map layout and does the same thing as AdjacencyMap, but for

VertexAttribute returns a function that adds the given key-value pair to the vertex attributes. This is a functional option for the [graph.Graph.Verte

ListEdges should return all edges in the graph in a slice.

Order returns the number of vertices in the graph.

UpdateEdge should update the edge between the given vertices with the data of the given Edge instance. If the edge doesn't exist, ErrEdgeNotFound shou

VertexWeight returns a function that sets the weight of a vertex to the given weight. This is a functional option for the [graph.Graph.Vertex] and [gr

AddEdgesFrom adds all edges along with their properties from the given graph to the receiving graph. All vertices that the edges are joining have to

AddVerticesFrom adds all vertices along with their properties from the given graph to the receiving graph. All vertices will be added until an error

Clone creates a deep copy of the graph and returns that cloned graph. The cloned graph will use the default in-memory store for storing the vertices

CreatesCycle determines whether adding an edge between the two given vertices would introduce a cycle in the graph. CreatesCycle will not create an ed

EdgeAttribute returns a function that adds the given key-value pair to the attributes of an edge. This is a functional option for the [graph.Graph.Edg

Edges returns a slice of all edges in the graph. These edges are of type Edge[K] and hence will contain the vertex hashes, not the vertex values.

Weighted creates a weighted graph. To set weights, use the Edge and AddEdge functions.

Acyclic creates an acyclic graph. Note that creating edges that form a cycle will still be possible. To prevent this explicitly, use PreventCycles.

ListVertices should return all vertices in the graph in a slice.

forEach iterate the stack from bottom to top

BFS performs a breadth-first search on the graph, starting from the given vertex. The visit function will be invoked with the hash of the vertex curre

BFSWithDepth works just as BFS and performs a breadth-first search on the graph, but its visit function is passed the current depth level as a second

DFS performs a depth-first search on the graph, starting from the given vertex. The visit function will be invoked with the hash of the vertex current

MaximumSpanningTree returns a minimum spanning tree within the given graph. The MST contains all vertices from the given graph as well as the require

MinimumSpanningTree returns a minimum spanning tree within the given graph. The MST contains all vertices from the given graph as well as the require

NewLike creates a graph that is "like" the given graph: It has the same type, the same hashing function, and the same traits. The new graph is indepen

Rooted creates a rooted graph. This is particularly common for building tree data structures.

ShortestPath computes the shortest path between a source and a target vertex under consideration of the edge weights. It returns a slice of hash value

Size returns the number of edges in the graph.

StronglyConnectedComponents detects all strongly connected components within the graph and returns the hashes of the vertices shaping these components

TopologicalSort runs a topological sort on a given directed graph and returns the vertex hashes in topological order. The topological order is a non-u

TransitiveReduction returns a new graph with the same vertices and the same reachability as the given graph, but with as few edges as possible. The gr

UpdatePriority updates the priority of a given item and sets it to the given priority. If the item doesn't exist, nothing happens. This operation may

VertexCount should return the number of vertices in the graph. This should be equal to the length of the slice returned by ListVertices.

AllPathsBetween computes and returns all paths between two given vertices. A path is represented as a slice of vertex hashes. The returned slice conta

CreatesCycle is a fastpath version of [CreatesCycle] that avoids calling [PredecessorMap], which generates large amounts of garbage to collect. Becau

EdgeAttributes returns a function that sets the given map as the attributes of an edge. This is a functional option for the [graph.Graph.AddEdge] and

GraphAttribute is a functional option for the [DOT] method.

IntHash is a hashing function that accepts an integer and uses that exact integer as a hash value. Using it as Hash will yield a Graph[int, int].

NewWithStore creates a new graph same as [New] but uses the provided store instead of the default memory store.

PreventCycles creates an acyclic graph that prevents and proactively prevents the creation of cycles. These cycle checks affect the performance and co

StableTopologicalSort does the same as [TopologicalSort], but takes a function for comparing (and then ordering) two given vertices. This allows for a

StringHash is a hashing function that accepts a string and uses that exact string as a hash value. Using it as Hash will yield a Graph[string, string]

Tree is an alias for Acyclic and Rooted, since most trees in Computer Science are rooted trees.

Union combines two given graphs into a new graph. The vertex hashes in both graphs are expected to be unique. The two input graphs will remain unchang

VertexAttributes returns a function that sets the given map as the attributes of a vertex. This is a functional option for the [graph.Graph.AddVertex]