Should mutableSublist not be required to support mutation operations for changing size?

[AlexKnauth]

What should the mutableSublist method on mutable lists produce?

If the hierarchy of list interfaces looks something like this:

• ReadableList reading operations: elements, unmodifiable sublists
  • List functional operations including changing size
  • MutableList mutation operations including changing size

Then it seems like any mutable list implementation would have to have to make mutableSublist produce a MutableList that supports mutation operations that can change the size, such as appending, prepending, inserting, and removing.

But for many mutable list implementations, it wouldn't make sense to do this. Instead, it might make more sense for their mutableSublist to produce a "slice", like Rust's &mut [T], that does not support operations that can change the size.

So should a new interface be inserted between MutableList and ReadableList which doesn't support those operations that can change the size?

• ReadableList reading operations: elements, unmodifiable sublists
  • List functional operations including changing size
  • IndexMutableList mutation operations by existing index only, NO changing size
    • MutableList mutation operations including changing size

ReadableList method sublist produces ReadableList:

• A functional list implementation can choose to produce either a view or a copy, depending on what's best for the situation,
  and can produce List if desired.
• A mutable list implementation must produce an unmodifiable read-through view that implements ReadableList,
  and should NOT produce IndexMutableList or MutableList.

IndexMutableList method mutableSublist produces IndexMutableList:

• A mutable list implementation must produce a write-through view that implements IndexMutableList,
  but does not have to implement MutableList.

Fixed-length mutable lists such as Racket's vector should implement IndexMutableList but not MutableList.
Flexible-length mutable lists such as Racket's gvector should implement MutableList.

I expect most mutable list implementations will choose to make mutableSublist produce only IndexMutableList, not MutableList.
There's nothing stopping a mutable list implementation that wants to override mutableSublist to produce a MutableList with the "appending to the sublist inserts into the middle of the backing list" behavior, but this way it wouldn't be mandatory.