anchor.diff:      module Graph = VertexLabeledSparseDigraph
       module BiGraph = VertexLabeledSparseBipartiteDigraph
   
  +    /// A binary relation over a set of elements.
  +    // For each 'x', contains the 'y' values such that xRy (given a relation 'R').
  +    type Relation<'T when 'T : comparison> =
  +        Map<'T, Set<'T>>
  +
  +    /// Partial function.
  +    type PartialFunction<'T, 'U
  +        when 'T : comparison
  +        and 'U : comparison> =
  +        Map<'T, Set<'U>>
  +
  +    /// The traversal status of an element.
  +    type private TraversalStatus =
  +        /// The element has not yet been traversed.
  +        | NotStarted
  +        /// Traversal of the element is in-progress.
  +        | InProgress of int // depth
  +        /// Traversal of the element has been completed.
  +        | Completed
  +
       //
  -    type private TraversalStatus =
  -        //
  -        | Untraversed
  -        //
  -        | Traversing of int // depth
  -        //
  -        | Traversed
  -
  -    //
  -    let rec private traverse (x, N, stack, F, X : Set<'T>, R, F' : Map<'T, Set<'U>>)
  +    let rec private traverse (x, N, stack, F, X : Set<'T>, R : Relation<'T>, F' : PartialFunction<'T, 'U>)
           : Map<_,_> * Map<_,_> * _ list =
           let stack = x :: stack
           let d = List.length stack
  -        let N = Map.add x (Traversing d) N
  +        let N = Map.add x (InProgress d) N
           let F =
               let ``F'(x)`` = Map.find x F'
               Map.add x ``F'(x)`` F
  
positive.code:             #if DEBUG
              let untraversed =
                  X |> Set.filter (fun x ->
                      match Map.find x N with Traversed -> false | _ -> true)
              Debug.Assert (
                  Set.isEmpty untraversed,
                  sprintf "There are %i elements of X (Count = %i) which have not been completely traversed." (Set.count untraversed) (Set.count X))
  
negative.code: 
          // Walk back up the stack, if necessary.
          match Map.find x N with
          | InProgress depth when depth = d ->
              let ``F(x)`` = Map.find x F
              let rec unwind (F, N, stack) =
                  match stack with
                  | [] ->
                      failwith "Unexpectedly empty stack."
                  | element :: stack ->
                      let N = Map.add element Completed N
                      let F = Map.add element ``F(x)`` F
  
                      if element = x then
  