/// You can use any type that conforms to the `Hashable` protocol in a set or
/// as a dictionary key. Many types in the standard library conform to
/// `Hashable`: Strings, integers, floating-point and Boolean values, and even
/// sets provide a hash value by default. Your own custom types can be
/// hashable as well.
public protocol Hashable : Equatable {
public var hashValue: Int { get }
}
/// A hash value, provided by a type's `hashValue` property, is an integer that
/// is the same for any two instances that compare equally. That is, for two
/// instances `a` and `b` of the same type, if `a == b`, then
/// `a.hashValue == b.hashValue`. The reverse is not true: Two instances with
/// equal hash values are not necessarily equal to each other.
public protocol Equatable {
public static func == (lhs: Self, rhs: Self) -> Bool
}
extension Equatable {
public static func != (lhs: Self, rhs: Self) -> Bool
}
public func === (lhs: Swift.AnyObject?, rhs: Swift.AnyObject?) -> Bool
public func !== (lhs: Swift.AnyObject?, rhs: Swift.AnyObject?) -> Bool
/// let a = IntegerRef(100)
/// let b = IntegerRef(100)
///
/// print(a == a, a == b, separator: ", ")
/// // Prints "true, true"
/// class StreetAddress {
/// let number: String
/// let street: String
/// let unit: String?
///
/// init(_ number: String, _ street: String, unit: String? = nil) {
/// self.number = number
/// self.street = street
/// self.unit = unit
/// }
/// }
/// extension StreetAddress: Equatable {
/// static func == (lhs: StreetAddress, rhs: StreetAddress) -> Bool {
/// return
/// lhs.number == rhs.number &&
/// lhs.street == rhs.street &&
/// lhs.unit == rhs.unit
/// }
/// }
public protocol Comparable : Equatable{
public static func < (lhs: Self, rhs: Self) -> Bool
}
