comparable_switch_case_pattern.swift

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 where Self: Comparable {
    func patterned<E where E: Comparable>(op: (lhs: E, rhs: E) -> Bool) -> Pattern<E> {
        return Pattern<E>(op: op, to: self as! E)
    }
}

let value = "test"

switch value {
case patternize(<=, "test1"):
    print("smaller than test1")
case patternize(>, "tes"):
    print("bigger than tes")
default:
    print("default")
}

let value1 = 100.1

switch value1 {
case 100.0.patterned(<=):
    print("smaller than 100.0")
case patternize(>, 100.0):
    print("bigger than 100.0")
default:
    print("default")
}