fgl 5.6.0.0 → 5.7.0.0

raw patch · 6 files changed

+27/−14 lines, 6 filesdep ~QuickCheckdep ~basedep ~hspecPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: QuickCheck, base, hspec

API changes (from Hackage documentation)

- Data.Graph.Inductive.Internal.Heap: instance (GHC.Classes.Eq b, GHC.Classes.Eq a) => GHC.Classes.Eq (Data.Graph.Inductive.Internal.Heap.Heap a b)

- Data.Graph.Inductive.Internal.Heap: instance (GHC.Read.Read b, GHC.Read.Read a) => GHC.Read.Read (Data.Graph.Inductive.Internal.Heap.Heap a b)

- Data.Graph.Inductive.Internal.Heap: instance (GHC.Show.Show b, GHC.Show.Show a) => GHC.Show.Show (Data.Graph.Inductive.Internal.Heap.Heap a b)

- Data.Graph.Inductive.NodeMap: instance (GHC.Read.Read a, GHC.Classes.Ord a) => GHC.Read.Read (Data.Graph.Inductive.NodeMap.NodeMap a)

+ Data.Graph.Inductive.Internal.Heap: instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (Data.Graph.Inductive.Internal.Heap.Heap a b)

+ Data.Graph.Inductive.Internal.Heap: instance (GHC.Read.Read a, GHC.Read.Read b) => GHC.Read.Read (Data.Graph.Inductive.Internal.Heap.Heap a b)

+ Data.Graph.Inductive.Internal.Heap: instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Data.Graph.Inductive.Internal.Heap.Heap a b)

+ Data.Graph.Inductive.NodeMap: instance (GHC.Classes.Ord a, GHC.Read.Read a) => GHC.Read.Read (Data.Graph.Inductive.NodeMap.NodeMap a)

- Data.Graph.Inductive.Basic: efilter :: (DynGraph gr) => (LEdge b -> Bool) -> gr a b -> gr a b

+ Data.Graph.Inductive.Basic: efilter :: DynGraph gr => (LEdge b -> Bool) -> gr a b -> gr a b

- Data.Graph.Inductive.Basic: elfilter :: (DynGraph gr) => (b -> Bool) -> gr a b -> gr a b

+ Data.Graph.Inductive.Basic: elfilter :: DynGraph gr => (b -> Bool) -> gr a b -> gr a b

- Data.Graph.Inductive.Basic: gfold :: (Graph gr) => (Context a b -> [Node]) -> (Context a b -> c -> d) -> (Maybe d -> c -> c, c) -> [Node] -> gr a b -> c

+ Data.Graph.Inductive.Basic: gfold :: Graph gr => (Context a b -> [Node]) -> (Context a b -> c -> d) -> (Maybe d -> c -> c, c) -> [Node] -> gr a b -> c

- Data.Graph.Inductive.Basic: grev :: (DynGraph gr) => gr a b -> gr a b

+ Data.Graph.Inductive.Basic: grev :: DynGraph gr => gr a b -> gr a b

- Data.Graph.Inductive.Basic: gsel :: (Graph gr) => (Context a b -> Bool) -> gr a b -> [Context a b]

+ Data.Graph.Inductive.Basic: gsel :: Graph gr => (Context a b -> Bool) -> gr a b -> [Context a b]

- Data.Graph.Inductive.Basic: hasLoop :: (Graph gr) => gr a b -> Bool

+ Data.Graph.Inductive.Basic: hasLoop :: Graph gr => gr a b -> Bool

- Data.Graph.Inductive.Basic: isSimple :: (Graph gr) => gr a b -> Bool

+ Data.Graph.Inductive.Basic: isSimple :: Graph gr => gr a b -> Bool

- Data.Graph.Inductive.Basic: unlab :: (DynGraph gr) => gr a b -> gr () ()

+ Data.Graph.Inductive.Basic: unlab :: DynGraph gr => gr a b -> gr () ()

- Data.Graph.Inductive.Example: genLNodes :: (Enum a) => a -> Int -> [LNode a]

+ Data.Graph.Inductive.Example: genLNodes :: Enum a => a -> Int -> [LNode a]

- Data.Graph.Inductive.Example: star :: (Graph gr) => Int -> gr () ()

+ Data.Graph.Inductive.Example: star :: Graph gr => Int -> gr () ()

- Data.Graph.Inductive.Example: starM :: (GraphM m gr) => Int -> m (gr () ())

+ Data.Graph.Inductive.Example: starM :: GraphM m gr => Int -> m (gr () ())

- Data.Graph.Inductive.Example: ucycle :: (Graph gr) => Int -> gr () ()

+ Data.Graph.Inductive.Example: ucycle :: Graph gr => Int -> gr () ()

- Data.Graph.Inductive.Example: ucycleM :: (GraphM m gr) => Int -> m (gr () ())

+ Data.Graph.Inductive.Example: ucycleM :: GraphM m gr => Int -> m (gr () ())

- Data.Graph.Inductive.Graph: buildGr :: (DynGraph gr) => [Context a b] -> gr a b

+ Data.Graph.Inductive.Graph: buildGr :: DynGraph gr => [Context a b] -> gr a b

- Data.Graph.Inductive.Graph: class Graph gr where matchAny g = case labNodes g of { [] -> error "Match Exception, Empty Graph" (v, _) : _ -> (c, g') where (Just c, g') = match v g } noNodes = length . labNodes nodeRange g | isEmpty g = error "nodeRange of empty graph" | otherwise = (minimum vs, maximum vs) where vs = nodes g labEdges = ufold (\ (_, v, _, s) -> (map (\ (l, w) -> (v, w, l)) s ++)) []

+ Data.Graph.Inductive.Graph: class Graph gr

- Data.Graph.Inductive.Graph: context :: (Graph gr) => gr a b -> Node -> Context a b

+ Data.Graph.Inductive.Graph: context :: Graph gr => gr a b -> Node -> Context a b

- Data.Graph.Inductive.Graph: deg :: (Graph gr) => gr a b -> Node -> Int

