Pomijanie niejawne powraca w Swift

Question

Rozważmy następujący zestaw funkcji:

func testFunc(someFunc: (Int[]) ->()) { 
    someFunc([1, 2, 3]) 
} 

func someFunc<T>(arr : T[]) -> T[] { 
    return arr 
} 

func someOtherFunc<T>(arr : T[]) { 
    println(arr) 
} 

// case 1 - ERROR 
testFunc() { 
    someFunc($0) 
} 

// case 2 - no error 
testFunc() { 
    println("whatever") 
    someFunc($0) 
} 

// case 3 - no error 
testFunc() { 
    someOtherFunc($0) 
} 

Wygląda jak w przypadku 1, Swift stara się niejawnie powrócić z zamknięciem od funkcji someFunc() zwraca wartość. Robi to tylko wtedy, gdy w zamknięciu znajduje się tylko jedna linia (Implicit Returns from Single-Expression Closures) - dlatego przypadek 2 działa. Nie robi tego, jeśli funkcja, jak w przypadku 3, jest Void, tj. Nie zwraca wartości.

Moje pytanie brzmi, czy istnieje sposób, aby powstrzymać to zachowanie, tak, że mogę mieć funkcję z wartością zwracaną jako jedno-wierszowe wyrażenie w zamknięciu, które nie ma wartości zwracanej.

Answer 1

UPDATE: Po Swift 1.2, nie jest to już problem

Ten błąd nadal istnieje w Xcode beta6, mam nadzieję, że będzie naprawione w wersji 1.0, przed tym, że jest to obejście

testFunc() { 
    someFunc($0) 

    // The explicit return statement corrects the wrong return type of the auto implicit return. 
    // It makes more sense than printing nonsense strings 
    return //TODO: remove after the bug is fixed 
} 

Answer 2

Oprócz wymienionych rozwiązań:

testFunc { someFunc($0); return() } // returning Void explicitly (with or without parenthesis) 

testFunc { someFunc($0); 42 } // or, indeed, just adding a second expression 

można również spożywać wartość zwracana:

testFunc { let x = someFunc($0) } 

lub po prostu:

testFunc { _ = someFunc($0) } 

Wartość zwracana zawsze musi być typu obiecanej podpisem funkcji, a sprawa niejawna zamian nie jest inaczej. To nie jest błąd. Po prostu niejawne powroty są tak często tak elegancką składnią, że mniej częsty przypadek niedopasowanych typów trochę przełamuje zaklęcie. Nie oznacza to, że ładne syntaktyczne rozwiązanie nie byłoby mile widziane, przynajmniej gdy oczekiwane jest Void. Być może coś tak prostego jak:

testFunc { someFunc($0) ; } // with the trailing semicolon 

Kiedy to irytuje mnie najbardziej to, kiedy moja własna funkcja zmusza mnie do tańca wokół niego. Kilka razy uciekam się do wyraźnego ignorowania typu zwrotu:

func testFunc<Ignored>(someFunc: [Int] -> Ignored) { 
    someFunc([1, 2, 3]) 
} 

testFunc { someFunc($0) }