Swift 2.2 example showing how a generic protocol can be "Equatable"

generic-equatable-protocol.swift

import Foundation

/**
 generic protocol that is Equatable by itself 
 and wraps any equatable data type
*/
protocol SameOldThingable: Equatable {
    associatedtype DataType: Equatable
    
    var data: DataType { get set }
}

/**
 "equals" operator overloading

 this makes SameOldThingable Equatable
 
 - parameter lhs: SameOldThingable
 - parameter rhs: SameOldThingable
 
 - return: Bool
*/
func ==<T: SameOldThingable>(lhs: T, rhs: T) -> Bool {
    return lhs.data == rhs.data
}

/**
 concrete type that adopts "SameOldThingable"
 
 this is implemented using generics but "SameOldThing" could also use a 
 typealias to specify what concrete type the associated type "DataType" 
 of the "SameOldThingable" protocol should be
*/
struct SameOldThing<DataType: Equatable>: SameOldThingable {
    
    var data: DataType
    
}

// MARK: demo

let hello = SameOldThing<String>(data: "Hello")
let world = SameOldThing<String>(data: "World")

// not equal
assert((hello == world) == false)

let anotherHello = SameOldThing<String>(data: "Hello")

// equal
assert((hello == anotherHello) == true)