Unterdrück Implizite Returns in Swift

Question

den folgenden Satz von Funktionen vor:

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

Es sieht aus wie in Fall 1, Swift versucht implizit, da die Funktion von der Schließung zurück someFunc() einen Wert zurückgibt. Dies wird nur ausgeführt, wenn nur eine Zeile in der Closure vorhanden ist (Implizite Rückgabe von Closures für Einzelausdrücke). Aus diesem Grund funktioniert case 2. Dies geschieht nicht, wenn die Funktion wie in Fall 3 Void ist, d. H. Sie gibt keinen Wert zurück.

Meine Frage ist, ob es eine Möglichkeit gibt, dieses Verhalten zu unterdrücken, so dass ich eine Funktion mit einem Rückgabewert als einzeiligen Ausdruck in einem Abschluss haben kann, der keinen Rückgabewert hat.

Answer 1

UPDATE: Nach dem Swift 1.2, ist dies kein Problem mehr

Dieser Fehler wird in Xcode beta6 existiert immer noch, ich hoffe, es wird in der Version 1.0 behoben wird, vor, dass dies ein Problem umgehen,

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

Neben den genannten Lösungen:

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

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

können Sie verbrauchen auch den Rückgabewert:

testFunc { let x = someFunc($0) } 

oder einfach:

testFunc { _ = someFunc($0) } 

Rückgabewert muss immer der durch die Funktion Unterschrift versprochen Typ sein, und der Fall der impliziten Rendite ist nicht anders. Dies ist kein Fehler. Es ist einfach so, dass die impliziten Renditen so oft eine elegante Syntax sind, dass der weniger häufige Fall der nicht übereinstimmenden Typen den Zauber ein wenig bricht. Das soll nicht heißen, dass eine nette syntaktische Lösung nicht zu begrüßen wäre, zumindest wenn Void erwartet wird. Vielleicht etwas so einfach wie:

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

Wenn ich das ärgert am meisten, wenn meine eigene Funktion mich um ihn herum zu tanzen zwingt. Ich habe ein paar Mal darauf zurückgegriffen, den Rückgabetyp explizit zu ignorieren:

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

testFunc { someFunc($0) }