infix operator >= { associativity none precedence 130 } Declarations func >=(_: _SwiftNSOperatingSystemVersion, rhs: _SwiftNSOperatingSystemVersion) Declaration func >=(lhs: _SwiftNSOperatingSystemVersion, rhs: _SwiftNSOperatingSystemVersion) -> Bool func >=(_: Double, rhs: Double) Declaration func >=(lhs: Double, rhs: Double) -> Bool func >=(_: Float, rhs: Float) Declaration func >=(lhs: Float, rhs: Float) -> Bool func >=(_: Float80, rhs: Float80) Declaration func >=(lhs: Float80, rhs: Float80) -> Bool func >=(_: Int, rhs: Int) Declaration func >=(lhs: Int, rhs: Int) -> Bool func >=(_: Int8, rhs: Int8) Declaration func >=(lhs: Int8, rhs: Int8) -> Bool func >=(_: Int16, rhs: Int16) Declaration func >=(lhs: Int16, rhs: Int16) -> Bool func >=(_: Int32, rhs: Int32) Declaration func >=(lhs: Int32, rhs: Int32) -> Bool func >=(_: Int64, rhs: Int64) Declaration func >=(lhs: Int64, rhs: Int64) -> Bool func >=(_: UInt, rhs: UInt) Declaration func >=(lhs: UInt, rhs: UInt) -> Bool func >=(_: UInt8, rhs: UInt8) Declaration func >=(lhs: UInt8, rhs: UInt8) -> Bool func >=(_: UInt16, rhs: UInt16) Declaration func >=(lhs: UInt16, rhs: UInt16) -> Bool func >=(_: UInt32, rhs: UInt32) Declaration func >=(lhs: UInt32, rhs: UInt32) -> Bool func >=(_: UInt64, rhs: UInt64) Declaration func >=(lhs: UInt64, rhs: UInt64) -> Bool func >= <A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) A lexicographical order over tuples of Comparable elements. Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is >= the second tuple iff a1 > b1 or (a1 == b1 and (a2, ..., aN) >= (b2, ..., bN)). Declaration func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool func >= <A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_: (A, B, C, D, E), rhs: (A, B, C, D, E)) A lexicographical order over tuples of Comparable elements. Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is >= the second tuple iff a1 > b1 or (a1 == b1 and (a2, ..., aN) >= (b2, ..., bN)). Declaration func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool func >= <A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_: (A, B, C, D), rhs: (A, B, C, D)) A lexicographical order over tuples of Comparable elements. Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is >= the second tuple iff a1 > b1 or (a1 == b1 and (a2, ..., aN) >= (b2, ..., bN)). Declaration func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool func >= <A : Comparable, B : Comparable, C : Comparable>(_: (A, B, C), rhs: (A, B, C)) A lexicographical order over tuples of Comparable elements. Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is >= the second tuple iff a1 > b1 or (a1 == b1 and (a2, ..., aN) >= (b2, ..., bN)). Declaration func >=<A : Comparable, B : Comparable, C : Comparable>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool func >= <A : Comparable, B : Comparable>(_: (A, B), rhs: (A, B)) A lexicographical order over tuples of Comparable elements. Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is >= the second tuple iff a1 > b1 or (a1 == b1 and (a2, ..., aN) >= (b2, ..., bN)). Declaration func >=<A : Comparable, B : Comparable>(lhs: (A, B), rhs: (A, B)) -> Bool func >= <T : Comparable>(_: T, rhs: T) Declaration func >=<T : Comparable>(lhs: T, rhs: T) -> Bool func >= <T : Comparable>(_: T?, rhs: T?) Declaration func >=<T : Comparable>(lhs: T?, rhs: T?) -> Bool