Algebra.Graph.ToGraph

Alga is a library for algebraic construction and manipulation of graphs in Haskell. See this paper for the motivation behind the library, the underlying theory, and implementation details.

This module defines the type class ToGraph for capturing data types that can be converted to algebraic graphs. To make an instance of this class you need to define just a single method (toGraph or foldg), which gives you access to many other useful methods for free. This type class is similar to the standard Data.Foldable defined for lists.

Documentation

class ToGraph t where

The ToGraph type class captures data types that can be converted to algebraic graphs.

Minimal complete definition

toGraph | foldg

Associated Types

type ToVertex t

Methods

toGraph :: t -> Graph (ToVertex t)

Convert a value to the corresponding algebraic graph, see Algebra.Graph.

toGraph == foldg Empty Vertex Overlay Connect

foldg :: r -> (ToVertex t -> r) -> (r -> r -> r) -> (r -> r -> r) -> t -> r

The method foldg is used for generalised graph folding. It collapses a given value by applying the provided graph construction primitives. The order of arguments is: empty, vertex, overlay and connect, and it is assumed that the arguments satisfy the axioms of the graph algebra.

foldg == Algebra.Graph.foldg . toGraph

isEmpty :: t -> Bool

Check if a graph is empty.

isEmpty == foldg True (const False) (&&) (&&)

size :: t -> Int

The size of a graph, i.e. the number of leaves of the expression including empty leaves.

size == foldg 1 (const 1) (+) (+)

hasVertex :: Eq (ToVertex t) => ToVertex t -> t -> Bool

Check if a graph contains a given vertex.

hasVertex x == foldg False (==x) (||) (||)

hasEdge :: Eq (ToVertex t) => ToVertex t -> ToVertex t -> t -> Bool

Check if a graph contains a given edge.

hasEdge x y == Algebra.Graph.hasEdge x y . toGraph

vertexCount :: Ord (ToVertex t) => t -> Int

The number of vertices in a graph.

vertexCount == Set.size . vertexSet

edgeCount :: Ord (ToVertex t) => t -> Int

The number of edges in a graph.

edgeCount == Set.size . edgeSet

vertexList :: Ord (ToVertex t) => t -> [ToVertex t]

The sorted list of vertices of a given graph.

vertexList == Set.toAscList . vertexSet

edgeList :: Ord (ToVertex t) => t -> [(ToVertex t, ToVertex t)]

The sorted list of edges of a graph.

edgeList == Set.toAscList . edgeSet

vertexSet :: Ord (ToVertex t) => t -> Set (ToVertex t)

The set of vertices of a graph.

vertexSet == foldg Set.empty Set.singleton Set.union Set.union

vertexIntSet :: ToVertex t ~ Int => t -> IntSet

The set of vertices of a graph. Like vertexSet but specialised for graphs with vertices of type Int.

vertexIntSet == foldg IntSet.empty IntSet.singleton IntSet.union IntSet.union

edgeSet :: Ord (ToVertex t) => t -> Set (ToVertex t, ToVertex t)

The set of edges of a graph.

edgeSet == Algebra.Graph.AdjacencyMap.edgeSet . toAdjacencyMap

preSet :: Ord (ToVertex t) => ToVertex t -> t -> Set (ToVertex t)

The preset of a vertex is the set of its direct predecessors.

preSet x == Algebra.Graph.AdjacencyMap.preSet x . toAdjacencyMap

preIntSet :: ToVertex t ~ Int => Int -> t -> IntSet

The preset (here preIntSet) of a vertex is the set of its direct predecessors. Like preSet but specialised for graphs with vertices of type Int.

preIntSet x == Algebra.Graph.AdjacencyIntMap.preIntSet x . toAdjacencyIntMap

postSet :: Ord (ToVertex t) => ToVertex t -> t -> Set (ToVertex t)

The postset of a vertex is the set of its direct successors.

postSet x == Algebra.Graph.AdjacencyMap.postSet x . toAdjacencyMap

postIntSet :: ToVertex t ~ Int => Int -> t -> IntSet

The postset (here postIntSet) of a vertex is the set of its direct successors. Like postSet but specialised for graphs with vertices of type Int.

postIntSet x == Algebra.Graph.AdjacencyIntMap.postIntSet x . toAdjacencyIntMap