+ Data.Graph.Inductive.Graph: deg :: Graph gr => gr a b -> Node -> Int

- Data.Graph.Inductive.Graph: delEdge :: (DynGraph gr) => Edge -> gr a b -> gr a b

+ Data.Graph.Inductive.Graph: delEdge :: DynGraph gr => Edge -> gr a b -> gr a b

- Data.Graph.Inductive.Graph: delEdges :: (DynGraph gr) => [Edge] -> gr a b -> gr a b

+ Data.Graph.Inductive.Graph: delEdges :: DynGraph gr => [Edge] -> gr a b -> gr a b

- Data.Graph.Inductive.Graph: delNode :: (Graph gr) => Node -> gr a b -> gr a b

+ Data.Graph.Inductive.Graph: delNode :: Graph gr => Node -> gr a b -> gr a b

- Data.Graph.Inductive.Graph: delNodes :: (Graph gr) => [Node] -> gr a b -> gr a b

+ Data.Graph.Inductive.Graph: delNodes :: Graph gr => [Node] -> gr a b -> gr a b

- Data.Graph.Inductive.Graph: edges :: (Graph gr) => gr a b -> [Edge]

+ Data.Graph.Inductive.Graph: edges :: Graph gr => gr a b -> [Edge]

- Data.Graph.Inductive.Graph: emap :: (DynGraph gr) => (b -> c) -> gr a b -> gr a c

+ Data.Graph.Inductive.Graph: emap :: DynGraph gr => (b -> c) -> gr a b -> gr a c

- Data.Graph.Inductive.Graph: gelem :: (Graph gr) => Node -> gr a b -> Bool

+ Data.Graph.Inductive.Graph: gelem :: Graph gr => Node -> gr a b -> Bool

- Data.Graph.Inductive.Graph: gmap :: (DynGraph gr) => (Context a b -> Context c d) -> gr a b -> gr c d

+ Data.Graph.Inductive.Graph: gmap :: DynGraph gr => (Context a b -> Context c d) -> gr a b -> gr c d

- Data.Graph.Inductive.Graph: indeg :: (Graph gr) => gr a b -> Node -> Int

+ Data.Graph.Inductive.Graph: indeg :: Graph gr => gr a b -> Node -> Int

- Data.Graph.Inductive.Graph: inn :: (Graph gr) => gr a b -> Node -> [LEdge b]

+ Data.Graph.Inductive.Graph: inn :: Graph gr => gr a b -> Node -> [LEdge b]

- Data.Graph.Inductive.Graph: insEdge :: (DynGraph gr) => LEdge b -> gr a b -> gr a b

+ Data.Graph.Inductive.Graph: insEdge :: DynGraph gr => LEdge b -> gr a b -> gr a b

- Data.Graph.Inductive.Graph: insEdges :: (DynGraph gr) => [LEdge b] -> gr a b -> gr a b

+ Data.Graph.Inductive.Graph: insEdges :: DynGraph gr => [LEdge b] -> gr a b -> gr a b

- Data.Graph.Inductive.Graph: insNode :: (DynGraph gr) => LNode a -> gr a b -> gr a b

+ Data.Graph.Inductive.Graph: insNode :: DynGraph gr => LNode a -> gr a b -> gr a b

- Data.Graph.Inductive.Graph: insNodes :: (DynGraph gr) => [LNode a] -> gr a b -> gr a b

+ Data.Graph.Inductive.Graph: insNodes :: DynGraph gr => [LNode a] -> gr a b -> gr a b

- Data.Graph.Inductive.Graph: lab :: (Graph gr) => gr a b -> Node -> Maybe a

+ Data.Graph.Inductive.Graph: lab :: Graph gr => gr a b -> Node -> Maybe a

- Data.Graph.Inductive.Graph: lneighbors :: (Graph gr) => gr a b -> Node -> Adj b

+ Data.Graph.Inductive.Graph: lneighbors :: Graph gr => gr a b -> Node -> Adj b

- Data.Graph.Inductive.Graph: lpre :: (Graph gr) => gr a b -> Node -> [(Node, b)]

+ Data.Graph.Inductive.Graph: lpre :: Graph gr => gr a b -> Node -> [(Node, b)]

- Data.Graph.Inductive.Graph: lsuc :: (Graph gr) => gr a b -> Node -> [(Node, b)]

+ Data.Graph.Inductive.Graph: lsuc :: Graph gr => gr a b -> Node -> [(Node, b)]

- Data.Graph.Inductive.Graph: mkUGraph :: (Graph gr) => [Node] -> [Edge] -> gr () ()

+ Data.Graph.Inductive.Graph: mkUGraph :: Graph gr => [Node] -> [Edge] -> gr () ()

- Data.Graph.Inductive.Graph: neighbors :: (Graph gr) => gr a b -> Node -> [Node]

+ Data.Graph.Inductive.Graph: neighbors :: Graph gr => gr a b -> Node -> [Node]

- Data.Graph.Inductive.Graph: nemap :: (DynGraph gr) => (a -> c) -> (b -> d) -> gr a b -> gr c d

+ Data.Graph.Inductive.Graph: nemap :: DynGraph gr => (a -> c) -> (b -> d) -> gr a b -> gr c d

- Data.Graph.Inductive.Graph: newNodes :: (Graph gr) => Int -> gr a b -> [Node]

+ Data.Graph.Inductive.Graph: newNodes :: Graph gr => Int -> gr a b -> [Node]

- Data.Graph.Inductive.Graph: nmap :: (DynGraph gr) => (a -> c) -> gr a b -> gr c b

+ Data.Graph.Inductive.Graph: nmap :: DynGraph gr => (a -> c) -> gr a b -> gr c b

- Data.Graph.Inductive.Graph: nodes :: (Graph gr) => gr a b -> [Node]

+ Data.Graph.Inductive.Graph: nodes :: Graph gr => gr a b -> [Node]

- Data.Graph.Inductive.Graph: order :: (Graph gr) => gr a b -> Int

