anchor.diff:  
   
   /// An immutable implementation of a vertex-labeled sparse digraph.
  -type private VertexLabeledSparseDigraph<[<EqualityConditionalOn>]'Vertex when 'Vertex : comparison>
  +type internal VertexLabeledSparseDigraph<[<EqualityConditionalOn>]'Vertex when 'Vertex : comparison>
           private (vertices : Set<'Vertex>, edges : Set<'Vertex * 'Vertex>) =
       //
       static member internal Empty
  
positive.code:             Choice2Of2 errorMsg
          | Choice1Of2 root ->
              /// The predecessors of each vertex.
              let predecessorsOf =
                  let initialPreds =
                      (Map.empty, graph.Vertices)
                      ||> Set.fold (fun initialMap vertex ->
                          Map.add vertex Set.empty initialMap)
  
                  (initialPreds, 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)
  
              /// The graph vertices, excluding the root vertex.
              let vertices = Set.remove root graph.Vertices
  
negative.code:             |> Choice1Of2
  
      /// Computes the set of vertices reachable from each vertex in a graph.
      // NOTE : This is equivalent to computing the non-reflexive transitive closure of the graph.
      let reachable (graph : VertexLabeledSparseDigraph<'Vertex>) =
          // This is a simplified version of the Floyd-Warshall algorithm
          // which checks only for reachability (Warshall's algorithm).
  