clean up

ChangeLog.md

 Revision history for haskell-igraph
 ===================================
 
+v0.4.* --
+-------------------
+
+* Fix memory leaks.
+
+
 v0.4.0 -- 2018-04-20
 -------------------
 

haskell-igraph.cabal

@@ -69,6 +69,7 @@ library
   extra-libraries:     igraph
   hs-source-dirs:      src
   default-language:    Haskell2010
+  ghc-options:         -Wall
   build-tools:         c2hs >=0.25.0
   c-sources:
     cbits/haskell_igraph.c

src/IGraph.hs

@@ -3,8 +3,8 @@
 module IGraph
     ( Graph(..)
     , LGraph(..)
-    , U(..)
-    , D(..)
+    , U
+    , D
     , decodeC
     , empty
     , mkGraph
@@ -20,19 +20,16 @@ module IGraph
     , pre
     , suc
 
-    , mapNodes
-    , mapEdges
-    , filterNodes
-    , filterEdges
-
     , nmap
     , emap
+
+    , nfilter
+    , efilter
     ) where
 
 import           Conduit
-import           Control.Arrow             ((***))
-import           Control.Monad             (forM, forM_, liftM, replicateM,
-                                            unless)
+import           Control.Arrow             ((&&&))
+import           Control.Monad             (forM, forM_, liftM, replicateM)
 import           Control.Monad.Primitive
 import           Control.Monad.ST          (runST)
 import qualified Data.ByteString           as B
@@ -42,10 +39,9 @@ import           Data.Hashable             (Hashable)
 import qualified Data.HashMap.Strict       as M
 import qualified Data.HashSet              as S
 import           Data.List                 (sortBy)
-import           Data.Maybe
 import           Data.Ord                  (comparing)
 import           Data.Serialize
-import           Foreign                   (castPtr, with)
+import           Foreign                   (castPtr)
 import           System.IO.Unsafe          (unsafePerformIO)
 
 import           IGraph.Internal
