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 !=(_: Any.Type?, t1: Any.Type?)

Returns false iff t0 is identical to t1; i.e. if they are both nil or they both represent the same type.

Declaration

func !=(t0: Any.Type?, t1: Any.Type?) -> Bool
func != <A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(_: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F))

Returns true iff any component of lhs is not equal to the corresponding component of rhs.

Declaration

func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool
func != <A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(_: (A, B, C, D, E), rhs: (A, B, C, D, E))

Returns true iff any component of lhs is not equal to the corresponding component of rhs.

Declaration

func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool
func != <A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_: (A, B, C, D), rhs: (A, B, C, D))

Returns true iff any component of lhs is not equal to the corresponding component of rhs.

Declaration

func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool
func != <A : Equatable, B : Equatable, C : Equatable>(_: (A, B, C), rhs: (A, B, C))

Returns true iff any component of lhs is not equal to the corresponding component of rhs.

Declaration

func !=<A : Equatable, B : Equatable, C : Equatable>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool
func != <A : Equatable, B : Equatable>(_: (A, B), rhs: (A, B))

Returns true iff any component of lhs is not equal to the corresponding component of rhs.

Declaration

func !=<A : Equatable, B : Equatable>(lhs: (A, B), rhs: (A, B)) -> Bool
func != <Element : Equatable>(_: [Element], rhs: [Element])

Returns true if the arrays do not contain the same elements.

Declaration

func !=<Element : Equatable>(lhs: [Element], rhs: [Element]) -> Bool
func != <Element : Equatable>(_: ArraySlice<Element>, rhs: ArraySlice<Element>)

Returns true if the arrays do not contain the same elements.

Declaration

func !=<Element : Equatable>(lhs: ArraySlice<Element>, rhs: ArraySlice<Element>) -> Bool
func != <Element : Equatable>(_: ContiguousArray<Element>, rhs: ContiguousArray<Element>)

Returns true if the arrays do not contain the same elements.

Declaration

func !=<Element : Equatable>(lhs: ContiguousArray<Element>, rhs: ContiguousArray<Element>) -> Bool
func != <Key : Equatable, Value : Equatable>(_: [Key : Value], rhs: [Key : Value])

Declaration

func !=<Key : Equatable, Value : Equatable>(lhs: [Key : Value], rhs: [Key : Value]) -> Bool
func != <T : Equatable where T : RawRepresentable, T.RawValue : Equatable>(_: T, rhs: T)

Returns true iff lhs.rawValue != rhs.rawValue.

Declaration

func !=<T : Equatable where T : RawRepresentable, T.RawValue : Equatable>(lhs: T, rhs: T) -> Bool
func != <T : Equatable>(_: T, rhs: T)

Declaration

func !=<T : Equatable>(lhs: T, rhs: T) -> Bool
func != <T : Equatable>(_: T?, rhs: T?)

Declaration

func !=<T : Equatable>(lhs: T?, rhs: T?) -> Bool
func != <T : RawRepresentable where T.RawValue : Equatable>(_: T, rhs: T)

Returns true iff lhs.rawValue != rhs.rawValue.

Declaration

func !=<T : RawRepresentable where T.RawValue : Equatable>(lhs: T, rhs: T) -> Bool
func != <T>(_: _OptionalNilComparisonType, rhs: T?)

Declaration

func !=<T>(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool
func != <T>(_: T?, rhs: _OptionalNilComparisonType)

Declaration

func !=<T>(lhs: T?, rhs: _OptionalNilComparisonType) -> Bool