[swift-evolution] Treating an Enum's Cases as Its Subtypes

[Niels Andriesse]

I'd like to discuss the possibility of treating the cases of a given enum
as if they are subtypes of that enum. This seems like a natural thing to do
because enum cases (especially when they have associated values)
effectively define a closed set of subtypes.

Doing so would allow for constructions such as the following:

enum Foo {
  case a(name: String)
}

func isA(foo: Foo) -> Bool {
  // The old way:
  if case .a = foo { return true }
  return false
  // The new way:
  return foo is .a
}

func printNameIfFooIsA(foo: Foo) -> Bool {
  // The old way:
  if case let .a(name) = foo {
    print(name)
  }
  // The new way (1):
  if let a = foo as? .a {
    print(a.name)
  }
  // The new way (2):
  if let name = (foo as? .a)?.name {
    print(name)
  }
}

Treating an enum's cases as its subtypes would make enums easier to work
with because handling them would be syntactically the same as handling
other types.

The pattern matching capabilities of enums wouldn't be affected by this
proposal.

Multiple other proposals have already attempted to simplify enum handling
(they have particularly focused on getting rid of "if case" and adding the
ability to treat enum case tests as expressions), but none of the solutions
presented in those proposals have worked out so far.

I believe that this could be the right solution to multiple enum-related
problems that have been brought up repeatedly.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170220/57786229/attachment-0001.html>