[swift-evolution] [Pitch] Small bit of sugar for enum case with Void associated value

[Robert Bennett]

Currently if you have the following enum:

enum E<T> {
	case c(T)
}

then if T is Void, you have to write one of the following:

let x: E<Void> = .c(Void())
let y: E<Void> = .c(())

Looks awkward, no? In this case you can omit `<Void>` after `E` because it can be inferred, but if writing a (non-generic) function taking an argument of type `E<Void>`, then the `<Void>` cannot be omitted, and you still have to write `.c(())` for the case name.

I’m proposing that for enum cases with a single associated value of Void type, or of a generic type that is equal to Void in some instance, you may omit the parentheses altogether and merely write

let x: E<Void> = .c

The rationale is twofold: first, double parentheses just looks bad; second, there is only a single value of type Void, which means the associated value of `.c` is trivially inferable, and hence should be omissible.

I am not proposing that a bare `E.c` imply a type of `E<Void>` — `E.c` should still be illegal in the absence of specification of the generic type — only that when the type is known to be `E<Void>`, `.c` can replace `.c(())`.

Thoughts?
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170725/033a1678/attachment.html>