+ Data.Graph.Inductive.Graph: order :: Graph gr => gr a b -> Int

- Data.Graph.Inductive.Graph: out :: (Graph gr) => gr a b -> Node -> [LEdge b]

+ Data.Graph.Inductive.Graph: out :: Graph gr => gr a b -> Node -> [LEdge b]

- Data.Graph.Inductive.Graph: outdeg :: (Graph gr) => gr a b -> Node -> Int

+ Data.Graph.Inductive.Graph: outdeg :: Graph gr => gr a b -> Node -> Int

- Data.Graph.Inductive.Graph: pre :: (Graph gr) => gr a b -> Node -> [Node]

+ Data.Graph.Inductive.Graph: pre :: Graph gr => gr a b -> Node -> [Node]

- Data.Graph.Inductive.Graph: size :: (Graph gr) => gr a b -> Int

+ Data.Graph.Inductive.Graph: size :: Graph gr => gr a b -> Int

- Data.Graph.Inductive.Graph: suc :: (Graph gr) => gr a b -> Node -> [Node]

+ Data.Graph.Inductive.Graph: suc :: Graph gr => gr a b -> Node -> [Node]

- Data.Graph.Inductive.Graph: ufold :: (Graph gr) => (Context a b -> c -> c) -> c -> gr a b -> c

+ Data.Graph.Inductive.Graph: ufold :: Graph gr => (Context a b -> c -> c) -> c -> gr a b -> c

- Data.Graph.Inductive.Internal.Heap: build :: (Ord a) => [(a, b)] -> Heap a b

+ Data.Graph.Inductive.Internal.Heap: build :: Ord a => [(a, b)] -> Heap a b

- Data.Graph.Inductive.Internal.Heap: deleteMin :: (Ord a) => Heap a b -> Heap a b

+ Data.Graph.Inductive.Internal.Heap: deleteMin :: Ord a => Heap a b -> Heap a b

- Data.Graph.Inductive.Internal.Heap: heapsort :: (Ord a) => [a] -> [a]

+ Data.Graph.Inductive.Internal.Heap: heapsort :: Ord a => [a] -> [a]

- Data.Graph.Inductive.Internal.Heap: insert :: (Ord a) => (a, b) -> Heap a b -> Heap a b

+ Data.Graph.Inductive.Internal.Heap: insert :: Ord a => (a, b) -> Heap a b -> Heap a b

- Data.Graph.Inductive.Internal.Heap: merge :: (Ord a) => Heap a b -> Heap a b -> Heap a b

+ Data.Graph.Inductive.Internal.Heap: merge :: Ord a => Heap a b -> Heap a b -> Heap a b

- Data.Graph.Inductive.Internal.Heap: mergeAll :: (Ord a) => [Heap a b] -> Heap a b

+ Data.Graph.Inductive.Internal.Heap: mergeAll :: Ord a => [Heap a b] -> Heap a b

- Data.Graph.Inductive.Internal.Heap: splitMin :: (Ord a) => Heap a b -> (a, b, Heap a b)

+ Data.Graph.Inductive.Internal.Heap: splitMin :: Ord a => Heap a b -> (a, b, Heap a b)

- Data.Graph.Inductive.Internal.Heap: toList :: (Ord a) => Heap a b -> [(a, b)]

+ Data.Graph.Inductive.Internal.Heap: toList :: Ord a => Heap a b -> [(a, b)]

- Data.Graph.Inductive.Monad: class (Monad m) => GraphM m gr where matchAnyM g = do { vs <- labNodesM g; case vs of { [] -> fail "Match Exception, Empty Graph" (v, _) : _ -> do { (Just c, g') <- matchM v g; return (c, g') } } } noNodesM = labNodesM >>. length nodeRangeM g = do { isE <- isEmptyM g; if isE then fail "nodeRangeM of empty graph" else do { vs <- nodesM g; return (minimum vs, maximum vs) } } labEdgesM = ufoldM (\ (p, v, _, s) -> ((map (i v) p ++ map (o v) s) ++)) [] where o v = \ (l, w) -> (v, w, l) i v = \ (l, w) -> (w, v, l)

+ Data.Graph.Inductive.Monad: class (MonadFail m) => GraphM m gr

- Data.Graph.Inductive.Monad: contextM :: (GraphM m gr) => m (gr a b) -> Node -> m (Context a b)

+ Data.Graph.Inductive.Monad: contextM :: GraphM m gr => m (gr a b) -> Node -> m (Context a b)

- Data.Graph.Inductive.Monad: delNodeM :: (GraphM m gr) => Node -> m (gr a b) -> m (gr a b)

+ Data.Graph.Inductive.Monad: delNodeM :: GraphM m gr => Node -> m (gr a b) -> m (gr a b)

- Data.Graph.Inductive.Monad: delNodesM :: (GraphM m gr) => [Node] -> m (gr a b) -> m (gr a b)

+ Data.Graph.Inductive.Monad: delNodesM :: GraphM m gr => [Node] -> m (gr a b) -> m (gr a b)

- Data.Graph.Inductive.Monad: edgesM :: (GraphM m gr) => m (gr a b) -> m [Edge]

+ Data.Graph.Inductive.Monad: edgesM :: GraphM m gr => m (gr a b) -> m [Edge]

- Data.Graph.Inductive.Monad: labM :: (GraphM m gr) => m (gr a b) -> Node -> m (Maybe a)

+ Data.Graph.Inductive.Monad: labM :: GraphM m gr => m (gr a b) -> Node -> m (Maybe a)

- Data.Graph.Inductive.Monad: mkUGraphM :: (GraphM m gr) => [Node] -> [Edge] -> m (gr () ())

+ Data.Graph.Inductive.Monad: mkUGraphM :: GraphM m gr => [Node] -> [Edge] -> m (gr () ())

- Data.Graph.Inductive.Monad: newNodesM :: (GraphM m gr) => Int -> m (gr a b) -> m [Node]

