anchor.diff:              // when adding values to the cache.
               Some (KeyValuePair (key, keyIndexAndValue.Value)),
               LruCache (cache', indexedKeys', capacity, currentIndex)
  +
  +    //
  +    member private this.Evict () : LruCache<'Key, 'T> =
  +        // If the cache is empty, there's nothing to do so just
  +        // return the cache without modifying it.
  +        if IntMap.isEmpty indexedKeys then this
  +        else
  +            // Remove the minimum key from the key-index and cache.
  +            // TODO : Fix this so it works correctly even when the index rolls over from 0xffffffff to 0x00000000
  +            // OPTIMIZE : Use IntMap.extractMin here once it's implemented.
  +            let minKeyIndex = IntMap.minKey indexedKeys
  +            let minKey = IntMap.find minKeyIndex indexedKeys
  +            let newIndexedKeys = IntMap.remove minKeyIndex indexedKeys
  +            let newCache = HashMap.remove minKey cache
  +
  +            // Return a new cache with the updated map and key-index.
  +            LruCache (newCache, newIndexedKeys, capacity, currentIndex)
  +
  +    //
  +    member private this.EvictMany (count : uint32) : LruCache<'Key, 'T> =
  +        if count = 0u then this
  +        else
  +            // Evict the next key/value from the cache.
  +            let this' = this.Evict ()
  +
  +            // Continue evicting keys until we've evicted the specified number.
  +            this'.EvictMany (count - 1u)
       
       //
       member this.ChangeCapacity (newCapacity : uint32) : LruCache<'Key, 'T> =
  
positive.code:     static member internal Empty
          with get () = empty
  
      /// Create an LruCache from a sequence of key-value pairs.
      new (capacity : uint32, elements : seq<'Key * 'T>) =
          // Preconditions
  
negative.code:         else
              // The new capacity is smaller than the old capacity, so we need to
              // evict (capacity - newCapacity) values.
              this.EvictMany (capacity - newCapacity)
  
      //
      member __.ToSeq () : seq<'Key * 'T> =
  