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:                 then this
                  else other
          | []                                    -> failwith "This should never happen"
  
      let rec toListOrdered descending roots =
          let rec treeToList acc = function
  
negative.code: //****************************************************************************************************
  //TODO: Implement equality to be able to compare two heaps
  //TODO: Maybe implement comparison too?
  type 'T SkewBinomialHeap when 'T: comparison private (count, descending, roots: 'T SBHTreeRoot list) =
      
      static let hashElements = 20
  
      let hash = lazy(
          let rec hashIt n hash roots =
              if n = 0 then
                  hash
              else
                  let h, t = SBHTreeRoot.uncons descending roots
                  hashIt (n - 1) (hash * 397 ^^^ Operators.hash h) t
          hashIt (min hashElements count) 0 roots)
          
      new() = SkewBinomialHeap(0, false, [])
  
  