anchor.diff:      let inline containsEdge source target (graph : VertexLabeledSparseDigraph<'Vertex>) =
           graph.ContainsEdge (source, target)
   
  +    /// Creates a VertexLabeledSparseDigraph from a list of edges.
  +    let ofEdgeList (edgeList : ('Vertex * 'Vertex) list) =
  +        (VertexLabeledSparseDigraph.Empty, edgeList)
  +        ||> List.fold (fun graph (source, target) ->
  +            graph
  +            |> addVertex source
  +            |> addVertex target
  +            |> addEdge source target)            
  +
  +    //
  +    let predecessors (graph : VertexLabeledSparseDigraph<'Vertex>) =
  +        let initialMap =
  +            (Map.empty, graph.Vertices)
  +            ||> Set.fold (fun initialMap vertex ->
  +                Map.add vertex Set.empty initialMap)
  +
  +        (initialMap, graph.Edges)
  +        ||> Set.fold (fun predecessorsOf (source, target) ->
  +            let predsOfTarget =
  +                Map.find target predecessorsOf
  +                // Add the source vertex to the predecessor set of target.
  +                |> Set.add source
  +
  +            // Add the updated set to the map.
  +            Map.add target predsOfTarget predecessorsOf)
  +
  +    //
  +    let successors (graph : VertexLabeledSparseDigraph<'Vertex>) =
  +        let initialMap =
  +            (Map.empty, graph.Vertices)
  +            ||> Set.fold (fun initialMap vertex ->
  +                Map.add vertex Set.empty initialMap)
  +
  +        (initialMap, graph.Edges)
  +        ||> Set.fold (fun successorsOf (source, target) ->
  +            let successorsOfSource =
  +                Map.find source successorsOf
  +                // Add the target vertex to the successor set of source.
  +                |> Set.add target
  +
  +            // Add the updated set to the map.
  +            Map.add source successorsOfSource successorsOf)
  +
       //
       let dominators (graph : VertexLabeledSparseDigraph<'Vertex>) =
  +        // If the graph's vertex-set is empty, return an
  +        // empty map instead of raising an exception.
  +        if isEmpty graph then
  +            Choice1Of2 Map.empty
  +        else
           // Find the root vertex.
           let root =
               let roots =
  
positive.code:             |> Choice1Of2
  
      /// Computes the set of vertices reachable from each vertex in a graph.
      let reachable (graph : VertexLabeledSparseDigraph<'Vertex>) =
          // This is a simplified version of the Floyd-Warshall algorithm
          // which checks only for reachability (Warshall's algorithm).
  
negative.code:     let inline isEmpty (graph : VertexLabeledSparseDigraph<'Vertex>) =
          graph.IsEmpty
  
      (* TODO :   Implement a function to determine if the graph's edge-set is empty;
                  i.e., it may (or may not) have some vertices, but it does not have any edges. *)
  
      //
      let inline addVertex (vertex : 'Vertex) (graph : VertexLabeledSparseDigraph<'Vertex>) =
          graph.AddVertex vertex
  