anchor.diff:      "Vertices = {VertexCount}, \
        EdgeSets = {EdgeSetCount}, \
        Edges = {EdgeCount}")>]
  -type LexerDfaGraph private (vertexCount : int,
  -                            adjacencyMap : Map<TransitionEdgeKey, CharSet>,
  -                            eofTransition : TransitionEdgeKey option) =
  +type SparseMultiDigraph<[<Measure>] 'Tag>
  +    private (vertexCount : int, adjacencyMap : Map<TransitionEdgeKey<'Tag>, CharSet>, eofTransition : TransitionEdgeKey<'Tag> option) =
       //
       static let empty =
  -        LexerDfaGraph (GenericZero, Map.empty, None)
  +        SparseMultiDigraph (GenericZero, Map.empty, None)
   
       //
       static member internal Empty
  
positive.code: 
      //
      member __.CreateVertex () =
          let newVertex : DfaStateId = Int32WithMeasure vertexCount
          newVertex,
          LexerDfaGraph (
              vertexCount + 1,
              adjacencyMap,
              eofTransition)
  
      //
      member __.TryGetEdgeSet (source : DfaStateId, target : DfaStateId) =
          // Preconditions
          if int source < 0 || int source >= vertexCount then
              invalidArg "source" "The vertex is not in the graph's vertex-set."
          elif int target < 0 || int target >= vertexCount then
              invalidArg "target" "The vertex is not in the graph's vertex-set."
  
          let key = TransitionEdgeKey (source, target)
          Map.tryFind key adjacencyMap
  
      //
      member __.AddEdges (source : DfaStateId, target : DfaStateId, edges : CharSet) =
          // Preconditions
          if int source < 0 || int source >= vertexCount then
              invalidArg "source" "The vertex is not in the graph's vertex-set."
  
negative.code: open FSharpLex.SpecializedCollections
  
  
  /// <summary>The source and target state of a transition
  /// edge in an NFA transition graph.</summary>
  /// <remarks>Used as a key for sparse graph implementations
  /// because it's more efficient than an F# tuple.</remarks>
  [<Struct>]
  [<DebuggerDisplay("{Source} -> {Target}")>]
  type TransitionEdgeKey<[<Measure>] 'Tag> =
      /// The source vertex of the edge.
      val Source : int<'Tag>
      /// The target vertex of the edge.
      val Target : int<'Tag>
  
      new (source, target) =
          {   Source = source;
  