anchor.diff:          &karr.[key]
   
       /// Make a KeyedArray with the given compaction threshold and initial capaticy.
  -    let make<'k, 'v when 'k : comparison> threshold capacity =
  +    let make<'k, 'v when 'k : comparison> threshold capacity : KeyedArray<'k, 'v> =
           { Keys_ = SortedDictionary<int, 'k> ()
             Indices_ = Dictionary<'k, int> ()
             Values_ = Array.zeroCreate capacity
  
positive.code:         if overflowing karr then
  
              // grow
              let values = Array.zeroCreate (karr.Current_ * int (1.0f / karr.Threshold_))
              Array.blit karr.Values_ 0 values 0 karr.Current_
              karr.Values_ <- values
  
  
negative.code:           Removed_ = 0.0f
            Threshold_ = threshold }
  
      /// Convert a keyed array to a sequence.
      let toSeq (karr : KeyedArray<_, _>) =
          seq karr
  
      /// Convert a keyed array from a sequence.
      let ofSeq threshold seq =
          let arr = Seq.toArray seq
          let karr = make threshold arr.Length
          for (key, value) in arr do add key value karr
          karr
  
  /// A garbage-collected keyed array.
  /// TODO: once this is well-tested, let's consider moving into Prime.
  type KeyedArray<'k, 'v when 'k : comparison> = KeyedArray.KeyedArray<'k, 'v>