Swift：重用闭包定义（带有typealias）

Question

I'm trying to do create some closure definitions which I'm gonna use a lot in my iOS app. So I thought to use a typealias as it seemed the most promising ...

I did a small Playground example which shows my issue in 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})

Am I missing something or is it just not supported in Swift? Thanks

EDIT/ADDITION:

The above is just a simple example. In real life my typealias is more complicated. Something like:

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

I basically want to use a typealias as a shortcut so I don't have to type that much. Maybe typealias isn't the right choice... Is there another?

Answer 1

You aren't rewriting the typealias declaration in this code, you're declaring the parameters and return type:

AnonymousFunction({(another: Int) -> Bool in return another < 0})

Happily, Swift's type inference lets you use any of the following - pick the style that feels best to you:

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 }

Answer 2

I don't think you'll be able to do what you want. To simplify your example slightly, you can do this:

typealias NamedCheck = (number: Int) -> Bool
let f: NamedCheck = { $0 < 5 }
f(number: 1)
NamedFunction(f)

NamedFunction( { $0 < 5 } as NamedCheck)

But you can't do what you want, which is to rely on the fact that the tuple arg is called number to refer to it inside the closure without giving it as part of the closure:

// compiler error, no idea what "number" is
let g: NamedCheck = { number < 5 }

Bear in mind that you can name the parameter without giving it a type (which is inferred from the type of g ):

let g: NamedCheck = { number in number < 5 }

but also, you can name it whatever you want:

let h: NamedCheck = { whatevs in whatevs < 5 }
NamedFunction(h)

Here's what I think is happening (this is partly guesswork). Remember how functions can have external and internal argument names:

func takesNamedArgument(#namedArg: Int) { etc... }

Or, to write it longhand:

func takesNamedArgument(namedArg namedArg: Int) { etc... }

But you can also give as the second, internal, name whatever you like:

func takesNamedArgument(namedArg whatevs: Int) { etc... }

I think this is what is happening with the closures with named tuples. The "external" name is "number", but you must give it an "internal" name too, which is what you must use in the function body. You can't make use of the external argument within your function. In case of closure expressions, if you don't give an internal name, you can use $0 etc, but you can't just skip it, any more than you can skip the internal name altogether and just rely on the external name when defining a regular function.

I was hoping that I could prove this theory by the following:

let f = { (#a: Int, #b: Int)->Bool in a < b }

resulting in f being of type (a: Int, b: Int)->Bool) . This compiles, as does:

let g = { (number1 a: Int, number2 b: Int)->Bool in a < b }

but it doesn't look like the external names for the argument make it out to the type of f or g .

Answer 3

The syntax to create a closure is:

{ (parameters) -> return type in
    statements
}

What's at the left of in is the closure signature (parameters and return value). In some cases the signature can be omitted or simplified when type inference is able to determine the number of parameters and their type, and the return value.

In your case it doesn't work because you are passing a type alias, but it is interpreted as a parameter name. The 3 lines work if either you:

1. name the parameter properly

    NamedFunction({number in return number < 0}) AnonymousFunction({number in return number < 0}) 

2. use shorthand arguments:

    NamedFunction({ return $0 < 0}) AnonymousFunction({ return $0 < 0}) 

3. use shorthand arguments and implicit return:

    NamedFunction({ $0 < 0}) AnonymousFunction({ $0 < 0})