Fehler: nicht konform mit dem Protokoll 'Equatable'

Question

Ich bin neu zu schnell und ein Tutorial folgen, um mehr zu erfahren.

Im folgenden Code habe ich benutzerdefinierte Operatoren definiert (< und ==) und der Code funktioniert aber gut, aber xcode zeigt diese Fehler in der ersten Zeile des Codes.

Type 'SuitedCard' does not conform to protocol 'Equatable' 
Type 'SuitedCard' does not conform to protocol 'Comparable' 

hier ist der Code:

struct SuitedCard: Equatable, Comparable { 

    // a card can be ♥️, ♣️, ♦️, ♠️ 
    enum Suit { 
     case hearts 
     case spades 
     case diamonds 
     case clubs 
    } 

    // the possible values of a card 
    enum Value: Int { 
     case two = 2 
     case three = 3 
     case four = 4 
     case five = 5 
     case six = 6 
     case seven = 7 
     case eight = 8 
     case nine = 9 
     case ten = 10 
     case jack = 11 
     case queen = 12 
     case king = 13 
     case ace = 14 
    } 

    // properties 
    let suit: Suit 
    let value: Value 
    var isFaceDown: Bool 
} 

var valueArray: [SuitedCard.Value] = [.ten, .jack, .queen, .king] 


func ==(lhs: SuitedCard, rhs: SuitedCard) -> Bool { 
    for cardValue in valueArray { 
     if lhs.value == cardValue { 
      for cardValue2 in valueArray { 
       if rhs.value == cardValue2 { 
        return true 
       } 
      } 
     } 
    } 
    if lhs.value == rhs.value { 
     return true 
    } 
    return false 
} 

func <(lhs: SuitedCard, rhs: SuitedCard) -> Bool { 
    var lhsRawValue: Int 
    var rhsRawValue: Int 
    if lhs.value == .jack || lhs.value == .queen || lhs.value == .king { 
     lhsRawValue = 10 
    } else { 
     lhsRawValue = lhs.value.rawValue 
    } 
    if rhs.value == .jack || rhs.value == .queen || rhs.value == .king { 
     rhsRawValue = 10 
    } else { 
     rhsRawValue = rhs.value.rawValue 
    } 
    return lhsRawValue < rhsRawValue 
} 

let smaller = SuitedCard(suit: .hearts, value: .five, isFaceDown: true) 

let bigger = SuitedCard(suit: .diamonds, value: .six, isFaceDown: false) 

smaller >= smaller 

smaller < bigger 

Was ist los?

Answer 1

In Swift 3 werden für Protokolle erforderliche Operatoren als statische Elemente deklariert.

Eine Möglichkeit, mit solchen Protokollen arbeiten wird Ihre Operator Definitionen in die Struktur als statisches Element bewegt:

struct SuitedCard: Comparable { //### Comparable implies Equatable 

    //... 

    // function for custom operator == 
    static func ==(lhs: SuitedCard, rhs: SuitedCard) -> Bool { 
     //... 
     return false 
    } 
    // function for custom operator < 
    static func <(lhs: SuitedCard, rhs: SuitedCard) -> Bool { 
     //... 
     return false 
    } 
} 

---

Ein anderer Weg, können Sie die Konformität mit dem Protokoll-Erweiterung deklarieren:

struct SuitedCard { 

    //... 
} 

// function for custom operator == 
func ==(lhs: SuitedCard, rhs: SuitedCard) -> Bool { 
    //... 
    return false 
} 
// function for custom operator < 
func <(lhs: SuitedCard, rhs: SuitedCard) -> Bool { 
    //... 
    return false 
} 

extension SuitedCard: Comparable {} 

Answer 2

Die Antwort von OOPer löst das Problem, aber in Swift 3 können Operatormethoden auch außerhalb des Klassen-/Strukturkörpers definiert werden. In diesem Fall löst das Verschieben der valueArray-Deklaration in den body of == -Verfahren das Problem. Hier ist die korrigierte Code:

struct SuitedCard: Equatable, Comparable { 

    // a card can be ♥️, ♣️, ♦️, ♠️ 
    enum Suit { 
     case hearts 
     case spades 
     case diamonds 
     case clubs 
    } 

    // the possible values of a card 
    enum Value: Int { 
     case two = 2 
     case three = 3 
     case four = 4 
     case five = 5 
     case six = 6 
     case seven = 7 
     case eight = 8 
     case nine = 9 
     case ten = 10 
     case jack = 11 
     case queen = 12 
     case king = 13 
     case ace = 14 
    } 

    // properties 
    let suit: Suit 
    let value: Value 
    var isFaceDown: Bool 
} 


func ==(lhs: SuitedCard, rhs: SuitedCard) -> Bool { 

// Deklaration von Wertarray hier bewegt:

let valueArray: [SuitedCard.Value] = [.ten, .jack, .queen, .king] 
    for cardValue in valueArray { 
     if lhs.value == cardValue { 
      for cardValue2 in valueArray { 
       if rhs.value == cardValue2 { 
        return true 
       } 
      } 
     } 
    } 
    if lhs.value == rhs.value { 
     return true 
    } 
    return false 
} 

func <(lhs: SuitedCard, rhs: SuitedCard) -> Bool { 
    var lhsRawValue: Int 
    var rhsRawValue: Int 
    if lhs.value == .jack || lhs.value == .queen || lhs.value == .king { 
     lhsRawValue = 10 
    } else { 
     lhsRawValue = lhs.value.rawValue 
    } 
    if rhs.value == .jack || rhs.value == .queen || rhs.value == .king { 
     rhsRawValue = 10 
    } else { 
     rhsRawValue = rhs.value.rawValue 
    } 
    return lhsRawValue < rhsRawValue 
} 

let smaller = SuitedCard(suit: .hearts, value: .five, isFaceDown: true) 

let bigger = SuitedCard(suit: .diamonds, value: .six, isFaceDown: false) 

smaller >= smaller 

smaller < bigger