我正在编写一个图形库以在图形中显示数据。由于我所做的大多数项目都倾向于在其中包含大量学习组件，因此我决定创建一个通用类型的结构来管理我的数据集 DataSet<T: Plottable> (注意这里 Plottable 也是 Comparable )。

试图符合 MutableCollectionType ，我遇到了一个错误。我想使用 sort() 的默认实现, 但编译器在尝试使用排序功能时给出以下错误。

Ambiguous reference to member 'sort()'

这是一个代码示例:

var data = DataSet<Int>(elements: [1,2,3,4])
data.sort() //Ambiguous reference to member 'sort()'

编译器建议了两个候选项，但不会实际显示给我。请注意，如果我显式实现 sort()，编译器错误就会消失在我的结构上。

但我还有更大的问题。我没有看到我希望默认实现提供什么？还是我在 Swift 3 中遇到了一个错误(这种情况很少见……通常我忽略了一些东西)。

这是结构的平衡:

struct DataSet<T: Plottable>: MutableCollection, BidirectionalCollection {
typealias Element = T
typealias Iterator = DataSetIterator<T>
typealias Index = Int

/**
 The list of elements in the data set. Private.
*/
private var elements: [Element] = []

/**
 Initalize the data set with an array of data.
 */
init(elements data: [T] = []) {
    self.elements = data
}

//MARK: Sequence Protocol
func makeIterator() -> DataSetIterator<T> {
    return DataSetIterator(self)
}

//MARK: Collection Protocol
subscript(_ index:DataSet<T>.Index) -> DataSet<T>.Iterator.Element {
    set {
        elements[index] = newValue
    }
    get {
        return elements[index]
    }
}

subscript(_ inRange:Range<DataSet<T>.Index>) -> DataSet<T> {
    set {
        elements.replaceSubrange(inRange, with: newValue)
    }
    get {
        return DataSet<T>(elements: Array(elements[inRange]))
    }
}

//required index for MutableCollection and BidirectionalCollection
var endIndex: Int {
    return elements.count
}
var startIndex: Int {
    return 0
}
func index(after i: Int) -> Int {
    return i+1
}
func index(before i: Int) -> Int {
    return i-1
}

mutating func append(_ newElement: T) {
    elements.append(newElement)
}

//    /**
//     Sorts the elements of the DataSet from lowest value to highest value.
//     Commented because I'd like to use the default implementation.
//     - note: This is equivalent to calling `sort(by: { $0 < $1 })` 
//     */
//    mutating func sort() {
//        self.sort(by: { $0 < $1 })
//    }
//    
//    /**
//     Sorts the elements of the DataSet by an abritrary block.
//     */
//    mutating func sort(by areInIncreasingOrder: @noescape (T, T) -> Bool) {
//        self.elements = self.elements.sorted(by: areInIncreasingOrder)
//    }

/**
 Returns a `DataSet<T>` with the elements sorted by a provided block.

 This is the default implementation `sort()` modified to return `DataSet<T>` rather than `Array<T>`.

 - returns: A sorted `DataSet<T>` by the provided block.
 */
func sorted(by areInIncreasingOrder: @noescape (T, T) -> Bool) -> DataSet<T> {
    return DataSet<T>(elements: self.elements.sorted(by: areInIncreasingOrder))
}

func sorted() -> DataSet<T> {
    return self.sorted(by: { $0 < $1 })
}
}

最佳答案

您的数据集是一个双向集合。您尝试使用的 sort() 需要一个 RandomAccessCollection。您需要添加的最重要的事情是 Indicies 类型别名。

typealias Indices = Array<Element>.Indices

这是我的类型:

protocol Plottable: Comparable {}
extension Int: Plottable {}

struct DataSet<Element: Plottable>:  MutableCollection, RandomAccessCollection {
    private var elements: [Element] = []

    typealias Indices = Array<Element>.Indices

    init(elements data: [Element] = []) {
        self.elements = data
    }

    var startIndex: Int {
        return elements.startIndex
    }

    var endIndex: Int {
        return elements.endIndex
    }

    func index(after i: Int) -> Int {
        return elements.index(after: i)
    }

    func index(before i: Int) -> Int {
        return elements.index(before: i)
    }

    subscript(position: Int) -> Element {
        get {
            return elements[position]
        }
        set {
            elements[position] = newValue
        }
    }

    subscript(bounds: Range<Int>) -> DataSet<Element> {
        get {
            return DataSet(elements: Array(elements[bounds]))
        }
        set {
            elements[bounds] = ArraySlice(newValue.elements)
        }
    }
}

var data = DataSet(elements: [4,2,3,1])
data.sort()
print(data.elements) // [1,2,3,4]

如果您不想要 Iterator，您实际上并不需要 Iterator。如果您实现 Collection，Swift 会自动为您提供 Sequence。

关于swift - 在 Swift 中采用 CollectionType(集合)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/38810405/