adjacencyList :: Ord (ToVertex t) => t -> [(ToVertex t, [ToVertex t])]

The sorted adjacency list of a graph.

adjacencyList == Algebra.Graph.AdjacencyMap.adjacencyList . toAdjacencyMap

adjacencyMap :: Ord (ToVertex t) => t -> Map (ToVertex t) (Set (ToVertex t))

The adjacency map of a graph: each vertex is associated with a set of its direct successors.

adjacencyMap == Algebra.Graph.AdjacencyMap.adjacencyMap . toAdjacencyMap

adjacencyIntMap :: ToVertex t ~ Int => t -> IntMap IntSet

The adjacency map of a graph: each vertex is associated with a set of its direct successors. Like adjacencyMap but specialised for graphs with vertices of type Int.

adjacencyIntMap == Algebra.Graph.AdjacencyIntMap.adjacencyIntMap . toAdjacencyIntMap

adjacencyMapTranspose :: Ord (ToVertex t) => t -> Map (ToVertex t) (Set (ToVertex t))

The transposed adjacency map of a graph: each vertex is associated with a set of its direct predecessors.

adjacencyMapTranspose == Algebra.Graph.AdjacencyMap.adjacencyMap . toAdjacencyMapTranspose

adjacencyIntMapTranspose :: ToVertex t ~ Int => t -> IntMap IntSet

The transposed adjacency map of a graph: each vertex is associated with a set of its direct predecessors. Like adjacencyMapTranspose but specialised for graphs with vertices of type Int.

adjacencyIntMapTranspose == Algebra.Graph.AdjacencyIntMap.adjacencyIntMap . toAdjacencyIntMapTranspose

dfsForest :: Ord (ToVertex t) => t -> Forest (ToVertex t)

Compute the depth-first search forest of a graph that corresponds to searching from each of the graph vertices in the Ord a order.

dfsForest == Algebra.Graph.AdjacencyMap.dfsForest . toAdjacencyMap

dfsForestFrom :: Ord (ToVertex t) => [ToVertex t] -> t -> Forest (ToVertex t)

Compute the depth-first search forest of a graph, searching from each of the given vertices in order. Note that the resulting forest does not necessarily span the whole graph, as some vertices may be unreachable.

dfsForestFrom vs == Algebra.Graph.AdjacencyMap.dfsForestFrom vs . toAdjacencyMap

dfs :: Ord (ToVertex t) => [ToVertex t] -> t -> [ToVertex t]

Compute the list of vertices visited by the depth-first search in a graph, when searching from each of the given vertices in order.

dfs vs == Algebra.Graph.AdjacencyMap.dfs vs . toAdjacencyMap

reachable :: Ord (ToVertex t) => ToVertex t -> t -> [ToVertex t]

Compute the list of vertices that are reachable from a given source vertex in a graph. The vertices in the resulting list appear in the depth-first order.

reachable x == Algebra.Graph.AdjacencyMap.reachable x . toAdjacencyMap

topSort :: Ord (ToVertex t) => t -> Maybe [ToVertex t]

Compute the topological sort of a graph or return Nothing if the graph is cyclic.

topSort == Algebra.Graph.AdjacencyMap.topSort . toAdjacencyMap

isAcyclic :: Ord (ToVertex t) => t -> Bool

Check if a given graph is acyclic.

isAcyclic == Algebra.Graph.AdjacencyMap.isAcyclic . toAdjacencyMap

toAdjacencyMap :: Ord (ToVertex t) => t -> AdjacencyMap (ToVertex t)

Convert a value to the corresponding AdjacencyMap.

toAdjacencyMap == foldg empty vertex overlay connect

toAdjacencyMapTranspose :: Ord (ToVertex t) => t -> AdjacencyMap (ToVertex t)

Convert a value to the corresponding AdjacencyMap and transpose the result.

toAdjacencyMapTranspose == foldg empty vertex overlay (flip connect)

toAdjacencyIntMap :: ToVertex t ~ Int => t -> AdjacencyIntMap

Convert a value to the corresponding AdjacencyIntMap.

toAdjacencyIntMap == foldg empty vertex overlay connect

toAdjacencyIntMapTranspose :: ToVertex t ~ Int => t -> AdjacencyIntMap

