What does $0 and $1 mean in Swift Closures?

Question

let sortedNumbers = numbers.sort { $0 > $1 }
print(sortedNumbers)

Can anyone explain what $0 and $1 means in Swift?

Another Sample

array.forEach {
    actions.append($0)
}

score 150 · Accepted Answer · answered Mar 22 '16 at 00:51

150

$0 is the first parameter passed into the closure. $1 is the second parameter, etc. That closure you showed is shorthand for:

let sortedNumbers = numbers.sort { (firstObject, secondObject) in 
    return firstObject > secondObject
}

answered Mar 22 '16 at 00:51

AdamPro13

7,232
2
30
28

Can i write my own logic in a closure using first parameter and second? – aashish tamsya Mar 22 '16 at 01:00
6

Yep, that's the entire purpose of the closure. – AdamPro13 Mar 22 '16 at 01:12
2

thanks mate, your answer helped me understand the better part of closures – aashish tamsya Mar 22 '16 at 03:28

Andy Jazz · Answer 2 · 2023-06-30T07:20:24.630

TL;DR

Swift 5.9

$0 and $1 are closure’s first and second Shorthand Argument Names (SAN for short) or implicit parameter names, if you like. The shorthand argument names are automatically provided by Swift. The first argument is referenced by $0, the second argument is referenced by $1, the third one by $2, and so on.

As you know, a Closure is a self-contained block of functionality (a function without name) that can be passed around and used in your code. Closure has different names in other programming languages as well as slight differences in meaning – it's Lambda in Python and Kotlin, or it's Block in C and Objective-C.

Shortening a closure

Let's assume that we have an array with four elements and we need to sort these elements in reverse alphabetical order. We will create a backward(..) method that will pass its content to the higher order function sorted(..). However, the usage of a closure in this case is the most practical. Let's see how it works.

let coffee: [String] = ["Cappuccino", "Espresso", "Latte", "Ristretto"]

1. Regular method as argument of a Higher Order Function

func backward(_ n1: String, _ n2: String) -> Bool {
    return n1 > n2
}
var reverseOrder = coffee.sorted(by: backward)


/* RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"] */

2. Full closure expression

reverseOrder = coffee.sorted { 
    (n1: String, n2: String) -> Bool in return n1 > n2 
}

3. Inferring Type from context in a closure with an implicit return

reverseOrder = coffee.sorted { n1, n2 in n1 > n2 }

4. Shorthand Argument Names

reverseOrder = coffee.sorted { $0 > $1 }

/* $0 and $1 are closure’s first and second String arguments. */

5. Operator methods

reverseOrder = coffee.sorted(by: >)

/* RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"] */

Higher Order Function with closure

let companies = ["bmw", "kfc", "ibm", "htc"]

let uppercased = companies.map { 
    (item: String) -> String in return item.uppercased() 
}

print(uppercased)

/* RESULT: ["BMW", "KFC", "IBM", "HTC"] */

Shorthand Argument Name $0

let uppercased = companies.map { $0.uppercased() }

print(uppercased)

/* RESULT: ["BMW", "KFC", "IBM", "HTC"] */

Full closure expression with remainder operator (a.k.a. modulo)

let numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

let filteredNumbers = numbers.filter { 
    (arg: Int) -> Bool in return (arg % 2) == 0 
}

print(filteredNumbers)

/* RESULT: [2, 4, 6, 8, 10] */

Shorthand Argument Name with remainder operator

let numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

let filteredNumbers = numbers.filter { ($0 % 2) == 0 }

print(filteredNumbers)

/* RESULT: [2, 4, 6, 8, 10] */

SAN in variadic functions

Variadic functions are ones that accept any number of parameters. One of the most famous variadic methods is print(...). Shorthand Argument Names are perfect for variadic functions.

fileprivate func dessert(_ fruits: String...) -> Bool {

    return fruits.contains { $0 == "Apple" }
}

let contains = dessert("Mango", "Durian", "Papaya")

print(contains)

/* RESULT:  false */

$0 for existential Sequence type

Here, allSatisfy() method indicates whether every element of a sequence satisfies a given predicate or not. The Any type represents values of any type. Existential any type is used for storing an any kind of value which conforms to a specific protocol. Also, I used here a shorthand syntax for optional binding (shadowing an existing constant).

