anchor.diff:  /// Functions for working with `Indexed<'a>`.
   module Indexed =
   
  -    open Operators.Checked
  -
       /// Creates an `Indexed` object, with the ability to explicitly specify its type.
       let create<'a> i: Indexed<'a> = Indexed i
   
       /// Converts an `Indexed` value to an actual object lased on the index in a specified list.
  +    [<System.Obsolete("Use SafeArray.getUnsafe")>]
       let getfromList (i: Indexed<'a>) (list: #IReadOnlyList<'a>) =
           let i = i |> (fun (Indexed i) -> i) |> int
           if list.Count > i then
  
positive.code:             /// [omit]
              member x.Count = x.Count
  
  type [<Struct>] Keyed<'TKey,'TCorrespondingValue when 'TKey: comparison> = Keyed of 'TKey
      with
          member x.Key = x |> (fun (Keyed x) -> x)
  
  module Keyed =
      let create<'TKey,'TCorrespondingValue when 'TKey: comparison> k: Keyed<'TKey,'TCorrespondingValue> = Keyed k
  
  type RandomAccessMap<'TKey,'TValue when 'TKey: comparison> = private RandomAccessMap of Map<'TKey,'TValue>
      with
          static member Create x = x |> Map.ofSeq |> RandomAccessMap
          member private x.Value = x |> (fun (RandomAccessMap x) -> x)
          member x.ContainsKey k = x.Value.ContainsKey k
          member x.Count = x.Value.Count
          member x.Item
              with get (k: Keyed<'TKey, 'TValue>) = x.Value.[k.Key]
  
          member x.Keyed
              with get k =
                  match k with
                  | k when x.ContainsKey k -> k |> Keyed.create<'TKey,'TValue> |> Ok
                  | k -> Error k
          interface IEnumerable with
              member x.GetEnumerator() = (x.Value :> IEnumerable).GetEnumerator()
          interface IEnumerable<KeyValuePair<'TKey,'TValue>> with
              member x.GetEnumerator() = (x.Value :> seq<_>).GetEnumerator()
          interface IReadOnlyCollection<KeyValuePair<'TKey,'TValue>> with
              member x.Count = x.Count
  
negative.code: module Indexable =
      /// Gets the index of an `Indexable` object.
      let index (x: #Indexable) = x.Index
  
  /// A type-safe reference to a value based on its index.
  type [<Struct>] Indexed<'a> = Indexed of uint32
  