Convert a value to the corresponding AdjacencyIntMap and transpose the result.

toAdjacencyIntMapTranspose == foldg empty vertex overlay (flip connect)

isDfsForestOf :: Ord (ToVertex t) => Forest (ToVertex t) -> t -> Bool

Check if a given forest is a valid depth-first search forest of a graph.

isDfsForestOf f == Algebra.Graph.AdjacencyMap.isDfsForestOf f . toAdjacencyMap

isTopSortOf :: Ord (ToVertex t) => [ToVertex t] -> t -> Bool

Check if a given list of vertices is a valid topological sort of a graph.

isTopSortOf vs == Algebra.Graph.AdjacencyMap.isTopSortOf vs . toAdjacencyMap

Instances

ToGraph AdjacencyIntMap

Defined in Algebra.Graph.ToGraph

Associated Types

type ToVertex AdjacencyIntMap :: *

Methods

toGraph :: AdjacencyIntMap -> Graph (ToVertex AdjacencyIntMap)

foldg :: r -> (ToVertex AdjacencyIntMap -> r) -> (r -> r -> r) -> (r -> r -> r) -> AdjacencyIntMap -> r

isEmpty :: AdjacencyIntMap -> Bool

size :: AdjacencyIntMap -> Int

hasVertex :: ToVertex AdjacencyIntMap -> AdjacencyIntMap -> Bool

hasEdge :: ToVertex AdjacencyIntMap -> ToVertex AdjacencyIntMap -> AdjacencyIntMap -> Bool

vertexCount :: AdjacencyIntMap -> Int

edgeCount :: AdjacencyIntMap -> Int

vertexList :: AdjacencyIntMap -> [ToVertex AdjacencyIntMap]

edgeList :: AdjacencyIntMap -> [(ToVertex AdjacencyIntMap, ToVertex AdjacencyIntMap)]

vertexSet :: AdjacencyIntMap -> Set (ToVertex AdjacencyIntMap)

vertexIntSet :: AdjacencyIntMap -> IntSet

edgeSet :: AdjacencyIntMap -> Set (ToVertex AdjacencyIntMap, ToVertex AdjacencyIntMap)

preSet :: ToVertex AdjacencyIntMap -> AdjacencyIntMap -> Set (ToVertex AdjacencyIntMap)

preIntSet :: Int -> AdjacencyIntMap -> IntSet

postSet :: ToVertex AdjacencyIntMap -> AdjacencyIntMap -> Set (ToVertex AdjacencyIntMap)

postIntSet :: Int -> AdjacencyIntMap -> IntSet

adjacencyList :: AdjacencyIntMap -> [(ToVertex AdjacencyIntMap, [ToVertex AdjacencyIntMap])]

adjacencyMap :: AdjacencyIntMap -> Map (ToVertex AdjacencyIntMap) (Set (ToVertex AdjacencyIntMap))

adjacencyIntMap :: AdjacencyIntMap -> IntMap IntSet

adjacencyMapTranspose :: AdjacencyIntMap -> Map (ToVertex AdjacencyIntMap) (Set (ToVertex AdjacencyIntMap))

adjacencyIntMapTranspose :: AdjacencyIntMap -> IntMap IntSet

dfsForest :: AdjacencyIntMap -> Forest (ToVertex AdjacencyIntMap)

dfsForestFrom :: [ToVertex AdjacencyIntMap] -> AdjacencyIntMap -> Forest (ToVertex AdjacencyIntMap)

dfs :: [ToVertex AdjacencyIntMap] -> AdjacencyIntMap -> [ToVertex AdjacencyIntMap]

reachable :: ToVertex AdjacencyIntMap -> AdjacencyIntMap -> [ToVertex AdjacencyIntMap]

topSort :: AdjacencyIntMap -> Maybe [ToVertex AdjacencyIntMap]

isAcyclic :: AdjacencyIntMap -> Bool

toAdjacencyMap :: AdjacencyIntMap -> AdjacencyMap (ToVertex AdjacencyIntMap)

toAdjacencyMapTranspose :: AdjacencyIntMap -> AdjacencyMap (ToVertex AdjacencyIntMap)

toAdjacencyIntMap :: AdjacencyIntMap -> AdjacencyIntMap

toAdjacencyIntMapTranspose :: AdjacencyIntMap -> AdjacencyIntMap

isDfsForestOf :: Forest (ToVertex AdjacencyIntMap) -> AdjacencyIntMap -> Bool

isTopSortOf :: [ToVertex AdjacencyIntMap] -> AdjacencyIntMap -> Bool

Ord a => ToGraph (AdjacencyMap a)

Defined in Algebra.Graph.ToGraph

Associated Types

type ToVertex (AdjacencyMap a) :: *

Methods

toGraph :: AdjacencyMap a -> Graph (ToVertex (AdjacencyMap a))

foldg :: r -> (ToVertex (AdjacencyMap a) -> r) -> (r -> r -> r) -> (r -> r -> r) -> AdjacencyMap a -> r

isEmpty :: AdjacencyMap a -> Bool

size :: AdjacencyMap a -> Int

hasVertex :: ToVertex (AdjacencyMap a) -> AdjacencyMap a -> Bool

hasEdge :: ToVertex (AdjacencyMap a) -> ToVertex (AdjacencyMap a) -> AdjacencyMap a -> Bool

vertexCount :: AdjacencyMap a -> Int

edgeCount :: AdjacencyMap a -> Int

vertexList :: AdjacencyMap a -> [ToVertex (AdjacencyMap a)]

edgeList :: AdjacencyMap a -> [(ToVertex (AdjacencyMap a), ToVertex (AdjacencyMap a))]

vertexSet :: AdjacencyMap a -> Set (ToVertex (AdjacencyMap a))

vertexIntSet :: AdjacencyMap a -> IntSet

edgeSet :: AdjacencyMap a -> Set (ToVertex (AdjacencyMap a), ToVertex (AdjacencyMap a))

preSet :: ToVertex (AdjacencyMap a) -> AdjacencyMap a -> Set (ToVertex (AdjacencyMap a))

preIntSet :: Int -> AdjacencyMap a -> IntSet

postSet :: ToVertex (AdjacencyMap a) -> AdjacencyMap a -> Set (ToVertex (AdjacencyMap a))

postIntSet :: Int -> AdjacencyMap a -> IntSet

adjacencyList :: AdjacencyMap a -> [(ToVertex (AdjacencyMap a), [ToVertex (AdjacencyMap a)])]

adjacencyMap :: AdjacencyMap a -> Map (ToVertex (AdjacencyMap a)) (Set (ToVertex (AdjacencyMap a)))

adjacencyIntMap :: AdjacencyMap a -> IntMap IntSet

adjacencyMapTranspose :: AdjacencyMap a -> Map (ToVertex (AdjacencyMap a)) (Set (ToVertex (AdjacencyMap a)))

adjacencyIntMapTranspose :: AdjacencyMap a -> IntMap IntSet

dfsForest :: AdjacencyMap a -> Forest (ToVertex (AdjacencyMap a))

dfsForestFrom :: [ToVertex (AdjacencyMap a)] -> AdjacencyMap a -> Forest (ToVertex (AdjacencyMap a))

dfs :: [ToVertex (AdjacencyMap a)] -> AdjacencyMap a -> [ToVertex (AdjacencyMap a)]

reachable :: ToVertex (AdjacencyMap a) -> AdjacencyMap a -> [ToVertex (AdjacencyMap a)]

topSort :: AdjacencyMap a -> Maybe [ToVertex (AdjacencyMap a)]

isAcyclic :: AdjacencyMap a -> Bool

toAdjacencyMap :: AdjacencyMap a -> AdjacencyMap (ToVertex (AdjacencyMap a))

toAdjacencyMapTranspose :: AdjacencyMap a -> AdjacencyMap (ToVertex (AdjacencyMap a))

toAdjacencyIntMap :: AdjacencyMap a -> AdjacencyIntMap

toAdjacencyIntMapTranspose :: AdjacencyMap a -> AdjacencyIntMap

isDfsForestOf :: Forest (ToVertex (AdjacencyMap a)) -> AdjacencyMap a -> Bool

isTopSortOf :: [ToVertex (AdjacencyMap a)] -> AdjacencyMap a -> Bool

Ord a => ToGraph (Relation a)

