[swift-evolution] [Pitch] Hashable types on RawRepresentable enums or a protocol for custom enum-like types

[Rien]

+1.

I have several cases where I cannot use enums, this proposal would solve that.


> On 03 Oct 2016, at 21:53, Adrian Zubarev via swift-evolution <swift-evolution at swift.org> wrote:
> 
> I made a typo in my previous post.
> 
> Bikeshdding with correct types:
> 
> struct A : Hashable { /* implement everything */ }
> 
> // Variant 1:
> enum Test : A {
>     case something = A(value: "something")
>     case nothing = A(value: "nothing")
> }
> 
> // Variant 2:
> 
> protocol SomeFancyName : RawRepresentable { … }
> 
> struct Test : SomeFancyName {
>       
>     let rawValue: A
>     init?(rawValue: A) {
>             // Implement + reject unwanted `A`s   
>     }
>       
>     static let something = Test(rawValue: A(value: "something"))
>     static let nothing = Test(rawValue: A(value: "nothing"))
> }
> 
> let value = Test.something
> 
> switch value {
>       
> case .something:
>     // handle
>       
> case .nothing:
>     // handle
>       
> // Because of `SomeFancyName` the switch can use enum-like pattern matching + does not need the `default` case when all cases are present
> }
> 
> 
> 
> 
> -- 
> Adrian Zubarev
> Sent with Airmail
> 
> Am 3. Oktober 2016 um 21:50:07, Adrian Zubarev (adrian.zubarev at devandartist.com) schrieb:
> 
>> Hi there,
>> 
>> I’m interested if this idea has some potential future in Swift or not.
>> 
>> Currently RawRepresentable enums accept only a subset of literal types like String, Character and the Integer family (enum Name : String { … }).
>> 
>> Sometimes this is not enough for my use-case and I wish I could feed my enums with other Hashable types!
>> 
>> As a workaround I can create a custom struct or even a class and conform it to RawRepresentable and fake an enum with some static variables (similar to what is done with OptionSet types).
>> 
>> The problem there is that I cannot use the same switch pattern matching like with enums. I’d wish either enums could accept Hashable types (maybe with some restriction) or the existence on a protocol to build custom enum-like types with strucs/classes and use the same switch pattern matching.
>> 
>> struct A : Hashable { /* implement everything */ }
>> 
>> // Variant 1:
>> enum Test : A {
>>     case something = A(rawValue: A(value: "something"))
>>     case nothing = A(rawValue: A(value: "nothing"))   
>> }
>> 
>> // Variant 2:
>> 
>> protocol SomeFancyName : RawRepresentable { … }
>> 
>> struct Test : SomeFancyName {
>>       
>>     let rawValue: A
>>     init?(rawValue: A) {
>>             // Implement + reject unwanted `A`s   
>>     }
>>       
>>     static let something = A(rawValue: A(value: "something"))
>>     static let nothing = A(rawValue: A(value: "nothing"))
>> }
>> 
>> let value = Test.something
>> 
>> switch value {
>>       
>> case .something:
>>     // handle
>>       
>> case .nothing:
>>     // handle
>>       
>> // Because of `SomeFancyName` the switch can use enum-like pattern matching + does not need the `default` case when all cases are present
>> }
>> 
>> 
>> 
>> -- 
>> Adrian Zubarev
>> Sent with Airmail
> 
> _______________________________________________
> swift-evolution mailing list
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution