operator == { associativity precedence } Declarations func ==(_: Int, rhs: Int) Returns a Boolean value that indicates whether the two arguments have equal 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 equal 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 equal 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 equal 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 equal 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 equal 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 equal 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 equal 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 equal 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 equal values. See Also: Equatable, Comparable Declaration func ==(lhs: UInt64, rhs: UInt64) -> Bool func ==(_: Any.Type?, t1: Any.Type?) Returns true 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, B where A : Equatable, B : Equatable>(_: (A, B), rhs: (A, B)) Returns a Boolean value indicating whether the corresponding components of two tuples are 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 "true" let c = ("a", 2) print(a == c) // Prints "false" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. Declaration func ==<A, B where A : Equatable, B : Equatable>(lhs: (A, B), rhs: (A, B)) -> Bool func == <A, B, C where A : Equatable, B : Equatable, C : Equatable>(_: (A, B, C), rhs: (A, B, C)) Returns a Boolean value indicating whether the corresponding components of two tuples are 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 "true" let c = ("a", 1, 3) print(a == c) // Prints "false" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. Declaration func ==<A, B, C where A : Equatable, B : Equatable, C : Equatable>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool func == <A, B, C, D where A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_: (A, B, C, D), rhs: (A, B, C, D)) Returns a Boolean value indicating whether the corresponding components of two tuples are 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 "true" let c = ("a", 1, 2, 4) print(a == c) // Prints "false" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. Declaration func ==<A, B, C, D where A : Equatable, B : Equatable, C : Equatable, D : Equatable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool func == <A, B, C, D, E where 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 the corresponding components of two tuples are 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 "true" let c = ("a", 1, 2, 3, 5) print(a == c) // Prints "false" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. Declaration func ==<A, B, C, D, E where 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, B, C, D, E, F where 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 the corresponding components of two tuples are 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 "true" let c = ("a", 1, 2, 3, 4, 6) print(a == c) // Prints "false" Parameters: lhs: A tuple of Equatable elements. rhs: Another tuple of elements of the same type as lhs. Declaration func ==<A, B, C, D, E, F where 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 == <Base where Base : Collection>(_: LazyDropWhileIndex<Base>, rhs: LazyDropWhileIndex<Base>) Declaration func ==<Base where Base : Collection>(lhs: LazyDropWhileIndex<Base>, rhs: LazyDropWhileIndex<Base>) -> Bool func == <Base where Base : Collection>(_: LazyPrefixWhileIndex<Base>, rhs: LazyPrefixWhileIndex<Base>) Declaration func ==<Base where Base : Collection>(lhs: LazyPrefixWhileIndex<Base>, rhs: LazyPrefixWhileIndex<Base>) -> Bool func == <Element where Element : Equatable>(_: [Element], rhs: [Element]) Returns true if these arrays contain the same elements. Declaration func ==<Element where Element : Equatable>(lhs: [Element], rhs: [Element]) -> Bool func == <Element where Element : Equatable>(_: ArraySlice<Element>, rhs: ArraySlice<Element>) Returns true if these arrays contain the same elements. Declaration func ==<Element where Element : Equatable>(lhs: ArraySlice<Element>, rhs: ArraySlice<Element>) -> Bool func == <Element where Element : Equatable>(_: ContiguousArray<Element>, rhs: ContiguousArray<Element>) Returns true if these arrays contain the same elements. Declaration func ==<Element where Element : Equatable>(lhs: ContiguousArray<Element>, rhs: ContiguousArray<Element>) -> Bool func == <Header, Element>(_: ManagedBufferPointer<Header, Element>, rhs: ManagedBufferPointer<Header, Element>) Declaration func ==<Header, Element>(lhs: ManagedBufferPointer<Header, Element>, rhs: ManagedBufferPointer<Header, Element>) -> Bool func == <Pointee>(_: AutoreleasingUnsafeMutablePointer<Pointee>, rhs: AutoreleasingUnsafeMutablePointer<Pointee>) Declaration func ==<Pointee>(lhs: AutoreleasingUnsafeMutablePointer<Pointee>, rhs: AutoreleasingUnsafeMutablePointer<Pointee>) -> Bool func == <T where T : BinaryInteger>(_: T, rhs: T) Declaration func ==<T where T : BinaryInteger>(lhs: T, rhs: T) -> Bool func == <T where T : Equatable>(_: T?, rhs: T?) Returns a Boolean value indicating whether two optional instances are equal. Use this equal-to operator (==) to compare any two optional instances of a type that conforms to the Equatable protocol. The comparison returns true if both arguments are nil or if the two arguments wrap values that are equal. Conversely, the comparison returns false if only one of the arguments is nil or if the two arguments wrap values that are not equal. let group1 = [1, 2, 3, 4, 5] let group2 = [1, 3, 5, 7, 9] if group1.first == group2.first { print("The two groups start the same.") } // Prints "The two groups start the same." You can also use this operator to compare a non-optional value to an optional that wraps the same type. The non-optional value is wrapped as an optional before the comparison is made. In the following example, the numberToMatch constant is wrapped as an optional before comparing to the optional numberFromString: let numberToFind: Int = 23 let numberFromString: Int? = Int("23") // Optional(23) if numberToFind == numberFromString { print("It's a match!") } // Prints "It's a match!" An instance that is expressed as a literal can also be used with this operator. In the next example, an integer literal is compared with the optional integer numberFromString. The literal 23 is inferred as an Int instance and then wrapped as an optional before the comparison is performed. if 23 == numberFromString { print("It's a match!") } // Prints "It's a match!" Parameters: lhs: An optional value to compare. rhs: Another optional value to compare. Declaration func ==<T where T : Equatable>(lhs: T?, rhs: T?) -> Bool func == <T where T : FloatingPoint>(_: T, rhs: T) Declaration func ==<T where T : FloatingPoint>(lhs: T, rhs: T) -> Bool func == <T where T : RawRepresentable, T.RawValue : Equatable>(_: T, rhs: T) Returns a Boolean value indicating whether the two arguments are equal. Parameters: lhs: A raw-representable instance. rhs: A second raw-representable instance. Declaration func ==<T where T : RawRepresentable, T.RawValue : Equatable>(lhs: T, rhs: T) -> Bool func == <T where T : Strideable>(_: T, y: T) Declaration func ==<T where T : Strideable>(x: T, y: T) -> Bool func == <T, U where T : BinaryInteger, U : BinaryInteger>(_: T, rhs: U) Declaration func ==<T, U where T : BinaryInteger, U : BinaryInteger>(lhs: T, rhs: U) -> Bool func == <T>(_: _OptionalNilComparisonType, rhs: T?) Returns a Boolean value indicating whether the right-hand-side argument is nil. You can use this equal-to operator (==) to test whether an optional instance is nil even when the wrapped value's type does not conform to the Equatable protocol. The following example declares the stream variable as an optional instance of a hypothetical DataStream type. Although DataStream is not an Equatable type, this operator allows checking whether stream is nil. var stream: DataStream? = nil if nil == stream { print("No data stream is configured.") } // Prints "No data stream is configured." Parameters: lhs: A nil literal. rhs: A value to compare to nil. Declaration func ==<T>(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool func == <T>(_: T?, rhs: _OptionalNilComparisonType) Returns a Boolean value indicating whether the left-hand-side argument is nil. You can use this equal-to operator (==) to test whether an optional instance is nil even when the wrapped value's type does not conform to the Equatable protocol. The following example declares the stream variable as an optional instance of a hypothetical DataStream type. Although DataStream is not an Equatable type, this operator allows checking whether stream is nil. var stream: DataStream? = nil if stream == nil { print("No data stream is configured.") } // Prints "No data stream is configured." Parameters: lhs: A value to compare to nil. rhs: A nil literal. Declaration func ==<T>(lhs: T?, rhs: _OptionalNilComparisonType) -> Bool func == <Value, Element>(_: _HeapBuffer<Value, Element>, rhs: _HeapBuffer<Value, Element>) Declaration func ==<Value, Element>(lhs: _HeapBuffer<Value, Element>, rhs: _HeapBuffer<Value, Element>) -> Bool