{-# LANGUAGE TypeFamilies, PatternGuards, RankNTypes #-}
-- | An adapter to create graphs with labeled vertices and unlabeled edges.
--
-- See 'LabeledGraph' for an overview.  The only significant difference
-- is that this graph only supports adding unlabeled edges, and thus you
-- must use 'addEdge' instead of 'addLabeledEdge'.
module Data.Graph.Haggle.VertexLabelAdapter (
  VertexLabeledMGraph,
  VertexLabeledGraph,
  -- * Mutable Graph API
  newVertexLabeledGraph,
  newSizedVertexLabeledGraph,
  -- * Immutable Graph API
  mapVertexLabel,
  fromEdgeList
  ) where

import qualified Control.DeepSeq as DS
import qualified Control.Monad.Primitive as P
import qualified Control.Monad.Ref as R
import Control.Monad.ST ( ST, runST )

import qualified Data.Graph.Haggle.Classes as I
import qualified Data.Graph.Haggle.VertexMap as VM
import qualified Data.Graph.Haggle.Internal.Adapter as A

newtype VertexLabeledMGraph g nl m = VLMG { forall (g :: (* -> *) -> *) nl (m :: * -> *).
VertexLabeledMGraph g nl m -> LabeledMGraph g nl () m
unVLMG :: A.LabeledMGraph g nl () m }
newtype VertexLabeledGraph g nl = VLG { forall g nl. VertexLabeledGraph g nl -> LabeledGraph g nl ()
unVLG :: A.LabeledGraph g nl () }

instance (DS.NFData g, DS.NFData nl) => DS.NFData (VertexLabeledGraph g nl) where
  rnf :: VertexLabeledGraph g nl -> ()
rnf (VLG LabeledGraph g nl ()
g) = LabeledGraph g nl ()
g forall a b. NFData a => a -> b -> b
`DS.deepseq` ()

mapVertexLabel :: VertexLabeledGraph g nl -> (nl -> nl') -> VertexLabeledGraph g nl'
mapVertexLabel :: forall g nl nl'.
VertexLabeledGraph g nl -> (nl -> nl') -> VertexLabeledGraph g nl'
mapVertexLabel VertexLabeledGraph g nl
g = forall g nl. LabeledGraph g nl () -> VertexLabeledGraph g nl
VLG forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl el nl'.
LabeledGraph g nl el -> (nl -> nl') -> LabeledGraph g nl' el
A.mapVertexLabel (forall g nl. VertexLabeledGraph g nl -> LabeledGraph g nl ()
unVLG VertexLabeledGraph g nl
g)
{-# INLINE mapVertexLabel #-}

vertices :: (I.Graph g) => VertexLabeledGraph g nl -> [I.Vertex]
vertices :: forall g nl. Graph g => VertexLabeledGraph g nl -> [Vertex]
vertices = forall g. Graph g => g -> [Vertex]
I.vertices forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl. VertexLabeledGraph g nl -> LabeledGraph g nl ()
unVLG
{-# INLINE vertices #-}

edges :: (I.Graph g) => VertexLabeledGraph g nl -> [I.Edge]
edges :: forall g nl. Graph g => VertexLabeledGraph g nl -> [Edge]
edges = forall g. Graph g => g -> [Edge]
I.edges forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl. VertexLabeledGraph g nl -> LabeledGraph g nl ()
unVLG
{-# INLINE edges #-}

successors :: (I.Graph g) => VertexLabeledGraph g nl -> I.Vertex -> [I.Vertex]
successors :: forall g nl.
Graph g =>
VertexLabeledGraph g nl -> Vertex -> [Vertex]
successors (VLG LabeledGraph g nl ()
lg) = forall g. Graph g => g -> Vertex -> [Vertex]
I.successors LabeledGraph g nl ()
lg
{-# INLINE successors #-}

outEdges :: (I.Graph g) => VertexLabeledGraph g nl -> I.Vertex -> [I.Edge]
outEdges :: forall g nl. Graph g => VertexLabeledGraph g nl -> Vertex -> [Edge]
outEdges (VLG LabeledGraph g nl ()
lg) = forall g. Graph g => g -> Vertex -> [Edge]
I.outEdges LabeledGraph g nl ()
lg
{-# INLINE outEdges #-}

edgesBetween :: (I.Graph g) => VertexLabeledGraph g nl -> I.Vertex -> I.Vertex -> [I.Edge]
edgesBetween :: forall g nl.
Graph g =>
VertexLabeledGraph g nl -> Vertex -> Vertex -> [Edge]
edgesBetween (VLG LabeledGraph g nl ()
lg) = forall g. Graph g => g -> Vertex -> Vertex -> [Edge]
I.edgesBetween LabeledGraph g nl ()
lg
{-# INLINE edgesBetween #-}

maxVertexId :: (I.Graph g) => VertexLabeledGraph g nl -> Int
maxVertexId :: forall g nl. Graph g => VertexLabeledGraph g nl -> Int
maxVertexId = forall g. Graph g => g -> Int
I.maxVertexId forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl. VertexLabeledGraph g nl -> LabeledGraph g nl ()
unVLG
{-# INLINE maxVertexId #-}

isEmpty :: (I.Graph g) => VertexLabeledGraph g nl -> Bool
isEmpty :: forall g nl. Graph g => VertexLabeledGraph g nl -> Bool
isEmpty = forall g. Graph g => g -> Bool
I.isEmpty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl. VertexLabeledGraph g nl -> LabeledGraph g nl ()
unVLG
{-# INLINE isEmpty #-}

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

instance (I.Thawable g) => I.Thawable (VertexLabeledGraph g nl) where
  type MutableGraph (VertexLabeledGraph g nl) =
    VertexLabeledMGraph (I.MutableGraph g) nl
  thaw :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
VertexLabeledGraph g nl
-> m (MutableGraph (VertexLabeledGraph g nl) m)
thaw (VLG LabeledGraph g nl ()
lg) = do
    LabeledMGraph (MutableGraph g) nl () m
g' <- forall g (m :: * -> *).
(Thawable g, PrimMonad m, MonadRef m) =>
g -> m (MutableGraph g m)
I.thaw LabeledGraph g nl ()
lg
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (g :: (* -> *) -> *) nl (m :: * -> *).
LabeledMGraph g nl () m -> VertexLabeledMGraph g nl m
VLMG LabeledMGraph (MutableGraph g) nl () m
g'


predecessors :: (I.Bidirectional g) => VertexLabeledGraph g nl -> I.Vertex -> [I.Vertex]
predecessors :: forall g nl.
Bidirectional g =>
VertexLabeledGraph g nl -> Vertex -> [Vertex]
predecessors (VLG LabeledGraph g nl ()
lg) = forall g. Bidirectional g => g -> Vertex -> [Vertex]
I.predecessors LabeledGraph g nl ()
lg
{-# INLINE predecessors #-}

inEdges :: (I.Bidirectional g) => VertexLabeledGraph g nl -> I.Vertex -> [I.Edge]
inEdges :: forall g nl.
Bidirectional g =>
VertexLabeledGraph g nl -> Vertex -> [Edge]
inEdges (VLG LabeledGraph g nl ()
lg) = forall g. Bidirectional g => g -> Vertex -> [Edge]
I.inEdges LabeledGraph g nl ()
lg
{-# INLINE inEdges #-}

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

vertexLabel :: (I.Graph g) => VertexLabeledGraph g nl -> I.Vertex -> Maybe nl
vertexLabel :: forall g nl.
Graph g =>
VertexLabeledGraph g nl -> Vertex -> Maybe nl
vertexLabel (VLG LabeledGraph g nl ()
g) = forall g. HasVertexLabel g => g -> Vertex -> Maybe (VertexLabel g)
I.vertexLabel LabeledGraph g nl ()
g
{-# INLINE vertexLabel #-}

instance (I.Graph g) => I.HasVertexLabel (VertexLabeledGraph g nl) where
  type VertexLabel (VertexLabeledGraph g nl) = nl
  vertexLabel :: VertexLabeledGraph g nl
-> Vertex -> Maybe (VertexLabel (VertexLabeledGraph g nl))
vertexLabel = forall g nl.
Graph g =>
VertexLabeledGraph g nl -> Vertex -> Maybe nl
vertexLabel
  labeledVertices :: VertexLabeledGraph g nl
-> [(Vertex, VertexLabel (VertexLabeledGraph g nl))]
labeledVertices = forall g nl. Graph g => VertexLabeledGraph g nl -> [(Vertex, nl)]
labeledVertices

labeledVertices :: (I.Graph g) => VertexLabeledGraph g nl -> [(I.Vertex, nl)]
labeledVertices :: forall g nl. Graph g => VertexLabeledGraph g nl -> [(Vertex, nl)]
labeledVertices = forall g. HasVertexLabel g => g -> [(Vertex, VertexLabel g)]
I.labeledVertices forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl. VertexLabeledGraph g nl -> LabeledGraph g nl ()
unVLG
{-# INLINE labeledVertices #-}

newVertexLabeledGraph :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                      => m (g m)
                      -> m (VertexLabeledMGraph g nl m)
newVertexLabeledGraph :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, PrimMonad m, MonadRef m) =>
m (g m) -> m (VertexLabeledMGraph g nl m)
newVertexLabeledGraph 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 :: (* -> *) -> *) nl (m :: * -> *).
LabeledMGraph g nl () m -> VertexLabeledMGraph g nl m
VLMG LabeledMGraph g nl () m
g
{-# INLINE newVertexLabeledGraph #-}

newSizedVertexLabeledGraph :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                           => (Int -> Int -> m (g m))
                           -> Int
                           -> Int
                           -> m (VertexLabeledMGraph g nl m)
newSizedVertexLabeledGraph :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, PrimMonad m, MonadRef m) =>
(Int -> Int -> m (g m))
-> Int -> Int -> m (VertexLabeledMGraph g nl m)
newSizedVertexLabeledGraph Int -> Int -> m (g m)
newG Int
szV Int
szE = do
  LabeledMGraph g nl () 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 :: (* -> *) -> *) nl (m :: * -> *).
LabeledMGraph g nl () m -> VertexLabeledMGraph g nl m
VLMG LabeledMGraph g nl () m
g
{-# INLINE newSizedVertexLabeledGraph #-}

addEdge :: (I.MGraph g, I.MAddEdge g, P.PrimMonad m, R.MonadRef m)
        => VertexLabeledMGraph g nl m
        -> I.Vertex
        -> I.Vertex
        -> m (Maybe I.Edge)
addEdge :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> Vertex -> Vertex -> m (Maybe Edge)
addEdge VertexLabeledMGraph g nl m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MAddEdge g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> Vertex -> m (Maybe Edge)
I.addEdge (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
A.rawMGraph (forall (g :: (* -> *) -> *) nl (m :: * -> *).
VertexLabeledMGraph g nl m -> LabeledMGraph g nl () m
unVLMG VertexLabeledMGraph g nl m
lg))
{-# INLINE addEdge #-}

addLabeledVertex :: (I.MGraph g, I.MAddVertex g, P.PrimMonad m, R.MonadRef m)
                 => VertexLabeledMGraph g nl m
                 -> nl
                 -> m I.Vertex
addLabeledVertex :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, MAddVertex g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> nl -> m Vertex
addLabeledVertex VertexLabeledMGraph g nl m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MLabeledVertex g, PrimMonad m, MonadRef m) =>
g m -> MVertexLabel g -> m Vertex
I.addLabeledVertex (forall (g :: (* -> *) -> *) nl (m :: * -> *).
VertexLabeledMGraph g nl m -> LabeledMGraph g nl () m
unVLMG VertexLabeledMGraph g nl m
lg)
{-# INLINE addLabeledVertex #-}

getVertexLabel :: (I.MGraph g, I.MAddVertex g, P.PrimMonad m, R.MonadRef m)
               => VertexLabeledMGraph g nl m
               -> I.Vertex
               -> m (Maybe nl)
getVertexLabel :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, MAddVertex g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> Vertex -> m (Maybe nl)
getVertexLabel VertexLabeledMGraph g nl m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MLabeledVertex g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> m (Maybe (MVertexLabel g))
I.getVertexLabel (forall (g :: (* -> *) -> *) nl (m :: * -> *).
VertexLabeledMGraph g nl m -> LabeledMGraph g nl () m
unVLMG VertexLabeledMGraph g nl m
lg)
{-# INLINE getVertexLabel #-}

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

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

countVertices :: (I.MGraph g, P.PrimMonad m, R.MonadRef m) => VertexLabeledMGraph g nl m -> m Int
countVertices :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl 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 :: (* -> *) -> *) nl (m :: * -> *).
VertexLabeledMGraph g nl m -> LabeledMGraph g nl () m
unVLMG
{-# INLINE countVertices #-}

getVertices :: (I.MGraph g, P.PrimMonad m, R.MonadRef m) => VertexLabeledMGraph g nl m -> m [I.Vertex]
getVertices :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl 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 :: (* -> *) -> *) nl (m :: * -> *).
VertexLabeledMGraph g nl m -> LabeledMGraph g nl () m
unVLMG
{-# INLINE getVertices #-}

countEdges :: (I.MGraph g, P.PrimMonad m, R.MonadRef m) => VertexLabeledMGraph g nl m -> m Int
countEdges :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl 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 :: (* -> *) -> *) nl (m :: * -> *).
VertexLabeledMGraph g nl m -> LabeledMGraph g nl () m
unVLMG
{-# INLINE countEdges #-}

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

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

checkEdgeExists :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                => VertexLabeledMGraph g nl m
                -> I.Vertex
                -> I.Vertex
                -> m Bool
checkEdgeExists :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> Vertex -> Vertex -> m Bool
checkEdgeExists VertexLabeledMGraph g nl m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> Vertex -> m Bool
I.checkEdgeExists (forall (g :: (* -> *) -> *) nl (m :: * -> *).
VertexLabeledMGraph g nl m -> LabeledMGraph g nl () m
unVLMG VertexLabeledMGraph g nl m
lg)
{-# INLINE checkEdgeExists #-}

freeze :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
       => VertexLabeledMGraph g nl m
       -> m (VertexLabeledGraph (I.ImmutableGraph g) nl)
freeze :: forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m
-> m (VertexLabeledGraph (ImmutableGraph g) nl)
freeze VertexLabeledMGraph g nl m
lg = do
  LabeledGraph (ImmutableGraph g) nl ()
g' <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m (ImmutableGraph g)
I.freeze (forall (g :: (* -> *) -> *) nl (m :: * -> *).
VertexLabeledMGraph g nl m -> LabeledMGraph g nl () m
unVLMG VertexLabeledMGraph g nl m
lg)
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall g nl. LabeledGraph g nl () -> VertexLabeledGraph g nl
VLG LabeledGraph (ImmutableGraph g) nl ()
g'
{-# INLINE freeze #-}

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

instance (I.MAddVertex g) => I.MLabeledVertex (VertexLabeledMGraph g nl) where
  type MVertexLabel (VertexLabeledMGraph g nl) = nl
  getVertexLabel :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m
-> Vertex -> m (Maybe (MVertexLabel (VertexLabeledMGraph g nl)))
getVertexLabel = forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, MAddVertex g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> Vertex -> m (Maybe nl)
getVertexLabel
  addLabeledVertex :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m
-> MVertexLabel (VertexLabeledMGraph g nl) -> m Vertex
addLabeledVertex = forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, MAddVertex g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> nl -> m Vertex
addLabeledVertex

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

instance (I.MAddEdge g) => I.MAddEdge (VertexLabeledMGraph g nl) where
  addEdge :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> Vertex -> Vertex -> m (Maybe Edge)
addEdge = forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> Vertex -> Vertex -> m (Maybe Edge)
addEdge

-- | Build a new (immutable) graph from a list of edges.  Edges are defined
-- by pairs of /node labels/.  A new 'Vertex' will be allocated for each
-- node label.
--
-- The type of the constructed graph is controlled by the first argument,
-- which is a constructor for a mutable graph.
--
-- Example:
--
-- > import Data.Graph.Haggle.VertexLabelAdapter
-- > import Data.Graph.Haggle.SimpleBiDigraph
-- >
-- > let (g,m) = fromEdgeList newMSimpleBiDigraph [(0,1), (1,2), (2,3), (3,0)]
--
-- @g@ has type SimpleBiDigraph.
--
-- An alternative that is fully polymorphic in the return type would be
-- possible, but it would require type annotations on the result of
-- 'fromEdgeList', which could be very annoying.
fromEdgeList :: (I.MGraph g, I.MAddEdge g, I.MAddVertex g, Ord nl)
             => (forall s . ST s (g (ST s)))
             -> [(nl, nl)]
             -> (VertexLabeledGraph (I.ImmutableGraph g) nl, VM.VertexMap nl)
fromEdgeList :: forall (g :: (* -> *) -> *) nl.
(MGraph g, MAddEdge g, MAddVertex g, Ord nl) =>
(forall s. ST s (g (ST s)))
-> [(nl, nl)]
-> (VertexLabeledGraph (ImmutableGraph g) nl, VertexMap nl)
fromEdgeList forall s. ST s (g (ST s))
con [(nl, nl)]
es = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
  VertexLabeledMGraph g nl (ST s)
g <- forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, PrimMonad m, MonadRef m) =>
m (g m) -> m (VertexLabeledMGraph g nl m)
newVertexLabeledGraph forall s. ST s (g (ST s))
con
  VertexMapRef nl (ST s)
vm <- forall (m :: * -> *) nl.
(PrimMonad m, MonadRef m) =>
m (VertexMapRef nl m)
VM.newVertexMapRef
  forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (forall (g :: (* -> *) -> *) nl (m :: * -> *).
(MAddVertex g, MAddEdge g, Ord nl, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> VertexMapRef nl m -> (nl, nl) -> m ()
fromListAddEdge VertexLabeledMGraph g nl (ST s)
g VertexMapRef nl (ST s)
vm) [(nl, nl)]
es
  VertexLabeledGraph (ImmutableGraph g) nl
g' <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m (ImmutableGraph g)
I.freeze VertexLabeledMGraph g nl (ST s)
g
  VertexMap nl
vm' <- forall (m :: * -> *) nl.
(PrimMonad m, MonadRef m) =>
VertexMapRef nl m -> m (VertexMap nl)
VM.vertexMapFromRef VertexMapRef nl (ST s)
vm
  forall (m :: * -> *) a. Monad m => a -> m a
return (VertexLabeledGraph (ImmutableGraph g) nl
g', VertexMap nl
vm')

fromListAddEdge :: (I.MAddVertex g, I.MAddEdge g, Ord nl, P.PrimMonad m, R.MonadRef m)
                => VertexLabeledMGraph g nl m
                -> VM.VertexMapRef nl m
                -> (nl, nl)
                -> m ()
fromListAddEdge :: forall (g :: (* -> *) -> *) nl (m :: * -> *).
(MAddVertex g, MAddEdge g, Ord nl, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> VertexMapRef nl m -> (nl, nl) -> m ()
fromListAddEdge VertexLabeledMGraph g nl m
g VertexMapRef nl m
vm (nl
src, nl
dst) = do
  Vertex
vsrc <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MLabeledVertex g, Ord (MVertexLabel g), PrimMonad m,
 MonadRef m) =>
g m
-> VertexMapRef (MVertexLabel g) m -> MVertexLabel g -> m Vertex
VM.vertexForLabelRef VertexLabeledMGraph g nl m
g VertexMapRef nl m
vm nl
src
  Vertex
vdst <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MLabeledVertex g, Ord (MVertexLabel g), PrimMonad m,
 MonadRef m) =>
g m
-> VertexMapRef (MVertexLabel g) m -> MVertexLabel g -> m Vertex
VM.vertexForLabelRef VertexLabeledMGraph g nl m
g VertexMapRef nl m
vm nl
dst
  Maybe Edge
_ <- forall (g :: (* -> *) -> *) (m :: * -> *) nl.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
VertexLabeledMGraph g nl m -> Vertex -> Vertex -> m (Maybe Edge)
addEdge VertexLabeledMGraph g nl m
g Vertex
vsrc Vertex
vdst
  forall (m :: * -> *) a. Monad m => a -> m a
return ()