[swift-evolution] [Proposal] Enums with static stored properties foreach case

[Jānis Kiršteins]

That would replace current enum raw value functionality and I see two
problems with that.

1. A lot of breaking changes
2. Raw values currently are unique values among all cases. That makes
a possibility that enums can be easily serialized/deserialized to
formats like JSON, property lists, etc. In "case mercury = (mass:
3.303e+23, radius: 2.4397e6)" neither mass nor radius is unique value
(it is possible that two different planets could have the same mass as
radius).



On Wed, May 25, 2016 at 3:37 PM, Leonardo Pessoa <me at lmpessoa.com> wrote:
> Hi,
>
> Couldn't this be solved by using tuples? If not because the syntax is not
> allowed I think this would be more coherent to do it using current syntax.
>
> enum Planet : (mass: Float, radius: Float) {
>     case mercury = (mass: 3.303e+23, radius: 2.4397e6)
>     case venus = (mass: 4.869e+24, radius: 6.0518e6)
>     case earth = (mass: 5.976e+24, radius: 6.37814e6)
>     case mars = (mass: 6.421e+23, radius: 3.3972e6)
>     case jupiter = (mass: 1.9e+27, radius: 7.1492e7)
>     case saturn = (mass: 5.688e+26, radius: 6.0268e7)
>     case uranus = (mass: 8.686e+25, radius: 2.5559e7)
>     case neptune = (mass: 1.024e+26, radius: 2.4746e7)
> }
> ________________________________
> From: Jānis Kiršteins via swift-evolution
> Sent: ‎25/‎05/‎2016 08:58 AM
> To: swift-evolution at swift.org
> Subject: [swift-evolution] [Proposal] Enums with static stored properties
> foreach case
>
> Hello everyone,
>
> Currently Swift only supports computed properties for each enum case.
> If you want to somehow get static values with each case you would
> probably do it like this:
>
> enum Planet {
>     case mercury
>     case venus
>     case earth
>     case mars
>     case jupiter
>     case saturn
>     case uranus
>     case neptune
>
>     var mass: Float {
>         switch self {
>         case .mercury: return 3.303e+23
>         case .venus: return 4.869e+24
>         case .earth: return 5.976e+24
>         case .mars: return 6.421e+23
>         case .jupiter: return 1.9e+27
>         case .saturn: return 5.688e+26
>         case .uranus: return 8.686e+25
>         case .neptune: return 1.024e+26
>         }
>     }
>
>     var radius: Float {
>         switch self {
>         case .mercury: return 2.4397e6
>         case .venus: return 6.0518e6
>         case .earth: return 6.37814e6
>         case .mars: return 3.3972e6
>         case .jupiter: return 7.1492e7
>         case .saturn: return 6.0268e7
>         case .uranus: return 2.5559e7
>         case .neptune: return 2.4746e7
>         }
>     }
> }
>
> However I see two problems with this approach:
>
> 1. These value definitions are spread out and difficult to read and
> maintain (especially if you have many computed properties for each
> enum case);
> 2. These values are not static. They are computed each time property
> is accessed. This can be a problem when value is expensive to create.
>
> The proposed solution is to have single static initializer for each
> enum case that initializes stored properties. For example,
>
> enum Planet {
>     var mass: Float
>     var radius: Float
>
>     static init(mass: Float, radius: Float) {
>         self.mass = mass
>         self.radius = radius
>     }
>
>     case mercury where (mass: 3.303e+23, radius: 2.4397e6)
>     case venus where (mass: 4.869e+24, radius: 6.0518e6)
>     case earth where (mass: 5.976e+24, radius: 6.37814e6)
>     case mars where (mass: 6.421e+23, radius: 3.3972e6)
>     case jupiter where (mass: 1.9e+27, radius: 7.1492e7)
>     case saturn where (mass: 5.688e+26, radius: 6.0268e7)
>     case uranus where (mass: 8.686e+25, radius: 2.5559e7)
>     case neptune where (mass: 1.024e+26, radius: 2.4746e7)
> }
>
> This approach do not affect enums that have raw or associated values,
> or custom enum initializers:
>
> case A = "A" where (id: 0)
>
> or
>
> case B(Int, Int, Int) where (id: 0)
>
> Benefits:
> 1. Less verbosity
> 2. Improved readability
> 3. Related values are closer to each other
> 4. Static values are not recomputed
> _______________________________________________
> swift-evolution mailing list
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution