Blog

Some codes and contents are sourced from Apple’s official documentation. This post is for personal notes where I summarize the original contents to grasp the key concepts

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/declarations/#Rethrowing-Functions-and-Methods

What is rethrows in Swift?

A function or method can be declared with the rethrows keyword to indicate that it throws an error only if one of its function parameters throws an error. These functions and methods are known as rethrowing functions and rethrowing methods. Rethrowing functions and methods must have at least one throwing function parameter.

Apple

Let’s check Foundation’s map function. A transform is a rethrowing function parameter.

It means transform function can throwing an error.

A rethrowing function or method can contain a throw statement only inside a catch clause. This lets you call the throwing function inside a do–catch statement and handle errors in the catch clause by throwing a different error. In addition, the catch clause must handle only errors thrown by one of the rethrowing function’s throwing parameters. For example, the following is invalid because the catch clause would handle the error thrown by alwaysThrows().

A throwing method can’t override a rethrowing method, and a throwing method can’t satisfy a protocol requirement for a rethrowing method. That said, a rethrowing method can override a throwing method, and a rethrowing method can satisfy a protocol requirement for a throwing method.

Apple

alwaysThrows function is not a function parameter. In a someFunction, only callback function parameter can throwing a error.

enum SomeError: Error {
    case error
}

enum AnotherError: Error {
    case error
}

func alwaysThrows() throws {
    throw SomeError.error
}

Example 1. This one it working fine.

func someFunction(callback: () throws -> Void) rethrows {
    do {
        try callback()
    } catch {
        throw AnotherError.error
    }
}

Example 2. This one also working fine

func someFunction(callback: () throws -> Void) rethrows {
    try callback()
}

Example 3. This one compile error (A function declared ‘rethrows’ may only throw if its parameter does)

func someFunction(callback: () throws -> Void) rethrows {
    do {
        try alwaysThrows()
    } catch {
        throw AnotherError.error
    }
}

Because alwaysThrows function is not a part of someFunction’s parameter.

Example 4. Use try in a closure

When you use try in a closure, You should marked try someFunction

try someFunction {
    let decoder = JSONDecoder()
    try decoder.decode(String.self, from: Data())
    print("someFunction")
}

Example 5. Call a closure without using try

If you don’t use try in a closure, It’s okay not marking try at someFuntion.

If I change rethrows to throws in the example above, what happens?

There is a compile error. Always use try keyword when you call a someFunction.

Let’s make a customMap using rethrows keyword.

Built-In map function uses rethrows keyword.

var input = [1, 2, 3, 4, 5]

extension Array {
    func customMap<T>(_ transform: ((Element) throws -> T)) rethrows -> [T] {
        var result = [T]()
        for item in self {
            let transformedValue = try transform(item)
            result.append(transformedValue)
        }
        return result
    }
}

let output = input.customMap { item in
    "\(item)"
}

let output2 = input.map { item in
    "\(item)"
}

map itself uses try keyword. Because It allows users to use try in a closure. It we are not using try keyword in a closure we can simply use it without try keyword.

Some codes and contents are sourced from Apple’s official documentation. This post is for personal notes where I summarize the original contents to grasp the key concepts

https://developer.apple.com/documentation/foundation/runloop

Your code provides the control statements used to implement the actual loop portion of the run loop—in other words, your code provides the while or for loop that drives the run loop. Within your loop, you use a run loop object to “run” the event-processing code that receives events and calls the installed handlers.

A run loop receives events from two different types of sources. Input sources deliver asynchronous events, usually messages from another thread or from a different application. Timer sources deliver synchronous events, occurring at a scheduled time or repeating interval. Both types of source use an application-specific handler routine to process the event when it arrives.

Figure 3-1 shows the conceptual structure of a run loop and a variety of sources. The input sources deliver asynchronous events to the corresponding handlers and cause the runUntilDate: method (called on the thread’s associated NSRunLoop object) to exit. Timer sources deliver events to their handler routines but do not cause the run loop to exit.

In addition to handling sources of input, run loops also generate notifications about the run loop’s behavior. Registered run-loop observers can receive these notifications and use them to do additional processing on the thread. You use Core Foundation to install run-loop observers on your threads.

The following sections provide more information about the components of a run loop and the modes in which they operate. They also describe the notifications that are generated at different times during the handling of events.

