{-# LANGUAGE TypeFamilies #-}
-- | This adapter adds edge labels (but not vertex labels) to graphs.
--
-- It only supports 'addLabeledEdge', not 'addEdge'.  See 'LabeledGraph'
-- for more details.
module Data.Graph.Haggle.EdgeLabelAdapter (
  EdgeLabeledMGraph,
  EdgeLabeledGraph,
  newEdgeLabeledGraph,
  newSizedEdgeLabeledGraph,
  mapEdgeLabel
  ) where

import qualified Control.DeepSeq as DS
import qualified Control.Monad.Primitive as P
import qualified Control.Monad.Ref as R
import qualified Data.Graph.Haggle.Classes as I
import qualified Data.Graph.Haggle.Internal.Adapter as A

newtype EdgeLabeledMGraph g el s = ELMG { forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG :: A.LabeledMGraph g () el s }
newtype EdgeLabeledGraph g el = ELG { forall g el. EdgeLabeledGraph g el -> LabeledGraph g () el
unELG :: A.LabeledGraph g () el }

instance (DS.NFData g, DS.NFData el) => DS.NFData (EdgeLabeledGraph g el) where
  rnf :: EdgeLabeledGraph g el -> ()
rnf (ELG LabeledGraph g () el
g) = LabeledGraph g () el
g forall a b. NFData a => a -> b -> b
`DS.deepseq` ()

mapEdgeLabel :: EdgeLabeledGraph g el -> (el -> el') -> EdgeLabeledGraph g el'
mapEdgeLabel :: forall g el el'.
EdgeLabeledGraph g el -> (el -> el') -> EdgeLabeledGraph g el'
mapEdgeLabel EdgeLabeledGraph g el
g = forall g el. LabeledGraph g () el -> EdgeLabeledGraph g el
ELG forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl el el'.
LabeledGraph g nl el -> (el -> el') -> LabeledGraph g nl el'
A.mapEdgeLabel (forall g el. EdgeLabeledGraph g el -> LabeledGraph g () el
unELG EdgeLabeledGraph g el
g)
{-# INLINE mapEdgeLabel #-}

vertices :: (I.Graph g) => EdgeLabeledGraph g el -> [I.Vertex]
vertices :: forall g el. Graph g => EdgeLabeledGraph g el -> [Vertex]
vertices = forall g. Graph g => g -> [Vertex]
I.vertices forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g el. EdgeLabeledGraph g el -> LabeledGraph g () el
unELG
{-# INLINE vertices #-}

edges :: (I.Graph g) => EdgeLabeledGraph g el -> [I.Edge]
edges :: forall g el. Graph g => EdgeLabeledGraph g el -> [Edge]
edges = forall g. Graph g => g -> [Edge]
I.edges forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g el. EdgeLabeledGraph g el -> LabeledGraph g () el
unELG
{-# INLINE edges #-}

successors :: (I.Graph g) => EdgeLabeledGraph g el -> I.Vertex -> [I.Vertex]
successors :: forall g el. Graph g => EdgeLabeledGraph g el -> Vertex -> [Vertex]
successors (ELG LabeledGraph g () el
lg) = forall g. Graph g => g -> Vertex -> [Vertex]
I.successors LabeledGraph g () el
lg
{-# INLINE successors #-}

outEdges :: (I.Graph g) => EdgeLabeledGraph g el -> I.Vertex -> [I.Edge]
outEdges :: forall g el. Graph g => EdgeLabeledGraph g el -> Vertex -> [Edge]
outEdges (ELG LabeledGraph g () el
lg) = forall g. Graph g => g -> Vertex -> [Edge]
I.outEdges LabeledGraph g () el
lg
{-# INLINE outEdges #-}

edgesBetween :: (I.Graph g) => EdgeLabeledGraph g el -> I.Vertex -> I.Vertex -> [I.Edge]
edgesBetween :: forall g el.
Graph g =>
EdgeLabeledGraph g el -> Vertex -> Vertex -> [Edge]
edgesBetween (ELG LabeledGraph g () el
lg) = forall g. Graph g => g -> Vertex -> Vertex -> [Edge]
I.edgesBetween LabeledGraph g () el
lg
{-# INLINE edgesBetween #-}

maxVertexId :: (I.Graph g) => EdgeLabeledGraph g el -> Int
maxVertexId :: forall g el. Graph g => EdgeLabeledGraph g el -> Int
maxVertexId = forall g. Graph g => g -> Int
I.maxVertexId forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g el. EdgeLabeledGraph g el -> LabeledGraph g () el
unELG
{-# INLINE maxVertexId #-}

isEmpty :: (I.Graph g) => EdgeLabeledGraph g el -> Bool
isEmpty :: forall g el. Graph g => EdgeLabeledGraph g el -> Bool
isEmpty = forall g. Graph g => g -> Bool
I.isEmpty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g el. EdgeLabeledGraph g el -> LabeledGraph g () el
unELG
{-# INLINE isEmpty #-}

instance (I.Graph g) => I.Graph (EdgeLabeledGraph g el) where
  vertices :: EdgeLabeledGraph g el -> [Vertex]
vertices = forall g el. Graph g => EdgeLabeledGraph g el -> [Vertex]
vertices
  edges :: EdgeLabeledGraph g el -> [Edge]
edges = forall g el. Graph g => EdgeLabeledGraph g el -> [Edge]
edges
  successors :: EdgeLabeledGraph g el -> Vertex -> [Vertex]
successors = forall g el. Graph g => EdgeLabeledGraph g el -> Vertex -> [Vertex]
successors
  outEdges :: EdgeLabeledGraph g el -> Vertex -> [Edge]
outEdges = forall g el. Graph g => EdgeLabeledGraph g el -> Vertex -> [Edge]
outEdges
  edgesBetween :: EdgeLabeledGraph g el -> Vertex -> Vertex -> [Edge]
edgesBetween = forall g el.
Graph g =>
EdgeLabeledGraph g el -> Vertex -> Vertex -> [Edge]
edgesBetween
  maxVertexId :: EdgeLabeledGraph g el -> Int
maxVertexId = forall g el. Graph g => EdgeLabeledGraph g el -> Int
maxVertexId
  isEmpty :: EdgeLabeledGraph g el -> Bool
isEmpty = forall g el. Graph g => EdgeLabeledGraph g el -> Bool
isEmpty

instance (I.Thawable g) => I.Thawable (EdgeLabeledGraph g el) where
  type MutableGraph (EdgeLabeledGraph g el) =
    EdgeLabeledMGraph (I.MutableGraph g) el
  thaw :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledGraph g el -> m (MutableGraph (EdgeLabeledGraph g el) m)
thaw (ELG LabeledGraph g () el
lg) = do
    LabeledMGraph (MutableGraph g) () el m
g' <- forall g (m :: * -> *).
(Thawable g, PrimMonad m, MonadRef m) =>
g -> m (MutableGraph g m)
I.thaw LabeledGraph g () el
lg
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (g :: (* -> *) -> *) el (s :: * -> *).
LabeledMGraph g () el s -> EdgeLabeledMGraph g el s
ELMG LabeledMGraph (MutableGraph g) () el m
g'


predecessors :: (I.Bidirectional g) => EdgeLabeledGraph g el -> I.Vertex -> [I.Vertex]
predecessors :: forall g el.
Bidirectional g =>
EdgeLabeledGraph g el -> Vertex -> [Vertex]
predecessors (ELG LabeledGraph g () el
lg) = forall g. Bidirectional g => g -> Vertex -> [Vertex]
I.predecessors LabeledGraph g () el
lg
{-# INLINE predecessors #-}

inEdges :: (I.Bidirectional g) => EdgeLabeledGraph g el -> I.Vertex -> [I.Edge]
inEdges :: forall g el.
Bidirectional g =>
EdgeLabeledGraph g el -> Vertex -> [Edge]
inEdges (ELG LabeledGraph g () el
lg) = forall g. Bidirectional g => g -> Vertex -> [Edge]
I.inEdges LabeledGraph g () el
lg
{-# INLINE inEdges #-}

instance (I.Bidirectional g) => I.Bidirectional (EdgeLabeledGraph g el) where
  predecessors :: EdgeLabeledGraph g el -> Vertex -> [Vertex]
predecessors = forall g el.
Bidirectional g =>
EdgeLabeledGraph g el -> Vertex -> [Vertex]
predecessors
  inEdges :: EdgeLabeledGraph g el -> Vertex -> [Edge]
inEdges = forall g el.
Bidirectional g =>
EdgeLabeledGraph g el -> Vertex -> [Edge]
inEdges

instance (I.Bidirectional g) => I.BidirectionalEdgeLabel (EdgeLabeledGraph g el)

edgeLabel :: (I.Graph g) => EdgeLabeledGraph g el -> I.Edge -> Maybe el
edgeLabel :: forall g el. Graph g => EdgeLabeledGraph g el -> Edge -> Maybe el
edgeLabel (ELG LabeledGraph g () el
lg) = forall g. HasEdgeLabel g => g -> Edge -> Maybe (EdgeLabel g)
I.edgeLabel LabeledGraph g () el
lg
{-# INLINE edgeLabel #-}

labeledEdges :: (I.Graph g) => EdgeLabeledGraph g el -> [(I.Edge, el)]
labeledEdges :: forall g el. Graph g => EdgeLabeledGraph g el -> [(Edge, el)]
labeledEdges = forall g. HasEdgeLabel g => g -> [(Edge, EdgeLabel g)]
I.labeledEdges forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g el. EdgeLabeledGraph g el -> LabeledGraph g () el
unELG
{-# INLINE labeledEdges #-}

instance (I.Graph g) => I.HasEdgeLabel (EdgeLabeledGraph g el) where
  type EdgeLabel (EdgeLabeledGraph g el) = el
  edgeLabel :: EdgeLabeledGraph g el
-> Edge -> Maybe (EdgeLabel (EdgeLabeledGraph g el))
edgeLabel = forall g el. Graph g => EdgeLabeledGraph g el -> Edge -> Maybe el
edgeLabel
  labeledEdges :: EdgeLabeledGraph g el
-> [(Edge, EdgeLabel (EdgeLabeledGraph g el))]
labeledEdges = forall g el. Graph g => EdgeLabeledGraph g el -> [(Edge, el)]
labeledEdges

newEdgeLabeledGraph :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                    => m (g m)
                    -> m (EdgeLabeledMGraph g nl m)
newEdgeLabeledGraph :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, PrimMonad m, MonadRef m) =>
m (g m) -> m (EdgeLabeledMGraph g nl m)
newEdgeLabeledGraph m (g m)
newG = do
  LabeledMGraph g () nl m
g <- forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
m (g m) -> m (LabeledMGraph g nl el m)
A.newLabeledGraph m (g m)
newG
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (g :: (* -> *) -> *) el (s :: * -> *).
LabeledMGraph g () el s -> EdgeLabeledMGraph g el s
ELMG LabeledMGraph g () nl m
g
{-# INLINE newEdgeLabeledGraph #-}

newSizedEdgeLabeledGraph :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                         => (Int -> Int -> m (g m))
                         -> Int
                         -> Int
                         -> m (EdgeLabeledMGraph g el m)
newSizedEdgeLabeledGraph :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
(Int -> Int -> m (g m))
-> Int -> Int -> m (EdgeLabeledMGraph g el m)
newSizedEdgeLabeledGraph Int -> Int -> m (g m)
newG Int
szV Int
szE = do
  LabeledMGraph g () el m
g <- forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
(Int -> Int -> m (g m))
-> Int -> Int -> m (LabeledMGraph g nl el m)
A.newSizedLabeledGraph Int -> Int -> m (g m)
newG Int
szV Int
szE
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (g :: (* -> *) -> *) el (s :: * -> *).
LabeledMGraph g () el s -> EdgeLabeledMGraph g el s
ELMG LabeledMGraph g () el m
g
{-# INLINE newSizedEdgeLabeledGraph #-}

addLabeledEdge :: (I.MGraph g, I.MAddEdge g, P.PrimMonad m, R.MonadRef m)
               => EdgeLabeledMGraph g el m
               -> I.Vertex
               -> I.Vertex
               -> el
               -> m (Maybe I.Edge)
addLabeledEdge :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m
-> Vertex -> Vertex -> el -> m (Maybe Edge)
addLabeledEdge EdgeLabeledMGraph g el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MLabeledEdge g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> Vertex -> MEdgeLabel g -> m (Maybe Edge)
I.addLabeledEdge (forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG EdgeLabeledMGraph g el m
lg)
{-# INLINE addLabeledEdge #-}

addVertex :: (I.MGraph g, I.MAddVertex g, P.PrimMonad m, R.MonadRef m)
          => EdgeLabeledMGraph g el m
          -> m I.Vertex
addVertex :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, MAddVertex g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m Vertex
addVertex EdgeLabeledMGraph g el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MAddVertex g, PrimMonad m, MonadRef m) =>
g m -> m Vertex
I.addVertex (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
A.rawMGraph (forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG EdgeLabeledMGraph g el m
lg))
{-# INLINE addVertex #-}

unsafeGetEdgeLabel :: (I.MGraph g, I.MAddEdge g, P.PrimMonad m, R.MonadRef m)
                   => EdgeLabeledMGraph g el m
                   -> I.Edge
                   -> m el
unsafeGetEdgeLabel :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Edge -> m el
unsafeGetEdgeLabel (ELMG LabeledMGraph g () el m
g) Edge
e =
  forall (g :: (* -> *) -> *) (m :: * -> *).
(MLabeledEdge g, PrimMonad m, MonadRef m) =>
g m -> Edge -> m (MEdgeLabel g)
I.unsafeGetEdgeLabel LabeledMGraph g () el m
g Edge
e
{-# INLINE unsafeGetEdgeLabel #-}

getSuccessors :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
              => EdgeLabeledMGraph g el m
              -> I.Vertex
              -> m [I.Vertex]
getSuccessors :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Vertex]
getSuccessors EdgeLabeledMGraph g el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> m [Vertex]
I.getSuccessors (forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG EdgeLabeledMGraph g el m
lg)
{-# INLINE getSuccessors #-}

getOutEdges :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
            => EdgeLabeledMGraph g el m -> I.Vertex -> m [I.Edge]
getOutEdges :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Edge]
getOutEdges EdgeLabeledMGraph g el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> m [Edge]
I.getOutEdges (forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG EdgeLabeledMGraph g el m
lg)
{-# INLINE getOutEdges #-}

countVertices :: (I.MGraph g, P.PrimMonad m, R.MonadRef m) => EdgeLabeledMGraph g el m -> m Int
countVertices :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m Int
countVertices = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m Int
I.countVertices forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG
{-# INLINE countVertices #-}

getVertices :: (I.MGraph g, P.PrimMonad m, R.MonadRef m) => EdgeLabeledMGraph g el m -> m [I.Vertex]
getVertices :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m [Vertex]
getVertices = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m [Vertex]
I.getVertices forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG
{-# INLINE getVertices #-}

countEdges :: (I.MGraph g, P.PrimMonad m, R.MonadRef m) => EdgeLabeledMGraph g el m -> m Int
countEdges :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m Int
countEdges = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m Int
I.countEdges forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG
{-# INLINE countEdges #-}

getPredecessors :: (I.MBidirectional g, P.PrimMonad m, R.MonadRef m)
                => EdgeLabeledMGraph g el m -> I.Vertex -> m [I.Vertex]
getPredecessors :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MBidirectional g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Vertex]
getPredecessors EdgeLabeledMGraph g el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MBidirectional g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> m [Vertex]
I.getPredecessors (forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG EdgeLabeledMGraph g el m
lg)
{-# INLINE getPredecessors #-}

getInEdges :: (I.MBidirectional g, P.PrimMonad m, R.MonadRef m)
           => EdgeLabeledMGraph g el m -> I.Vertex -> m [I.Edge]
getInEdges :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MBidirectional g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Edge]
getInEdges EdgeLabeledMGraph g el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MBidirectional g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> m [Edge]
I.getInEdges (forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG EdgeLabeledMGraph g el m
lg)
{-# INLINE getInEdges #-}

checkEdgeExists :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                => EdgeLabeledMGraph g el m
                -> I.Vertex
                -> I.Vertex
                -> m Bool
checkEdgeExists :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> Vertex -> m Bool
checkEdgeExists EdgeLabeledMGraph g el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> Vertex -> m Bool
I.checkEdgeExists (forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG EdgeLabeledMGraph g el m
lg)
{-# INLINE checkEdgeExists #-}

freeze :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
       => EdgeLabeledMGraph g el m
       -> m (EdgeLabeledGraph (I.ImmutableGraph g) el)
freeze :: forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m
-> m (EdgeLabeledGraph (ImmutableGraph g) el)
freeze EdgeLabeledMGraph g el m
lg = do
  LabeledGraph (ImmutableGraph g) () el
g' <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m (ImmutableGraph g)
I.freeze (forall (g :: (* -> *) -> *) el (s :: * -> *).
EdgeLabeledMGraph g el s -> LabeledMGraph g () el s
unELMG EdgeLabeledMGraph g el m
lg)
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall g el. LabeledGraph g () el -> EdgeLabeledGraph g el
ELG LabeledGraph (ImmutableGraph g) () el
g'
{-# INLINE freeze #-}

instance (I.MGraph g) => I.MGraph (EdgeLabeledMGraph g el) where
  type ImmutableGraph (EdgeLabeledMGraph g el) =
    EdgeLabeledGraph (I.ImmutableGraph g) el
  getVertices :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m [Vertex]
getVertices = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m [Vertex]
getVertices
  getSuccessors :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Vertex]
getSuccessors = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Vertex]
getSuccessors
  getOutEdges :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Edge]
getOutEdges = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Edge]
getOutEdges
  countVertices :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m Int
countVertices = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m Int
countVertices
  countEdges :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m Int
countEdges = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m Int
countEdges
  checkEdgeExists :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> Vertex -> m Bool
checkEdgeExists = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> Vertex -> m Bool
checkEdgeExists
  freeze :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m
-> m (ImmutableGraph (EdgeLabeledMGraph g el))
freeze = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m
-> m (EdgeLabeledGraph (ImmutableGraph g) el)
freeze

instance (I.MBidirectional g) => I.MBidirectional (EdgeLabeledMGraph g el) where
  getPredecessors :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Vertex]
getPredecessors = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MBidirectional g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Vertex]
getPredecessors
  getInEdges :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Edge]
getInEdges = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MBidirectional g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Vertex -> m [Edge]
getInEdges

instance (I.MAddVertex g) => I.MAddVertex (EdgeLabeledMGraph g el) where
  addVertex :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m Vertex
addVertex = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, MAddVertex g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> m Vertex
addVertex

instance (I.MAddEdge g) => I.MLabeledEdge (EdgeLabeledMGraph g el) where
  type MEdgeLabel (EdgeLabeledMGraph g el) = el
  unsafeGetEdgeLabel :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m
-> Edge -> m (MEdgeLabel (EdgeLabeledMGraph g el))
unsafeGetEdgeLabel = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m -> Edge -> m el
unsafeGetEdgeLabel
  addLabeledEdge :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m
-> Vertex
-> Vertex
-> MEdgeLabel (EdgeLabeledMGraph g el)
-> m (Maybe Edge)
addLabeledEdge = forall (g :: (* -> *) -> *) (m :: * -> *) el.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
EdgeLabeledMGraph g el m
-> Vertex -> Vertex -> el -> m (Maybe Edge)
addLabeledEdge