operator== {associativityprecedence}
Declarations
Note: This may be more efficient than Strideable's implementation calling UnsafeMutableRawPointer.distance().
Declaration
func==(lhs:UnsafeMutableRawPointer,rhs:UnsafeMutableRawPointer) ->Bool
Note: This may be more efficient than Strideable's implementation calling UnsafeRawPointer.distance().
Declaration
func==(lhs:UnsafeRawPointer,rhs:UnsafeRawPointer) ->Bool
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
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:
leta= ("a",1,2,3,4,5)letb= ("a",1,2,3,4,5)(a==b)// Prints "true"letc= ("a",1,2,3,4,6)(a==c)// Prints "false"
Parameters:
lhs: A tuple of Equatable elements.
rhs: Another tuple of elements of the same type as lhs.
Declaration
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:
leta= ("a",1,2,3,4)letb= ("a",1,2,3,4)(a==b)// Prints "true"letc= ("a",1,2,3,5)(a==c)// Prints "false"
Parameters:
lhs: A tuple of Equatable elements.
rhs: Another tuple of elements of the same type as lhs.
Declaration
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:
leta= ("a",1,2,3)letb= ("a",1,2,3)(a==b)// Prints "true"letc= ("a",1,2,4)(a==c)// Prints "false"
Parameters:
lhs: A tuple of Equatable elements.
rhs: Another tuple of elements of the same type as lhs.
Declaration
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:
leta= ("a",1,2)letb= ("a",1,2)(a==b)// Prints "true"letc= ("a",1,3)(a==c)// Prints "false"
Parameters:
lhs: A tuple of Equatable elements.
rhs: Another tuple of elements of the same type as lhs.
Declaration
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:
leta= ("a",1)letb= ("a",1)(a==b)// Prints "true"letc= ("a",2)(a==c)// Prints "false"
Parameters:
lhs: A tuple of Equatable elements.
rhs: Another tuple of elements of the same type as lhs.
Declaration
Returns true if these arrays contain the same elements.
Declaration
func==<Element:Equatable>(lhs:ArraySlice<Element>,rhs:ArraySlice<Element>) ->Bool
Returns true if these arrays contain the same elements.
Declaration
func==<Element:Equatable>(lhs:ContiguousArray<Element>,rhs:ContiguousArray<Element>) ->Bool
Declaration
func==<Header,Element>(lhs:ManagedBufferPointer<Header,Element>,rhs:ManagedBufferPointer<Header,Element>) ->Bool
Declaration
func==<Pointee>(lhs:AutoreleasingUnsafeMutablePointer<Pointee>,rhs:AutoreleasingUnsafeMutablePointer<Pointee>) ->Bool
Note: Strideable's implementation is potentially less efficient and cannot handle misaligned pointers.
Declaration
func==<Pointee>(lhs:UnsafeMutablePointer<Pointee>,rhs:UnsafeMutablePointer<Pointee>) ->Bool
Note: Strideable's implementation is potentially less efficient and cannot handle misaligned pointers.
Declaration
func==<Pointee>(lhs:UnsafePointer<Pointee>,rhs:UnsafePointer<Pointee>) ->Bool
Declaration
func==<T:FloatingPoint>(lhs:T,rhs:T) ->Bool
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:RawRepresentablewhereT.RawValue:Equatable>(lhs:T,rhs:T) ->Bool
Declaration
func==<T:Strideable>(x:T,y:T) ->Bool
Declaration
func==<T>(lhs:_OptionalNilComparisonType,rhs:T?) ->Bool
Declaration
func==<T>(lhs:T?,rhs:_OptionalNilComparisonType) ->Bool
Declaration
func==<Value,Element>(lhs:_HeapBuffer<Value,Element>,rhs:_HeapBuffer<Value,Element>) ->Bool
Returns a Boolean value that indicates whether the two arguments have equal values.
See Also:
Equatable,ComparableDeclaration
func==(lhs:Int,rhs:Int) ->Bool