+ Data.Graph.Inductive.Monad: newNodesM :: GraphM m gr => Int -> m (gr a b) -> m [Node]

- Data.Graph.Inductive.Monad: nodesM :: (GraphM m gr) => m (gr a b) -> m [Node]

+ Data.Graph.Inductive.Monad: nodesM :: GraphM m gr => m (gr a b) -> m [Node]

- Data.Graph.Inductive.Monad: ufoldM :: (GraphM m gr) => (Context a b -> c -> c) -> c -> m (gr a b) -> m c

+ Data.Graph.Inductive.Monad: ufoldM :: GraphM m gr => (Context a b -> c -> c) -> c -> m (gr a b) -> m c

- Data.Graph.Inductive.Monad.IOArray: SGr :: (GraphRep a b) -> SGr a b

+ Data.Graph.Inductive.Monad.IOArray: SGr :: GraphRep a b -> SGr a b

- Data.Graph.Inductive.Monad.STArray: SGr :: (GraphRep s a b) -> SGr s a b

+ Data.Graph.Inductive.Monad.STArray: SGr :: GraphRep s a b -> SGr s a b

- Data.Graph.Inductive.NodeMap: mkEdge :: (Ord a) => NodeMap a -> (a, a, b) -> Maybe (LEdge b)

+ Data.Graph.Inductive.NodeMap: mkEdge :: Ord a => NodeMap a -> (a, a, b) -> Maybe (LEdge b)

- Data.Graph.Inductive.NodeMap: mkEdgeM :: (Ord a) => (a, a, b) -> NodeMapM a b g (Maybe (LEdge b))

+ Data.Graph.Inductive.NodeMap: mkEdgeM :: Ord a => (a, a, b) -> NodeMapM a b g (Maybe (LEdge b))

- Data.Graph.Inductive.NodeMap: mkEdges :: (Ord a) => NodeMap a -> [(a, a, b)] -> Maybe [LEdge b]

+ Data.Graph.Inductive.NodeMap: mkEdges :: Ord a => NodeMap a -> [(a, a, b)] -> Maybe [LEdge b]

- Data.Graph.Inductive.NodeMap: mkEdgesM :: (Ord a) => [(a, a, b)] -> NodeMapM a b g (Maybe [LEdge b])

+ Data.Graph.Inductive.NodeMap: mkEdgesM :: Ord a => [(a, a, b)] -> NodeMapM a b g (Maybe [LEdge b])

- Data.Graph.Inductive.NodeMap: mkNode :: (Ord a) => NodeMap a -> a -> (LNode a, NodeMap a)

+ Data.Graph.Inductive.NodeMap: mkNode :: Ord a => NodeMap a -> a -> (LNode a, NodeMap a)

- Data.Graph.Inductive.NodeMap: mkNodeM :: (Ord a) => a -> NodeMapM a b g (LNode a)

+ Data.Graph.Inductive.NodeMap: mkNodeM :: Ord a => a -> NodeMapM a b g (LNode a)

- Data.Graph.Inductive.NodeMap: mkNode_ :: (Ord a) => NodeMap a -> a -> LNode a

+ Data.Graph.Inductive.NodeMap: mkNode_ :: Ord a => NodeMap a -> a -> LNode a

- Data.Graph.Inductive.NodeMap: mkNodes :: (Ord a) => NodeMap a -> [a] -> ([LNode a], NodeMap a)

+ Data.Graph.Inductive.NodeMap: mkNodes :: Ord a => NodeMap a -> [a] -> ([LNode a], NodeMap a)

- Data.Graph.Inductive.NodeMap: mkNodesM :: (Ord a) => [a] -> NodeMapM a b g [LNode a]

+ Data.Graph.Inductive.NodeMap: mkNodesM :: Ord a => [a] -> NodeMapM a b g [LNode a]

- Data.Graph.Inductive.NodeMap: mkNodes_ :: (Ord a) => NodeMap a -> [a] -> [LNode a]

+ Data.Graph.Inductive.NodeMap: mkNodes_ :: Ord a => NodeMap a -> [a] -> [LNode a]

- Data.Graph.Inductive.Query.ArtPoint: ap :: (Graph gr) => gr a b -> [Node]

+ Data.Graph.Inductive.Query.ArtPoint: ap :: Graph gr => gr a b -> [Node]

- Data.Graph.Inductive.Query.BCC: bcc :: (DynGraph gr) => gr a b -> [gr a b]

+ Data.Graph.Inductive.Query.BCC: bcc :: DynGraph gr => gr a b -> [gr a b]

- Data.Graph.Inductive.Query.BFS: bfe :: (Graph gr) => Node -> gr a b -> [Edge]

+ Data.Graph.Inductive.Query.BFS: bfe :: Graph gr => Node -> gr a b -> [Edge]

- Data.Graph.Inductive.Query.BFS: bfen :: (Graph gr) => [Edge] -> gr a b -> [Edge]

+ Data.Graph.Inductive.Query.BFS: bfen :: Graph gr => [Edge] -> gr a b -> [Edge]

- Data.Graph.Inductive.Query.BFS: bfs :: (Graph gr) => Node -> gr a b -> [Node]

+ Data.Graph.Inductive.Query.BFS: bfs :: Graph gr => Node -> gr a b -> [Node]

- Data.Graph.Inductive.Query.BFS: bfsWith :: (Graph gr) => (Context a b -> c) -> Node -> gr a b -> [c]

+ Data.Graph.Inductive.Query.BFS: bfsWith :: Graph gr => (Context a b -> c) -> Node -> gr a b -> [c]

- Data.Graph.Inductive.Query.BFS: bfsn :: (Graph gr) => [Node] -> gr a b -> [Node]

+ Data.Graph.Inductive.Query.BFS: bfsn :: Graph gr => [Node] -> gr a b -> [Node]

- Data.Graph.Inductive.Query.BFS: bfsnWith :: (Graph gr) => (Context a b -> c) -> [Node] -> gr a b -> [c]

+ Data.Graph.Inductive.Query.BFS: bfsnWith :: Graph gr => (Context a b -> c) -> [Node] -> gr a b -> [c]