https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html

RunLoop.mode

common

When you add an object to a run loop using this mode, the runloop monitors the object when running in any of the common modes. For details about adding a runloop mode to the set of common modes,

Apple

default

• for handling input sources

perform a task

RunLoop.current.perform {
    print("Hello RunLoop")
}

RunLoop.main.perform {
    print("Hellow?")
}

current

• Returns the run loop for the current thread.

main

• Returns the run loop of the main thread.

Add Timer to run a code at specific time

class RunLoopTest {
    var timer: Timer!
    init() {
        let date = Date.now.addingTimeInterval(5)
        
        //After 5 secs from not, timer will fire an event, every 2 seconds It run a function
        timer = Timer(
            fireAt: date,
            interval: 2,
            target: self,
            selector: #selector(run),
            userInfo: ["time": date],
            repeats: true
        )
        RunLoop.main.add(timer, forMode: .common)
    }
    
    @objc func run() {
        print("Hellow? : \(timer.userInfo)")
    }
    
    func stop() {
        timer.invalidate()
    }
}

RunLoopTest()

//Prints
Hellow? : Optional({
    time = "2024-03-11 15:25:30 +0000";
})
Hellow? : Optional({
    time = "2024-03-11 15:25:30 +0000";
})
Hellow? : Optional({
    time = "2024-03-11 15:25:30 +0000";
})

Run a timer in a RunLoop while scrolling the table

import UIKit

class ViewController: UIViewController {
    var timer: Timer!
    var firedCount = 0
    
    lazy var tableView: UITableView = {
       let tableView = UITableView()
        tableView.dataSource = self
        tableView.register(UITableViewCell.self, forCellReuseIdentifier: "cell")
        return tableView
    }()
    
    lazy var items: [Int] = {
       var items = [Int]()
        for i in 0...1000 {
            items.append(i)
        }
        return items
    }()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        timer = Timer(
            fireAt: Date.now.addingTimeInterval(5),
            interval: 0.2,
            target: self,
            selector: #selector(run),
            userInfo: nil,
            repeats: true
        )
        RunLoop.main.add(timer, forMode: .default)
        tableView.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(tableView)
        NSLayoutConstraint.activate([
            tableView.topAnchor.constraint(equalTo: view.topAnchor),
            tableView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            tableView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
        ])
    }
    
    @objc func run() {
        print("🔥 timer fired: \(firedCount)")
        firedCount += 1
    }
}

extension ViewController: UITableViewDataSource {
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        items.count
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "cell", for: indexPath)
        cell.textLabel?.text = "\(items[indexPath.row])"
        return cell
    }
}

//Prints
🔥 timer fired: 0

🔥 timer fired: 1

🔥 timer fired: 2

🔥 timer fired: 3
🔥 timer fired: 4
🔥 timer fired: 5
🔥 timer fired: 6

Example 1. RunLoop Mode is defaults

Above the code, timer starts after 5 secs. And I scrolling the table for 20 secs.

Example 2. Changed RunLoop Mode to common

Now I understand what RunLoop mode is…

When you use default mode, timer might not fired if user touching the screens. defaults mode handles Input source.

Useful Foundation APIs

swapAt

• swap the value in an array by passing the index

Bubble Sort

func bubbleSort(input: inout [Int]) {
    for i in 0..<input.count {
        for j in 1..<input.count {
            if input[j] < input[j - 1] {
                input.swapAt(j, j-1)
            }
        }
    }
}

var input = [4, 5, 2, 1, 6, 8, 9, 12, 13]
bubbleSort(input: &input)

Every steps compares 2 values and swapped it

Red = Sorted Item

Time complexity is O(n^2)

Space complexity is O(1)

Insertion Sort

Apple Foundation uses TimSort (InsertionSort + MergeSort)

Insertion Sort is another O(N^2) quadratic running time algorithm

