anchor.diff:  
       //
       member this.Remove (key : 'Key) : LruCache<'Key, 'T> =
  -        snd <| this.Extract key
  -
  -    //
  -    member private this.Extract (key : 'Key) : KeyValuePair<'Key, 'T> option * LruCache<'Key, 'T> =
  +        match HashMap.tryFind key cache with
  +        | None ->
  +            this
  +        | Some keyIndexAndValue ->
  +            let cache' = HashMap.remove key cache
  +            let indexedKeys' = IntMap.remove keyIndexAndValue.Key indexedKeys
  +
  +            // Return the new cache with the modified maps.
  +            // NOTE : The index is not updated here -- that is only done
  +            // when adding values to the cache.
  +            LruCache (cache', indexedKeys', capacity, currentIndex)
  +
  +    /// Try to extract the specified key from the cache, returning
  +    /// the key and it's associated value along with the updated cache.
  +    member this.TryExtract (key : 'Key) : ('Key * 'T) option * LruCache<'Key, 'T> =
           match HashMap.tryFind key cache with
           | None ->
               None, this
  
positive.code:         with get () =
              IntMap.count indexedKeys
  
      /// Look up a key in the cache, returning Some with the associated value if
      /// if the key is in the domain of the cache and None if not. The (possibly)
      /// updated cache is also returned.
      member this.TryFind (key : 'Key) : 'T option * LruCache<'Key, 'T> =
          // Try extracting the key/value from the cache.
          let value, this' = this.Extract key
  
          // If the key was found (and the value extracted), re-insert the key/value
          // in the cache so the key's index will be updated.
  
negative.code:         | None ->
              None, this
          | Some keyIndexAndValue ->
              Some (snd keyIndexAndValue),
              this'.Add (key, snd keyIndexAndValue)
  
      /// Tests if a key is in the domain of the cache.
      member __.ContainsKey (key : 'Key) : bool =
  