Comment faire un enum se conformer à un protocole Swift?

Ici est mon point de vue à elle.

Que c'est un enum et pas un class, vous devez think different(TM): il est de votre description doit changer lorsque "l'état" de votre enum changements (comme l'a fait remarquer @hu qiang).

enum SimpleEnumeration: ExampleProtocol {
  case Basic, Adjusted

  var description: String {
    switch self {
    case .Basic:
      return "A simple Enumeration"
    case .Adjusted:
      return "A simple Enumeration [adjusted]"
    }
  }

  mutating func adjust()  {
    self = .Adjusted
  }
}

var c = SimpleEnumeration.Basic
c.description
c.adjust()
c.description

Espère que ça aide.

Voici une solution qui n'est pas de modifier la valeur d'enum, mais leurs valeurs d'instance de la place (juste au cas où il est utile à personne).

enum ProtoEnumeration : ExampleProtocol {
    case One(String)
    case Two(String)

    var simpleDescription: String {
        get {
            switch self {
            case let .One(desc):
                return desc
            case let .Two(desc):
                return desc
            }
        }
    }
    mutating func adjust() {
        switch self {
        case let .One(desc):
            self = .One(desc + ", adjusted 1")
        case let .Two(desc):
            self = .Two(desc + ", adjusted 2")
        }
    }
}

var p = ProtoEnumeration.One("test")
p.simpleDescription
p.adjust()
p.simpleDescription

C'est un lien sur enum swift.

Les Structures et les énumérations sont des types de valeur. Par défaut, les propriétés d'un type de valeur ne peut pas être modifiée à partir de l'intérieur de ses méthodes d'instance. lien

Ensuite, vous devez utiliser la mutation de la fonction.

enum ProtocolEnum: ExampleProtocol {
    case on, off
    var simpleDescription: String {
        switch self {
        case .on:
            return "Switch is ON"
        case .off:
            return "Switch is OFF"
        }
    }
    mutating func adjust() {
        switch self {
        case .on:
            self = off
        case .off:
            self = on
        }
    }
}

var c = ProtocolEnum.on
c.simpleDescription
c.adjust()
let cDescription = c.simpleDescription

Voici bâtiment sur Jack réponse:

protocol ICanWalk {
    var description: String { get }
    mutating func stepIt()
}

enum TwoStepsForwardThreeStepsBack: Int, ICanWalk {
    case Base = 0, Step1, Step2

    var description: String {
        return "Step \(self.rawValue)"
    }

    mutating func stepIt() {
        if let nextStep = TwoStepsForwardThreeStepsBack( rawValue: self.rawValue + 1 ) {
            //going forward.
            self = nextStep
        } else {
            //back to the base.
            self = TwoStepsForwardThreeStepsBack.Base
        }
    }
}

voici mon code

enum SimpleEnum: ExampleProtocol {
    case Base, Adjusted
    var simpleDescription: String {
        get {
            var description = "A simple enum."
            switch self {
            case .Base:
                return description
            case .Adjusted:
                return description + " - [adjusted]"
            }
        }
    }
    mutating func adjust() {
        self = SimpleEnum.Adjusted
    }
}
var simpleEnum = SimpleEnum.Base
simpleEnum.adjust()
simpleEnum.simpleDescription

Cette expérience m'a jeté aussi, en raison de la précédente SimpleClass et SimpleStructure exemples montrant la propriété simpleDescription être modifiée en interne, ce qui m'a fait penser que je devais faire la même chose. Après avoir regardé dans les autres réponses postées ici et la lecture de l'officiel d'Apple Swift 2.1 documentation, j'ai trouvé ceci:

protocol ExampleProtocol {
     var simpleDescription: String { get }
     mutating func adjust()
}

enum SimpleEnum: ExampleProtocol {
    case Simple
    case Adjusted

    var simpleDescription: String {
        switch self {
        case .Simple:
            return "A simple enumeration"
        case .Adjusted:
            return "A simple enumeration somewhat changed."
        }
    }

    mutating func adjust() {
        self = .Adjusted
    }

    mutating func restore() {
        self = .Simple
    }
}

var d: SimpleEnum = .Simple
d.simpleDescription

d.adjust()
d.simpleDescription

d.restore()
d.simpleDescription

Également remarquer que, dans les exemples donnés par Apple pour SimpleClass et SimpleStructure avant cette expérience, la simple description est perdu en interne, - vous ne pouvez pas obtenir la valeur d'origine à l'arrière (à moins bien sûr que vous l'enregistrez en dehors de la classe/structure); c'est ce qui m'a incité à créer un restore() méthode pour la SimpleEnum exemple, qui vous permet de basculer d'avant en arrière entre les valeurs. Espérons que cela est utile à quelqu'un!

Une autre variante: à l'Aide de valeurs associées à tenir et affichage de l'option précédente
(de la forme "1, ajusté de 2, ajustée de 1, ajusté de 2, ajustée de 1")

protocol ExampleProtocol {
     var simpleDescription: String { get }
     mutating func adjust()
}

indirect enum EnumWithDescription: ExampleProtocol {
    case option1(EnumWithDescription?)
    case option2(EnumWithDescription?)
    var simpleDescription: String {
        return "Selected " + getDescription()
    }
    internal func getDescription() -> String {
        var currentValue: String
        let previousValue : EnumWithDescription?
        switch self {
        case .option1(let previous):
            currentValue = "1"
            previousValue = previous
        case .option2(let previous):
            currentValue = "2"
            previousValue = previous
        }
        if let adjustedFrom = previousValue?.getDescription() {
            return "\(currentValue) adjusted from \(adjustedFrom)"
        }
        else {
            return "\(currentValue)"
        }
    }
    mutating func adjust() {
        switch self {
        case .option1:
            self = .option2(self)
        case .option2:
            self = .option1(self)
        }
    }
}
var d = EnumWithDescription.option1(nil)
d.simpleDescription
d.adjust()
d.adjust()
d.simpleDescription
// Output: "Selected 1, adjusted from 2, adjusted from 1, adjusted from 2, adjusted from 1"