On large datasets it is very inefficient – but on arrays with 10-20 items it is quite good. (Apple uses TimSort, It items is less than 64 then use Insertion Sort. -> https://github.com/apple/swift/blob/387580c995fc9844d4f268723bd55e22440b1a3d/stdlib/public/core/Sort.swift#L462)

A huge advantage is that it is easy to implement

It is more efficient than other quadratic running time sorting procedures such as bubble sort or selection sort

It is an adaptive algorithm – It speeds up when array is already substantially sorted

It is stable so preserves the order of the items with equal keys

Insertion sort is an in-place algorithm – does not need any additional memory

It is an online algorithm – It can sort an array as it receives the items for example downloading data from web

Hybrid algorithms uses insertion sort if the subarray is small enough: Insertion sort is faster for small subarrays than quicksort

Variant of insertion sort is shell sort

Sometimes selection sort is better: they are very similar algorithms

Insertion sort requires more writes because the inner loop can require shifting large sections of the sorted portion of the array

In general insertion sort will write to the array O(N^2) times while selection sort will write only O(N) times

For this reason selection sort may be preferable in cases where writing to memory is significantly more expensive than reading (such as with flash memory)

https://www.udemy.com/course/algorithms-and-data-structures-in-java-part-ii/learn/lecture/4901832#questions

func insertSort(_ input: inout [Int]) {
    var i = 1
    for i in 1..<input.count {
        var j = i
        while j-1 >= 0, input[j] < input[j-1] {
            input.swapAt(j, j-1)
            j-=1
        }
    }
}
var input = [-9, 4, -9, 5, 8, 12]
insertSort(&input)
print(input)


var input2 = [-9, 4, -9, 5, 8, 12, -249, 241, 4, 2, 12, 24140, 539, 3, 0, -2314]
insertSort(&input2)
print(input2)

Merge Sort

Divide and Conquer

Break down into small subproblem, Use recursion.

It needs two functions

• split – divide into two array
• merge – merging two array into the sorted array

func mergeSort(input: inout [Int]) {
    //Base case
    if input.count == 1 {
        return
    }
    let midIndex = input.count / 2
    var left = Array(repeating: 0, count: midIndex)
    var right = Array(repeating: 0, count: input.count - midIndex)
    
    //Split into 2 sub array (create sub problems)
    split(input: &input, left: &left, right: &right)
    
    //Recursive - Divide and Conquer
    mergeSort(input: &left)
    mergeSort(input: &right)
    
    //Merge all together
    merge(input: &input, left: &left, right: &right)
}

func split(input: inout [Int], left: inout [Int], right: inout [Int]) {
    let leftCount = left.count
    for (index, item) in input.enumerated() {
        if index < leftCount {
            left[index] = item
        }
        else {
            right[index - leftCount] = item
        }
    }
}

func merge(input: inout [Int], left: inout [Int], right: inout [Int]) {
    var mergeIndex = 0
    var leftIndex = 0
    var rightIndex = 0
    
    while (leftIndex < left.count && rightIndex < right.count) {
        if left[leftIndex] < right[rightIndex] {
            input[mergeIndex] = left[leftIndex]
            leftIndex += 1
        }
        else if rightIndex < right.count {
            input[mergeIndex] = right[rightIndex]
            rightIndex += 1
        }
        mergeIndex += 1
    }
    if leftIndex < left.count {
        while mergeIndex < input.count {
            input[mergeIndex] = left[leftIndex]
            mergeIndex += 1
            leftIndex += 1
        }
    }
    if rightIndex < right.count {
        while mergeIndex < input.count {
            input[mergeIndex] = right[rightIndex]
            mergeIndex += 1
            rightIndex += 1
        }
    }
}

Split Function

Calculate midIndex

Split them into two subarray

Time complexity: O(nlogn)

Space complexity: O(n)

• Because It needs a copy values when merging two array into the one sorted array

Quick Sort

func partition(_ input: inout [Int], low: Int, high: Int) -> Int {
    let pivot = input[low]
    var l = low
    var h = high
    while l < h {
        while (input[l] <= pivot && l < h) {
            l += 1
        }
        while (input[h] > pivot) {
            h -= 1
        }
        if l < h {
            input.swapAt(l, h)
        }
    }
    //Put pivot to the right position
    input.swapAt(low, h)
    return h
}

func quickSort(_ input: inout [Int], low: Int, high: Int) {
    //base
    if low >= high {
        return
    }
    //pivot
    let pivot = partition(&input, low: low, high: high)
    
    //left
    quickSort(&input, low: low, high: pivot - 1)

    //right
    quickSort(&input, low: pivot + 1, high: high)
}

var input = [2, 3, 1, 4, 9]
quickSort(&input, low: 0, high: input.count - 1)
print(input)

Quick Sort is also Divide and Conquer.

Time Complexity

• Average Time Complexity is O(nlogn)

Space Complexity

• O(logn) -> Extra space for the call stack in the recursive call
• O(n) -> worst case

Binary Search

Search a sorted list!

//Binary Search
func findIndex(array: [Int], value: Int) -> Int {
    var min = 0
    var max = array.count - 1
    
    while min <= max {
        let mid = min + (max - min) / 2
        
        if value == array[mid] {
            return mid
        }
        //search right side
        if value > array[mid] {
            min = mid - 1
        }
        //search left side
        else {
            max = mid + 1
        }
    }
    return -1
}

let sortedArray = Array(0...100)
findIndex(array: sortedArray, value: 49)
findIndex(array: sortedArray, value: 78)
findIndex(array: sortedArray, value: 22)
findIndex(array: sortedArray, value: 89)

✍️ Note

All the codes and contents are sourced from Apple’s official documentation. This post is for personal notes where I summarize the original contents to grasp the key concepts

Apple documents

DispatchQueue

QoS (Quality of Service)

• UserInteractive
  • Animations, event handling, or updates to your app’s user interface.
  • User-interactive tasks have the highest priority on the system. Use this class for tasks or queues that interact with the user or actively update your app’s user interface. For example, use this class for animations or for tracking events interactively.
• UserInitiated
  • Prevent the user from actively using your app
  • User-initiated tasks are second only to user-interactive tasks in their priority on the system. Assign this class to tasks that provide immediate results for something the user is doing, or that would prevent the user from using your app. For example, you might use this quality-of-service class to load the content of an email that you want to display to the user.
• Default
  • Default tasks have a lower priority than user-initiated and user-interactive tasks, but a higher priority than utility and background tasks. Assign this class to tasks or queues that your app initiates or uses to perform active work on the user’s behalf.
• Utility
  • Utility tasks have a lower priority than default, user-initiated, and user-interactive tasks, but a higher priority than background tasks. Assign this quality-of-service class to tasks that do not prevent the user from continuing to use your app. For example, you might assign this class to long-running tasks whose progress the user does not follow actively.
• Background
  • Background tasks have the lowest priority of all tasks. Assign this class to tasks or dispatch queues that you use to perform work while your app is running in the background.

let concurrentQueue = DispatchQueue(label: "concurrent", qos: .userInitiated, attributes: 
.concurrent)
let serialQueue = DispatchQueue(label: "serial", qos: . userInitiated)

Example 1. Perform async tasks on serialQueue

for i in 0...3 {
  serialQueue.async {
    print("serial task(\(i)) start")
    sleep(1)
    print("serial task(\(i)) end")
  }
}

//prints
serial task(0) start
serial task(0) end

serial task(1) start
serial task(1) end

serial task(2) start
serial task(2) end

serial task(3) start
serial task(3) end

It’s make sense because serialQueue can run a one task at a time.

Example 2. Perform sync tasks on serialQueue

for i in 0...3 {
  serialQueue.sync {
    print("serial task(\(i)) start")
    sleep(1)
    print("serial task(\(i)) end")
  }
}

//prints
serial task(0) start
serial task(0) end

serial task(1) start
serial task(1) end

serial task(2) start
serial task(2) end

serial task(3) start
serial task(3) end

Results are the same as example 1

Submits a work item for execution on the current queue and returns after that block finishes executing.

https://developer.apple.com/documentation/dispatch/dispatchqueue/2016083-sync

Example 3. Perform a sync task on the concurrentQueue

for i in 0...3 {
  concurrentQueue.sync {
    print("concurrent task(\(i)) start")
    sleep(1)
    print("concurrent task(\(i)) end")
  }
}

//Prints
concurrent task(0) start
concurrent task(0) end

concurrent task(1) start
concurrent task(1) end

concurrent task(2) start
concurrent task(2) end

concurrent task(3) start
concurrent task(3) end

Example 4. Perform a async task on the concurrentQueue

for i in 0...3 {
  concurrentQueue.async {
    print("concurrent task(\(i)) start")
    sleep(1)
    print("concurrent task(\(i)) end")
  }
}

//Prints
concurrent task(0) start
concurrent task(3) start
concurrent task(1) start
concurrent task(2) start

concurrent task(0) end
concurrent task(1) end
concurrent task(3) end
concurrent task(2) end

Schedules a work item for immediate execution, and returns immediately.

https://developer.apple.com/documentation/dispatch/dispatchqueue/2016103-async

It immediate execution and returns immediately.

Example 5. Perform async task on the concurrentQueue and sync task on the serialQueue

for i in 0...3 {
  concurrentQueue.async {
    print("concurrent task(\(i)) start")
    sleep(1)
    print("concurrent task(\(i)) end")
  }
            
  serialQueue.sync {
    print("serial task(\(i)) start")
    sleep(1)
    print("serial task(\(i)) end")
  }
}

//Prints
concurrent task(0) start
serial task(0) start
serial task(0) end
serial task(1) start
concurrent task(1) start
concurrent task(0) end
concurrent task(1) end
serial task(1) end
serial task(2) start
concurrent task(2) start
serial task(2) end
serial task(3) start
concurrent task(3) start
concurrent task(2) end
serial task(3) end
concurrent task(3) end

Example 6. Run async tasks on the concurrentQueue and serialQueue

for i in 0...3 {
   concurrentQueue.async {
     print("concurrent task(\(i)) start")
     sleep(1)
     print("concurrent task(\(i)) end")
   }

   serialQueue.async {
     print("serial task(\(i)) start")
     sleep(1)
     print("serial task(\(i)) end")
   }
}

//Prints
concurrent task(0) start
concurrent task(2) start
concurrent task(3) start
serial task(0) start
concurrent task(1) start
concurrent task(3) end
concurrent task(0) end
concurrent task(2) end
serial task(0) end
concurrent task(1) end
serial task(1) start
serial task(1) end
serial task(2) start
serial task(2) end
serial task(3) start
serial task(3) end

As you can see a SerialQueue run a task and returned when task has finished either perform it on sync or async.

What about dispatchQueue.main.async?

for i in 0...3 {
  DispatchQueue.main.async {
    print("main task(\(i)) start")
    sleep(1)
    print("main task(\(i)) end")
  }
}

//Prints
main task(0) start
main task(0) end

main task(1) start
main task(1) end

main task(2) start
main task(2) end

main task(3) start
main task(3) end

The dispatch queue associated with the main thread of the current process.

The system automatically creates the main queue and associates it with your application’s main thread. Your app uses one (and only one) of the following three approaches to execute blocks submitted to the main queue:

• Calling dispatchMain()
• Starting your app with a call to UIApplicationMain(_:_:_:_:) (iOS) or NSApplicationMain(_:_:)(macOS) 
• Using a CFRunLoop on the main thread

As with the global concurrent queues, calls to suspend(), resume(), dispatch_set_context(_:_:), and the like have no effect when used on the queue in this property.

https://developer.apple.com/documentation/dispatch/dispatchqueue/1781006-main

As the results, It is not returns immediately like a concurrent queue. Because It’s a serial queue. You can check it on Xcode.

What about dispatchQueue.global().async?

for i in 0...3 {
  DispatchQueue.global().async {
    print("global task(\(i)) start")
    sleep(1)
    print("global task(\(i)) end")
  }
}

//Prints
global task(3) start
global task(2) start
global task(0) start
global task(1) start

global task(1) end
global task(0) end
global task(3) end
global task(2) end

This method returns a queue suitable for executing tasks with the specified quality-of-service level. Calls to the suspend(), resume(), and dispatch_set_context(_:_:) functions have no effect on the returned queues.

Tasks submitted to the returned queue are scheduled concurrently with respect to one another

https://developer.apple.com/documentation/dispatch/dispatchqueue/2300077-global

🤯 When function is returned?

It’s a good example for understanding sync vs async.

Before look at the example, let’s remind

Dispatch queues are FIFO queues to which your application can submit tasks in the form of block objects. Dispatch queues execute tasks either serially or concurrently. Work submitted to dispatch queues executes on a pool of threads managed by the system. Except for the dispatch queue representing your app’s main thread, the system makes no guarantees about which thread it uses to execute a task.

You schedule work items synchronously or asynchronously. When you schedule a work item synchronously, your code waits until that item finishes execution. When you schedule a work item asynchronously, your code continues executing while the work item runs elsewhere.

https://developer.apple.com/documentation/dispatch/dispatchqueue

ConcurrentQueue with sync

runWorkItem function is returned when after finishing the sync task.

ConcurrentQueue with async

runWorkItem function returned and then async task starts

SerialQueue with async

DispatchQueue.main.async

Custom Serial DispatchQueue

SerialQueue with sync but what if a submitted task is delayed?

Keep in mind

Work submitted to dispatch queues executes on a pool of threads managed by the system. Except for the dispatch queue representing your app’s main thread, the system makes no guarantees about which thread it uses to execute a task.

https://developer.apple.com/documentation/dispatch/dispatchqueue

sync -> block will run and returned when task finished

async -> block will immediately returned when task started

	sync	async	when function returned?
SerialQeueue	wait until task finished	wait until task finished	either sync or async it returned when after task finished
ConcurrentQueue	wait until task finished	immediately return when task started	sync: it returned after task finished async: it returned before task finished

✍️ Note

All the codes and contents are sourced from Apple’s official documentation. This post is for personal notes where I summarize the original contents to grasp the key concepts

Apple document

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

Check Strong Reference Count

Example 1

var person = Person(name: "Shawn") //1
CFGetRetainCount(person) //2

Example 2

CFGetRetainCount(Person(name: "Shawn") //1

Example 3

var person = Person(name: "Shawn") //2
var person2 = person //3
var person3 = person //4

CFGetRetainCount(person) //4

As you can see when you initiate an object, the retain count is 1. And when you assign it, retain count will be counting up.

Strong Reference Cycle between classes

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}


class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

Example 1

var person = Person(name: "Shawn")
var apt = Apartment(unit: "3")

CFGetRetainCount(person) //2
CFGetRetainCount(apt) //2

Example 2 (🔥 Strong Reference Cycle)

var person = Person(name: "Shawn")
var apt = Apartment(unit: "3")

person.apartment = apt
apt.tenant = person

CFGetRetainCount(person) //3 (apt.tenant -> count up)
CFGetRetainCount(apt) //3 (person.apartment -> count up)

✅ Solution -> weak / unowned

What is weak reference and when to use it?

Use a weak reference when the other instance has a shorter lifetime — that is, when the other instance can be deallocated first.

Apple – https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

ARC automatically sets a weak reference to nil when the instance that it refers to is deallocated. And, because weak references need to allow their value to be changed to nil at runtime, they’re always declared as variables, rather than constants, of an optional type.

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}


