One-sided Range operators

OneSidedRanges.swift

postfix operator ..< { }
prefix operator ..< { }

struct RangeStart<I: ForwardIndexType> { let start: I }
struct RangeEnd<I: ForwardIndexType> { let end: I }

postfix func ..<<I: ForwardIndexType>(lhs: I) -> RangeStart<I>
{ return RangeStart(start: lhs) }

prefix func ..<<I: ForwardIndexType>(rhs: I) -> RangeEnd<I>
{ return RangeEnd(end: rhs) }

extension Sliceable {
    subscript(r: RangeStart<Self.Index>) -> SubSlice {
        return self[r.start..<self.endIndex]
    }
    subscript(r: RangeEnd<Self.Index>) -> SubSlice {
        return self[self.startIndex..<r.end]
    }
}




extension Sliceable where Generator.Element: Equatable, SubSlice.Generator.Element == Generator.Element
{
    func search<S: SequenceType where S.Generator.Element == Generator.Element>(pat: S) -> Index?
    {
        return self.indices.indexOf {
            self[$0..<].startsWith(pat)
        }
    }
}

let greeting = "Hello, world"
if let idx = greeting.characters.search(", ".characters) {
    print(String(greeting.characters[..<idx]))
}

Very clever! 👏