let inputData: [Any]? = [1, 2, 3, "Hello"]

func satisfiesOrNot(_ inputData: any Sequence) -> Bool {
    inputData.allSatisfy { $0 is Int }
}

if let inputData {
    satisfiesOrNot(inputData)
}

/* RESULT:  false */

Repeating $0

let cubedNumber = { $0 * $0 * $0 } (25)

print(cubedNumber)

/* RESULT:  25^3 = 15625 */

$0 in closure capturing

Swift method can return a closure, that is capable of capturing some value.

func trainer(_ said: String) -> ((String) -> String) {
    return {
        return "¡\(said) \($0)!"
    }
}

let announcement = trainer("Bienvenido a mis cursos")
announcement("RealityKit 2023")

/* RESULT:  "¡Bienvenido a mis cursos RealityKit 2023!"  */

Shorthand Argument Names $0, $1, $2

let math: (Int8, Int8, Int8) -> Int8 = { $0 + $1 - $2 }

func feedClosure() -> (Int8, Int8, Int8) -> Int8 {
    return math
}
feedClosure()(10, 20, 100)

/* RESULT:  (10 + 20 - 100) = -70 */

SANs $0, $1, $2, $3, $4

let factorial = { $0 * $1 * $2 * $3 * $4 } (1, 2, 3, 4, 5)

print(factorial)

/* RESULT:  5! = 120 */

Key path expression

Starting from Swift 5.2+ you can access parameters of every instance via key path expression:

struct Lighter {
    let manufacturer: String
    let refillable: Bool
}

let zippo = Lighter(manufacturer: "Zippo", refillable: true)
let cricket = Lighter(manufacturer: "Cricket", refillable: false)

let lighters: [Lighter] = [zippo, cricket]

let refillableOnes = lighters.map(\.refillable)

print(refillableOnes)

/* RESULT:  [true, false] */

Of course, you can alternatively use a familiar syntax:

Regular syntax – $0.property:

let refillableOnes = lighters.map { $0.refillable }

print(refillableOnes)

/* RESULT:  [true, false] */

SAN with a subscript

(If you want to know how to implement negative indexing in arrays, read this post please.)

let arrays: [[String]] = [["Hello","Hola","你好"], ["world","mundo","世界"]]

let helloWorld = arrays.compactMap { $0[0] }

print(helloWorld)

/* RESULT:  ["Hello", "world"] */

One more example with key shortcut (Swift 5.6) and a subscript:

let dictionaries: [[_ : Any?]] = [[1: "x"], [2: nil], [3: true]]

let values = dictionaries.compactMap { $0[$0.startIndex].value }

print(values) 

/* RESULT:  ["x", true] */

Or look at the example of unordered set:

let collection: Set<String> = ["One", "", "Three"]

collection.map {
    switch $0.isEmpty {
        case true:
            print("Empty")
        case false:
            print("Element \($0) isn't empty")
    }
}

/*   RESULT:   "Element Three isn't empty"  */
/*             "Empty"                      */
/*             "Element One isn't empty"    */

SAN in a completion handler

let completionHandler: ((Bool) -> Void)? = {
    if $0 {
        print("It is true, sister...")
    } else {
        print("False")
    }
}
completionHandler?(true)

/* RESULT:  It is true, sister... */

Regular syntax, however, is as following:

let completionHandler: ((Bool) -> Void)? = { sayTheTruth in
    if sayTheTruth {
        print("It is true, sister...")
    } else {
        print("False")
    }
}
completionHandler?(false)

/* RESULT:  False */

SAN in ForEach structure in SwiftUI

let columns: [GridItem] = Array(repeating: .init(.fixed(70)), count: 5)

var body: some View {
    ScrollView {
        LazyVGrid(columns: columns) {
            ForEach((1...10), id: \.self) {

                Text("\($0)").frame(maxWidth: .infinity)
            }
        }
    }
}

/*   RESULT:   1  2  3  4  5   */
/*             6  7  8  9  10  */

Operator method vs SAN

Operator Method:

let records: [Int] = [110, 108, 107, 109, 108]

public func averageSpeed(records: [Int]) throws -> Int {
    let average = records.reduce(0, +) / records.count
    return average
}
try averageSpeed(records: records)

