Boundaries operator implementation in Swift

BoundariesOp.swift

protocol Boundary {
    typealias Element : Comparable
    var part : Element {get}
    var isTrue : Bool {get}
}

protocol LowerBoundary : Boundary{}
protocol UpperBoundary : Boundary{}

struct LowerBoundaryExclusive<T : Comparable> : LowerBoundary {
    let ls : T
    let rs : T
    var part : T {return rs}
    var isTrue : Bool { return ls < rs }
}

struct LowerBoundaryInclusive <T : Comparable> : LowerBoundary {
    let ls : T
    let rs : T
    var part : T {return rs}
    var isTrue : Bool { return ls <= rs }
}

struct UpperBoundaryExclusive <T : Comparable> : UpperBoundary {
    let ls : T
    let rs : T
    var part : T {return rs}
    var isTrue : Bool { return ls > rs }
}

struct UpperBoundaryInclusive <T : Comparable> : UpperBoundary {
    let ls : T
    let rs : T
    var part : T {return rs}
    var isTrue : Bool { return ls >= rs }
}



infix operator <& { associativity left precedence 200 }
func <& <Element: Comparable> (left: Element, right: Element) -> LowerBoundaryExclusive<Element> {
    return LowerBoundaryExclusive(ls: left, rs: right)
}

infix operator <=& { associativity left precedence 200 }
func <=& <Element: Comparable> (left: Element, right: Element) -> LowerBoundaryInclusive<Element> {
    return LowerBoundaryInclusive(ls: left, rs: right)
}


infix operator >& { associativity left precedence 200 }
func >& <Element: Comparable> (left: Element, right: Element) -> UpperBoundaryExclusive<Element> {
    return UpperBoundaryExclusive(ls: left, rs: right)
}

infix operator >=& { associativity left precedence 200 }
func >=& <Element: Comparable> (left: Element, right: Element) -> UpperBoundaryInclusive<Element> {
    return UpperBoundaryInclusive(ls: left, rs: right)
}


func < <A : LowerBoundary, B : Comparable where B == A.Element> (left: A, right: B) -> Bool {
    return left.isTrue && left.part < right
}

func <= <A : LowerBoundary, B : Comparable where B == A.Element> (left: A, right: B) -> Bool {
    return left.isTrue && left.part <= right
}

func > <A : UpperBoundary, B : Comparable where B == A.Element> (left: A, right: B) -> Bool {
    return left.isTrue && left.part > right
}

func >= <A : UpperBoundary, B : Comparable where B == A.Element> (left: A, right: B) -> Bool {
    return left.isTrue && left.part >= right
}


10 <& 10 < 50
10 <=& 10 < 50
10 >=& 10 > 5
10 >& 10 > 5