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

[Adrian Zubarev]

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
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20161003/f7ba92c7/attachment.html>