- Data.Graph.Inductive.Query.BFS: bft :: (Graph gr) => Node -> gr a b -> RTree

+ Data.Graph.Inductive.Query.BFS: bft :: Graph gr => Node -> gr a b -> RTree

- Data.Graph.Inductive.Query.BFS: esp :: (Graph gr) => Node -> Node -> gr a b -> Path

+ Data.Graph.Inductive.Query.BFS: esp :: Graph gr => Node -> Node -> gr a b -> Path

- Data.Graph.Inductive.Query.BFS: lbft :: (Graph gr) => Node -> gr a b -> LRTree b

+ Data.Graph.Inductive.Query.BFS: lbft :: Graph gr => Node -> gr a b -> LRTree b

- Data.Graph.Inductive.Query.BFS: lesp :: (Graph gr) => Node -> Node -> gr a b -> LPath b

+ Data.Graph.Inductive.Query.BFS: lesp :: Graph gr => Node -> Node -> gr a b -> LPath b

- Data.Graph.Inductive.Query.BFS: level :: (Graph gr) => Node -> gr a b -> [(Node, Int)]

+ Data.Graph.Inductive.Query.BFS: level :: Graph gr => Node -> gr a b -> [(Node, Int)]

- Data.Graph.Inductive.Query.BFS: leveln :: (Graph gr) => [(Node, Int)] -> gr a b -> [(Node, Int)]

+ Data.Graph.Inductive.Query.BFS: leveln :: Graph gr => [(Node, Int)] -> gr a b -> [(Node, Int)]

- Data.Graph.Inductive.Query.DFS: components :: (Graph gr) => gr a b -> [[Node]]

+ Data.Graph.Inductive.Query.DFS: components :: Graph gr => gr a b -> [[Node]]

- Data.Graph.Inductive.Query.DFS: dff :: (Graph gr) => [Node] -> gr a b -> [Tree Node]

+ Data.Graph.Inductive.Query.DFS: dff :: Graph gr => [Node] -> gr a b -> [Tree Node]

- Data.Graph.Inductive.Query.DFS: dff' :: (Graph gr) => gr a b -> [Tree Node]

+ Data.Graph.Inductive.Query.DFS: dff' :: Graph gr => gr a b -> [Tree Node]

- Data.Graph.Inductive.Query.DFS: dffWith :: (Graph gr) => CFun a b c -> [Node] -> gr a b -> [Tree c]

+ Data.Graph.Inductive.Query.DFS: dffWith :: Graph gr => CFun a b c -> [Node] -> gr a b -> [Tree c]

- Data.Graph.Inductive.Query.DFS: dffWith' :: (Graph gr) => CFun a b c -> gr a b -> [Tree c]

+ Data.Graph.Inductive.Query.DFS: dffWith' :: Graph gr => CFun a b c -> gr a b -> [Tree c]

- Data.Graph.Inductive.Query.DFS: dfs :: (Graph gr) => [Node] -> gr a b -> [Node]

+ Data.Graph.Inductive.Query.DFS: dfs :: Graph gr => [Node] -> gr a b -> [Node]

- Data.Graph.Inductive.Query.DFS: dfs' :: (Graph gr) => gr a b -> [Node]

+ Data.Graph.Inductive.Query.DFS: dfs' :: Graph gr => gr a b -> [Node]

- Data.Graph.Inductive.Query.DFS: dfsWith :: (Graph gr) => CFun a b c -> [Node] -> gr a b -> [c]

+ Data.Graph.Inductive.Query.DFS: dfsWith :: Graph gr => CFun a b c -> [Node] -> gr a b -> [c]

- Data.Graph.Inductive.Query.DFS: dfsWith' :: (Graph gr) => CFun a b c -> gr a b -> [c]

+ Data.Graph.Inductive.Query.DFS: dfsWith' :: Graph gr => CFun a b c -> gr a b -> [c]

- Data.Graph.Inductive.Query.DFS: isConnected :: (Graph gr) => gr a b -> Bool

+ Data.Graph.Inductive.Query.DFS: isConnected :: Graph gr => gr a b -> Bool

- Data.Graph.Inductive.Query.DFS: noComponents :: (Graph gr) => gr a b -> Int

+ Data.Graph.Inductive.Query.DFS: noComponents :: Graph gr => gr a b -> Int

- Data.Graph.Inductive.Query.DFS: rdff :: (Graph gr) => [Node] -> gr a b -> [Tree Node]

+ Data.Graph.Inductive.Query.DFS: rdff :: Graph gr => [Node] -> gr a b -> [Tree Node]

- Data.Graph.Inductive.Query.DFS: rdff' :: (Graph gr) => gr a b -> [Tree Node]

+ Data.Graph.Inductive.Query.DFS: rdff' :: Graph gr => gr a b -> [Tree Node]

- Data.Graph.Inductive.Query.DFS: rdffWith :: (Graph gr) => CFun a b c -> [Node] -> gr a b -> [Tree c]

+ Data.Graph.Inductive.Query.DFS: rdffWith :: Graph gr => CFun a b c -> [Node] -> gr a b -> [Tree c]

- Data.Graph.Inductive.Query.DFS: rdffWith' :: (Graph gr) => CFun a b c -> gr a b -> [Tree c]

+ Data.Graph.Inductive.Query.DFS: rdffWith' :: Graph gr => CFun a b c -> gr a b -> [Tree c]

- Data.Graph.Inductive.Query.DFS: rdfs :: (Graph gr) => [Node] -> gr a b -> [Node]

+ Data.Graph.Inductive.Query.DFS: rdfs :: Graph gr => [Node] -> gr a b -> [Node]

- Data.Graph.Inductive.Query.DFS: rdfs' :: (Graph gr) => gr a b -> [Node]

+ Data.Graph.Inductive.Query.DFS: rdfs' :: Graph gr => gr a b -> [Node]

- Data.Graph.Inductive.Query.DFS: reachable :: (Graph gr) => Node -> gr a b -> [Node]

