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: 
              // reorg
              let mutable current = 0
              for kvp in karr.Keys_ do
                  let key = kvp.Key
                  let index = karr.Indices_.[key]
                  let value = karr.Values_.[index]
                  karr.Keys_.[current] <- key
                  karr.Indices_.[key] <- current
                  karr.Values_.[current] <- value
                  current <- inc current
  
              // shrink
              let values = Array.zeroCreate (karr.Current_ * int karr.Threshold_)
              Array.blit karr.Values_ 0 values 0 values.Length
              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>