anchor.diff:  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
  
positive.code:                 match i with
                  | i when i < uint32 x.Count -> i |> Indexed.create<'a> |> Ok
                  | i -> Error i
          interface IEnumerable with
              /// [omit]
              member x.GetEnumerator() = (x.Value :> IEnumerable).GetEnumerator()
  
negative.code:     /// Removes the indexable wrapper of an item.
      let item {Item = x} = x
  
  /// An immutable array that exhibits good random access performance and safe index access.
  /// It intentionally lacks methods such as `map` and `filter`. This type should be at the final stage of data manipulation.
  /// It is advised to work with sequences before, just until the end.
  /// Safe random access is faciliated through `Indexed` objects.
  type SafeArray<'a> = private SafeArray of 'a[]
      with
          /// O(n) Creates a random-access list. Data will be copied to this new list.
          static member Create<'a> (x: 'a seq) =
              x
              |> Array.ofSeq
              |> SafeArray
          member private x.Value = x |> (fun (SafeArray x) -> x)
          /// O(1) Gets the length of the list.
          member x.Count = x.Value.Length
          /// Gets the item at the given position the `Indexed` object points to.
  