anchor.diff:      module DHeap = 
   
           /// Return the number of entries in the dheap priority queue
  -        let size dheap = 
  +        let size (dheap: DHeap<'T>) : int = 
               dheap.Heap.Count
   
           /// Is the dheap priority queue empty
  -        let isEmpty dheap = 
  +        let isEmpty (dheap: DHeap<'T>) : bool = 
               dheap.Heap.Count = 0
   
   
           /// Convert a power of two number into its value as a power of two integer exponent
  -        let private asPowerOfTwoExponent n = 
  +        let private asPowerOfTwoExponent (n: int) : int = 
               Math.Log(float n, 2.0) |> int
       
           /// Extract the capacity value or return a default.
  -        let private capacityValue capacity = 
  +        let private capacityValue (capacity: Capacity) : int = 
               match capacity with
               | Capacity(cap) -> int cap 
               | DefaultCapacity -> 16
   
           /// Return the arity of a tree node in the heap as an integer
  -        let private arityToInteger arity = 
  +        let private arityToInteger (arity: HeapArity) : int = 
               match arity with
               | Binary -> 2
               | Quaternary -> 4
  
positive.code:                 fail EmptyHeap
      
                  
      let minBinaryHeap = fun _ -> DHeap.empty Binary MinKey DefaultCapacity 
      let maxBinaryHeap = fun _ -> DHeap.empty Binary MaxKey DefaultCapacity
      let minQuaternaryHeap = fun _ -> DHeap.empty Quaternary MinKey DefaultCapacity 
      let maxQuaternaryHeap = fun _ -> DHeap.empty Quaternary MaxKey DefaultCapacity 
  
      let minBinaryHeapWith items = DHeap.ofSeq Binary MinKey DefaultCapacity items
      let maxBinaryHeapWith items = DHeap.ofSeq Binary MaxKey DefaultCapacity items
      let minQuaternaryHeapWith items = DHeap.ofSeq Quaternary MinKey DefaultCapacity items
      let maxQuaternaryHeapWith items = DHeap.ofSeq Quaternary MaxKey DefaultCapacity items
  
  
  
  
negative.code: 
          /// Ensure that a key (identified by index) is higher priority than its children and if not 
          /// sink it down the tree swapping with a child (and grandchildren etc) as required
          let rec private sink (dheap: DHeap<'T>) (index: int) = 
              let highestChildIndex = highestPriorityChildIndex dheap index
              if highestChildIndex < (size dheap) && 
                  isHigherPriority dheap highestChildIndex index then
  