+ Data.Graph.Inductive.Query.DFS: reachable :: Graph gr => Node -> gr a b -> [Node]

- Data.Graph.Inductive.Query.DFS: scc :: (Graph gr) => gr a b -> [[Node]]

+ Data.Graph.Inductive.Query.DFS: scc :: Graph gr => gr a b -> [[Node]]

- Data.Graph.Inductive.Query.DFS: topsort :: (Graph gr) => gr a b -> [Node]

+ Data.Graph.Inductive.Query.DFS: topsort :: Graph gr => gr a b -> [Node]

- Data.Graph.Inductive.Query.DFS: topsort' :: (Graph gr) => gr a b -> [a]

+ Data.Graph.Inductive.Query.DFS: topsort' :: Graph gr => gr a b -> [a]

- Data.Graph.Inductive.Query.DFS: udff :: (Graph gr) => [Node] -> gr a b -> [Tree Node]

+ Data.Graph.Inductive.Query.DFS: udff :: Graph gr => [Node] -> gr a b -> [Tree Node]

- Data.Graph.Inductive.Query.DFS: udff' :: (Graph gr) => gr a b -> [Tree Node]

+ Data.Graph.Inductive.Query.DFS: udff' :: Graph gr => gr a b -> [Tree Node]

- Data.Graph.Inductive.Query.DFS: udffWith :: (Graph gr) => CFun a b c -> [Node] -> gr a b -> [Tree c]

+ Data.Graph.Inductive.Query.DFS: udffWith :: Graph gr => CFun a b c -> [Node] -> gr a b -> [Tree c]

- Data.Graph.Inductive.Query.DFS: udffWith' :: (Graph gr) => CFun a b c -> gr a b -> [Tree c]

+ Data.Graph.Inductive.Query.DFS: udffWith' :: Graph gr => CFun a b c -> gr a b -> [Tree c]

- Data.Graph.Inductive.Query.DFS: udfs :: (Graph gr) => [Node] -> gr a b -> [Node]

+ Data.Graph.Inductive.Query.DFS: udfs :: Graph gr => [Node] -> gr a b -> [Node]

- Data.Graph.Inductive.Query.DFS: udfs' :: (Graph gr) => gr a b -> [Node]

+ Data.Graph.Inductive.Query.DFS: udfs' :: Graph gr => gr a b -> [Node]

- Data.Graph.Inductive.Query.DFS: xdfWith :: (Graph gr) => CFun a b [Node] -> CFun a b c -> [Node] -> gr a b -> ([Tree c], gr a b)

+ Data.Graph.Inductive.Query.DFS: xdfWith :: Graph gr => CFun a b [Node] -> CFun a b c -> [Node] -> gr a b -> ([Tree c], gr a b)

- Data.Graph.Inductive.Query.DFS: xdffWith :: (Graph gr) => CFun a b [Node] -> CFun a b c -> [Node] -> gr a b -> [Tree c]

+ Data.Graph.Inductive.Query.DFS: xdffWith :: Graph gr => CFun a b [Node] -> CFun a b c -> [Node] -> gr a b -> [Tree c]

- Data.Graph.Inductive.Query.DFS: xdfsWith :: (Graph gr) => CFun a b [Node] -> CFun a b c -> [Node] -> gr a b -> [c]

+ Data.Graph.Inductive.Query.DFS: xdfsWith :: Graph gr => CFun a b [Node] -> CFun a b c -> [Node] -> gr a b -> [c]

- Data.Graph.Inductive.Query.Dominators: dom :: (Graph gr) => gr a b -> Node -> [(Node, [Node])]

+ Data.Graph.Inductive.Query.Dominators: dom :: Graph gr => gr a b -> Node -> [(Node, [Node])]

- Data.Graph.Inductive.Query.Dominators: iDom :: (Graph gr) => gr a b -> Node -> [(Node, Node)]

+ Data.Graph.Inductive.Query.Dominators: iDom :: Graph gr => gr a b -> Node -> [(Node, Node)]

- Data.Graph.Inductive.Query.Indep: indep :: (DynGraph gr) => gr a b -> [Node]

+ Data.Graph.Inductive.Query.Indep: indep :: DynGraph gr => gr a b -> [Node]

- Data.Graph.Inductive.Query.Indep: indepSize :: (DynGraph gr) => gr a b -> ([Node], Int)

+ Data.Graph.Inductive.Query.Indep: indepSize :: DynGraph gr => gr a b -> ([Node], Int)

- Data.Graph.Inductive.Query.MaxFlow: getRevEdges :: (Num b) => [Edge] -> [LEdge b]

+ Data.Graph.Inductive.Query.MaxFlow: getRevEdges :: Num b => [Edge] -> [LEdge b]

- Data.Graph.Inductive.Query.MaxFlow: updAdjList :: (Num b) => Adj (b, b, b) -> Node -> b -> Bool -> Adj (b, b, b)

+ Data.Graph.Inductive.Query.MaxFlow: updAdjList :: Num b => Adj (b, b, b) -> Node -> b -> Bool -> Adj (b, b, b)

- Data.Graph.Inductive.Query.Monad: apply' :: (Monad m) => GT m g a -> g -> m (a, g)

+ Data.Graph.Inductive.Query.Monad: apply' :: Monad m => GT m g a -> g -> m (a, g)

- Data.Graph.Inductive.Query.Monad: applyWith :: (Monad m) => (a -> b) -> GT m g a -> m g -> m (b, g)

+ Data.Graph.Inductive.Query.Monad: applyWith :: Monad m => (a -> b) -> GT m g a -> m g -> m (b, g)

- Data.Graph.Inductive.Query.Monad: applyWith' :: (Monad m) => (a -> b) -> GT m g a -> g -> m (b, g)

+ Data.Graph.Inductive.Query.Monad: applyWith' :: Monad m => (a -> b) -> GT m g a -> g -> m (b, g)

