How to make an enum conform to a protocol in Swift?

Question

Swift documentation says that classes, structs, and enums can all conform to protocols, and I can get to a point where they all conform. But I can't get the enum to behave quite like the class and struct examples:

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

class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105

    func adjust() {
        simpleDescription += " Now 100% adjusted."
    }
}

var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription

struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"

    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}

var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

enum SimpleEnum: ExampleProtocol {
    case Base

    var simpleDescription: String {
        get {
            return "A Simple Enum"
        }
        set {
            newValue
        }
    }

    mutating func adjust() {
        self.simpleDescription += ", adjusted"
    }
}

var c = SimpleEnum.Base
c.adjust()
let cDescription = c.simpleDescription

I haven't figured out how to get the simpleDescription to change as a result of calling adjust(). My example obviously won't do that because the getter has a value hard-coded, but how can I set a value for the simpleDescription while still conforming to the ExampleProtocol?

score 170 · Accepted Answer · edited Jan 17 '17 at 16:08

170

This is my attempt:

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

enum ExampleEnum : ExampleProtocol {
    case Base, Adjusted

    var simpleDescription: String {
        return self.getDescription()
    }

    func getDescription() -> String {
        switch self {
        case .Base:
            return "A simple description of enum"
        case .Adjusted:
            return "Adjusted description of enum"
        }
    }

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

var c = ExampleEnum.Base
c.adjust()
let cDescription = c.simpleDescription

edited Jan 17 '17 at 16:08

Uwe Keim

39,551
56
175
291

answered Jun 04 '14 at 08:35

Hu Qiang

1,862
1
12
7

1

Awesome! I had that idea of creating an adjusted state, but it didn't occur to me that I could change to .Adjusted in the adjust method. Thanks! – Adrian Harris Crowne Jun 04 '14 at 17:22
Excellent pointer. Was a bit stuck on this one. One question though: Any reason you added the return value of Void to the adjust function? – jpittman Jun 07 '14 at 19:45
1

@jpittman because the `adjust` function returns `Void` in the `ExampleProtocol`, it's the same as just using `mutating func adjust()`. If you want `adjust` to have a return type, you can change the protocol to: https://gist.github.com/anjerodesu/e1bf640576a3b6fa415f – Angelo Jun 09 '14 at 10:37
1

Could not edit the answer to correct the syntax error, it is missing a dot, should be `case .Base:` – John Doe Oct 12 '16 at 04:44
can someone 69 this post. also #POP is touchy subject. visa once tested me heavy #POP interview question. – CDM social medias in bio Dec 14 '22 at 22:02

Zedenem · Answer 2 · 2017-03-16T12:47:35.590

46

Here is my take at it.

As this is an enum and not a class, you have to think different(TM): it is your description that has to change when the "state" of your enum changes (as pointed out by @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

Hope that helps.

edited Mar 16 '17 at 12:47

answered Jun 04 '14 at 10:52

Zedenem

2,479
21
23

i agree with your take on the enum itself, and with the code you provided. nice. – Jun 05 '14 at 11:31
5

This answer is nicer and more succinct than the accepted one. – Ricardo Sanchez-Saez Nov 07 '14 at 17:23
2

Just a side note that you can remove the SimpleEnumeration.Adjusted and replace with just ".Adjusted". If the name of the enumeration ever changes then it's one less thing to refactor. – Shaolo Dec 29 '14 at 10:12
Yeah, this is better. Thanks. – Arjun Kalidas Aug 23 '17 at 07:50
This doesn't conform to the given protocol though – barry Sep 20 '17 at 10:11

score 12 · Answer 3 · edited Mar 04 '16 at 05:19

Here's another approach, using only the knowledge gained from the tour until that point*

enum SimpleEnumeration: String, ExampleProtocol {
    case Basic = "A simple enumeration", Adjusted = "A simple enumeration (adjusted)"

    var simpleDescription: String {
        get {
            return self.toRaw()
        }
    }

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

var c = SimpleEnumeration.Basic
c.adjust()
let cDescription = c.simpleDescription

If you want to have adjust() act as a toggle (although there's nothing to suggest this is the case), use:

mutating func adjust() {
    switch self {
    case .Basic:
        self = .Adjusted
    default:
        self = .Basic
    }
}

*(Although it doesn't explicitly mention how to specify a return type and a protocol)

I think this approach is probably the best one of the bunch. Quick update is that the simpleDescription should return self.rawValue — Justin Levi Winter, Nov 04 '14 at 03:30

DiogoNeves · Answer 4 · 2014-06-13T23:21:54.660

Here's a solution that doesn't change the current enum value, but their instance values instead (just in case it is useful to anyone).

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

Extra points for whoever finds a way to avoid all those switches. Something along the lines of this fictitious copy `self = copy(self, self.desc + ", asdfasdf")` — DiogoNeves, Jun 13 '14 at 23:17

score 4 · Answer 5 · answered Jun 03 '14 at 11:07

4

It is not possible to define variables without getter and setter in enums and therefore it is impossible to have a variable that you can modify.

You can conform to the protocol but you cannot have same behavior with mutating as in classes.

answered Jun 03 '14 at 11:07

Tomáš Linhart

13,509
5
51
54

Jeff Gu Kang · Answer 6 · 2014-06-13T03:54:32.120

It is a link about enum in swift.

Structures and enumerations are value types. By default, the properties of a value type cannot be modified from within its instance methods. link

Then, you have to use mutating function.

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

Endersstocker · Answer 7 · 2014-06-08T12:25:22.430

1

Another option is for adjust() to flip between cases as follows:

enum SimpleEnum: ExampleProtocol {
    case Foo, Bar

    var simpleDescription: String {
    get {
        let value = self == .Foo
            ? "Foo"
            : "Bar"
        return "A simple \(value) enum."
    }
    }

    mutating func adjust() {
        self = self == .Foo
            ? .Bar
            : .Foo
    }
}

edited Jun 08 '14 at 12:25

answered Jun 08 '14 at 12:19

Endersstocker

1,061
9
26

score 1 · Answer 8 · answered Jan 15 '15 at 14:53

Here's building on Jack's answer:

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
        }
    }
}

score 1 · Answer 9 · answered Jun 05 '16 at 19:43

I came up with this

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

enum Seat: ExampleProtocol {
    case WindowSeat, MiddleSeat, AisleSeat

    var simpleDescription : String {
        switch self {
        case .WindowSeat:
            return "Window Seat"
        case .MiddleSeat:
            return "Middle Seat"
        case .AisleSeat:
            return "Aisle Seat"
        }
    }

    mutating func adjust() {
        switch self {
        case .WindowSeat:
            self = .MiddleSeat
        case .MiddleSeat:
            self = . AisleSeat
        case .AisleSeat:
            self = .WindowSeat
        }
    }
}

var seat = Seat.MiddleSeat
print(seat.simpleDescription) // Middle Seat
seat.adjust()
print(seat.simpleDescription) // Aisle Seat

nkalvi · Answer 10 · 2017-01-17T16:51:11.157

Another variation: Using associated values to hold and display previous option (of the form "Selected 1, adjusted from 2, adjusted from 1, adjusted from 2, adjusted from 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"

score 0 · Answer 11 · answered Mar 11 '15 at 07:13

here's my 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

score 0 · Answer 12 · answered Jun 10 '15 at 10:41

0

My first contribution here:

enum SimpleEnum: ExampleProtocol {
    case Basic(String), Adjusted(String)
    init() {
        self = SimpleEnum.Basic("A simple Enum")

    }

    var simpleDescription: String {
        get {
            switch self {
            case let .Basic(string):
                return string
            case let .Adjusted(string):
                return string
            }
        }
    }

    mutating func adjust() {
        self = SimpleEnum.Adjusted("full adjusted")

    }
}

var c = SimpleEnum()
c.adjust()
let cDescription = c.simpleDescription

Thanks for others!

answered Jun 10 '15 at 10:41

Indra Rusmita

1

1

Could you also add an explanation? – Robert Jun 10 '15 at 11:07
@Robert it should be self explained like others but the different are that I am using init method in enum and have default basic enum. so you'll see that when you create enum object like in structure and class example in Swift playground. – Indra Rusmita Jun 11 '15 at 12:15

score 0 · Answer 13 · answered Oct 15 '15 at 19:19

This experiment threw me off too, due to the previous SimpleClass and SimpleStructure examples showing the property simpleDescription being modified internally, which caused me to think that I needed to do the same thing. After looking over the other answers posted here and reading the official Apple Swift 2.1 documentation, I came up with this:

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

Also notice that in the examples given by Apple for SimpleClass and SimpleStructure prior to this experiment, the simple description is lost internally - you cannot get the original value back (unless of course you save it outside of the class/structure); this is what prompted me to create a restore() method for the SimpleEnum example, which allows you to toggle it back and forth between values. Hope this is useful to someone!

score 0 · Answer 14 · answered Oct 23 '15 at 11:07

I was thinking that the goal is simply to retain state and use a description to make the current state easier to read:

enum SimpleEnum: ExampleProtocol {

    case Default, Adjusted

    init() {
        self = .Default
    }

    var simpleDescription: String { get { return "\(self) Value" }}

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

var simpleEnum = SimpleEnum()
simpleEnum.adjust()
let adjustedSimple = simpleEnum.simpleDescript

michex · Answer 15 · 2015-10-25T10:41:02.360

how about this

enum SimpleEnum : ExampleProtocol {
    case Desc(String)
    init() {
        self = Desc("a simple enum")
    }
    var simpleDescription:String {
        get {
            return (Mirror(reflecting: self).children.first!.value as? String)!
        }
    }
    mutating func adjust() {
        self = SimpleEnum.Desc(self.desc + " adjusted")
    }
}
var e = SimpleEnum()
e.simpleDescription    # => "a simple enum"
e.adjust()
e.simpleDescription    # => "a simple enum adjusted"

How to make an enum conform to a protocol in Swift?

15 Answers15

Linked