New range operator `..+`

Evolution Pitches
1

I propose to add support for start ..+ length expression, which is equivalent to start ..< start + length (e.g. 100..+5 is the same as 100..<105).

This is especially useful for slicing when start expression is quite long.

Also, I do not think start ..+ length needs a special separate range type, i.e. it can be just of type Range with end set to start + length.

Do you find this feature useful?
  • Yes
  • Maybe
  • No
0 voters
2 Likes
3

Maybe just this?

for i in OpenRange(100, 110) {            // 100 ..< 110
    print(i)
}
for i in OpenRange(100, length: 10) {     // 100 ..< 110
    print(i)
}
for i in ClosedRange(100, 110) {          // 100 ... 110
    print(i)
}
for i in ClosedRange(100, length: 10) {   // 100 ... 110
    print(i)
}
Implementation 
typealias OpenRange = Range

extension OpenRange {
    init(_ from: Bound, _ to: Bound) {
        self = from ..< to
    }
}

extension OpenRange where Bound: AdditiveArithmetic {
    init(_ from: Bound, length: Bound) {
        self = from ..< from + length
    }
}

extension ClosedRange {
    init(_ from: Bound, _ to: Bound) {
        self = from ... to
    }
}

extension ClosedRange where Bound: AdditiveArithmetic {
    init(_ from: Bound, length: Bound) {
        self = from ... from + length
    }
}
1 Like
4

I would've expected 0..+10 to index ten elements, but if defined like here it would not be

Also, it wouldn't work for non-numeric indices

I would rather have something like lhs..<collection(lhs, offsetBy: rhs)

infix operator ..+

func ..+<T: Numeric>(lhs: T, rhs: T) -> Range<T> {
    lhs..<(lhs+rhs)
}

let multiplesOfTwo = Array(0...100).lazy.filter { $0.isMultiple(of: 2) }

print(Array(multiplesOfTwo.prefix(10))) // [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
print(Array(multiplesOfTwo[0..<multiplesOfTwo.index(0, offsetBy: 10)])) // [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
print(Array(multiplesOfTwo[0..+10])) // [0, 2, 4, 6, 8]
1 Like
5

In my proposal 0..+10 is the same as 0 ..< (0+10), i.e. 0..<10, so it indexes exactly ten elements (from 0 through 9).

6

Swift indexes are weird. Check out my code sample - multiplesOfTwo[0..<10] is only five elements

1 Like