anchor.diff:  
       [<DefaultValue>]
       val mutable version:int
  +
  +    interface IEnumerable with
  +        member this.GetEnumerator() = this.GetEnumerator() :> IEnumerator
  +
  +    interface IDictionary<'TKey, 'TValue> with
  +        member this.Add(key:'TKey, value:'TValue) = this.Add(key, value)
  +        member this.Add(item:KeyValuePair<'TKey, 'TValue>) = this.Add(item)
  +        member this.Clear() = this.Clear()
  +        member this.ContainsKey(key:'TKey) = this.ContainsKey(key)
  +        member this.Contains(item:KeyValuePair<'TKey, 'TValue>) = this.Contains(item)
  +        member this.Remove(key:'TKey) = this.Remove(key)
  +        member this.Remove(item:KeyValuePair<'TKey, 'TValue>) = this.Remove(item)
  +        member this.CopyTo(array:KeyValuePair<'TKey, 'TValue>[], arrayIndex:int) = this.CopyTo(array, arrayIndex)
  +        member this.GetEnumerator() = this.GetEnumerator()
  +        member this.TryGetValue(key:'TKey, value:byref<'TValue>) =
  +            let result = this.TryGetValue(key)
  +            if result.IsSome then
  +                value <- result.Value
  +                true
  +            else
  +                value <- Unchecked.defaultof<'TValue>
  +                false
  +        member this.Item
  +            with get(key:'TKey) = this.[key]
  +            and set(key:'TKey) value = this.[key] <- value
  +        member this.Keys
  +            with get() = this.Keys
  +        member this.Values
  +            with get() = this.Values
  +        member this.Count
  +            with get() = this.Count
  +        member this.IsReadOnly
  +            with get() = this.IsReadOnly
   
       member this.Add(key:'TKey, value:'TValue) =
           this.Set(key, value, true)
  
positive.code:     member this.CopyTo(array:KeyValuePair<'TKey, 'TValue>[], arrayIndex:int) =
          this.AsList(fun node -> new KeyValuePair<'TKey, 'TValue>(node.Key, node.Value)).CopyTo(array, arrayIndex)
  
      member this.GetEnumerator() : IEnumerator<KeyValuePair<'TKey, 'TValue>> =
          let backingList = this.AsList<KeyValuePair<'TKey, 'Value>>(fun node -> new KeyValuePair<'TKey, 'TValue>(node.Key, node.Value));
          let tiedList = new TiedList<KeyValuePair<'TKey, 'Value>, 'TKey, 'TValue>(this, this.version, backingList)
          tiedList.GetEnumerator()
  
      member private this.AsList<'TEnumerator>(selector:SplayTreeNode<'TKey, 'TValue>->'TEnumerator) : IList<'TEnumerator> =
          let result = new List<'TEnumerator>(this.count)
          if this.root <> null then
  
negative.code:     member this.Clear() =
          raise (new NotSupportedException())
  
      member this.Contains(item) =
          this.CheckVersion()
          backingList.Contains(item)
  
      member this.CopyTo(array, arrayIndex) =
          this.CheckVersion()
          backingList.CopyTo(array, arrayIndex)
  
  