operator != { associativity precedence } Declarations func !=(_: Int, rhs: Int) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable Declaration func !=(lhs: Int, rhs: Int) -> Bool func !=(_: Int8, rhs: Int8) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable Declaration func !=(lhs: Int8, rhs: Int8) -> Bool func !=(_: Int16, rhs: Int16) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable Declaration func !=(lhs: Int16, rhs: Int16) -> Bool func !=(_: Int32, rhs: Int32) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable Declaration func !=(lhs: Int32, rhs: Int32) -> Bool func !=(_: Int64, rhs: Int64) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable Declaration func !=(lhs: Int64, rhs: Int64) -> Bool func !=(_: UInt, rhs: UInt) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable Declaration func !=(lhs: UInt, rhs: UInt) -> Bool func !=(_: UInt8, rhs: UInt8) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable Declaration func !=(lhs: UInt8, rhs: UInt8) -> Bool func !=(_: UInt16, rhs: UInt16) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable Declaration func !=(lhs: UInt16, rhs: UInt16) -> Bool func !=(_: UInt32, rhs: UInt32) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable Declaration func !=(lhs: UInt32, rhs: UInt32) -> Bool func !=(_: UInt64, rhs: UInt64) Returns a Boolean value that indicates whether the two arguments have unequal values. See Also: Equatable, Comparable 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 a Boolean value indicating whether any corresponding components of the two tuples are not equal. For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 6 components: let a = ("a", 1, 2, 3, 4, 5) let b = ("a", 1, 2, 3, 4, 5) print(a != b) // Prints "false" let c = ("a", 1, 2, 3, 4, 6) print(a != c) // Prints "true" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. 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 a Boolean value indicating whether any corresponding components of the two tuples are not equal. For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 5 components: let a = ("a", 1, 2, 3, 4) let b = ("a", 1, 2, 3, 4) print(a != b) // Prints "false" let c = ("a", 1, 2, 3, 5) print(a != c) // Prints "true" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. 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 a Boolean value indicating whether any corresponding components of the two tuples are not equal. For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 4 components: let a = ("a", 1, 2, 3) let b = ("a", 1, 2, 3) print(a != b) // Prints "false" let c = ("a", 1, 2, 4) print(a != c) // Prints "true" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. 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 a Boolean value indicating whether any corresponding components of the two tuples are not equal. For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 3 components: let a = ("a", 1, 2) let b = ("a", 1, 2) print(a != b) // Prints "false" let c = ("a", 1, 3) print(a != c) // Prints "true" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. 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 a Boolean value indicating whether any corresponding components of the two tuples are not equal. For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 2 components: let a = ("a", 1) let b = ("a", 1) print(a != b) // Prints "false" let c = ("a", 2) print(a != c) // Prints "true" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. 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 != <T : Equatable where T : RawRepresentable, T.RawValue : Equatable>(_: T, rhs: T) Returns a Boolean value indicating whether the two arguments are not equal. Parameters: lhs: A raw-representable instance. rhs: A second raw-representable instance. Declaration func !=<T : Equatable where T : RawRepresentable, T.RawValue : Equatable>(lhs: T, rhs: T) -> Bool func != <T : Equatable>(_: T, rhs: T) Returns a Boolean value indicating whether two values are not equal. Inequality is the inverse of equality. For any values a and b, a != b implies that a == b is false. This is the default implementation of the not-equal-to operator (!=) for any type that conforms to Equatable. Parameters: lhs: A value to compare. rhs: Another value to compare. 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 a Boolean value indicating whether the two arguments are not equal. Parameters: lhs: A raw-representable instance. rhs: A second raw-representable instance. 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