¿Hay una manera simple y definida en Swift para verificar si algo es un bloque / función invocable? En algunos idiomas es algo trivial, pero ¿tal vez estoy mirando esto desde una perspectiva incorrecta en Swift? Considera lo siguiente.

func foo(){ print("foo") }
var bar: () -> () = { print("bar") }
var baz: () -> (Bool) = { print("baz"); return true }

print(foo) // (Function)
print(bar) // (Function)
print(baz) // (Function)

print(foo is () -> ()) // true
print(bar is () -> ()) // true
print(baz is () -> ()) // false
print(baz is () -> (Bool)) // true

Swift sabe que todas son funciones, aunque no existe ese tipo de datos. Puedo verificar usando una firma sólida, pero puede haber una situación en la que no me importa la firma* y simplemente quiero invocarlo. Por ejemplo:

func call(callable: () -> ()) {
    callable()
}

call(foo) // foo
call(bar) // bar
call(baz) // error: cannot convert value of type '() -> (Bool)' to expected argument type '() -> ()'

Puedo reescribirlo así, lo que funcionará paraVoid yBool devolver tipos, pero hacer esto para cada tipo es una locura, especialmente porque no me importa, pero el compilador sí ...

func call(callable: Any) {
    if let block: () -> () = callable as? () -> () {
        block()
    } else if let block: () -> (Bool) = callable as? () -> (Bool) {
        block()
    }
}

call(foo) // foo
call(bar) // bar
call(baz) // truely baz

* De acuerdo, no preocuparse por la firma es un pecado. Por el bien de la discusión, no nos preocupemos por el tipo de retorno.