Open-ended range operators for Swift

openRanges.swift

// Open-ended range operators
// 
// 100... is equivalent to 100...Int.max
// ...-100 is equivalent to Int.min...-100
// ..<3 is equivalent to Int.min..<3

import Swift

/// Conforming types provide static `max` and `min` constants.
protocol MinMaxType {
    class var min: Self { get }
    class var max: Self { get }
}

// extend relevant types
extension Int : MinMaxType {}
extension Int8 : MinMaxType {}
extension Int16 : MinMaxType {}
extension Int32 : MinMaxType {}
extension Int64 : MinMaxType {}
extension UInt : MinMaxType {}
extension UInt8 : MinMaxType {}
extension UInt16 : MinMaxType {}
extension UInt32 : MinMaxType {}
extension UInt64 : MinMaxType {}

// declare the prefix and postfix operators
prefix operator ..< { }
prefix operator ... { }
postfix operator ..< { }
postfix operator ... { }

/// Forms a closed range that contains both `T.min` and `value`
prefix func ...<T: ForwardIndexType where T: Comparable, T: MinMaxType>(value: T) -> Range<T> {
    return Range(start: T.min, end: value.successor())
}
/// Returns a closed interval from `T.min` through `value`
prefix func ...<T: Comparable where T: MinMaxType>(value: T) -> ClosedInterval<T> {
    return ClosedInterval(T.min, value)
}

/// Forms a half-open range that contains `T.min`, but not `value`
prefix func ..<<T: ForwardIndexType where T: Comparable, T: MinMaxType>(value: T) -> Range<T> {
    return Range(start: T.min, end: value)
}
/// Returns a half-open interval from `T.min` to `value`
prefix func ..<<T: Comparable where T: MinMaxType>(value: T) -> HalfOpenInterval<T> {
    return HalfOpenInterval(T.min, value)
}

/// Forms a half-open range that contains `value`, but not `T.max`
postfix func ..<<T: ForwardIndexType where T: Comparable, T: MinMaxType>(value: T) -> Range<T> {
    return Range(start: value, end: T.max)
}
// a closed range containing `T.max` fails, since it would need to call `T.max.successor()`

/// Returns a closed interval from `value` through `T.max`
postfix func ...<T: Comparable where T: MinMaxType>(value: T) -> ClosedInterval<T> {
    return ClosedInterval(value, T.max)
}


// example:
for i in 1...10 {
    switch i {
    case ...3:
        println("...3")
    case 4..<6:
        println("4..<6")
    case 6...:
        println("6...")
    default:
        println("no match")
    }
}

/*
...3
...3
...3
4..<6
4..<6
6...
6...
6...
6...
6...
*/