/* RESULT:  108 */

Shorthand Argument Names $0 and $1:

public func averageSpeed(records: [Int]) throws -> Int {
    let average = records.reduce(0) { $0 + $1 } / records.count
    return average
}
try averageSpeed(records: records)

/* RESULT:  108 */

$0 as the resulting value

.onChanged and .onEnded modifiers perform an @escaping closure when a SwiftUI gesture changed or ended.

@State private var rotate: Angle = .zero

var myGesture: some Gesture {
    RotationGesture()
        .onChanged { rotate = $0 }
        .onEnded { angle in rotate = angle }
}

var body: some View {
    Rectangle()
        .rotationEffect(rotate)
        .gesture(myGesture)
}

Closure as array's element

var closureArray: [() -> Void] = []
var counter: Int = 0

for _ in 1...2 {
    closureArray.append {
        counter += 1
        print(counter)
    }
}

closureArray.forEach { $0() }
closureArray.forEach { closure in closure() }

/*  RESULT:  */

/*     1     */
/*     2     */
/*     3     */
/*     4     */

Swift vs Kotlin

Now, let's see how Kotlin's lambda is similar to Swift's closure:

Swift

let element: [String] = ["Argentum","Aurum","Platinum"]

let characterCount = element.map { $0.count }

print(characterCount)

/* RESULT:  [8, 5, 8] */

Kotlin

Kotlin's lambda expression has just one parameter with implicit name: it. In other words, if you have a function literal with exactly one parameter you don’t need to define that parameter explicitly, you can use it instead (like $0 in Swift).

val element = listOf("Argentum","Aurum","Platinum")

val characterCount = element.map { it.length }

println(characterCount)

/* RESULT:  [8, 5, 8] */

Your Python example is needlessly using a lambda. `list(map(len, ....))` would suffice. Personally, unless in a critical performance section, I’d use `[len(v) for v in ...]` because it’s cleaner and more readable. — Martijn Pieters, Aug 30 '20 at 22:02

Bobby · Answer 3 · 2018-01-11T01:43:14.260

33

It represents shorthanded arguments sent into a closure, this example breaks it down:

Swift 4:

var add = { (arg1: Int, arg2: Int) -> Int in
    return arg1 + arg2
}
add = { (arg1, arg2) -> Int in
    return arg1 + arg2
}
add = { arg1, arg2 in
    arg1 + arg2
}
add = {
    $0 + $1
}

let result = add(20, 20) // 40

edited Jan 11 '18 at 01:43

answered Apr 28 '17 at 03:16

Bobby

6,115
4
35
36

7

Since the addition operator has the same function signature as that closure, you can break it down even further to just: `add = (+)` – Samah Jan 31 '18 at 23:13
It should specify the type with `var add:((Int, Int) -> Int) = ...` explicitly for the case 3 and 4, in my swift 5 test. – Itachi Jun 18 '19 at 06:35

score 6 · Answer 4 · answered Mar 22 '16 at 00:52

The refer to the first and second arguments of sort. Here, sort compares 2 elements and order them. You can look up Swift official documentation for more info:

Swift automatically provides shorthand argument names to inline closures, which can be used to refer to the values of the closure’s arguments by the names $0, $1, $2, and so on.

score 4 · Answer 5 · edited Apr 10 '22 at 16:49

4

In Addition with @Bobby's Answer I would like to Add an Example

var add: (Int,Int,Int)->Int
add = {
//So here the $0 is first argument $1 is second argument $2 is third argument
    return $0 + $1 + $2
//The above statement can also be written as $0 + $1 + $2 i.e is return is optional
}

let result = add(20, 30, 40) 
print(result) // Prints 90

edited Apr 10 '22 at 16:49

Nazmul Hasan

10,130
7
50
73

answered Aug 14 '19 at 07:40

BharathRao

1,846
1
18
28

1

this cannot count as an answer. If you want to add an example, simply edit @bobby's answer – aashish tamsya Aug 15 '19 at 08:26
1

haha - i actually voted this up, but then, I stopped reading after the first paragraph with the closure definition. I agree, this isn't an answer, its a transcription of the entire Swift doc on closures. – mobibob May 09 '21 at 19:12

score 2 · Answer 6 · answered Mar 22 '16 at 00:54

It is shorthand argument names.