infix operator == { associativity none precedence 130 } Declarations func ==(_: _SwiftNSOperatingSystemVersion, right: _SwiftNSOperatingSystemVersion) Declaration func ==(left: _SwiftNSOperatingSystemVersion, right: _SwiftNSOperatingSystemVersion) -> Bool func ==(_: AnyBidirectionalIndex, rhs: AnyBidirectionalIndex) Return 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) Return 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) Return 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 ==(_: FloatingPointClassification, rhs: FloatingPointClassification) Declaration func ==(lhs: FloatingPointClassification, rhs: FloatingPointClassification) -> 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?) Return 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 == <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 : _Strideable>(_: T, y: T) Declaration func ==<T : _Strideable>(x: T, y: 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 true iff lhs.rawValue == rhs.rawValue. 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 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