anchor.diff:              Map.add key kvp.Value map)
   
       //
  -    static member internal OfSeq (source : seq<'Key * 'T>) : LruCache<'Key, 'T> =
  +    static member internal OfSeq (source : seq<'Key * 'T>, capacity : uint32) : LruCache<'Key, 'T> =
           // Preconditions
           checkNonNull "source" source
   
  -        (empty, source)
  +        (LruCache.Create capacity, source)
           ||> Seq.fold (fun cache (key, value) ->
               cache.Add (key, value))
   
       //
  -    static member internal OfList (source : ('Key * 'T) list) : LruCache<'Key, 'T> =
  +    static member internal OfList (source : ('Key * 'T) list, capacity : uint32) : LruCache<'Key, 'T> =
           // Preconditions
           checkNonNull "source" source
   
  -        (empty, source)
  +        (LruCache.Create capacity, source)
           ||> List.fold (fun cache (key, value) ->
               cache.Add (key, value))
   
       //
  -    static member internal OfArray (source : ('Key * 'T)[]) : LruCache<'Key, 'T> =
  +    static member internal OfArray (source : ('Key * 'T)[], capacity : uint32) : LruCache<'Key, 'T> =
           // Preconditions
           checkNonNull "source" source
           
  -        (empty, source)
  +        (LruCache.Create capacity, source)
           ||> Array.fold (fun cache (key, value) ->
               cache.Add (key, value))
   
       //
  -    static member internal OfMap (source : Map<'Key, 'T>) : LruCache<'Key, 'T> =
  +    static member internal OfMap (source : Map<'Key, 'T>, capacity : uint32) : LruCache<'Key, 'T> =
           // Preconditions
           checkNonNull "source" source
   
  -        (empty, source)
  +        (LruCache.Create capacity, source)
           ||> Map.fold (fun cache key value ->
               cache.Add (key, value))
   
  
positive.code:         // Preconditions
          checkNonNull "cache" cache
          
          map.Filter predicate
  
      /// <summary>
      /// Applies the given function to each binding in the map.
  
negative.code:         checkNonNull "cache" cache
  
          cache.ToMap ()
  
      /// Searches the cache looking for the least-recently-used element where the given function
      /// returns a Some value. If no such element is found, returns None.
      [<CompiledName("TryPick")>]
      let inline tryPick (picker : 'Key -> 'T -> 'U option) (cache : LruCache<'Key, 'T>) : 'U option =
          // Preconditions
          checkNonNull "cache" cache
          
          cache.TryPick picker
  
      /// Searches the cache looking for the least-recently-used element where the given function
      /// returns a Some value. If no such element is found, KeyNotFoundException is raised.
      [<CompiledName("Pick")>]
      let inline pick (picker : 'Key -> 'T -> 'U option) (cache : LruCache<'Key, 'T>) : 'U =
          // Preconditions
          checkNonNull "cache" cache
  
          cache.Pick picker
  
      /// Determines if any binding in the map matches the specified predicate.
      [<CompiledName("Exists")>]
      let inline exists (predicate : 'Key -> 'T -> bool) (cache : LruCache<'Key, 'T>) : bool =
          // Preconditions
          checkNonNull "cache" cache
          
          cache.Exists predicate
  
      /// Determines if all bindings in the map match the specified predicate.
      [<CompiledName("Forall")>]
      let inline forall (predicate : 'Key -> 'T -> bool) (cache : LruCache<'Key, 'T>) : bool =
          // Preconditions
          checkNonNull "cache" cache
  
          cache.Forall predicate
  
      /// <summary>
      /// Builds a new map containing only the bindings for which the given
  