anchor.diff:      member this.ToList () =
           SBHTreeRoot.toListOrdered descending roots
   
  +    interface 'T SkewBinomialHeap System.IEquatable with
  +        member this.Equals other =
  +            this.ToList () = other.ToList()
  +
  +    override this.Equals other =
  +        match other with
  +        | :? ('T SkewBinomialHeap System.IEquatable) as eheap -> eheap.Equals this
  +        | _ -> false
  +
  +    override this.GetHashCode () = match hash with Lazy h -> h
  +
       interface IEnumerable<'T> with
           member this.GetEnumerator () = (SBHTreeRoot.toListOrdered descending roots |> List.toSeq).GetEnumerator ()
           
  
positive.code:         if count = 0 then
              None
          else
              //find the root with the minimum value a return it along with the remaining roots
              let (Root(rank, Node(_, aux, children)), roots') = SBHTreeRoot.extractMinRoot descending roots
  
              //reverse the children a set their ranks based on the parent's rank
              let (_, reversed) = children |> List.fold (fun (rank, trees) tree -> rank - 1, Root(rank - 1, tree)::trees) (rank, [])
  
              //merge the reversed children with the remaining trees
              let merged = SBHTreeRoot.mergeRoots descending reversed (SBHTreeRoot.normalize descending roots') 
  
              //reinsert all "auxiliary" elements
              let newRoots = aux |> List.fold (fun roots value -> SBHTreeRoot.insert descending value roots) merged
  
              Some (SkewBinomialHeap (count - 1, descending, newRoots))
  
      member this.Tail () =
          match this.TryTail () with
  
negative.code:         | _      -> raise (Empty "Empty heap, no tail")
  
      member this.TryUncons () =
          if this.IsEmpty 
              then None
              else let (h, t) = SBHTreeRoot.uncons descending roots in Some (h, SkewBinomialHeap (count - 1, descending, t))
  
      member this.Uncons () =
          match this.TryUncons () with
  