More about Enumerations and Associated Types

I have briefly covered Associated Types before, but I would like to discuss what I like about them a little bit further.

So, to recap, let’s assume we have an enumeration like this:

enum TrackingEvent {
    case AppStart
    case AppEnd
}

enum MessageType {
    case Error
    case Warning
    case Info
    case Tracking(TrackingEvent)
}

If we want to check what message is, we need to do this:

let message: MessageType = .Tracking(.AppEnd)

switch message {
    case .Error:
        print("error ", message)
    case .Warning:
        print("warning ", message)
    case .Info:
        print("info ", message)
    case .Tracking(let event) :
        print("I only care about this ", event)
}

Now, imagine we only care about the case when message matches a tracking event (any tracking event). We would need to do something like this (which as I far as I know, was the only way):

switch message {
    case .Tracking(let event):
        print("I only care about this ", event)
    default:
        print("I'll do nothing")
}

Notice how (as of Xcode 7.1) we need to implement something in the default block. It can not be empty.

Now, somewhere along the journey, I honestly don’t recall if it was with Swift 2 or 2.1, this was introduced:

if case .Tracking(let event) = message {
    print("trackingEvent ", event)
}

Syntactic sugar? Yes. Useful syntactic sugar? Hell, yes! It makes code more expressive and therefore easier to read.

And here is the playground: AssociatedTypes.playground