[swift-evolution] [Idea] Find alternatives to `switch self`

[Dave Abrahams]

on Wed Mar 23 2016, Brent Royal-Gordon <swift-evolution at swift.org> wrote:

> If you've written enums before, you've no doubt noticed the irritating
> phenomenon of `switch self` being absolutely everywhere. I first
> discovered this in some of my very first Swift code, code so old we
> were still using the `T[]` shorthand syntax:
>
>     enum Suit: Int {
>         case Hearts, Spades, Diamonds, Clubs
>
>         static var all: Suit[] { return [ Hearts, Spades, Diamonds, Clubs ] }
>
>         var description: String {
>             switch(self) {
>             case .Hearts:
>                 return "♥️"
>             case .Spades:
>                 return "♠️"
>             case .Diamonds:
>                 return "♦️"
>             case .Clubs:
>                 return "♣️"
>             }
>         }
>
>         var isRed: Bool {
>             switch(self) {
>             case .Hearts, .Diamonds:
>                 return true
>             case .Spades, .Clubs:
>                 return false
>             }
>         }
>     }
>
> It would be nice if we could somehow eliminate that. I have two suggestions:
>
> * Implicitly switch on `self` at the top level of a function or
> accessor (or at least an enum one with top-level `case` statements).
>
>     enum Suit: Int {
>         case Hearts, Spades, Diamonds, Clubs
>
>         static var all = [ Hearts, Spades, Diamonds, Clubs ]
>
>         var description: String {
>         case .Hearts:
>             return "♥️"
>         case .Spades:
>             return "♠️"
>         case .Diamonds:
>             return "♦️"
>         case .Clubs:
>             return "♣️"
>         }
>
>         var isRed: Bool {
>         case .Hearts, .Diamonds:
>             return true
>         case .Spades, .Clubs:
>             return false
>         }
>     }
>
> * Allow you to attach member definitions to particular cases. It would
> be an error if they didn't all define the same members, unless there
> was a top-level catchall.
>
>     enum Suit: Int {
>         var isRed: Bool { return false }
>
>         case Hearts {
>             let description: String { return "♥️" }
>             let isRed: Bool { return true }
>         }
>         case Spades {
>             let description: String { return  "♠️" }
>         }
>         case Diamonds {
>             let description: String { return  "♦️" }
>             let isRed: Bool { return true }
>         }
>         case Clubs {
>             let description: String { return  "♣️" }
>         }
>
>         static var all = [ Hearts, Spades, Diamonds, Clubs ]
>     }
>
> Any thoughts? This has, to be honest, bothered me since approximately
> the third day I used the language; I'd love to address it sooner or
> later.

Type-switching is a “feature” of enums. If you don't want it, you could
consider using protocols instead :-)

-- 
Dave