[Rant] Indexing into ArraySlice

[hooman (Hooman Mehr)]

Thanks for your feedback.

@Nevin

I notice you must use parentheses here. Have you considered a second operator spelled ...- that would let you omit the parentheses?

I mentioned the possibility of adding ...- operator in a comment a couple of lines down.

Another possibility would be to emulate the Matlab-esque “end” by introducing simple types called Start and End . Then, by providing suitable operators, we could write things like:

someCollection[Start()+3 ... End()-2]

I brought this particular minimalist design up to avoid over-complicating it. As @palimondo mentioned up-thread, and If you remember, a through discussion of your suggested approach and multiple other possibilities is explored in this thread:

Shorthand for Offsetting startIndex and endIndex

Hello, Swift-Evolution Using collection indexes are a bit of a bother when you want to do simple slicing and a type is not indexed by Int. For a simple example take the code here: let s = "Hello, Swift" let m = s[...s.index(s.startIndex, offsetBy: 4)] The intent of advancing startIndex gets a bit muddled. So to ease this I think we could add startIndex(offsetBy:) and endIndex(offsetBy:) to Collection . Making the example above: let s = "Hello, Swift" let m = s[...s.startIndex(offsetBy: 4)…

I brought this up to show that with random access collections like Array (or its slice) we don't really have to worry about the actual indexes, because offset always gives us a zero based integer "index" into the collection. If added to the standard library, this approach can be completely optimized away in cases like Array (and its slice) and produce identical performance characteristics as using the normal index APIs.

The designs explored in the above thread, drifted towards overly complex solutions, and I think that is why the thread died out without any tangible result and conclusion.

I am trying to revive that idea by showing how it can help here, and show that it can be pretty useful even with a minimalist design. (I don't like the fact that I had to make a custom type just to represent offset ranges)

My issue with this approach is that I don't like labeled subscripts. That is why I reduced the label to o: to make it less distracting. Maybe if we had true callable types we could use parenthesis for relative indexes (offsets). For example, instead of b[o: 2...] we could write b(2...). Don't yell at me for this outlandish suggestion, it does have precedent in programming languages.