Swift: die Wiederverwendung einer Schließung definition (mit typealias)

Ich versuche zu tun, erstellen eine Schließung Definitionen, die ich bin gonna verwenden eine Menge in meiner iOS-app. So dachte ich, ein typealias wie es schien die vielversprechendste ...

Habe ich einen kleinen Spielplatz Beispiel, das zeigt mein Problem im detail

//Here are two tries for the Closure I need
typealias AnonymousCheck = (Int) -> Bool
typealias NamedCheck = (number: Int) -> Bool

//This works fine
var var1: AnonymousCheck = {
    return $0 > 0
}
var1(-2)
var1(3343)

//This works fine
var var2: NamedCheck = {
    return $0 > 0
}
var2(number: -2)
var2(number: 12)

//But I want to use the typealias mainly as function parameter!
//So:

//Use typealias as function parameter
func NamedFunction(closure: NamedCheck) {
    closure(number: 3)
}
func AnonymousFunction(closure: AnonymousCheck) {
    closure(3)
}

//This works as well
//But why write again the typealias declaration?
AnonymousFunction({(another: Int) -> Bool in return another < 0})
NamedFunction({(another: Int) -> Bool in return another < 0})

//This is what I want... which doesn't work
//ERROR: Use of unresolved identifier 'number'
NamedFunction({NamedCheck in return number < 0})

//Not even these work
//ERROR for both: Anonymous closure arguments cannot be used inside a closure that has exlicit arguments
NamedFunction({NamedCheck in return $0 < 0})
AnonymousFunction({AnonymousCheck in return $0 < 0})

Bin ich etwas fehlt oder es einfach nicht unterstützt Swift?
Dank

EDIT/ERGÄNZUNG:

Das oben ist nur ein einfaches Beispiel. Im realen Leben meine typealias ist komplizierter. So etwas wie:

typealias RealLifeClosure = (number: Int, factor: NSDecimalNumber!, key: String, upperCase: Bool) -> NSAttributedString

Ich im Grunde verwenden möchten typealias als Verknüpfung, so dass ich nicht geben, dass viel. Vielleicht typealias ist nicht die richtige Wahl... gibt es eine andere?

InformationsquelleAutor Soko | 2015-01-06

9

Sind Sie nicht umschreiben der typealias Erklärung in diesem code sind Sie der Deklaration der Parameter und Rückgabetyp:
```
AnonymousFunction({(another: Int) -> Bool in return another < 0})
```
Glücklich, Swift, Typ-Inferenz, können Sie eine der folgenden Optionen verwenden - wählen Sie den Stil, die am besten fühlt sich für Sie:
```
AnonymousFunction( { (number: Int) -> Bool in number < 0 } )
AnonymousFunction { (number: Int) -> Bool in number < 0 }
AnonymousFunction { (number) -> Bool in number < 0 }
AnonymousFunction { number -> Bool in number < 0 }
AnonymousFunction { number in number < 0 }
AnonymousFunction { $0 < 0 }
```
- Ja OK, ich bin deklarieren die Parameter und den Rückgabetyp. Aber es wäre schön, wenn ich könnte die Art alias hab ich schon definiert, das zu tun. Das ist, was ich bin im Grunde nach...
- Denken Sie an Ihre Art alias wie ein type - es kann nicht zu den eigentlichen Parametern, die den Gültigkeitsbereich, die Schließung, es definiert nur, was Sie sind. Es ist der Unterschied zwischen number und Int im let number: Int = 3.
- OK... ich bekomme, was du meinst. Haben Sie einen Blick auf meine änderung der obwohl Frage. Ich dachte nur, ich könnte mit einem typealias, mir das zu ersparen-Typisierung komplexe Verschlüsse die ganze Zeit. Aber es scheint, ich kann das nicht tun.
- Ich habe das bekommen, was Sie zu tun versuchen, aber ich denke, das beste, was Sie gehen, um zu vermeiden, dass die Typen der Argumente – Sie werden nicht in der Lage zu vermeiden, benennen Sie Sie. Da aber die Typen sind viel mehr ein Schmerz - /Unordnung (ich denke, es ist wahrscheinlich vernünftiger, Typ { number, factor, key in ... } als sich auf Namen, die an anderer Stelle definierten) es ist nicht so schlimm.
- Genau das, was @AirspeedVelocity sagte. Und vergessen Sie nicht, wenn Sie nicht brauchen, einen bestimmten parameter, Sie können es ignorieren, die mit einem Unterstrich: { number, _, _, _ in ... }.
InformationsquelleAutor Nate Cook
7

Ich glaube nicht, dass Sie werde in der Lage sein, das zu tun, was Sie wollen. Zur Vereinfachung Ihrer Beispiel etwas, können Sie dies tun:
```
typealias NamedCheck = (number: Int) -> Bool
let f: NamedCheck = { $0 < 5 }
f(number: 1)
NamedFunction(f)

NamedFunction( { $0 < 5 } as NamedCheck)
```
Aber Sie können nicht tun, was Sie wollen, und das ist auf die Tatsache stützen, dass das Tupel arg aufgerufen wird number zu finden, um es innerhalb der Schließung, ohne es als Teil der Schließung:
```
//compiler error, no idea what "number" is
let g: NamedCheck = { number < 5 }
```
Beachten Sie, dass Sie können die Namen der parameter, ohne dass eine Art (die abgeleitet ist von der Art der g):
```
let g: NamedCheck = { number in number < 5 }
```
aber auch, man kann es nennen, was Sie wollen:
```
let h: NamedCheck = { whatevs in whatevs < 5 }
NamedFunction(h)
```
Hier ist was ich denke passiert ist (dies ist zum Teil Spekulation). Denken Sie daran, wie Funktionen können externen und internen argument-Namen:
```
func takesNamedArgument(#namedArg: Int) { etc... }
```
Oder, um es zu schreiben longhand:
```
func takesNamedArgument(namedArg namedArg: Int) { etc... }
```
Aber Sie können auch als die zweite, innere, name, was auch immer Sie mögen:
```
func takesNamedArgument(namedArg whatevs: Int) { etc... }
```
Ich denke, das ist, was passiert mit den Verschlüssen mit benannten Tupel. Die "externen" name "Nummer", aber Sie muss es geben, einen "internen" Namen, das ist, was Sie verwenden müssen, die in der Funktion Körper. Sie können nicht machen, verwenden Sie das externe argument innerhalb der Funktion. Im Falle der Schließung Ausdrücke, wenn Sie nicht geben Sie einen internen Namen, die Sie verwenden können $0 etc, aber kann man nicht einfach überspringen, mehr, als Sie können überspringen Sie den internen Namen ganz und ausschließlich auf den externen Namen bei der Definition einer regulären Funktion.

Ich hatte gehofft, dass ich beweisen könnte, diese Theorie durch Folgendes:
```
let f = { (#a: Int, #b: Int)->Bool in a < b }
```
was in f Typ (a: Int, b: Int)->Bool). Dies stellt, wie:
```
let g = { (number1 a: Int, number2 b: Int)->Bool in a < b }
```
aber es sieht nicht wie die externen Namen für das argument machen es sich die Art der f oder g.

InformationsquelleAutor Airspeed Velocity
3

Die syntax zum erstellen einer Schließung ist:
```
{ (parameters) -> return type in
    statements
}
```
Was auf der linken Seite der in ist der Verschluss Signatur (Parameter und Rückgabewert). In einigen Fällen kann die Signatur weggelassen werden, oder vereinfacht, wenn Typ-Inferenz ist in der Lage, um zu bestimmen, die Anzahl der Parameter und Ihr Typ, und der Rückgabewert.

In Ihrem Fall es nicht funktioniert, weil Sie auf der Durchreise sind eine Art alias, aber es wird so ausgelegt, dass Sie einen parameter name. Die 3 Zeilen funktionieren, wenn Sie entweder:
1. Namen der parameter richtig
```
NamedFunction({number in return number < 0})
AnonymousFunction({number in  return number < 0})
```
2. verwenden Sie die Kurzform Argumente:
```
NamedFunction({ return $0 < 0})
AnonymousFunction({ return $0 < 0})
```
3. verwenden Sie die Kurzform Argumente und impliziter return:
```
NamedFunction({ $0 < 0})
AnonymousFunction({ $0 < 0})
```
- Dank Antonio. Was möchte ich erreichen mit der typealias zu verkürzen meine Eingabe. Der real-life-Verschluss ist sehr viel komplexer als in dem Beispiel. Siehe meine änderung/Ergänzung der ursprünglichen Frage...
InformationsquelleAutor Antonio

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.