class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

What is unowned reference and when to use it?

In contrast, use an unowned reference when the other instance has the same lifetime or a longer lifetime. Unlike a weak reference, an unowned reference is expected to always have a value. As a result, marking a value as unowned doesn’t make it optional, and ARC never sets an unowned reference’s value to nil.

Important

Use an unowned reference only when you are sure that the reference always refers to an instance that hasn’t been deallocated.

If you try to access the value of an unowned reference after that instance has been deallocated, you’ll get a runtime error.

Apple – https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name) is being deinitialized") }
}


class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

Example 1

var customer: Customer! = Customer(name: "Shawn")
customer.card = CreditCard(number: 7788_9999_1223_1225, customer: customer)

CFGetRetainCount(customer) //2 (because CreditCard's customer is defined as unowned let)

customer = nil

//Shawn is being deinitialized
//Card #7788999912231225 is being deinitialized 

unowned(unsafe)

Swift also provides unsafe unowned references for cases where you need to disable runtime safety checks — for example, for performance reasons. As with all unsafe operations, you take on the responsibility for checking that code for safety. You indicate an unsafe unowned reference by writing unowned(unsafe). If you try to access an unsafe unowned reference after the instance that it refers to is deallocated, your program will try to access the memory location where the instance used to be, which is an unsafe operation.

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

