Compruebe si una matriz contiene todos los elementos de otra en Swift

Quiero escribir una extensión para la matriz para comprobar si una matriz contiene todos los elementos de otra matriz, en mi caso de uso son los objects de cadena, pero sigo get:

Cannot convert value of type 'T.Generator.Element' to expected argument type '@noescape _ throws -> Bool' 

en la línea self.contains(item) el error en el item

aquí está mi código:

 extension Array { func containsArray<T : SequenceType where T.Generator.Element : Equatable> (array:T) -> Bool{ for item:T.Generator.Element in array{ if !self.contains(item) { return false } } return true } } 

Ha requerido que los elementos de la secuencia sean Equatable , pero no están relacionados con los elementos de la matriz. Por lo tanto

  if !self.contains(item) { ... } 

no comstack

Lo que probablemente desee es exigir que los elementos de secuencia tengan el mismo tipo que los elementos de la matriz (y que deberían ser Equatable ):

 extension Array where Element: Equatable { func containsArray<T : SequenceType where T.Generator.Element == Element> (array:T) -> Bool { for item in array { if !self.contains(item) { return false } } return true } } 

Si necesita el método para los arguments de matriz solo y no para las secuencias generales, entonces puede simplificar la statement a

 extension Array where Element: Equatable { func containsArray(array: [Element]) -> Bool { for item in array { if !self.contains(item) { return false } } return true } } 

que se puede acortar a

 extension Array where Element: Equatable { func containsArray(array: [Element]) -> Bool { return !array.contains { !self.contains($0) } } } 

Como dijo @AMomchilov, contains() realiza una búsqueda lineal, por lo que tiene una complejidad O(M*N) donde M y N son la longitud de las dos matrices. Puede definir una especialización para el caso de que los elementos sean Hashable , y hacer la verificación de membresía en contra de un Set :

 extension Array where Element: Hashable { func containsArray(array: [Element]) -> Bool { let selfSet = Set(self) return !array.contains { !selfSet.contains($0) } } } 

Si esto es más rápido que el método anterior o no, dependería de los tamaños de matriz y también del tipo de elemento (qué tan "costoso" es comparar los elementos).