Defined in Algebra.Graph.ToGraph

Associated Types

type ToVertex (Relation a) :: *

Methods

toGraph :: Relation a -> Graph (ToVertex (Relation a))

foldg :: r -> (ToVertex (Relation a) -> r) -> (r -> r -> r) -> (r -> r -> r) -> Relation a -> r

isEmpty :: Relation a -> Bool

size :: Relation a -> Int

hasVertex :: ToVertex (Relation a) -> Relation a -> Bool

hasEdge :: ToVertex (Relation a) -> ToVertex (Relation a) -> Relation a -> Bool

vertexCount :: Relation a -> Int

edgeCount :: Relation a -> Int

vertexList :: Relation a -> [ToVertex (Relation a)]

edgeList :: Relation a -> [(ToVertex (Relation a), ToVertex (Relation a))]

vertexSet :: Relation a -> Set (ToVertex (Relation a))

vertexIntSet :: Relation a -> IntSet

edgeSet :: Relation a -> Set (ToVertex (Relation a), ToVertex (Relation a))

preSet :: ToVertex (Relation a) -> Relation a -> Set (ToVertex (Relation a))

preIntSet :: Int -> Relation a -> IntSet

postSet :: ToVertex (Relation a) -> Relation a -> Set (ToVertex (Relation a))

postIntSet :: Int -> Relation a -> IntSet

adjacencyList :: Relation a -> [(ToVertex (Relation a), [ToVertex (Relation a)])]

adjacencyMap :: Relation a -> Map (ToVertex (Relation a)) (Set (ToVertex (Relation a)))

adjacencyIntMap :: Relation a -> IntMap IntSet

adjacencyMapTranspose :: Relation a -> Map (ToVertex (Relation a)) (Set (ToVertex (Relation a)))

adjacencyIntMapTranspose :: Relation a -> IntMap IntSet

dfsForest :: Relation a -> Forest (ToVertex (Relation a))

dfsForestFrom :: [ToVertex (Relation a)] -> Relation a -> Forest (ToVertex (Relation a))

dfs :: [ToVertex (Relation a)] -> Relation a -> [ToVertex (Relation a)]

reachable :: ToVertex (Relation a) -> Relation a -> [ToVertex (Relation a)]

topSort :: Relation a -> Maybe [ToVertex (Relation a)]

isAcyclic :: Relation a -> Bool

toAdjacencyMap :: Relation a -> AdjacencyMap (ToVertex (Relation a))

toAdjacencyMapTranspose :: Relation a -> AdjacencyMap (ToVertex (Relation a))

toAdjacencyIntMap :: Relation a -> AdjacencyIntMap

toAdjacencyIntMapTranspose :: Relation a -> AdjacencyIntMap

isDfsForestOf :: Forest (ToVertex (Relation a)) -> Relation a -> Bool

isTopSortOf :: [ToVertex (Relation a)] -> Relation a -> Bool

Ord a => ToGraph (Graph a)

Defined in Algebra.Graph.ToGraph

Associated Types

type ToVertex (Graph a) :: *

Methods

toGraph :: Graph a -> Graph (ToVertex (Graph a))

foldg :: r -> (ToVertex (Graph a) -> r) -> (r -> r -> r) -> (r -> r -> r) -> Graph a -> r

isEmpty :: Graph a -> Bool

size :: Graph a -> Int

hasVertex :: ToVertex (Graph a) -> Graph a -> Bool

hasEdge :: ToVertex (Graph a) -> ToVertex (Graph a) -> Graph a -> Bool

vertexCount :: Graph a -> Int

edgeCount :: Graph a -> Int

vertexList :: Graph a -> [ToVertex (Graph a)]

edgeList :: Graph a -> [(ToVertex (Graph a), ToVertex (Graph a))]

vertexSet :: Graph a -> Set (ToVertex (Graph a))

vertexIntSet :: Graph a -> IntSet

edgeSet :: Graph a -> Set (ToVertex (Graph a), ToVertex (Graph a))

preSet :: ToVertex (Graph a) -> Graph a -> Set (ToVertex (Graph a))

preIntSet :: Int -> Graph a -> IntSet

postSet :: ToVertex (Graph a) -> Graph a -> Set (ToVertex (Graph a))

