arrays - Swift "-"CollectionTypes 上的二元运算符

Question

只有当对象包含在另一个数组中时，我才想删除数组中的对象。

myArray = myArray - otherArray

如何将此行为添加为 CollectionType 的扩展

Answer 1

因此，您可以通过多种方式来实现。我已经要求这些版本中的元素是可散列的，但是对于它们来说，方法将是相似的(如果慢得多的话)只是为了等同。

如果您的集合符合 RangeReplaceableCollectionType，则它可以使用 removeAtIndex 方法。这意味着您可以返回与给定类型相同类型的集合:

extension RangeReplaceableCollectionType where Generator.Element : Hashable {
  mutating func subtractInPlace(vals: Set<Generator.Element>) {
    // The indices need to be reversed, because removing at a given index invalidates all
    // those above it
    for idx in indices.reverse()
      where vals.contains(self[idx]) { // This is why hashable is a requirement: the 
      removeAtIndex(idx)               // contains method is much more efficient on sets
    }
  }
  mutating func subtractInPlace<
    S : SequenceType where
    S.Generator.Element == Generator.Element
    >(seq: S) {
      subtractInPlace(Set(seq))
  }
  func subtract(vals: Set<Generator.Element>) -> Self {
    var col = self
    col.subtractInPlace(vals)
    return col
  }
  func subtract<S : SequenceType where S.Generator.Element == Generator.Element>(seq: S) -> Self {
    return subtract(Set(seq))
  }
}

否则，您将只返回一个数组。 (其实我觉得这个方法更快)

extension SequenceType where Generator.Element : Hashable {
  func subtract(vals: Set<Generator.Element>) -> [Generator.Element] {
    return filter { !vals.contains($0) }
  }
  func subtract<
    S : SequenceType where
    S.Generator.Element == Generator.Element
    >(seq: S) -> [Generator.Element] {
      return subtract(Set(seq))
  }
}

然后，您需要定义运算符。这里有这么多不同版本的原因是 Swift 会在每种情况下选择最具体的实现。因此，在转换为集合的版本之前，将选择带有集合的版本。这使您能够实现高效的实现，而不会使其他效率较低的实现无效。

func - <
  C : RangeReplaceableCollectionType where
  C.Generator.Element : Hashable
  >(lhs: C, rhs: Set<C.Generator.Element>) -> C {
    return lhs.subtract(rhs)
}

func - <
  C : RangeReplaceableCollectionType,
  S : SequenceType, T : Hashable where
  C.Generator.Element == T,
  S.Generator.Element == T
  >(lhs: C, rhs: S) -> C {
    return lhs.subtract(rhs)
}

func - <
  S : SequenceType where
  S.Generator.Element : Hashable
  >(lhs: S, rhs: Set<S.Generator.Element>) -> [S.Generator.Element] {
    return lhs.subtract(rhs)
}

func - <
  S0 : SequenceType,
  S1 : SequenceType,
  T : Hashable where
  S0.Generator.Element == T,
  S1.Generator.Element == T
  >(lhs: S0, rhs: S1) -> [T] {
    return lhs.subtract(rhs)
}