anchor.diff:      /// Removes the indexable wrapper of an item.
       let item {Item = x} = x
   
  -    /// Sorts `Indexable` items based on their index and removes their wrapper.
  -    /// Duplicate indices do not raise an error.
  -    let collect x = x |> Seq.sortBy Indexable.index |> Seq.map item |> ImmutableArray.CreateRange
  -
  -/// An immutable array that exhibits good random-access performance and safe index access.
  +/// 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 RandomAccessList<'a> = private RandomAccessList of ImmutableArray<'a>
  +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 x = x |> ImmutableArray.CreateRange |> RandomAccessList
  -        member private x.Value = x |> (fun (RandomAccessList x) -> x)
  +        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.
  
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:                 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()
  