postIntSet :: Int -> Graph a -> IntSet

adjacencyList :: Graph a -> [(ToVertex (Graph a), [ToVertex (Graph a)])]

adjacencyMap :: Graph a -> Map (ToVertex (Graph a)) (Set (ToVertex (Graph a)))

adjacencyIntMap :: Graph a -> IntMap IntSet

adjacencyMapTranspose :: Graph a -> Map (ToVertex (Graph a)) (Set (ToVertex (Graph a)))

adjacencyIntMapTranspose :: Graph a -> IntMap IntSet

dfsForest :: Graph a -> Forest (ToVertex (Graph a))

dfsForestFrom :: [ToVertex (Graph a)] -> Graph a -> Forest (ToVertex (Graph a))

dfs :: [ToVertex (Graph a)] -> Graph a -> [ToVertex (Graph a)]

reachable :: ToVertex (Graph a) -> Graph a -> [ToVertex (Graph a)]

topSort :: Graph a -> Maybe [ToVertex (Graph a)]

isAcyclic :: Graph a -> Bool

toAdjacencyMap :: Graph a -> AdjacencyMap (ToVertex (Graph a))

toAdjacencyMapTranspose :: Graph a -> AdjacencyMap (ToVertex (Graph a))

toAdjacencyIntMap :: Graph a -> AdjacencyIntMap

toAdjacencyIntMapTranspose :: Graph a -> AdjacencyIntMap

isDfsForestOf :: Forest (ToVertex (Graph a)) -> Graph a -> Bool

isTopSortOf :: [ToVertex (Graph a)] -> Graph a -> Bool

ToGraph (NonEmptyGraph a)

Defined in Algebra.Graph.NonEmpty

Associated Types

type ToVertex (NonEmptyGraph a) :: *

Methods

toGraph :: NonEmptyGraph a -> Graph (ToVertex (NonEmptyGraph a))

foldg :: r -> (ToVertex (NonEmptyGraph a) -> r) -> (r -> r -> r) -> (r -> r -> r) -> NonEmptyGraph a -> r

isEmpty :: NonEmptyGraph a -> Bool

size :: NonEmptyGraph a -> Int

hasVertex :: ToVertex (NonEmptyGraph a) -> NonEmptyGraph a -> Bool

hasEdge :: ToVertex (NonEmptyGraph a) -> ToVertex (NonEmptyGraph a) -> NonEmptyGraph a -> Bool

vertexCount :: NonEmptyGraph a -> Int

edgeCount :: NonEmptyGraph a -> Int

vertexList :: NonEmptyGraph a -> [ToVertex (NonEmptyGraph a)]

edgeList :: NonEmptyGraph a -> [(ToVertex (NonEmptyGraph a), ToVertex (NonEmptyGraph a))]

vertexSet :: NonEmptyGraph a -> Set (ToVertex (NonEmptyGraph a))

vertexIntSet :: NonEmptyGraph a -> IntSet

edgeSet :: NonEmptyGraph a -> Set (ToVertex (NonEmptyGraph a), ToVertex (NonEmptyGraph a))

preSet :: ToVertex (NonEmptyGraph a) -> NonEmptyGraph a -> Set (ToVertex (NonEmptyGraph a))

preIntSet :: Int -> NonEmptyGraph a -> IntSet

postSet :: ToVertex (NonEmptyGraph a) -> NonEmptyGraph a -> Set (ToVertex (NonEmptyGraph a))

postIntSet :: Int -> NonEmptyGraph a -> IntSet

adjacencyList :: NonEmptyGraph a -> [(ToVertex (NonEmptyGraph a), [ToVertex (NonEmptyGraph a)])]

adjacencyMap :: NonEmptyGraph a -> Map (ToVertex (NonEmptyGraph a)) (Set (ToVertex (NonEmptyGraph a)))

adjacencyIntMap :: NonEmptyGraph a -> IntMap IntSet

adjacencyMapTranspose :: NonEmptyGraph a -> Map (ToVertex (NonEmptyGraph a)) (Set (ToVertex (NonEmptyGraph a)))

adjacencyIntMapTranspose :: NonEmptyGraph a -> IntMap IntSet

dfsForest :: NonEmptyGraph a -> Forest (ToVertex (NonEmptyGraph a))

