I wanted to ask why I'm able to do this:
let x = [Int].Element.self
But not this:
let x: [Int].Element = 1
Seems inconsistent to me
Also, this doesn't work either (unlike the array example), introducing even more inconsistency:
let x = Int?.Wrapped.self
Is this deliberate or a bug, and if it's deliberate, what's the rationale behind all of this?
Thank you in advance for your answers
That is bizarre. Made even more so by the fact that this works:
let x: Array<Int>.Element = 1
The grammar for types outside of expressions is actually quite clear on this (Types — The Swift Programming Language (Swift 5.7))
Although I agree that it should be possible, it's acceptable that it indeed isn't and only nominal types ("type identifiers") partake in the
I just don't quite understand how types are parsed inside of expressions, since it doesn't seem to completely follow those rules.
This is not a bug, but a historical hole in the language, that we 'potentially can fix'.
This works because
Element is an associated type from a protocol that
Array conforms to which exposes the type.
That does not work because Swift currently does not allow 'qualified lookup' in this context.
let x: Optional<Int>.Wrapped = ... // will error out
Please check this discussion: Allow Member Lookup to Find Generic Parameters
Based on the diagnostics output, I feel fairly confident that this is just a bug. Have you tried filing a bug report?