Why does Swift4 cast an array of UIButton! to [UIButton?] type?

Question

I met a strange issue today. Please look at this code:

class A {

    var button1: UIButton!
    var button2: UIButton!

    func foo() {
        let array = [button1, button2]
    }
}

Xcode says that array is [UIButton?] type. For some reason Swift4 casts UIButton! elements to UIButton?. Why?

Why are you force unwrapping with `!`? Are you trying to create an array of non-optional UIButtons? Typically unwrapping using `!` is only used if the object is nil at the time the class is initialized, but will be definitely initialized later. — Stephen, Jan 03 '18 at 16:38
@KamilHarasimowicz You cannot have a `[UIButton!]` – as per [SE-0054](https://github.com/apple/swift-evolution/blob/master/proposals/0054-abolish-iuo.md), `T!` is no longer a distinct type; it's now the same type as `T?` but it allows an attribute to be attached to a declaration (such as a property) allowing it to be force unwrapped in certain circumstances. Compare https://stackoverflow.com/q/38849549/2976878, https://stackoverflow.com/q/39537177/2976878, https://stackoverflow.com/q/39633481/2976878 & — Hamish, Jan 03 '18 at 16:41
@Stephen Let's assume that `button1` and `button2` are outlets and `foo()` function will customize them. — Kamil Harasimowicz, Jan 03 '18 at 16:41
Are you sure that your buttons in the array are really optionals? Or is just the type of the array [UIButton?]. — Retterdesdialogs, Jan 03 '18 at 16:42
@Retterdesdialogs buttons are optionals. I checked it by using `forEach` method. — Kamil Harasimowicz, Jan 03 '18 at 16:43
@KamilHarasimowicz Ok, it makes sense in the case that these are IBOutlets. Several of the answers below explain well, but I believe vadian's comment above is the correct solution. — Stephen, Jan 03 '18 at 16:45
@Stephen I know a solution I looking for explanation. Hamish's answer helps me the most. :) — Kamil Harasimowicz, Jan 03 '18 at 16:48

Milan Nosáľ · Accepted Answer · 2018-11-29T09:18:38.367

EXPLANATION

ImplicitlyUnwrappedOptional is not a distinct type, rather a normal Optional with an attribute declaring its value may be implicitly forced (based on SE-0054):

However, the appearance of ! at the end of a property or variable declaration's type no longer indicates that the declaration has IUO type; rather, it indicates that (1) the declaration has optional type, and (2) the declaration has an attribute indicating that its value may be implicitly forced. (No human would ever write or observe this attribute, but we will refer to it as @_autounwrapped.) Such a declaration is referred to henceforth as an IUO declaration.

Thus when you use this:

let array = [button1, button2]

The compiler derives the array type to [UIButton?], because the type of the button1 and button2 is Optional<UIButton>, not ImplicitlyUnwrappedOptional<UIButton> (even if only one of the buttons was optional, it would derive the optional type).

Read more in SE-0054.

Side note:

This behavior is not really related to arrays, in the following example the type of button2 will be derived to UIButton? even though there is the ! and there is a value set in button:

var button: UIButton! = UIButton()

func foo() {
    let button2 = button // button2 will be an optional: UIButton?
}

SOLUTION

If you want to get an array of unwrapped type, you have two options:

First, as Guy Kogus suggested in his answer, use explicit type instead of letting swift derive it:

let array: [UIButton] = [button1, button2]

However, if per chance one of the buttons contains nil, it will cause Unexpectedly found nil crash.

While by using implicitly unwrapped optional instead of optional (! instead of ?) you are claiming that there never will be nil in those buttons, I would still prefer the second safer option suggested by EmilioPelaez in his comment. That is to use flatMap (compactMap in Swift 4+) which will filter out nils, if there are any, and will return an array of unwrapped type:

let array = [button1, button2].flatMap { $0 }

Something I would add to this answer is that if you have an array of optionals, you can use `array.flatMap { $0 }` and it will become an array of non-optionals where the `nil` values have been stripped of the array. — EmilioPelaez, Jan 03 '18 at 23:53
@EmilioPelaez thanks for suggestion for improvement, I've elaborated it in the answer — Milan Nosáľ, Jan 04 '18 at 06:46

JeremyP · Answer 2 · 2018-01-03T16:56:17.047

7

Because UIButton! is not a type, or rather it is a UIButton? with some conventions. The ! means always implicitly unwrap the optional. The following

 var x: UIButton!
 // Later
 x.label = "foo"

Is syntactic sugar for

 var x: UIButton?
 // Later
 x!.label = "foo"

When you create an array of them. The compiler has the choice of implicitly unwrapping them and inferring [UIButton] or leaving them as optional and inferring [UIButton?]. It goes for the safer of the two options.

edited Jan 03 '18 at 16:56

answered Jan 03 '18 at 16:44

JeremyP

84,577
15
123
161

Im not the author of the post, but the last sentence make it clear to me :) Thank you – Retterdesdialogs Jan 03 '18 at 16:46
I think in the second snippet should be `var x: UIButton?` Am I correct? – Kamil Harasimowicz Jan 03 '18 at 16:49

score 1 · Answer 3 · answered Jan 03 '18 at 16:37

Swift is playing it safe by assuming them to be optionals, rather than unwrapping them by default, since they can technically be nil. If you try to explicitly mark them as implicitly-unwrapped like this

let array: [UIButton!] = [button1, button2]

you will receive the following error:

error: implicitly unwrapped optionals are only allowed at top level and as function results

In that case, if you want them to be unwrapped then just define it as

let array: [UIButton] = [button1, button2]

score 1 · Answer 4 · answered Sep 12 '18 at 08:46

I'm finding Swift blog as really the best source for such changes so:

Before Swift 4:

A mental model many people have for implicitly unwrapped optionals is that they are a type, distinct from regular optionals. In Swift 3, that was exactly how they worked: declarations like var a: Int? would result in a having type Optional, and declarations like var b: String! would result in b having type ImplicitlyUnwrappedOptional.

Swift 4

The new mental model for IUOs is one where you consider ! to be a synonym for ? with the addition that it adds a flag on the declaration letting the compiler know that the declared value can be implicitly unwrapped.

In other words, you can read String! as “this value has the type Optional and also carries information saying that it can be implicitly unwrapped if needed”.

This mental model matches the new implementation. Everywhere you have T!, the compiler now treats it as having type T? , and adds a flag in its internal representation of the declaration to let the type checker know it can implicitly unwrap the value where necessary.

All the quotes taken from Swift blog

Why does Swift4 cast an array of UIButton! to [UIButton?] type?

4 Answers4

Linked

Related