Operator: !=

  • infix operator != {
  •                   associativity none
  •                   precedence 130
  •                   }

Declarations

func !=(_: Double, rhs: Double)

Declaration

func !=(_: Float, rhs: Float)

Declaration

func !=(_: Float80, rhs: Float80)

Declaration

func !=(_: Int, rhs: Int)

Declaration

func !=(_: Int8, rhs: Int8)

Declaration

func !=(_: Int16, rhs: Int16)

Declaration

func !=(_: Int32, rhs: Int32)

Declaration

func !=(_: Int64, rhs: Int64)

Declaration

func !=(_: UInt, rhs: UInt)

Declaration

func !=(_: UInt8, rhs: UInt8)

Declaration

func !=(_: UInt16, rhs: UInt16)

Declaration

func !=(_: UInt32, rhs: UInt32)

Declaration

func !=(_: UInt64, rhs: UInt64)

Declaration

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>(_: (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>(_: (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>(_: (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>(_: (A, B), rhs: (A, B))

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

Declaration

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>(_: ContiguousArray<Element>, rhs: ContiguousArray<Element>)

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

Declaration

func != <Key : Equatable, Value : Equatable>(_: [Key : Value], rhs: [Key : Value])

Declaration

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

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

Declaration

func != <T : Equatable>(_: T, rhs: T)

Declaration

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

Declaration

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

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

Declaration

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