Wie kann ich eine Erweiterung für Array von bestimmten Typs in Swift

Question

für machen sagen, ich habe:

struct S { 
    var num = 0 
} 

ich umsetzen möchte eine Funktion allEqual() als Erweiterung für Array<S>, so konnte ich tun, was wie

var s1 = S() 
var s2 = S() 
var s3 = S() 
var equality = [s1,s2,s3].allEqual() 

Answer 1

für sagen die spezifische Art ist S

extension CollectionType where Generator.Element == S { 
} 

CollectionType Protocol

Answer 2

Ich habe eine Erweiterung erstellt, die träge für alle SequenceType arbeitet, deren Element s Equatable sind. In Swift ist es eine gute Übung, den Code so zu gestalten, dass er genau funktioniert, an was er arbeiten kann: Um zu erkennen, ob alle Elemente gleich sind, muss es sich um eine Folge von gleichwertigen Werten handeln. Hier ist der Code:

extension SequenceType where Generator.Element : Equatable { 
    var allEqual : Bool { 
     var gen = generate()   // Generate the sequence for the first element 
     return gen.next().map { fst in // Get first element and map it (when existing) 
      !contains { fst != $0 } // To whether self doesn't contain any elements unequal to first 
     } ?? true      // When first is nil, return true 
    }         
} 

Oder Sie können auch tun es mehr iterative (das ist im Grunde das gleiche Ich denke, schneller ist ?):

extension SequenceType where Generator.Element : Equatable { 
    var allEqual : Bool { 
     var gen = generate() 
     let first = gen.next() 
     return !contains { $0 != first } 
    } 
} 

Auch sollten Sie Ihre Struktur machen entsprechen das Equatable Protokoll wie folgt aus:

func ==(lhs: S, rhs: S) -> Bool { 
    return lhs.x == rhs.x 
} 

weil every value type should be equatable und offensichtlich macht es absolut Sinn in Ihrem Code, dies zu tun. Hier

ist einiger Testcode:

[S(x: 3), S(x: 3), S(x: 3)].allEqual // true 
[S(x: 5), S(x: 3), S(x: 3)].allEqual // false 
[S(x: 5), S(x: 5)].allEqual    // true 
[S(x: 0)].allEqual      // true 
[S]().allEqual       // true 

Beachten Sie, dass es faul ist, was bedeutet, dass es so bald falsch zurück, da es ein Element, das nicht gleich den ersten ist, also wenn Sie etwas wie folgt aus:

let longList = [S(x: 5)] + [S](count: 100000, repeatedValue: S(x: 4)) 
    // [{x 5}, {x 4}, {x 4}, {x 4}, {x 4}, {x 4}, {x 4}, ... 
longList.allEqual // false 

am zweiten Element zurückkehren wird, weil es eine Gleichheit bereits

ist

EDIT: Meine bisherigen Funktion war unnötig kompliziert. Der neue ist noch faul nur kürzer

Answer 3

In der aktuellen Swift 3.1. Sie können gleichartige Einschränkungen für die konkrete Erweiterung. Also in Ihrem Fall können Sie tun:

extension Array where Element == S { 
    func allEqual() -> Bool { 
     ... 
    } 
}