Subtle cast warning when using SQLite.Swift … Binding? to Any

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

  • Getting Optional(“”) when trying to get value from KeyChain
  • How to efficient insert and fetch UUID in Core Data
  • Objective-C and sqlite's DATETIME type
  • Swift Optional of Optional
  • Why does Swift's optional binding succeed with 'nil' in certain cases?
  • BWDB SQLite wrapper for iOS ARC issues
  •  r = Array(stmt)
    

    gives Expression implicitly coerced from ‘Binding?’ to Any.

    enter image description here

    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 …

    enter image description here

    … 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?

    Solutions Collect From Internet About “Subtle cast warning when using SQLite.Swift … Binding? to Any”

    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 } }
    

    enter image description here

    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.