@@ -68,6 +64,10 @@ class MGraph d => Graph d where
     nodes gr = [0 .. nNodes gr - 1]
     {-# INLINE nodes #-}
 
+    labNodes :: Serialize v => LGraph d v e -> [LNode v]
+    labNodes gr = map (\i -> (i, nodeLab gr i)) $ nodes gr
+    {-# INLINE labNodes #-}
+
     -- | Return the number of edges in a graph.
     nEdges :: LGraph d v e -> Int
     nEdges (LGraph g _) = unsafePerformIO $ igraphEcount g
@@ -75,11 +75,13 @@ class MGraph d => Graph d where
 
     -- | Return all edges.
     edges :: LGraph d v e -> [Edge]
-    edges gr@(LGraph g _) = unsafePerformIO $ mapM (igraphEdge g) [0..n-1]
-      where
-        n = nEdges gr
+    edges gr = map (getEdgeByEid gr) [0 .. nEdges gr - 1]
     {-# INLINE edges #-}
 
+    labEdges :: Serialize e => LGraph d v e -> [LEdge e]
+    labEdges gr = map (getEdgeByEid gr &&& getEdgeLabByEid gr) [0 .. nEdges gr - 1]
+    {-# INLINE labEdges #-}
+
     -- | Whether a edge exists in the graph.
     hasEdge :: LGraph d v e -> Edge -> Bool
     hasEdge (LGraph g _) (fr, to) = unsafePerformIO $ do
@@ -109,15 +111,15 @@ class MGraph d => Graph d where
 
     -- | Find the edge by edge ID.
     getEdgeByEid :: LGraph d v e -> Int -> Edge
-    getEdgeByEid gr@(LGraph g _) i = unsafePerformIO $ igraphEdge g i
+    getEdgeByEid (LGraph g _) i = unsafePerformIO $ igraphEdge g i
     {-# INLINE getEdgeByEid #-}
 
     -- | Find the edge label by edge ID.
-    edgeLabByEid :: Serialize e => LGraph d v e -> Int -> e
-    edgeLabByEid (LGraph g _) i = unsafePerformIO $
+    getEdgeLabByEid :: Serialize e => LGraph d v e -> Int -> e
+    getEdgeLabByEid (LGraph g _) i = unsafePerformIO $
         igraphHaskellAttributeEAS g edgeAttr i >>= bsToByteString >>=
             return . fromRight (error "decode failed") . decode
-    {-# INLINE edgeLabByEid #-}
+    {-# INLINE getEdgeLabByEid #-}
 
 instance Graph U where
     isDirected = const False
@@ -139,7 +141,7 @@ instance (Graph d, Serialize v, Serialize e, Hashable v, Eq v)
             put $ nNodes gr
             go (nodeLab gr) (nNodes gr) 0
             put $ nEdges gr
-            go (\i -> (getEdgeByEid gr i, edgeLabByEid gr i)) (nEdges gr) 0
+            go (\i -> (getEdgeByEid gr i, getEdgeLabByEid gr i)) (nEdges gr) 0
           where
             go f n i | i >= n = return ()
                      | otherwise = put (f i) >> go f n (i+1)
@@ -176,8 +178,6 @@ mkGraph vattr es = runST $ do
     addLNodes vattr g
     addLEdges es g
     unsafeFreeze g
-  where
-    n = length vattr
 
 -- | Create a graph from labeled edges.
 fromLabeledEdges :: (Graph d, Hashable v, Serialize v, Eq v, Serialize e)
@@ -223,7 +223,7 @@ deserializeGraph nds ne = do
             igraphVectorSet evec (i*2+1) $ fromIntegral to
             bsvectorSet bsvec i $ encode attr
             return $ i + 1
-    foldMC f 0
+    _ <- foldMC f 0
     gr@(MLGraph g) <- new 0
     addLNodes nds gr
     unsafePrimToPrim $ withAttr edgeAttr bsvec $ \ptr -> do
@@ -280,61 +280,40 @@ pre gr i = unsafePerformIO $ do
     vit <- igraphVitNew (_graph gr) vs
     vitToList vit
 
--- | Keep nodes that satisfy the constraint
-filterNodes :: (Hashable v, Eq v, Serialize v, Graph d)
-            => (LGraph d v e -> Node -> Bool) -> LGraph d v e -> LGraph d v e
-filterNodes f gr = runST $ do
-    let deleted = filter (not . f gr) $ nodes gr
-    gr' <- thaw gr
-    delNodes deleted gr'
-    unsafeFreeze gr'
-
 -- | Apply a function to change nodes' labels.
-mapNodes :: (Graph d, Serialize v1, Serialize v2, Hashable v2, Eq v2)
-         => (Node -> v1 -> v2) -> LGraph d v1 e -> LGraph d v2 e
-mapNodes f gr = runST $ do
+nmap :: (Graph d, Serialize v1, Serialize v2, Hashable v2, Eq v2)
+     => (LNode v1 -> v2) -> LGraph d v1 e -> LGraph d v2 e
+nmap f gr = runST $ do
     (MLGraph gptr) <- thaw gr
     let gr' = MLGraph gptr
-    forM_ (nodes gr) $ \x -> setNodeAttr x (f x $ nodeLab gr x) gr'
+    forM_ (nodes gr) $ \x -> setNodeAttr x (f (x, nodeLab gr x)) gr'
     unsafeFreeze gr'
 
 -- | Apply a function to change edges' labels.
-mapEdges :: (Graph d, Serialize e1, Serialize e2, Hashable v, Eq v, Serialize v)
-         => (Edge -> e1 -> e2) -> LGraph d v e1 -> LGraph d v e2
-mapEdges f gr = runST $ do
+emap :: (Graph d, Serialize e1, Serialize e2, Hashable v, Eq v, Serialize v)
+     => (LEdge e1 -> e2) -> LGraph d v e1 -> LGraph d v e2
+emap f gr = runST $ do
     (MLGraph gptr) <- thaw gr
     let gr' = MLGraph gptr
-    forM_ [0 .. nEdges gr - 1] $ \x -> do
-        e <- unsafePrimToPrim $ igraphEdge (_graph gr) x
-        setEdgeAttr x (f e $ edgeLabByEid gr x) gr'
+    forM_ [0 .. nEdges gr - 1] $ \i -> do
+        let lab = f (getEdgeByEid gr i, getEdgeLabByEid gr i)
+        setEdgeAttr i lab gr'
     unsafeFreeze gr'
 
 -- | Keep nodes that satisfy the constraint.
-filterEdges :: (Hashable v, Eq v, Serialize v, Graph d)
-            => (LGraph d v e -> Edge -> Bool) -> LGraph d v e -> LGraph d v e
-filterEdges f gr = runST $ do
-    let deleted = filter (not . f gr) $ edges gr
+nfilter :: (Hashable v, Eq v, Serialize v, Graph d)
+        => (LNode v -> Bool) -> LGraph d v e -> LGraph d v e
+nfilter f gr = runST $ do
+    let deleted = fst $ unzip $ filter (not . f) $ labNodes gr
     gr' <- thaw gr
-    delEdges deleted gr'
+    delNodes deleted gr'
     unsafeFreeze gr'
 
--- | Map a function over the node labels in a graph.
-nmap :: (Graph d, Serialize v, Hashable u, Serialize u, Eq u)
-     => ((Node, v) -> u) -> LGraph d v e -> LGraph d u e
-nmap fn gr = unsafePerformIO $ do
-    (MLGraph g) <- thaw gr
-    forM_ (nodes gr) $ \i -> do
-        let label = fn (i, nodeLab gr i)
-        asBS (encode label) (igraphHaskellAttributeVASSet g vertexAttr i)
-    unsafeFreeze (MLGraph g)
-
--- | Map a function over the edge labels in a graph.
-emap :: (Graph d, Serialize v, Hashable v, Eq v, Serialize e1, Serialize e2)
-     => ((Edge, e1) -> e2) -> LGraph d v e1 -> LGraph d v e2
-emap fn gr = unsafePerformIO $ do
-    (MLGraph g) <- thaw gr
-    forM_ (edges gr) $ \(fr, to) -> do
-        i <- igraphGetEid g fr to True True
-        let label = fn ((fr,to), edgeLabByEid gr i)
-        asBS (encode label) (igraphHaskellAttributeEASSet g edgeAttr i)
-    unsafeFreeze (MLGraph g)
+-- | Keep edges that satisfy the constraint.
+efilter :: (Hashable v, Eq v, Serialize v, Serialize e, Graph d)
+        => (LEdge e -> Bool) -> LGraph d v e -> LGraph d v e
+efilter f gr = runST $ do
+    let deleted = fst $ unzip $ filter (not . f) $ labEdges gr
+    gr' <- thaw gr
+    delEdges deleted gr'
+    unsafeFreeze gr'

src/IGraph/Clique.chs

@@ -7,10 +7,7 @@ module IGraph.Clique
 import Control.Applicative ((<$>))
 import System.IO.Unsafe (unsafePerformIO)
 
-import qualified Foreign.Marshal.Utils as C2HSImp
 import qualified Foreign.Ptr as C2HSImp
-import Foreign
-import Foreign.C.Types
 
 import IGraph
 {#import IGraph.Internal #}

src/IGraph/Community.chs

@@ -5,12 +5,10 @@ module IGraph.Community
     , findCommunity
     ) where
 
-import           Control.Applicative       ((<$>))
-import           Control.Monad
 import           Data.Default.Class
 import           Data.Function             (on)
-import           Data.List
-import           Data.Ord
+import           Data.List (sortBy, groupBy)
+import           Data.Ord (comparing)
 import           System.IO.Unsafe          (unsafePerformIO)
 
 import           Foreign
@@ -53,9 +51,9 @@ findCommunity gr opt = unsafePerformIO $ do
     result <- igraphVectorNew 0
     ws <- case _weights opt of
         Just w -> fromList w
-        _      -> liftM Vector $ newForeignPtr_ $ castPtr nullPtr
+        _      -> fmap Vector $ newForeignPtr_ $ castPtr nullPtr
 
-    case _method opt of
+    _ <- case _method opt of
         LeadingEigenvector -> do
             ap <- igraphArpackNew
             igraphCommunityLeadingEigenvector (_graph gr) ws nullPtr result
@@ -69,7 +67,7 @@ findCommunity gr opt = unsafePerformIO $ do
                                      IgraphSpincommUpdateConfig (_gamma opt)
                                      IgraphSpincommImpOrig 1.0
 
-    liftM ( map (fst . unzip) . groupBy ((==) `on` snd)
+    fmap ( map (fst . unzip) . groupBy ((==) `on` snd)
           . sortBy (comparing snd) . zip [0..] ) $ toList result
 
 {#fun igraph_community_spinglass as ^

src/IGraph/Exporter/GEXF.hs

@@ -15,11 +15,9 @@ import           Data.Colour.SRGB          (channelBlue, channelGreen,
                                             channelRed, toSRGB24)
 import           Data.Hashable
 import           Data.Serialize
-import           Data.Tree.NTree.TypeDefs
 import           GHC.Generics
 import           IGraph
 import           Text.XML.HXT.Core
-import           Text.XML.HXT.DOM.TypeDefs
 
 instance Serialize (AlphaColour Double) where
     get = do

src/IGraph/Generators.chs

@@ -11,7 +11,6 @@ import           Control.Monad                  (when)
 import           Data.Hashable                  (Hashable)
 import           Data.Serialize                 (Serialize)
 
-import qualified Foreign.Marshal.Utils as C2HSImp
 import qualified Foreign.Ptr as C2HSImp
 
 import           IGraph

src/IGraph/Internal.chs

@@ -92,10 +92,8 @@ import Control.Monad
 import qualified Data.ByteString.Char8 as B
 import Data.ByteString (packCStringLen)
 import Data.ByteString.Unsafe (unsafeUseAsCStringLen)
-import System.IO.Unsafe (unsafePerformIO)
 import Data.List (transpose)
 import Data.List.Split (chunksOf)
-import Data.Serialize (Serialize, decode, encode)
 
 import Foreign
 import Foreign.C.Types

src/IGraph/Internal/Constants.chs

 {-# LANGUAGE ForeignFunctionInterface #-}
 module IGraph.Internal.Constants where
 
-import Foreign
-
 #include "igraph/igraph.h"
 
 {#enum igraph_neimode_t as Neimode {underscoreToCase}

src/IGraph/Internal/Types.chs

@@ -20,6 +20,7 @@ module IGraph.Internal.Types
 
     -- * Bytestring
     , BSLen(..)
+    , withBSLen
 
     -- * Bytestring vector
     , BSVector(..)
@@ -65,6 +66,7 @@ module IGraph.Internal.Types
 
     -- * Igraph attribute record
     , AttributeRecord(..)
+    , withAttributeRecord
 
     -- * Igraph arpack options type
     , ArpackOpt(..)
@@ -72,20 +74,7 @@ module IGraph.Internal.Types
     , igraphArpackNew
     ) where
 
-import Control.Monad
-import qualified Data.ByteString.Char8 as B
-import Data.ByteString (packCStringLen)
-import Data.ByteString.Unsafe (unsafeUseAsCStringLen)
-import System.IO.Unsafe (unsafePerformIO)
-import Data.List (transpose)
-import Data.List.Split (chunksOf)
-import Data.Serialize (Serialize, decode, encode)
-
 import Foreign
-import Foreign.C.Types
-import Foreign.C.String
-
-{#import IGraph.Internal.Constants #}
 
 #include "haskell_attributes.h"
 #include "haskell_igraph.h"

src/IGraph/Isomorphism.chs

@@ -32,11 +32,18 @@ getSubisomorphisms g1 g2 = unsafePerformIO $ do
     gptr1 = _graph g1
     gptr2 = _graph g2
 {-# INLINE getSubisomorphisms #-}
-{#fun igraph_get_subisomorphisms_vf2 as ^ { `IGraph', `IGraph',
-    id `Ptr ()', id `Ptr ()', id `Ptr ()', id `Ptr ()', `VectorPtr',
-    id `FunPtr (Ptr IGraph -> Ptr IGraph -> CInt -> CInt -> Ptr () -> IO CInt)',
-    id `FunPtr (Ptr IGraph -> Ptr IGraph -> CInt -> CInt -> Ptr () -> IO CInt)',
-    id `Ptr ()'} -> `Int' #}
+{#fun igraph_get_subisomorphisms_vf2 as ^
+    { `IGraph'
+    , `IGraph'
+    , id `Ptr ()'
+    , id `Ptr ()'
+    , id `Ptr ()'
+    , id `Ptr ()'
+    , `VectorPtr'
+    , id `FunPtr (Ptr IGraph -> Ptr IGraph -> CInt -> CInt -> Ptr () -> IO CInt)'
+    , id `FunPtr (Ptr IGraph -> Ptr IGraph -> CInt -> CInt -> Ptr () -> IO CInt)'
+    , id `Ptr ()'
+    } -> `CInt' void- #}
 
 -- | Determine whether two graphs are isomorphic.
 isomorphic :: Graph d
@@ -47,7 +54,7 @@ isomorphic g1 g2 = unsafePerformIO $ alloca $ \ptr -> do
     _ <- igraphIsomorphic (_graph g1) (_graph g2) ptr
     x <- peek ptr
     return (x /= 0)
-{#fun igraph_isomorphic as ^ { `IGraph', `IGraph', id `Ptr CInt' } -> `Int' #}
+{#fun igraph_isomorphic as ^ { `IGraph', `IGraph', id `Ptr CInt' } -> `CInt' void- #}
 
 -- | Creates a graph from the given isomorphism class.
 -- This function is implemented only for graphs with three or four vertices.

src/IGraph/Layout.chs

@@ -6,16 +6,11 @@ module IGraph.Layout
     , defaultLGL
     ) where
 
-import           Control.Applicative    ((<$>))
-import           Data.Default.Class
 import           Data.Maybe             (isJust)
 import           Foreign                (nullPtr)
-import           System.IO.Unsafe       (unsafePerformIO)
 
-import qualified Foreign.Marshal.Utils as C2HSImp
 import qualified Foreign.Ptr as C2HSImp
 import Foreign
-import Foreign.C.Types
 
 import           IGraph
 {#import IGraph.Internal #}
@@ -91,27 +86,29 @@ getLayout gr method = do
     n = nNodes gr
     gptr = _graph gr
 
-{#fun igraph_layout_kamada_kawai as ^ { `IGraph'
-, `Matrix'
-, `Int'
-, `Double'
-, `Double'
-, `Double'
-, `Double'
-, `Bool'
-, id `Ptr Vector'
-, id `Ptr Vector'
-, id `Ptr Vector'
-, id `Ptr Vector'
-} -> `Int' #}
+{#fun igraph_layout_kamada_kawai as ^
+    { `IGraph'
+    , `Matrix'
+    , `Int'
+    , `Double'
+    , `Double'
+    , `Double'
+    , `Double'
+    , `Bool'
+    , id `Ptr Vector'
+    , id `Ptr Vector'
+    , id `Ptr Vector'
+    , id `Ptr Vector'
+    } -> `CInt' void- #}
 
-{# fun igraph_layout_lgl as ^ { `IGraph'
-, `Matrix'
-, `Int'
-, `Double'
-, `Double'
-, `Double'
-, `Double'
-, `Double'
-, `Int'
-} -> `Int' #}
+{# fun igraph_layout_lgl as ^
+    { `IGraph'
+    , `Matrix'
+    , `Int'
+    , `Double'
+    , `Double'
+    , `Double'
+    , `Double'
+    , `Double'
+    , `Int'
+    } -> `CInt' void- #}

src/IGraph/Motif.chs

@@ -7,14 +7,10 @@ module IGraph.Motif
 import Data.Hashable (Hashable)
 import System.IO.Unsafe (unsafePerformIO)
 
-import qualified Foreign.Marshal.Utils as C2HSImp
 import qualified Foreign.Ptr as C2HSImp
-import Foreign
-import Foreign.C.Types
 
 import IGraph
 {#import IGraph.Internal #}
-{#import IGraph.Internal.Constants #}
 
 #include "haskell_igraph.h"
 
@@ -68,7 +64,7 @@ triadCensus gr = unsafePerformIO $ do
 -- motifsRandesu
 
 {#fun igraph_triad_census as ^ { `IGraph'
-                               , `Vector' } -> `Int' #}
+                               , `Vector' } -> `CInt' void- #}
 
 {#fun igraph_motifs_randesu as ^ { `IGraph', `Vector', `Int'
-                                 , `Vector' } -> `Int' #}
+                                 , `Vector' } -> `CInt' void- #}

src/IGraph/Mutable.hs

@@ -10,10 +10,8 @@ module IGraph.Mutable
 
 import           Control.Monad                  (when, forM)
 import           Control.Monad.Primitive
-import qualified Data.ByteString.Char8          as B
 import           Data.Serialize                 (Serialize, encode)
 import           Foreign
-import           Foreign.C.String               (CString, withCString)
 
 import           IGraph.Internal
 import           IGraph.Internal.Initialization
@@ -55,7 +53,7 @@ class MGraph d where
     delNodes ns (MLGraph g) = unsafePrimToPrim $ do
         vptr <- fromList $ map fromIntegral ns
         vsptr <- igraphVsVector vptr
-        igraphDeleteVertices g vsptr
+        _ <- igraphDeleteVertices g vsptr
         return ()
 
     -- | Add edges to the graph.
@@ -87,7 +85,7 @@ instance MGraph U where
         eids <- forM es $ \(fr, to) -> igraphGetEid g fr to False True
         vptr <- fromList $ map fromIntegral eids
         esptr <- igraphEsVector vptr
-        igraphDeleteEdges g esptr
+        _ <- igraphDeleteEdges g esptr
         return ()
 
 instance MGraph D where

src/IGraph/Structure.chs

@@ -13,8 +13,6 @@ import           Data.Either               (fromRight)
 import           Data.Hashable             (Hashable)
 import qualified Data.HashMap.Strict       as M
 import           Data.Serialize            (Serialize, decode)
-import           Foreign
-import           Foreign.C.Types
 import           System.IO.Unsafe          (unsafePerformIO)
 
 import Foreign
@@ -132,24 +130,26 @@ personalizedPagerank gr reset ws d
     n = nNodes gr
     m = nEdges gr
 
-{#fun igraph_induced_subgraph as ^ { `IGraph'
-                                   , +160
-                                   , %`IGraphVs'
-                                   , `SubgraphImplementation' } -> `IGraph' #}
+{#fun igraph_induced_subgraph as ^
+    { `IGraph'
+    , allocaIGraph- `IGraph' addIGraphFinalizer*
+    , %`IGraphVs'
+    , `SubgraphImplementation'
+    } -> `CInt' void- #}
 
 {#fun igraph_closeness as ^ { `IGraph'
                             , `Vector'
                             , %`IGraphVs'
                             , `Neimode'
                             , `Vector'
-                            , `Bool' } -> `Int' #}
+                            , `Bool' } -> `CInt' void- #}
 
 {#fun igraph_betweenness as ^ { `IGraph'
                               , `Vector'
                               , %`IGraphVs'
                               , `Bool'
                               , `Vector'
-                              , `Bool' } -> `Int' #}
+                              , `Bool' } -> `CInt' void- #}
 
 {#fun igraph_eigenvector_centrality as ^ { `IGraph'
                                          , `Vector'
@@ -157,25 +157,29 @@ personalizedPagerank gr reset ws d
                                          , `Bool'
                                          , `Bool'
                                          , `Vector'
-                                         , `ArpackOpt' } -> `Int' #}
-
-{#fun igraph_pagerank as ^ { `IGraph'
-                           , `PagerankAlgo'
-                           , `Vector'
-                           , id `Ptr CDouble'
-                           , %`IGraphVs'
-                           , `Bool'
-                           , `Double'
-                           , `Vector'
-                           , id `Ptr ()' } -> `Int' #}
-
-{#fun igraph_personalized_pagerank as ^ { `IGraph'
-                                        , `PagerankAlgo'
-                                        , `Vector'
-                                        , id `Ptr CDouble'
-                                        , %`IGraphVs'
-                                        , `Bool'
-                                        , `Double'
-                                        , `Vector'
-                                        , `Vector'
-                                        , id `Ptr ()' } -> `Int' #}
+                                         , `ArpackOpt' } -> `CInt' void- #}
+
+{#fun igraph_pagerank as ^
+    { `IGraph'
+    , `PagerankAlgo'
+    , `Vector'
+    , id `Ptr CDouble'
+    , %`IGraphVs'
+    , `Bool'
+    , `Double'
+    , `Vector'
+    , id `Ptr ()'
+    } -> `CInt' void- #}
+
+{#fun igraph_personalized_pagerank as ^
+    { `IGraph'
+    , `PagerankAlgo'
+    , `Vector'
+    , id `Ptr CDouble'
+    , %`IGraphVs'
+    , `Bool'
+    , `Double'
+    , `Vector'
+    , `Vector'
+    , id `Ptr ()'
+    } -> `CInt' void- #}

src/IGraph/Types.hs

 
 module IGraph.Types where
 
-import qualified Data.HashMap.Strict   as M
-
 type Node = Int
+type LNode a = (Node, a)
+
 type Edge = (Node, Node)
 type LEdge a = (Edge, a)