anchor.diff:          // Preconditions
           checkNonNull "cache" cache
           
  -        map.Filter predicate
  +        cache.Filter predicate
   
       /// <summary>
       /// Applies the given function to each binding in the map.
  
positive.code:             Map.add key kvp.Value map)
  
      //
      static member internal OfSeq (source : seq<'Key * 'T>) : LruCache<'Key, 'T> =
          // Preconditions
          checkNonNull "source" source
  
          (empty, source)
          ||> Seq.fold (fun cache (key, value) ->
              cache.Add (key, value))
  
      //
      static member internal OfList (source : ('Key * 'T) list) : LruCache<'Key, 'T> =
          // Preconditions
          checkNonNull "source" source
  
          (empty, source)
          ||> List.fold (fun cache (key, value) ->
              cache.Add (key, value))
  
      //
      static member internal OfArray (source : ('Key * 'T)[]) : LruCache<'Key, 'T> =
          // Preconditions
          checkNonNull "source" source
          
          (empty, source)
          ||> Array.fold (fun cache (key, value) ->
              cache.Add (key, value))
  
      //
      static member internal OfMap (source : Map<'Key, 'T>) : LruCache<'Key, 'T> =
          // Preconditions
          checkNonNull "source" source
  
          (empty, source)
          ||> Map.fold (fun cache key value ->
              cache.Add (key, value))
  
  
negative.code:         // Preconditions
          checkNonNull "cache" cache
          
          cache.Choose chooser
  
      /// Apply a function to each key-value pair in the cache, in order from
      /// oldest (least-recently-used) to newest (most-recently-used).
      [<CompiledName("Iterate")>]
      let inline iter (action : 'Key -> 'T -> unit) (cache : LruCache<'Key, 'T>) : unit =
          // Preconditions
          checkNonNull "cache" cache
          
          cache.Iterate action
  
      /// Apply a function to each key-value pair in the cache, in order from
      /// newest (most-recently-used) to oldest (least-recently-used).
      [<CompiledName("IterateBack")>]
      let inline iterBack (action : 'Key -> 'T -> unit) (cache : LruCache<'Key, 'T>) : unit =
          // Preconditions
          checkNonNull "cache" cache
  
          cache.IterateBack action
  
      /// Apply a function to each key-value pair in the cache, in order from
      /// oldest (least-recently-used) to newest (most-recently-used), threading an
      /// accumulator value through the computation.
      [<CompiledName("Fold")>]
      let inline fold (folder : 'State -> 'Key -> 'T -> 'State) (state : 'State) (cache : LruCache<'Key, 'T>) : 'State =
          // Preconditions
          checkNonNull "cache" cache
          
          cache.Fold (folder, state)
  
      /// Apply a function to each key-value pair in the cache, in order from
      /// newest (most-recently-used) to oldest (least-recently-used), threading an
      /// accumulator value through the computation.
      [<CompiledName("FoldBack")>]
      let inline foldBack (folder : 'Key -> 'T -> 'State -> 'State) (cache : LruCache<'Key, 'T>) (state : 'State) : 'State =
          // Preconditions
          checkNonNull "cache" cache
  
          cache.FoldBack (folder, state)
  
      /// Builds a new cache whose values are the results of applying the given function
      /// to each key-value pair in the cache. The key passed to the function indicates
      /// the key of the element being transformed.
      [<CompiledName("Map")>]
      let inline map (mapping : 'Key -> 'T -> 'U) (cache : LruCache<'Key, 'T>) : LruCache<'Key, 'U> =
          // Preconditions
          checkNonNull "cache" cache
          
          cache.Map mapping
  
      /// Splits the cache into two caches containing the bindings for which the given
      /// predicate returns true and false, respectively.
      [<CompiledName("Partition")>]
      let inline partition (predicate : 'Key -> 'T -> bool) (cache : LruCache<'Key, 'T>) : LruCache<'Key, 'T> * LruCache<'Key, 'T> =
          // Preconditions
          checkNonNull "cache" cache
          
          cache.Partition predicate
  
      /// Splits the cache into two caches by applying the given partitioning function
      /// to each binding in the cache.
      [<CompiledName("MapPartition")>]
      let inline mapPartition (partitioner : 'Key -> 'T -> Choice<'U, 'V>) (cache : LruCache<'Key, 'T>) : LruCache<'Key, 'U> * LruCache<'Key, 'V> =
          // Preconditions
          checkNonNull "cache" cache
  
          cache.MapPartition partitioner
  
  