When you access the unowned(unsafe), It try to access the memory location where the instance used to be

when use unowned, error type is different.

Unowned Optional References

You can mark an optional reference to a class as unowned. In terms of the ARC ownership model, an unowned optional reference and a weak reference can both be used in the same contexts. The difference is that when you use an unowned optional reference, you’re responsible for making sure it always refers to a valid object or is set to nil.

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

class Department {
    var name: String
    var courses: [Course]
    init(name: String) {
        self.name = name
        self.courses = []
    }
}


class Course {
    var name: String
    unowned var department: Department
    unowned var nextCourse: Course?
    init(name: String, in department: Department) {
        self.name = name
        self.department = department
        self.nextCourse = nil
    }
}

Example

var department: Department! = Department(name: "Horticulture")

let intro = Course(name: "Survey of Plants", in: department)
var intermediate: Course! = Course(name: "Growing Common Herbs", in: department)
var advanced: Course = Course(name: "Caring for Tropical Plants", in: department)

intro.nextCourse = intermediate
intermediate.nextCourse = advanced
department.courses = [intro, intermediate, advanced]

//Deinit department and intermediate
department = nil
intermediate = nil

//Try to access nextCourse
intro.nextCourse //SIGABRT Error

Unlike weak, when you try to access the deallocated object, It causes a crash issue. Even you set it as unowned optionals.