- Data.Graph.Inductive.Query.Monad: condMGT :: (Monad m) => (m s -> m Bool) -> GT m s a -> GT m s a -> GT m s a

+ Data.Graph.Inductive.Query.Monad: condMGT :: Monad m => (m s -> m Bool) -> GT m s a -> GT m s a -> GT m s a

- Data.Graph.Inductive.Query.Monad: condMGT' :: (Monad m) => (s -> Bool) -> GT m s a -> GT m s a -> GT m s a

+ Data.Graph.Inductive.Query.Monad: condMGT' :: Monad m => (s -> Bool) -> GT m s a -> GT m s a -> GT m s a

- Data.Graph.Inductive.Query.Monad: dffM :: (GraphM m gr) => [Node] -> GT m (gr a b) [Tree Node]

+ Data.Graph.Inductive.Query.Monad: dffM :: GraphM m gr => [Node] -> GT m (gr a b) [Tree Node]

- Data.Graph.Inductive.Query.Monad: dfsGT :: (GraphM m gr) => [Node] -> GT m (gr a b) [Node]

+ Data.Graph.Inductive.Query.Monad: dfsGT :: GraphM m gr => [Node] -> GT m (gr a b) [Node]

- Data.Graph.Inductive.Query.Monad: dfsM :: (GraphM m gr) => [Node] -> m (gr a b) -> m [Node]

+ Data.Graph.Inductive.Query.Monad: dfsM :: GraphM m gr => [Node] -> m (gr a b) -> m [Node]

- Data.Graph.Inductive.Query.Monad: dfsM' :: (GraphM m gr) => m (gr a b) -> m [Node]

+ Data.Graph.Inductive.Query.Monad: dfsM' :: GraphM m gr => m (gr a b) -> m [Node]

- Data.Graph.Inductive.Query.Monad: getContext :: (GraphM m gr) => GT m (gr a b) (Context a b)

+ Data.Graph.Inductive.Query.Monad: getContext :: GraphM m gr => GT m (gr a b) (Context a b)

- Data.Graph.Inductive.Query.Monad: getNode :: (GraphM m gr) => GT m (gr a b) Node

+ Data.Graph.Inductive.Query.Monad: getNode :: GraphM m gr => GT m (gr a b) Node

- Data.Graph.Inductive.Query.Monad: getNodes :: (GraphM m gr) => GT m (gr a b) [Node]

+ Data.Graph.Inductive.Query.Monad: getNodes :: GraphM m gr => GT m (gr a b) [Node]

- Data.Graph.Inductive.Query.Monad: graphDff :: (GraphM m gr) => [Node] -> m (gr a b) -> m [Tree Node]

+ Data.Graph.Inductive.Query.Monad: graphDff :: GraphM m gr => [Node] -> m (gr a b) -> m [Tree Node]

- Data.Graph.Inductive.Query.Monad: graphDff' :: (GraphM m gr) => m (gr a b) -> m [Tree Node]

+ Data.Graph.Inductive.Query.Monad: graphDff' :: GraphM m gr => m (gr a b) -> m [Tree Node]

- Data.Graph.Inductive.Query.Monad: graphFilter :: (GraphM m gr) => (Context a b -> Bool) -> m (gr a b) -> m [Context a b]

+ Data.Graph.Inductive.Query.Monad: graphFilter :: GraphM m gr => (Context a b -> Bool) -> m (gr a b) -> m [Context a b]

- Data.Graph.Inductive.Query.Monad: graphFilterM :: (GraphM m gr) => (Context a b -> Bool) -> GT m (gr a b) [Context a b]

+ Data.Graph.Inductive.Query.Monad: graphFilterM :: GraphM m gr => (Context a b -> Bool) -> GT m (gr a b) [Context a b]

- Data.Graph.Inductive.Query.Monad: graphNodes :: (GraphM m gr) => m (gr a b) -> m [Node]

+ Data.Graph.Inductive.Query.Monad: graphNodes :: GraphM m gr => m (gr a b) -> m [Node]

- Data.Graph.Inductive.Query.Monad: graphNodesM :: (GraphM m gr) => GT m (gr a b) [Node]

+ Data.Graph.Inductive.Query.Monad: graphNodesM :: GraphM m gr => GT m (gr a b) [Node]

- Data.Graph.Inductive.Query.Monad: graphNodesM0 :: (GraphM m gr) => GT m (gr a b) [Node]

+ Data.Graph.Inductive.Query.Monad: graphNodesM0 :: GraphM m gr => GT m (gr a b) [Node]

- Data.Graph.Inductive.Query.Monad: graphRec :: (GraphM m gr) => GT m (gr a b) c -> (c -> d -> d) -> d -> GT m (gr a b) d

+ Data.Graph.Inductive.Query.Monad: graphRec :: GraphM m gr => GT m (gr a b) c -> (c -> d -> d) -> d -> GT m (gr a b) d

- Data.Graph.Inductive.Query.Monad: graphUFold :: (GraphM m gr) => (Context a b -> c -> c) -> c -> GT m (gr a b) c

+ Data.Graph.Inductive.Query.Monad: graphUFold :: GraphM m gr => (Context a b -> c -> c) -> c -> GT m (gr a b) c

- Data.Graph.Inductive.Query.Monad: recMGT :: (Monad m) => (m s -> m Bool) -> GT m s a -> (a -> b -> b) -> b -> GT m s b

+ Data.Graph.Inductive.Query.Monad: recMGT :: Monad m => (m s -> m Bool) -> GT m s a -> (a -> b -> b) -> b -> GT m s b

- Data.Graph.Inductive.Query.Monad: recMGT' :: (Monad m) => (s -> Bool) -> GT m s a -> (a -> b -> b) -> b -> GT m s b

+ Data.Graph.Inductive.Query.Monad: recMGT' :: Monad m => (s -> Bool) -> GT m s a -> (a -> b -> b) -> b -> GT m s b

- Data.Graph.Inductive.Query.Monad: runGT :: (Monad m) => GT m g a -> m g -> m a

