How should I implement Default Associated Values with Swift Enums?

Question

Swift question is there a way of having an enum type with one case that can have an associated value.

I have an API that gives me available filters, it's unlikely but possible that the API will add additional filter types. So if the API sends an unknown filter type I want to keep that information associated with the enum.

Below are the different ideas I had about doing this.

My first two tries didn't compile. My third try just feels a bit clunky.

Does anyone have a better way of doing this? Do you think I just shouldn't use an enum for this problem?

typealias APIFilterIdentifier = String

/* Does Not Compile */
enum EnumTestAssociatedValeu: APIFilterIdentifier {
    case Unknown(APIFilterIdentifier)
    case Everyone = "everyone"
    case Team = "myteam"
}

/* Does not compile */
enum EnumTestDefaultAssociatedValues: APIFilterIdentifier {
    case Unknown(APIFilterIdentifier)
    case Everyone(APIFilterIdentifier = "everyone")
    case Team(APIFilterIdentifier = "myteam")
}

/* Compiles but is there a better way? */
enum EnumTestWithCustomInit {

    case Unknown(APIFilterIdentifier)
    case Everyone
    case Team

    init(filterIdentifier: APIFilterIdentifier) {
        let everyone: APIFilterIdentifier = EnumTestWithCustomInit.everyoneFilterIdentifier
        let team: APIFilterIdentifier = EnumTestWithCustomInit.teamFilterIdentifier

        switch filterIdentifier {
        case everyone:
            self = .Everyone
        case team:
            self = .Team
        default:
            self = .Unknown(filterIdentifier)
        }
    }

    func asIdentifer() -> APIFilterIdentifier {
        switch self {
        case .Everyone:
            return EnumTestWithCustomInit.everyoneFilterIdentifier
        case .Team:
            return EnumTestWithCustomInit.teamFilterIdentifier
        case .Unknown(let filterIdentifier):
            return filterIdentifier
        }
    }

    private static var everyoneFilterIdentifier: APIFilterIdentifier {
        return "everyone"
    }

    private static var teamFilterIdentifier: APIFilterIdentifier {
        return "myteam"
    }
}

I would love if someone would make a better title for this question. — Tobias, Apr 22 '15 at 20:08
I have the same question How to implement Default Associated Values with Swift Enums? Did you find an answer? Thanks — Mariam, Jun 05 '15 at 17:16

score 9 · Accepted Answer · answered Sep 12 '15 at 05:01

9

I know this is a bit old, but would this work for what you want?

typealias FilterIdentifier = String

enum DefaultAPIFilters: FilterIdentifier {
    case Everyone = "everyone"
    case Team = "team"
}

enum APIFilters {
    case Default(DefaultAPIFilters)
    case Custom(FilterIdentifier)
}

let everyoneFilter = APIFilters.Default(.Everyone)
let teamFilter = APIFilters.Default(.Team)
let clownFilter = APIFilters.Custom("clowns_only")

answered Sep 12 '15 at 05:01

Nathan Perry

291
2
11

How do you get the underlying value back out of this construct? Eg, to get the string for arbitrary manipulation – SG1 Oct 02 '15 at 15:52
I like this method. I think I might make the DefaultAPIFilters an inner enum. – Tobias Oct 03 '15 at 18:05
What is default associated value ? – sathishkumar_kingmaker Nov 30 '16 at 08:29

score 4 · Answer 2 · answered Oct 02 '15 at 16:10

Extending Nathan Perry's response:

You can add a

var underlyingString: String {
  return getUnderlyingString(self) 
}

to the enum. Then define

func getUnderlyingString(apiFilter: APIFilters) -> String { 
    switch apiFilter {
    case .Default(let defaultAPIFilter):
        return defaultAPIFilter.rawValue
    case .Custom(let custom):
        return custom
    }
}

score 0 · Answer 3 · answered May 06 '20 at 14:40

According to this answer: Default value for Enum in Swift

I recommend using such an approach

public enum Result {
    case passed(hint: String)
    case failed(message: String)

    static let passed: Self = .passed(hint: "")
}


let res: Result = Result.passed

How should I implement Default Associated Values with Swift Enums?

3 Answers3

Linked