Unowned References and Implicitly Unwrapped Optional Properties

class Country {
    let name: String
    var capitalCity: City! //Unwrapped Optional Properties
    init(name: String, capitalName: String) {
        self.name = name
        //At this point, Country already initiated. So can pass self to City initializer
        self.capitalCity = City(name: capitalName, country: self)
    }
}


class City {
    let name: String
    unowned let country: Country //Unowned References
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
}

var capitalCity: City!

• It’s initial value is nil

Above the example is Two-Phased initialization

🤔 Strong Reference Cycles for Closures

It’s such an important topic.

A strong reference cycle can also occur if you assign a closure to a property of a class instance, and the body of that closure captures the instance. This capture might occur because the closure’s body accesses a property of the instance, such as self.someProperty, or because the closure calls a method on the instance, such as self.someMethod(). In either case, these accesses cause the closure to “capture” self, creating a strong reference cycle.

This strong reference cycle occurs because closures, like classes, are reference types. When you assign a closure to a property, you are assigning a reference to that closure. In essence, it’s the same problem as above — two strong references are keeping each other alive. However, rather than two class instances, this time it’s a class instance and a closure that are keeping each other alive.

Swift provides an elegant solution to this problem, known as a closure capture list

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

class HTMLElement {
    let name: String
    let text: String?

