anchor.diff:  
       //
       [<CompiledName("OfSeq")>]
  -    let inline ofSeq (source : seq<'Key * 'T>) : LruCache<'Key, 'T> =
  +    let ofSeq (source : seq<'Key * 'T>) : LruCache<'Key, 'T> =
           // Preconditions checked within the member.
           LruCache.OfSeq source
   
       //
       [<CompiledName("OfList")>]
  -    let inline ofList (source : ('Key * 'T) list) : LruCache<'Key, 'T> =
  +    let ofList (source : ('Key * 'T) list) : LruCache<'Key, 'T> =
           // Preconditions checked within the member.
           LruCache.OfList source
   
       //
       [<CompiledName("OfArray")>]
  -    let inline ofArray (source : ('Key * 'T)[]) : LruCache<'Key, 'T> =
  +    let ofArray (source : ('Key * 'T)[]) : LruCache<'Key, 'T> =
           // Preconditions checked within the member.
           LruCache.OfArray source
   
  
positive.code:             cache.Add (key, value))
  
      //
      static member OfList (source : ('Key * 'T) list) : LruCache<'Key, 'T> =
          // Preconditions
          checkNonNull "source" source
  
  
negative.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 : 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 : uint32) =
      /// The empty cache instance.
      static let empty = LruCache (HashMap.empty, IntMap.empty, 0u, 0u)
  
      /// The empty cache instance.
      static member internal Empty
          with get () = empty
  
      /// Create an LruCache from a sequence of key-value pairs.
  