@enumRepresentable attribute to automatically synthesise Enum cases and compose enums from Protocols

Evolution Pitches
1

Given this example enum

enum AsyncState<T> {
    case initial
    case isUpdating(Float)
    case didUpdate(T)
    case didFail(Error)
}

considering that enum cases without associated values are equivalent to:

static let initial: AsyncState<T>

considering that enum cases with associated values are equivalent to:

static func isUpdating(_ progress: Float) -> AsyncState<T>

it would be really useful to be able to declare a protocol like this:

protocol State {
    associatedtype T

    @enumRepresentable
    static var initial: Self { get }
   
    @enumRepresentable
    static func isUpdating(_ progress: Float) -> Self
    @enumRepresentable
    static func didUpdate(_ value: T) -> Self
    @enumRepresentable
    static func didFail(_ error: Error) -> Self
}

then simply declare:

enum AsyncState: State {
    typealias T = SomeType
}

and have all the cases synthesised automatically.
We could compose enums from protocols gaining flexibility and having compile time safety.
The @enumRepresentable annotation would be ignored when adopting the protocol in classes or structs.

2

Honestly, If this were to ever exist, I would rather prefer protocol Foo: enum and use cases as requirements.

3

That sounds good too, but with the annotation we'd have the flexibility of also specifying some requirements that are not enum cases in the same protocol.

4

What exactly does this let you do that is cumbersome or impossible today? I'm failing to see the benefit vs implementation case.

1 Like
5

Yes, I understand your reasons for the annotation – the protocol will not be constrained to enums only. The use case of having such an annotation for that reason is rather vague though.

However, this not a bad approach to the problem that was always faced with enum inheritance.

6

I could have an enum like

enum ComplexState: State {
    typealias T = SomeType

    case someOtherCase
}

that could extend the State protocol while having the other 4 cases automatically synthesised.

7

Imho that's way to much magic that isn't intuitive... inheritance for enums would be easy to understand, but using protocols for auto synthesis is a big step.

1 Like
8

I agree that it is a big step but inheritance would prevent composition from multiple protocols and also the reason why this may be not super-intuitive is that we're not very used to think about enum cases as static vars/functions which requires a more functional mindset, but I think we Swift developers are getting there.

1 Like
9

I would be ok with enum cases satisfying static vars from a protocol, but not sure about having this special compiler magic for automatically inferring cases when an enum conforms.

1 Like
10

Right now, if you copy/paste the code from my pitch (without the @enumRepresentable annotations) and make the enum conform to the State protocol, you'll get an error from the compiler about duplicate symbols so I don't think it would be too "magical".