Swift编号参数函数的内部原理及自定义实现方法问询

Great question! Let's break down exactly what's going on with those numbered parameters like $0 you see in Swift's map function, and how you can add this handy feature to your own custom functions.

What Are Numbered Parameters Anyway? #

When you write code like values.map { $0 * $0 }, that $0 is Swift's shorthand for the first (and only, in this case) parameter of the closure you're passing to map. Instead of writing the explicit parameter list with in—like { value in value * value }—Swift lets you use $0, $1, $2, etc., to refer to the closure's parameters in order.

This is purely syntactic sugar, but it makes short, single-expression closures much cleaner to write.

How Does This Work Under the Hood? #

The magic here comes down to Swift's type inference system and its support for implicit closure parameters. Let's use map as an example:

First, here's the simplified function signature for map on an array:

func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]

When you pass a closure without an explicit parameter list (no (param) in), Swift looks at the expected type of the closure parameter (transform here is (Element) -> T). It knows the closure takes exactly one parameter of type Element, so it automatically binds that parameter to $0.

Key details about how this works:

• This implicit parameter naming only works when Swift can fully infer the closure's parameter types and count from the surrounding context. For example, if you tried to write let myClosure = { $0 * $0 } without assigning it to a variable with a clear type, Swift would throw an error—it has no way to know what type $0 should be.
• Numbered parameters follow the order of the closure's parameters: $0 is the first, $1 the second, and so on. For a closure that takes two parameters, you'd use $0 and $1 respectively.
• This shorthand is limited to single-expression closures (or closures where the type is fully explicit) because Swift needs a clear path to infer the parameter types without extra hints from you.

Building Your Own Function That Supports Numbered Parameters #

Adding support for numbered parameters to your custom functions is straightforward—you just need to define a function that accepts a closure parameter, and ensure Swift can infer the closure's type from the function's signature.

Example 1: Single-Parameter Closure #

Let's make a function that applies a transformation to a value three times:

func applyThreeTimes<T>(to value: T, using transform: (T) -> T) -> T {
    return transform(transform(transform(value)))
}

// Call it with numbered parameters
let doubledThreeTimes = applyThreeTimes(to: 4, using: { $0 * 2 })
print(doubledThreeTimes) // Output: 32

Here, Swift sees that transform expects a closure that takes one T (which is Int in this case) and returns a T, so it automatically lets you use $0 to refer to that single parameter.

Example 2: Multi-Parameter Closure #

Now let's make a function that combines two values using a custom closure:

func merge<T, U, Result>(_ first: T, _ second: U, with merger: (T, U) -> Result) -> Result {
    return merger(first, second)
}

// Call it with numbered parameters
let mergedString = merge(10, " minutes left", with: { "\($0)\($1)" })
print(mergedString) // Output: "10 minutes left"

Here, the closure takes two parameters (T is Int, U is String), so $0 refers to the first parameter and $1 refers to the second. Swift infers their types from the function's signature and the values we pass in.

Important Note #

If you ever run into a situation where Swift can't infer the closure's type (e.g., if your function's closure parameter is generic in a way that leaves ambiguity), you'll need to fall back to explicit parameter names with in. But as long as the closure's type is clear from context, numbered parameters will work seamlessly.

内容的提问来源于stack exchange，提问作者Balázs Vincze