Проверьте, является ли переменная блоком/функцией/вызываемой в Swift

Question

Есть ли простой и определенный способ в Swift, чтобы проверить, является ли что-то вызываемым блоком/функцией? На некоторых языках это тривиально, но, возможно, я смотрю на это с неправильной точки зрения в Свифте? Рассмотрим следующее.

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 знает, что все они являются функциями, хотя таких типов данных нет. Я могу проверить, используя прочную подпись, но может быть ситуация, когда мне не нужна подпись ^* и просто хочу ее вызвать. Например:

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

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

Я могу переписать это так, что будет работать для Void и Bool типов возврата, но делать это для каждого типа ума, тем более, что я не забочусь об этом, но компилятор ...

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 

^* Согласитесь, не заботясь о подписи является грехом. Для аргументации давайте просто не заботимся о возвращаемом типе.

Answer 1

Вы можете проверить строковое представление .dynamicType вызываемого для существования подстроки ->. Не супер-элегантным, но это работает:

func isAClosure<T>(foo: T) -> Bool { 
    return String(foo.dynamicType).containsString("->") 
} 

var a :() ->() = { print("Foobar") } 
var b : (Double) -> (Bool) = { $0 > 0 } 
var c : Int = 1 

isAClosure(a) // true 
isAClosure(b) // true 
isAClosure(c) // false 

Конечно, как Маркус Россель указует в комментариях выше, вы все равно ничего не о параметрах вызываемых знаете (но, возможно, это может быть следующим шагом чтобы узнать, учитывая, что вы знаете, что это можно назвать).

---

Добавление в отношении OPS вопросов ниже: только техническое обсуждение, а не рекомендованных методов.

Вы используете один и тот же подход, что и выше, чтобы проверить, если аргумент функции является замыканием без аргументов (() -> (...)) или один ни с аргументами, ни тип возвращаемого значения (() ->()), и так далее. Используя этот подход, вы можете определить общую функцию, вызывающую аргумент, присланный функции, только если он имеет определенный тип замыкания. Для этого «in-function-call» вам нужно будет использовать преобразование типа в ожидаемый тип закрытия, как описано выше в вашем Q. Вероятно, будет трудно обойти этот «не общий» подход w.r.t. , вызывающий закрытие. Ниже приводятся несколько примеров.

/* Example functions */ 
func isAVoidParamClosure<T>(foo: T) -> Bool { 
    let bar = String(foo.dynamicType).componentsSeparatedByString(" -> ") 
    return bar.count > 1 && (bar.first?.characters.count ?? 0) == 2 
} 

func callIfVoidVoidClosure<T>(foo: T) { 
    let bar = String(foo.dynamicType).componentsSeparatedByString(" -> ") 
    if bar.count > 1 && !(bar.map{ $0 == "()" }.contains(false)) { 
     if let foo = foo as?() ->() { 
      foo() 
     } 
    } 
} 

func isASingleDoubleReturnTypeClosure<T>(foo: T) -> Bool { 
    let bar = String(foo.dynamicType).componentsSeparatedByString(" -> ") 
    return bar.count > 1 && bar[1] == "Double" 
     /* rhs of '&&' lazily evaluated: [1] ok */ 
} 

func printTwoTimesResultOfVoidDoubleClosure<T>(foo: T) { 
    if isAVoidParamClosure(foo) && isASingleDoubleReturnTypeClosure(foo) { 
     if let foo = foo as?() -> Double { 
      let a: Double = 2*foo() 
      print(a) 
     } 
    } 
} 

Пример вызовов:

/* Example calls */ 
let a :() ->() = { print("Foobar") } 
let b : (Double) -> (Bool) = { $0 > 0 } 
let c :() -> Double = { 21.0 } 
let d : Int = 1 

isAVoidParamClosure(a) // true 
isAVoidParamClosure(b) // false 
isAVoidParamClosure(c) // true 
isAVoidParamClosure(d) // false 

callIfVoidVoidClosure(a) // Prints "Foobar" 
callIfVoidVoidClosure(b) 
callIfVoidVoidClosure(c) 
callIfVoidVoidClosure(d) 

printTwoTimesResultOfVoidDoubleClosure(a) 
printTwoTimesResultOfVoidDoubleClosure(b) // Prints "42.0" 
printTwoTimesResultOfVoidDoubleClosure(c) 
printTwoTimesResultOfVoidDoubleClosure(d)