anchor.diff:              cache.Add (key, value))
   
       //
  -    static member OfList (source : ('Key * 'T) list) : LruCache<'Key, 'T> =
  +    static member internal OfList (source : ('Key * 'T) list) : LruCache<'Key, 'T> =
           // Preconditions
           checkNonNull "source" source
   
  
positive.code: (* OPTIMIZE :   In the HashMap used in the cache, change the KeyValuePair to a simple struct-tuple
                  so we can flip the order the index and value are stored in; this'll provide better
                  data alignment in most cases. (E.g., name the type ValueWithKeyIndex) *)
  // TODO : Perhaps use TagMap instead of IntMap, and tag the key indices with a tag type like KeyIndex.
  
  /// An immutable cache data structure with a Least-Recently-Used (LRU) eviction policy.
  type LruCache<'Key, 'T when 'Key : equality>
      private (cache : HashMap<'Key, KeyValuePair<int, 'T>>, indexedKeys : IntMap<'Key>,
               capacity : uint32, currentIndex : int) =
      /// The empty cache instance.
      static let empty = LruCache (HashMap.empty, IntMap.empty, 0u, 0)
  
      /// The empty cache instance.
      static member Empty
          with get () = empty
  
      /// Create an LruCache from a sequence of key-value pairs.
  
negative.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, 0u)
  
      /// Is the cache empty?
      member __.IsEmpty
  