anchor.diff:  let ``tryHead returns Some head when the heap is not empty`` () =
       fsCheck <| fun { Heap = heap; Items = orig } -> 
           heap |> SkewBinomialHeap.isEmpty |> not ==> 
  -            lazy(
  -                match SkewBinomialHeap.tryHead heap with 
  -                | Some head -> head |> should equal <| actualHead heap orig
  -                | None -> fail "tryHead to a non-empty heap returned None")
  +        match SkewBinomialHeap.tryHead heap with 
  +        | Some head -> head = actualHead heap orig
  +        | None -> false
   
   [<Test>]
   let ``tryHead returns None when the heap is empty`` () =
       fsCheck <| fun { Heap = heap } ->
  -        heap |> SkewBinomialHeap.isEmpty ==> lazy (heap |> SkewBinomialHeap.tryHead |> Option.isNone)
  +        heap |> SkewBinomialHeap.isEmpty ==> (heap |> SkewBinomialHeap.tryHead |> Option.isNone)
   
   [<Test>]
   let ``tail returns a heap with the first element removed when the heap is not empty`` () =
       fsCheck <| fun { Heap = heap; Items = orig } ->
  -        heap |> SkewBinomialHeap.isEmpty |> not ==> lazy(heap |> SkewBinomialHeap.tail |> SkewBinomialHeap.toList |> should equal <| actualTail heap orig)
  +        heap |> SkewBinomialHeap.isEmpty |> not ==> lazy(heap |> SkewBinomialHeap.tail |> SkewBinomialHeap.toList = actualTail heap orig)
   
   [<Test>]
   let ``tail throws when the heap is empty`` () =
  
positive.code:         heap |> SkewBinomialHeap.isEmpty |> not ==> 
              lazy(
                  match SkewBinomialHeap.tryTail heap with 
                  | Some tail -> tail |> SkewBinomialHeap.toList |> should equal <| actualTail heap orig
                  | None -> fail "tryTail to a non-empty heap returned None")
  
  [<Test>]
  let ``tryTail returns None when the heap is empty`` () =
      fsCheck <| fun { Heap = heap } ->
          heap |> SkewBinomialHeap.isEmpty ==> lazy(heap |> SkewBinomialHeap.tryTail |> Option.isNone)
  
  [<Test>]
  let ``uncons returns (head, tail) when the heap is not empty`` () =
  
negative.code: type HeapData<'T, 'L when 'T: comparison> = { Heap: 'T SkewBinomialHeap; Items: 'L list; Desc: bool }
  
  type SkewBinomialHeapGenerators() =
      static let genDesc d = 
          match d with
          | Some v -> Gen.constant v
          | None -> Gen.elements [true; false]
      // Empty heaps only, some are empty after removing all of its elements
      static member private EmptyOnly<'T when 'T: comparison> (d): Gen<HeapData<'T, 'T>> = gen{
          let! desc = genDesc d
          let! s = Gen.listOf (Arb.generate<'T>)
          return { Heap = Seq.init (s.Length) id |> Seq.fold (fun heap _ -> heap |> SkewBinomialHeap.tail) (ofList desc s); Items = []; Desc = desc }}
      // Non-emtpy heaps only, after a sucession of insertions and deletions
      static member private NonemptyOnly<'T when 'T: comparison> (d): Gen<HeapData<'T, 'T>> = gen{
          let! desc = genDesc d
          let! t = Gen.elements [true; false]
          let! s = Gen.nonEmptyListOf (Arb.generate<'T>)
          let! ndel = if t then Gen.constant Int32.MaxValue else Gen.choose (2, max 2 (s |> List.length))
  