anchor.diff:      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
  
positive.code: 
      //
      member this.Add (key : 'Key, value : 'T) : LruCache<'Key, 'T> =
          // 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> =
  
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> =
  