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

  • What is the best primary key strategy for an online/offline multi-client mobile application with SQLite and Azure SQL database as the central store?
  • How can I write a function that will unwrap a generic property in swift assuming it is an optional type?
  • Don't wan't to replacing the old database when app is updated
  • What are the advantages/use cases of optional patterns introduced in swift 2?
  • What is the maximum size of SQLite or Core Data database on iOS?
  • Count Number of Rows in a SQLite Database
  •  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 = { $ { $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.