    lazy var asHTML: () -> String = {
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())

//Deallocate HTMLElement
paragraph = nil // Can't deallocate it because the reference cycle between property (asHTML) and closure's capture list

Even though the closure refers to self multiple times (self.text and self.name), it only captures one strong reference to the HTMLElement instance.

Apple

Resolving Strong Reference Cycles for Closures

Use weak or unowned at capture lists

Defining a capture list

Each item in a capture list is a pairing of the weak or unowned keyword with a reference to a class instance (such as self) or a variable initialized with some value (such as delegate = self.delegate). These pairings are written within a pair of square braces, separated by commas.

Place the capture list before a closure’s parameter list and return type if they’re provided:

Apple

lazy var someClosure = {
        [unowned self, weak delegate = self.delegate]
        (index: Int, stringToProcess: String) -> String in
    // closure body goes here
}


lazy var someClosure2 = {
        [unowned self, weak delegate = self.delegate] in
    // closure body goes here
}

🔥 Think it again, weak vs unowned in Closures

Define a capture in a closure as an unowned reference when the closure and the instance it captures will always refer to each other, and will always be deallocated at the same time.

Conversely, define a capture as a weak reference when the captured reference may become nil at some point in the future. Weak references are always of an optional type, and automatically become nil when the instance they reference is deallocated. This enables you to check for their existence within the closure’s body.

Apple

class HTMLElement {
    let name: String
    let text: String?
    //Use unowned self to break reference cycle
    lazy var asHTML: () -> String = {
            [unowned self] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

Capture value from nested Closure

class Test {}
DispatchQueue.global().async {
  let test = Test()
   print("closure A: Start retain count is: \(CFGetRetainCount(test))")
   DispatchQueue.global().async {
     print("nested closure B retainCount: \(CFGetRetainCount(test))")
   }
   print("closure A: End")
}

//Prints
closure A: Start retain count is: 2
closure A: End
nested closure B retainCount: 3

As you can see nested closure also counting up ARC.

But… what about this example?

test object was already deallocated. And when you trying to access test, It should not be nil because It’s unowned.

Conclusion

Understanding How ARC works is very important to avoid memory leaks and crash issues. It’s also good to know what happens when objects are deallocated and How ARC handles those objects.