我正在尝试使用组合而不是继承，我想在符合给定协议的对象数组上使用diff。
为此，我实现了一个协议并使其符合Equatable：

// Playground - noun: a place where people can play
import XCPlayground
import Foundation

protocol Field:Equatable {
    var content: String { get }
}

func ==<T: Field>(lhs: T, rhs: T) -> Bool {
    return lhs.content == rhs.content
}

func ==<T: Field, U: Field>(lhs: T, rhs: U) -> Bool {
    return lhs.content == rhs.content
}

struct First:Field {
    let content:String
}

struct Second:Field {
    let content:String
}

let items:[Field] = [First(content: "abc"), Second(content: "cxz")] // ? boom

// Playground - noun: a place where people can play
import XCPlayground
import Foundation

protocol Field {
    var content: String { get }
}

func ==(lhs: Field, rhs: Field) -> Bool {
    return lhs.content == rhs.content
}

func ==(lhs: [Field], rhs: [Field]) -> Bool {
    return (lhs.count == rhs.count) && (zip(lhs, rhs).map(==).reduce(true, { $0 && $1 })) // naive, but let's go with it for the sake of the argument
}

struct First:Field {
    let content:String
}

struct Second:Field {
    let content:String
}


// Requirement #1: direct object comparison
print(First(content: "abc") == First(content: "abc")) // true
print(First(content: "abc") == Second(content: "abc")) // false

// Requirement #2: being able to diff an array of objects complying with the Field protocol
let array1:[Field] = [First(content: "abc"), Second(content: "abc")]
let array2:[Field] = [Second(content: "abc")]

print(array1 == array2) // false
let outcome = array1.diff(array2) // ? boom

最佳答案

问题来自于Equatable协议的含义和swift对类型重载函数的支持的结合。
让我们看一下Equatable协议：

protocol Equatable
{
    static func ==(Self, Self) -> Bool
}

protocol Field:Equatable 
{
    var content:String { get }
}

func ==<T:Field>(lhs:T, rhs:T) -> Bool 
{
    return lhs.content == rhs.content
}

func ==<T:Field, U:Field>(lhs:T, rhs:U) -> Bool 
{
    return lhs.content == rhs.content
}

First(content: "abc") == Second(content: "abc")

let array:[Equatable] = [5, "a", false]

let array:[Int] = [5, 6, 7]

let array:[String] = ["a", "b", "c"]

let array:[Bool] = [false, true, false]

let array:[Equatable] = [Int.self, String.self, Bool.self]

class Field:Equatable
{
    let content:String

    static func == (lhs:Field, rhs:Field) -> Bool
    {
        return lhs.content == rhs.content
    }

    init(_ content:String)
    {
        self.content = content
    }
}

class First:Field
{
    init(content:String)
    {
        super.init(content)
    }
}

class Second:Field
{
    init(content:String)
    {
        super.init(content)
    }
}


let items:[Field] = [First(content: "abc"), Second(content: "cxz")]

protocol LCSElement 
{
    associatedtype Key:Equatable
    var key:Key { get }
}

class Field:LCSElement
{
    let key:String // <- this is what specializes Key to a concrete type

    static func == (lhs:Field, rhs:Field) -> Bool
    {
        return lhs.key == rhs.key
    }

    init(_ key:String)
    {
        self.key = key
    }
}

func LCS<T: LCSElement>(array:[T])
{
    array[0].key == array[1].key
    ...
}

关于swift - 在符合协议(protocol)的对象数组中使用diff，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42916117/