Operator: ==

infix operator == { associativity none precedence 130 }

Declarations

func ==(_: _SwiftNSOperatingSystemVersion, rhs: _SwiftNSOperatingSystemVersion)

Declaration

func ==(lhs: _SwiftNSOperatingSystemVersion, rhs: _SwiftNSOperatingSystemVersion) -> Bool
func ==(_: AnyBidirectionalIndex, rhs: AnyBidirectionalIndex)

Returns true iff lhs and rhs wrap equal underlying AnyBidirectionalIndexs.

Requires: The types of indices wrapped by lhs and rhs are identical.

Declaration

func ==(lhs: AnyBidirectionalIndex, rhs: AnyBidirectionalIndex) -> Bool
func ==(_: AnyForwardIndex, rhs: AnyForwardIndex)

Returns true iff lhs and rhs wrap equal underlying AnyForwardIndexs.

Requires: The types of indices wrapped by lhs and rhs are identical.

Declaration

func ==(lhs: AnyForwardIndex, rhs: AnyForwardIndex) -> Bool
func ==(_: AnyRandomAccessIndex, rhs: AnyRandomAccessIndex)

Returns true iff lhs and rhs wrap equal underlying AnyRandomAccessIndexs.

Requires: The types of indices wrapped by lhs and rhs are identical.

Declaration

func ==(lhs: AnyRandomAccessIndex, rhs: AnyRandomAccessIndex) -> Bool
func ==(_: Bit, rhs: Bit)

Declaration

func ==(lhs: Bit, rhs: Bit) -> Bool
func ==(_: Bool, rhs: Bool)

Declaration

func ==(lhs: Bool, rhs: Bool) -> Bool
func ==(_: COpaquePointer, rhs: COpaquePointer)

Declaration

func ==(lhs: COpaquePointer, rhs: COpaquePointer) -> Bool
func ==(_: Character, rhs: Character)

Declaration

func ==(lhs: Character, rhs: Character) -> Bool
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 ==(_: Index, rhs: Index)

Declaration

func ==(lhs: Index, rhs: Index) -> 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 ==(_: String, rhs: String)

Declaration

func ==(lhs: String, rhs: String) -> Bool
func ==(_: String.UTF8View.Index, rhs: String.UTF8View.Index)

Declaration

func ==(lhs: String.UTF8View.Index, rhs: String.UTF8View.Index) -> Bool
func ==(_: String.UTF16View.Index, rhs: String.UTF16View.Index)

Declaration

func ==(lhs: String.UTF16View.Index, rhs: String.UTF16View.Index) -> Bool
func ==(_: String.UnicodeScalarView.Index, rhs: String.UnicodeScalarView.Index)

Declaration

func ==(lhs: String.UnicodeScalarView.Index, rhs: String.UnicodeScalarView.Index) -> 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 ==(_: UnicodeScalar, rhs: UnicodeScalar)

Declaration

func ==(lhs: UnicodeScalar, rhs: UnicodeScalar) -> 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 ==(_: ObjectIdentifier, y: ObjectIdentifier)

Declaration

func ==(x: ObjectIdentifier, y: ObjectIdentifier) -> 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 each component of lhs is 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 each component of lhs is 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 each component of lhs is 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 each component of lhs is 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 each component of lhs is equal to the corresponding component of rhs.

Declaration

func ==<A : Equatable, B : Equatable>(lhs: (A, B), rhs: (A, B)) -> Bool
func == <Base : CollectionType>(_: LazyFilterIndex<Base>, rhs: LazyFilterIndex<Base>)

Returns true iff lhs is identical to rhs.

Declaration

func ==<Base : CollectionType>(lhs: LazyFilterIndex<Base>, rhs: LazyFilterIndex<Base>) -> Bool
func == <Base>(_: ReverseIndex<Base>, rhs: ReverseIndex<Base>)

Declaration

