anchor.diff:  
       //
       member this.Add (key : 'Key, value : 'T) : LruCache<'Key, 'T> =
  -        // NOTE : Checked.add MUST be used when incrementing 'count'!
  -        notImpl "LruCache.Add"
  +        // NOTE : It is very important that we use checked addition here with uint32 operands --
  +        // this data structure currently breaks if the index rolls over from 0xffffffff to 0x00000000.
  +        let newIndex = Checked.(+) currentIndex 1u
  +        let newCache = HashMap.add key (KeyValuePair (int newIndex, value)) cache
  +
  +        let newIndexedKeys =
  +            // Update the key-index (if necessary, i.e., the key already exists in the cache).
  +            let newIndexedKeys =
  +                match HashMap.tryFind key cache with
  +                | None -> indexedKeys
  +                | Some keyIndexAndValue ->
  +                    IntMap.remove keyIndexAndValue.Key indexedKeys
  +
  +            // Add the key and it's new index to the key-index.
  +            IntMap.add (int newIndex) key newIndexedKeys
  +
  +        // Evict the least-recently-used key (and it's associated value) from the cache
  +        // if this map (the original) is already full.
  +        if uint32 (IntMap.count newIndexedKeys) > capacity then
  +            // 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.
  +            
  +            notImpl "LruCache.Add"
  +        else
  +            // Return a new cache with the updated map and key-index.
  +            LruCache (newCache, newIndexedKeys, capacity, newIndex)
   
       //
       member this.Remove (key : 'Key) : LruCache<'Key, 'T> =
           snd <| this.Extract key
   
       //
  -    member private __.Extract (key : 'Key) : KeyValuePair<'Key, 'T> option * LruCache<'Key, 'T> =
  -        notImpl "LruCache.Extract"
  +    member private this.Extract (key : 'Key) : KeyValuePair<'Key, 'T> option * LruCache<'Key, 'T> =
  +        match HashMap.tryFind key cache with
  +        | None ->
  +            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.
  +            Some (KeyValuePair (key, keyIndexAndValue.Value)),
  +            LruCache (cache', indexedKeys', capacity, currentIndex)
       
       //
       member this.ChangeCapacity (newCapacity : uint32) : LruCache<'Key, 'T> =
  
positive.code:             notImpl "LruCache::.ctor(uint32, seq<'Key, 'T>)"
              // TEMP : This is necessary because of the exception being raised (above).
              // It can be removed whenever this code path is implemented.
              LruCache (HashMap.empty, IntMap.empty, 0u, 0)
  
      /// Is the cache empty?
      member __.IsEmpty
  
negative.code: 
      //
      [<CompiledName("OfSeq")>]
      let ofSeq (source : seq<'Key * 'T>) : LruCache<'Key, 'T> =
          // Preconditions checked within the member.
          LruCache.OfSeq source
  
      //
      [<CompiledName("OfList")>]
      let ofList (source : ('Key * 'T) list) : LruCache<'Key, 'T> =
          // Preconditions checked within the member.
          LruCache.OfList source
  
      //
      [<CompiledName("OfArray")>]
      let ofArray (source : ('Key * 'T)[]) : LruCache<'Key, 'T> =
          // Preconditions checked within the member.
          LruCache.OfArray source
  
  