+ Data.Graph.Inductive.Query.Monad: runGT :: Monad m => GT m g a -> m g -> m a

- Data.Graph.Inductive.Query.Monad: sucGT :: (GraphM m gr) => Node -> GT m (gr a b) (Maybe [Node])

+ Data.Graph.Inductive.Query.Monad: sucGT :: GraphM m gr => Node -> GT m (gr a b) (Maybe [Node])

- Data.Graph.Inductive.Query.Monad: sucM :: (GraphM m gr) => Node -> m (gr a b) -> m (Maybe [Node])

+ Data.Graph.Inductive.Query.Monad: sucM :: GraphM m gr => Node -> m (gr a b) -> m (Maybe [Node])

- Data.Graph.Inductive.Query.TransClos: rc :: (DynGraph gr) => gr a b -> gr a ()

+ Data.Graph.Inductive.Query.TransClos: rc :: DynGraph gr => gr a b -> gr a ()

- Data.Graph.Inductive.Query.TransClos: tc :: (DynGraph gr) => gr a b -> gr a ()

+ Data.Graph.Inductive.Query.TransClos: tc :: DynGraph gr => gr a b -> gr a ()

- Data.Graph.Inductive.Query.TransClos: trc :: (DynGraph gr) => gr a b -> gr a ()

+ Data.Graph.Inductive.Query.TransClos: trc :: DynGraph gr => gr a b -> gr a ()

Files

ChangeLog +6/−0
Data/Graph/Inductive/Monad.hs +12/−2
Data/Graph/Inductive/PatriciaTree.hs +1/−3
Data/Graph/Inductive/Query/DFS.hs +1/−3
Data/Graph/Inductive/Query/MaxFlow.hs +1/−1
fgl.cabal +6/−5

ChangeLog view

@@ -1,3 +1,9 @@+5.7.0.0+-------++* Updating the GraphM class to be compatible with the MonadFail proposal and GHC's+  MonadFailDesugaring language extension which is enabled by default by GHC-8.6.1.+ 5.6.0.0 -------

Data/Graph/Inductive/Monad.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE CPP, MultiParamTypeClasses #-}  -- (c) 2002 by Martin Erwig [see file COPYRIGHT] -- | Monadic Graphs@@ -19,6 +19,10 @@   import Data.Graph.Inductive.Graph+#if MIN_VERSION_base(4,12,0)+import Control.Monad.Fail+import Prelude hiding (fail)+#endif  {-# ANN module "HLint: ignore Redundant lambda" #-} @@ -39,7 +43,13 @@  -- Monadic Graph ---class (Monad m) => GraphM m gr where+class+#if MIN_VERSION_base(4,12,0)+ (MonadFail m)+#else+ (Monad m)+#endif+  => GraphM m gr where   {-# MINIMAL emptyM, isEmptyM, matchM, mkGraphM, labNodesM #-}    emptyM     :: m (gr a b)

Data/Graph/Inductive/PatriciaTree.hs view

@@ -32,6 +32,7 @@ import qualified Data.IntMap         as IM import           Data.List           (foldl', sort) import           Data.Maybe          (fromMaybe)+import           Data.Tuple          (swap)  #if MIN_VERSION_containers (0,4,2) import Control.DeepSeq (NFData(..))@@ -258,9 +259,6 @@  fromContext :: Context a b -> Context' a b fromContext (ps, _, a, ss) = (fromAdj ps, a, fromAdj ss)--swap :: (a, b) -> (b, a)-swap (a, b) = (b, a)  -- A version of @++@ where order isn't important, so @xs ++ [x]@ -- becomes @x:xs@.  Used when we have to have a function of type @[a]

Data/Graph/Inductive/Query/DFS.hs view

@@ -50,7 +50,7 @@ import Data.Tree import qualified Data.Map as Map import Control.Monad (liftM2)-+import Data.Tuple (swap)   -- | Many functions take a list of nodes to visit as an explicit argument.@@ -243,8 +243,6 @@     sccs = scc gr     vs = zip [1..] sccs     vMap = Map.fromList $ map swap vs--    swap = uncurry $ flip (,)      getN = (vMap Map.!)     es = [ (getN c1, getN c2, ()) | c1 <- sccs, c2 <- sccs

Data/Graph/Inductive/Query/MaxFlow.hs view

@@ -108,7 +108,7 @@  -- | Compute the flow from s to t on a graph whose edges are labeled with --   @x@, which is the max capacity and where not all edges need to be---   of the form a\<---->b. Return the flow as a grap whose edges are+--   of the form a\<---->b. Return the flow as a graph whose edges are --   labeled with (x,y,z)=(max capacity,current flow,residual --   capacity) and all edges are of the form a\<---->b mf :: (DynGraph gr, Num b, Ord b) => gr a b -> Node -> Node -> gr a (b,b,b)

fgl.cabal view

@@ -1,5 +1,5 @@ name:          fgl-version:       5.6.0.0+version:       5.7.0.0 license:       BSD3 license-file:  LICENSE author:        Martin Erwig, Ivan Lazar Miljenovic@@ -18,7 +18,8 @@                ChangeLog  tested-with:   GHC == 7.0.4, GHC == 7.2.2, GHC == 7.4.2, GHC == 7.6.3,-               GHC == 7.8.4, GHC == 7.10.2, GHC == 8.0.1, GHC == 8.1.*+               GHC == 7.8.4, GHC == 7.10.2, GHC == 8.0.1, GHC == 8.2.2,+               GHC == 8.4.3, GHC == 8.6.1  source-repository head     type:         git@@ -65,7 +66,7 @@     other-modules:         Paths_fgl -    build-depends:    base < 5+    build-depends:    base >= 4.3 && < 5                     , transformers                     , array @@ -90,8 +91,8 @@      build-depends:    fgl                     , base-                    , QuickCheck >= 2.8 && < 2.10-                    , hspec >= 2.1 && < 2.5+                    , QuickCheck >= 2.8 && < 2.12+                    , hspec >= 2.1 && < 2.6                     , containers      hs-source-dirs:   test