protocol PatternComparable {}

struct Pattern<C: Comparable>: PatternComparable {
    let op: (lhs: C, rhs: C) -> Bool
    let to: C
    func compare(from: C) -> Bool {
        return op(lhs: from, rhs: to)
    }
}

func patternize<C: Comparable>(op: (lhs: C, rhs: C) -> Bool, _ to: C) -> Pattern<C> {
    return Pattern<C>(op: op, to: to)
}

func ~=<C: Comparable>(pattern: Pattern<C>, value: C) -> Bool {
    return pattern.compare(value)
}

func ~=<C: Comparable>(pattern: (op:(lhs: C, rhs: C)->Bool, to:C), value: C) -> Bool {
    return pattern.0(lhs:value, rhs: pattern.1)
}

protocol Patternable {}
extension Int: Patternable {}
extension Int8: Patternable {}
extension Int16: Patternable {}
extension Int32: Patternable {}
extension Int64: Patternable {}
extension UInt: Patternable {}
extension UInt8: Patternable {}
extension UInt16: Patternable {}
extension UInt32: Patternable {}
extension UInt64: Patternable {}
extension Double: Patternable {}
extension Float: Patternable {}
extension CGFloat: Patternable {}

extension Patternable {
    func patterned<C: Comparable>(op: (lhs:C, rhs:C) -> Bool) -> Pattern<C> {
        return Pattern<C>(op: op, to: self as! C)
    }
}

let value = 1000

switch value {
case patternize(<=, 101):
    print("smaller than 99")
case patternize(>, 999):
    print("bigger than 999")
default:
    print("default")
}