dfsForestFrom :: [ToVertex (NonEmptyGraph a)] -> NonEmptyGraph a -> Forest (ToVertex (NonEmptyGraph a))

dfs :: [ToVertex (NonEmptyGraph a)] -> NonEmptyGraph a -> [ToVertex (NonEmptyGraph a)]

reachable :: ToVertex (NonEmptyGraph a) -> NonEmptyGraph a -> [ToVertex (NonEmptyGraph a)]

topSort :: NonEmptyGraph a -> Maybe [ToVertex (NonEmptyGraph a)]

isAcyclic :: NonEmptyGraph a -> Bool

toAdjacencyMap :: NonEmptyGraph a -> AdjacencyMap (ToVertex (NonEmptyGraph a))

toAdjacencyMapTranspose :: NonEmptyGraph a -> AdjacencyMap (ToVertex (NonEmptyGraph a))

toAdjacencyIntMap :: NonEmptyGraph a -> AdjacencyIntMap

toAdjacencyIntMapTranspose :: NonEmptyGraph a -> AdjacencyIntMap

isDfsForestOf :: Forest (ToVertex (NonEmptyGraph a)) -> NonEmptyGraph a -> Bool

isTopSortOf :: [ToVertex (NonEmptyGraph a)] -> NonEmptyGraph a -> Bool

ToGraph (Fold a)

Defined in Algebra.Graph.Fold

Associated Types

type ToVertex (Fold a) :: *

Methods

toGraph :: Fold a -> Graph (ToVertex (Fold a))

foldg :: r -> (ToVertex (Fold a) -> r) -> (r -> r -> r) -> (r -> r -> r) -> Fold a -> r

isEmpty :: Fold a -> Bool

size :: Fold a -> Int

hasVertex :: ToVertex (Fold a) -> Fold a -> Bool

hasEdge :: ToVertex (Fold a) -> ToVertex (Fold a) -> Fold a -> Bool

vertexCount :: Fold a -> Int

edgeCount :: Fold a -> Int

vertexList :: Fold a -> [ToVertex (Fold a)]

edgeList :: Fold a -> [(ToVertex (Fold a), ToVertex (Fold a))]

vertexSet :: Fold a -> Set (ToVertex (Fold a))

vertexIntSet :: Fold a -> IntSet

edgeSet :: Fold a -> Set (ToVertex (Fold a), ToVertex (Fold a))

preSet :: ToVertex (Fold a) -> Fold a -> Set (ToVertex (Fold a))

preIntSet :: Int -> Fold a -> IntSet

postSet :: ToVertex (Fold a) -> Fold a -> Set (ToVertex (Fold a))

postIntSet :: Int -> Fold a -> IntSet

adjacencyList :: Fold a -> [(ToVertex (Fold a), [ToVertex (Fold a)])]

adjacencyMap :: Fold a -> Map (ToVertex (Fold a)) (Set (ToVertex (Fold a)))

adjacencyIntMap :: Fold a -> IntMap IntSet

adjacencyMapTranspose :: Fold a -> Map (ToVertex (Fold a)) (Set (ToVertex (Fold a)))

adjacencyIntMapTranspose :: Fold a -> IntMap IntSet

dfsForest :: Fold a -> Forest (ToVertex (Fold a))

dfsForestFrom :: [ToVertex (Fold a)] -> Fold a -> Forest (ToVertex (Fold a))

dfs :: [ToVertex (Fold a)] -> Fold a -> [ToVertex (Fold a)]

reachable :: ToVertex (Fold a) -> Fold a -> [ToVertex (Fold a)]

topSort :: Fold a -> Maybe [ToVertex (Fold a)]

isAcyclic :: Fold a -> Bool

toAdjacencyMap :: Fold a -> AdjacencyMap (ToVertex (Fold a))

toAdjacencyMapTranspose :: Fold a -> AdjacencyMap (ToVertex (Fold a))

toAdjacencyIntMap :: Fold a -> AdjacencyIntMap

toAdjacencyIntMapTranspose :: Fold a -> AdjacencyIntMap

isDfsForestOf :: Forest (ToVertex (Fold a)) -> Fold a -> Bool

isTopSortOf :: [ToVertex (Fold a)] -> Fold a -> Bool