anchor.diff:                  match i with
                   | i when i < uint32 x.Count -> i |> Indexed.create<'a> |> Ok
                   | i -> Error i
  +        member x.ItemUnsafe
  +            with get i =
  +                x.Indexed i |> Result.map (fun i -> x.Item i)
           interface IEnumerable with
               /// [omit]
               member x.GetEnumerator() = (x.Value :> IEnumerable).GetEnumerator()
  
positive.code: module Indexable =
      /// Gets the index of an `Indexable` object.
      let index (x: #Indexable) = x.Index
      /// Sorts `Indexable` items based on their index.
      /// Duplicate indices do not raise an error.
      let collect x = x |> Seq.sortBy index |> ImmutableArray.CreateRange
  
  /// A type-safe reference to a value based on its index.
  type [<Struct>] Indexed<'a> = Indexed of uint32
  
negative.code: /// Functions for working with `Indexed<'a>`.
  module Indexed =
  
      /// 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
  