func ==<Base>(lhs: ReverseIndex<Base>, rhs: ReverseIndex<Base>) -> Bool
func == <BaseElements>(_: FlattenBidirectionalCollectionIndex<BaseElements>, rhs: FlattenBidirectionalCollectionIndex<BaseElements>)

Declaration

func ==<BaseElements>(lhs: FlattenBidirectionalCollectionIndex<BaseElements>, rhs: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
func == <BaseElements>(_: FlattenCollectionIndex<BaseElements>, rhs: FlattenCollectionIndex<BaseElements>)

Declaration

func ==<BaseElements>(lhs: FlattenCollectionIndex<BaseElements>, rhs: FlattenCollectionIndex<BaseElements>) -> Bool
func == <Bound : Comparable>(_: ClosedInterval<Bound>, rhs: ClosedInterval<Bound>)

Two ClosedIntervals are equal if their start and end are equal.

Declaration

func ==<Bound : Comparable>(lhs: ClosedInterval<Bound>, rhs: ClosedInterval<Bound>) -> Bool
func == <Bound : Comparable>(_: HalfOpenInterval<Bound>, rhs: HalfOpenInterval<Bound>)

Two HalfOpenIntervals are equal if their start and end are equal.

Declaration

func ==<Bound : Comparable>(lhs: HalfOpenInterval<Bound>, rhs: HalfOpenInterval<Bound>) -> Bool
func == <Element : Equatable>(_: [Element], rhs: [Element])

Returns true if these arrays contain the same elements.

Declaration

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

Returns true if these arrays 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 these arrays contain the same elements.

Declaration

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

Declaration

func ==<Element : Hashable>(lhs: Set<Element>, rhs: Set<Element>) -> Bool
func == <Element : Hashable>(_: SetIndex<Element>, rhs: SetIndex<Element>)

Declaration

func ==<Element : Hashable>(lhs: SetIndex<Element>, rhs: SetIndex<Element>) -> Bool
func == <Element>(_: Range<Element>, rhs: Range<Element>)

Declaration

func ==<Element>(lhs: Range<Element>, rhs: Range<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 == <Key : Hashable, Value>(_: DictionaryIndex<Key, Value>, rhs: DictionaryIndex<Key, Value>)

Declaration

func ==<Key : Hashable, Value>(lhs: DictionaryIndex<Key, Value>, rhs: DictionaryIndex<Key, Value>) -> Bool
func == <Memory>(_: AutoreleasingUnsafeMutablePointer<Memory>, rhs: AutoreleasingUnsafeMutablePointer<Memory>)

Declaration

func ==<Memory>(lhs: AutoreleasingUnsafeMutablePointer<Memory>, rhs: AutoreleasingUnsafeMutablePointer<Memory>) -> Bool
func == <Memory>(_: UnsafeMutablePointer<Memory>, rhs: UnsafeMutablePointer<Memory>)

Declaration

func ==<Memory>(lhs: UnsafeMutablePointer<Memory>, rhs: UnsafeMutablePointer<Memory>) -> Bool
func == <Memory>(_: UnsafePointer<Memory>, rhs: UnsafePointer<Memory>)

Declaration

func ==<Memory>(lhs: UnsafePointer<Memory>, rhs: UnsafePointer<Memory>) -> 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 : Strideable>(_: T, y: T)

Declaration

func ==<T : Strideable>(x: T, y: 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
func == <Value, Element>(_: _HeapBuffer<Value, Element>, rhs: _HeapBuffer<Value, Element>)

Declaration

func ==<Value, Element>(lhs: _HeapBuffer<Value, Element>, rhs: _HeapBuffer<Value, Element>) -> Bool
func == <Value, Element>(_: ManagedBufferPointer<Value, Element>, rhs: ManagedBufferPointer<Value, Element>)

Declaration

func ==<Value, Element>(lhs: ManagedBufferPointer<Value, Element>, rhs: ManagedBufferPointer<Value, Element>) -> Bool