Operator: >

infix operator > { associativity none precedence 130 }

Declarations

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