Subtle cast warning when using SQLite.Swift … Bind

Question

Here's one,

 import SQLite

    var r:[[Any]] = []

    do {
        if let stmt = try local.db?.prepare(q) {
            r = Array(stmt)
        }
        else {
            print("woe in sql?")
        }
    }
    catch { return [] }

the call

 r = Array(stmt)

gives Expression implicitly coerced from 'Binding?' to Any.

And indeed, I do not know how to Provide a default value to avoid this warning, Force-unwrap the value to avoid this warning, or even Explicitly cast to Any with 'as Any' to silence this warning. :O

Here's a self-contained example that reproduces the same warning:

struct Binding {}

struct Statement : IteratorProtocol, Sequence {
    func next() -> [Binding?]? {
        return nil
    }
}

let stmt = Statement()

let r: [[Any]]

r = Array(stmt) // warning: Expression implicitly coerced from 'Binding?' to Any.

---

Related interesting question:

Why does the compiler ...

... appear to not know the line number, with problems like this? And indeed: why does the warning only arise once you compile?

Most warnings appear right there in the IDE as you're typing, before compilation.

This warning would appear to (a) only be known during compiling and (b) the compiler doesn't know the line number.

How so? What's the difference?

Answer 1

You're using Array's sequence initialiser, which has the signature:

init<S>(_ s: S) where S : Sequence, Element == S.Iterator.Element

Because you typed r as [[Any]], Element is [Any]. However, the sequence you're passing in has an Iterator.Element type of [Binding?]. Therefore, you're implicitly coercing Binding? to Any, and as per SE-0140, this will invoke a warning – as you're losing the optionality of the inner elements, which is potentially undesirable.

As the proposal says, one way to silence this warning is to add an explicit as Any cast. In your case, this can be achieved by using a nested map(_:):

r = stmt.map { $0.map { $0 as Any } }

This shouldn't be any more costly than using Array's sequence initialiser due to the fact that a walk over all the inner elements will have to be done in either case, due to the difference in how Swift stores abstract-typed values (see this Q&A for more info).

However, really you should be asking yourself whether r should be of type [[Any]]. I see no reason why you shouldn't just type it as [[Binding?]]. Doing so will both get rid of the warning and give you better type-safety.