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

[Matthew Johnson]

> On Feb 20, 2017, at 2:38 PM, Joe Groff <jgroff at apple.com> wrote:
> 
>> 
>> On Feb 20, 2017, at 7:32 AM, Matthew Johnson via swift-evolution <swift-evolution at swift.org <mailto:swift-evolution at swift.org>> wrote:
>> 
>>> 
>>> On Feb 20, 2017, at 12:40 AM, Niels Andriesse via swift-evolution <swift-evolution at swift.org <mailto:swift-evolution at swift.org>> wrote:
>>> 
>>> 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 <http://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.
>> 
>> I would like to see enum cases treated as subtypes of the enum type.  This is an interesting way to refer to the type of a case.  Unfortunately I don’t think it will work if we accept the proposal to give cases a compound name.  If we do that the name of this case becomes `a(name:)` which is not a valid type name.
> 
> I think there are definitely places where having cases be a subtype of an enum make sense, but I don't think it makes sense for *all* cases to be subtypes. For example, with "biased" containers like Optional and Result, it makes sense for the "right" side to be a subtype and the "wrong" side to be explicitly constructed, IMO.  If the types of cases overlap, it would also be *ambiguous* which case ought to be constructed when the payload is converted to the enum type

Identical case types would definitely be a problem but I don’t think overlapping case types are always a problem.  I imagine this conversion working the same as any other ordinary overload resolution for ad-hoc overloads.

For example let’s assume the numeric types have the desired subtype relationships and I have the following enum for which the cases are subtypes of the enum itself and are given the types of the associated value payloads.  This example uses the syntax I used in my value subtyping manifesto for anonymous cases that are subtypes of the enum:

enum FixedInt {
   case -> Int8
   case -> Int16
   case -> Int32
   case -> Int64
}

let fixedInt = Int8(42)   // resolves to `FixedInt.int8(42)`

Now imagine `FixedInt` does not include the `Int8` case:

let fixedInt = Int8(42)   // resolves to `FixedInt.int16(42)`

I don’t see how this is different than:

func foo(_ int8: Int8) {}
func foo(_ int16: Int16) {}
func foo(_ int16: Int16) {}
func foo(_ int16: Int16) {}

foo(Int16(42))

As long as value subtyping follows the same overload resolution rules that are used for classes and protocol existentials the right thing happens.

If there is no case with the exact type is getting converted the nearest ancestor type is preferred.  In the case of a non-linear type hierarchy (as we already have in protocols) if the overloads available to choose from do not form a strictly linear order *then* we do have ambiguity.  In that case it would need to be resolve manually by explicitly specifying which case is intended.

This doesn’t seem like a problem to me - just ordinary overload resolution.


> —remember that enums are sums, not unions, and that's important for composability and uniform behavior with generics.

I’ve always thought of enums as nominal discriminated unions.  Maybe I’m using the wrong terminology.  Can you elaborate on the difference between sums and unions?  When you say union are you talking about the kind of thing some people have brought up in the past where any members in common are automatically made available on the union type?

> I would be fine allowing enum subtyping with some opt-in attribute, e.g.:
> 
> enum Optional<Wrapped> {
>   sub case some(wrapped)
>   case none
> }
> 
> enum Result<Wrapped> {
>   sub case ok(wrapped)
>   case error(Error) // not a subtype
> }
> 
> enum JSON {
>   // OK for these to all be sub-cases, since they don't overlap
>   sub case string(String), number(Double), array([JSON]), object([String: JSON]), null
> }
> 
> enum Either<T, U> {
>   // Error: sub cases potentially overlap
>   sub case left(T), right(U)
> }

Why can’t we defer the error?  `Either<Int, String>` should be allowed but `Either<Int, Int>` should be an error.

Alternatively, if we agree that overlapping is allowed and overload resolution is used then we could introduce a `!=` constraint to verify correctness at the declaration of `Either`:

enum Either<T, U> where T != U { … }

> 
> -Joe

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170220/bb95539c/attachment.html>