DEV Community: Naveen Ragul B

Swift - Access Control

Naveen Ragul B — Fri, 08 Apr 2022 09:01:15 +0000

Access Control

Access control restricts access to parts of your code from code in other source files and modules.

Specific access levels can be assigned to individual types (classes, structures, and enumerations), as well as to properties, methods, initializers, and subscripts belonging to those types.
Protocols can be restricted to a certain context, as can global constants, variables, and functions.

Modules and Source Files

A module is a single unit of code distribution—a framework or application that’s built and shipped as a single unit and that can be imported by another module with Swift’s import keyword.
A source file is a single Swift source code file within a module.

Access Level

There are 5 different access level for entities in swift.

Open access
Public access
Internal access
File-private access
Private access

Open access and public access enable entities to be used within any source file from their defining module, and also in a source file from another module that imports the defining module.
Open access applies only to classes and class members, and it differs from public access by allowing code outside the module to subclass and override.
Internal access enables entities to be used within any source file from their defining module, but not in any source file outside of that module.
File-private access restricts the use of an entity to its own defining source file.
Private access restricts the use of an entity to the enclosing declaration, and to extensions of that declaration that are in the same file.
Open access is the highest (least restrictive) access level and private access is the lowest (most restrictive) access level.

Principle of Access Levels

No entity can be defined in terms of another entity that has a lower (more restrictive) access level.

A public variable can’t be defined as having an internal, file-private, or private type, because the type might not be available everywhere that the public variable is used.

struct someType {   //implicitly declared as internal
    var someInt : Int
}

public var instance = someType(someInt: 5) // Error : Variable cannot be declared public because its type 'someType' uses an internal type

function can’t have a higher access level than its parameter types and return type, because the function could be used in situations where its constituent types are unavailable to the surrounding code.

Default Access Levels

All entities in your code (with a few specific exceptions) have a default access level of internal if you don’t specify an explicit access level.

For Custom Type :

The access control level of a type also affects the default access level of that type’s members (its properties, methods, initializers, and subscripts).
If a type has access level as private or file private, the default access level of its members will also be private or file private respectively.
If you define a type’s acces level as internal or public, the default access level of the type’s members will be internal.
A public type defaults to having internal members (but can be explicitly set to public), not public members to avoid the internal workings of a type as public API by mistake.

example :

public class SomePublicClass {                  // explicitly public
    public var somePublicProperty = 0            // explicitly public
    var someInternalProperty = 0                 // implicitly internal
    fileprivate func someFilePrivateMethod() {}  // explicitly file-private
    private func somePrivateMethod() {}          // explicitly private
}

class SomeInternalClass {                       // implicitly internal
    var someInternalProperty = 0                 // implicitly internal
    fileprivate func someFilePrivateMethod() {}  // explicitly file-private
    private func somePrivateMethod() {}          // explicitly private
}

fileprivate class SomeFilePrivateClass {        // explicitly file-private
    func someFilePrivateMethod() {}              // implicitly file-private
    private func somePrivateMethod() {}          // explicitly private
}

private class SomePrivateClass {                // explicitly private
    func somePrivateMethod() {}                  // implicitly private

Tuple Types

The access level for a tuple type is the most restrictive access level of all types used in that tuple.
example :

fileprivate let object1 = (SomeFilePrivateClass(), SomePrivateClass())  // OK
internal let object2 = (SomeFilePrivateClass(), SomePrivateClass())  // Error : Constant cannot be declared internal because its type '(SomeFilePrivateClass, SomePrivateClass)' uses a private type

Function Types

The access level for a function type is calculated as the most restrictive access level of the function’s parameter types and return type.

example :

func someFunction() -> (SomeInternalClass, SomePrivateClass) {  //Error : Function must be declared private or fileprivate because its result uses a private type
    // function implementation goes here
}

private func someOtherFunction() -> (SomeInternalClass, SomePrivateClass) {  // OK
    // function implementation goes here
}

Enumeration Types

The individual cases of an enumeration automatically receive the same access level as the enumeration they belong to. Different access level can't be specified for individual enumeration cases.

Raw Values and Associated Values : The types used for any raw values or associated values in an enumeration definition must have an access level at least as high as the enumeration’s access level.

example :

struct UPC {  // implicitly internal
    let numberSystem : Int
    let manufacturer : Int
    let product : Int
    let check : Int

    init(_ numberSystem : Int, _ manufacturer: Int, _ product: Int, _ check: Int){
        self.numberSystem = numberSystem
        self.manufacturer = manufacturer
        self.product = product
        self.check = check
    }
}

fileprivate struct QRcode{  // explicitly fileprivate
    let productCode : String

    init( _ productCode : String ){
        self.productCode = productCode
    }
}

enum Barcode {  // implicitly internal
    case upc(UPC)
    case qrCode(QRcode)  // Error : Enum case in an internal enum uses a fileprivate type
}

Nested Types

The access level of a nested type is the same as its containing type, unless the containing type is public.
Nested types defined within a public type have an automatic access level of internal(but can be explicitly changed).

Subclassing

Subclass can be created for any class that can be accessed in the current access context and that’s defined in the same module as the subclass.
subclass can be created for any open class that’s defined in a different module.
A subclass can’t have a higher access level than its superclass.
For classes that are defined in the same module, class member that’s visible in a certain access context can be overidden. For classes that are defined in another module, any open class member can overriden.
An override can make an inherited class member more accessible than its superclass version.
It’s even valid for a subclass member to call a superclass member that has lower access permissions than the subclass member, as long as the call to the superclass’s member takes place within an allowed access level context

example :

public class A {
    fileprivate func someMethod() {}
}

internal class B: A {
    override internal func someMethod() {
        super.someMethod()
    }
}

Constants, Variables, Properties, and Subscripts

A constant, variable, or property can’t be more public than its type. It’s not valid to write a public property with a private type.

example :

private var privateInstance = SomePrivateClass()

Getters and setters for constants, variables, properties, and subscripts automatically receive the same access level as the constant, variable, property, or subscript they belong to.
setter can have a lower access level than its corresponding getter, to restrict the read-write scope of that variable, property, or subscript. Like fileprivate(set), private(set), or internal(set) can be prefixed before the var or subscript.
This rule applies to stored properties as well as computed properties. Even though you don’t write an explicit getter and setter for a stored property, Swift still synthesizes an implicit getter and setter for you to provide access to the stored property’s

example :

public struct TrackedString {
    public private(set) var numberOfEdits = 0 // public getter and private setter
    public var value: String = "" {
        didSet {
            numberOfEdits += 1
        }
    }
    public init() {}
}

Initializers

Custom initializers can be assigned an access level less than or equal to the type that they initialize.
A required initializer must have the same access level as the class it belongs to.
The types of an initializer’s parameters can’t be more private than the initializer’s own access level.
A default initializer has the same access level as the type it initializes, unless that type is defined as public. For a type that’s defined as public, the default initializer is considered internal (public no-argument initializer can be provided explicitly).
The default memberwise initializer for a structure type is considered private if any of the structure’s stored properties are private. Likewise, if any of the structure’s stored properties are file private, the initializer is file private. Otherwise, the initializer has an access level of internal.

Protocols

The access level of each requirement within a protocol definition is automatically set to the same access level as the protocol.
A protocol's requirement can't be changed to a different access level than the protocol it supports.
For a public protocol, the protocol’s requirements require a public access level for those requirements when they’re implemented(not Internal like in other places).
The Inherited protocol can have at most the same access level as the protocol it inherits from.
A type can conform to a protocol with a lower access level than the type itself. For a public type that can be used in other modules, but whose conformance to an internal protocol can only be used within the internal protocol’s defining module.
The context in which a type conforms to a particular protocol is the minimum of the type’s access level and the protocol’s access level. For example, if a type is public, but a protocol it conforms to is internal, the type’s conformance to that protocol is also internal.
When you write or extend a type to conform to a protocol, you must ensure that the type’s implementation of each protocol requirement has at least the same access level as the type’s conformance to that protocol. For example, if a public type conforms to an internal protocol, the type’s implementation of each protocol requirement must be at least internal.

example :

public protocol SomeProtocol{
    func someMethod() -> Int
    func someOtherMethod()-> Int
}

class SomeClass : SomeProtocol{
    private func someMethod() -> Int { return 5 } // Error : Method 'someMethod()' must be as accessible as its enclosing type because it matches a requirement in protocol 'SomeProtocol'
    func someOtherMethod() -> Int { return 10 }  // OK , implicitly internal
}

Extension

A class, structure, or enumeration can be extended in any access context in which the class, structure, or enumeration is available.

Any type members added in an extension have the same default access level as type members declared in the original type being extended.

If extended type is

public or internal type, any new type members you add have a default access level of internal.
file-private type, any new type members you add have a default access level of file private.
private type, any new type members you add have a default access level of private.

Alternatively, you can mark an extension with an explicit access-level modifier to set a new default access level for all members defined within the extension. This new default can still be overridden within the extension for individual type members.
Explicit access-level modifier can't be used for an extension if that extension is used to add protocol conformance.
Private Members in Extensions
Extensions that are in the same file as the class, structure, or enumeration that they extend behave as if the code in the extension had been written as part of the original type’s declaration. Below declarations are correct

Declare a private member in the original declaration, and access that member from extensions in the same file.
Declare a private member in one extension, and access that member from another extension in the same file.
Declare a private member in an extension, and access that member from the original declaration in the same file.

example :

protocol SomeProtocol {
    func doSomething()
}

struct SomeStruct {
    private var privateVariable = 12
}

extension SomeStruct: SomeProtocol {
    func doSomething() {
        print(privateVariable)
    }
}

Generics

The access level for a generic type or generic function is the minimum of the access level of the generic type or function itself and the access level of any type constraints on its type parameters.

Type Aliases

Any declared type aliases are treated as distinct types for the purposes of access control.
A type alias can have an access level less than or equal to the access level of the type it aliases. For example, a private type alias can alias a private, file-private, internal, public, or open type, but a public type alias can’t alias an internal, file-private, or private type.
This rule also applies to type aliases for associated types used to satisfy protocol conformances.

Swift - Memory Safety

Naveen Ragul B — Thu, 07 Apr 2022 12:02:56 +0000

Swift makes sure that multiple accesses to the same area of memory don’t conflict, by requiring code that modifies a location in memory to have exclusive access to that memory.
A conflicting access to memory can occur when different parts of your code are trying to access the same location in memory at the same time, which can produce unpredictable or inconsistent behavior.
If you have conflicting access to memory from within a single thread, Swift guarantees that you’ll get an error at either compile time or runtime. For multithreaded code, use Thread Sanitizer to help detect conflicting access across threads.
A conflict can occur if you have two accesses that meet all of the following conditions.

At least one is a write access or a nonatomic access.
They access the same location in memory.
Their durations overlap.

A write access changes the location in memory, but a read access doesn’t.
The duration of a memory access is either instantaneous or long-term.
An access is instantaneous if it’s not possible for other code to run after that access starts but before it ends.
Two instantaneous accesses can’t happen at the same time. Most memory access is instantaneous.
It’s possible for other code to run after a long-term access starts but before it ends, which is called overlap. A long-term access can overlap with other long-term accesses and instantaneous accesses.
Overlapping accesses appear primarily in code that uses in-out parameters in functions and methods or mutating methods of a structure.

Conflicting Access to In-Out Parameters

A function has long-term write access to all of its in-out parameters.
The write access for an in-out parameter starts after all of the non-in-out parameters have been evaluated and lasts for the entire duration of that function call.
If there are multiple in-out parameters, the write accesses start in the same order as the parameters appear.
Original variable that was passed as in-out can’t be accessed.

example :

var stepSize = 1

func increment(_ number: inout Int) {
    number += stepSize
}

increment(&stepSize)

Both number and stepSize refer to the same location in memory. The read access to stepSize overlaps with the write access to number, producing a conflict.

The conflict can be solved by :

// Make an explicit copy.
var copyOfStepSize = stepSize
increment(&copyOfStepSize)

// Update the original.
stepSize = copyOfStepSize
// stepSize is now 2

Another consequence of long-term write access to in-out parameters is that passing a single variable as the argument for multiple in-out parameters of the same function produces a conflict.

example :

func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}
var playerOneScore = 42
var playerTwoScore = 30
balance(&playerOneScore, &playerTwoScore)  // OK
balance(&playerOneScore, &playerOneScore) // Error: conflicting accesses to playerOneScore

passing playerOneScore as the value for both parameters produces a conflict because it tries to perform two write accesses to the same location in memory at the same time.

Conflicting Access to self in Methods

A mutating method on a structure has write access to self for the duration of the method call.

example :

struct Player {
    var name: String
    var health: Int
    var energy: Int

    static let maxHealth = 10
    mutating func restoreHealth() {
        health = Player.maxHealth
    }

    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}

var oscar = Player(name: "Oscar", health: 10, energy: 10)
var maria = Player(name: "Maria", health: 5, energy: 10)
oscar.shareHealth(with: &maria)  // OK
oscar.shareHealth(with: &oscar). // Error: conflicting accesses to oscar

The mutating method needs write access to self for the duration of the method, and the in-out parameter needs write access to teammate for the same duration.
Within the method, both self and teammate refer to the same location in memory and they overlap, producing a conflict.

Conflicting Access to Properties

structures, tuples, and enumerations are value types.
Mutating any piece of the value mutates the whole value, meaning read or write access to one of the properties requires read or write access to the whole value.

example :

var playerInformation = (health: 10, energy: 20)
balance(&playerInformation.health, &playerInformation.energy)
// Error: conflicting access to properties of playerInformation

A write access to the tuple element requires a write access to the entire tuple. This means there are two write accesses to playerInformation with durations that overlap, causing a conflict.

same error appears for overlapping write accesses to the properties of a structure that’s stored in a global variable.

var holly = Player(name: "Holly", health: 10, energy: 10)
balance(&holly.health, &holly.energy)  // Error

When the scope of struct is changed to a local variable instead of a global variable, the compiler can prove that overlapping access to stored properties of the structure is safe:

func someFunction() {
    var oscar = Player(name: "Oscar", health: 10, energy: 10)
    balance(&oscar.health, &oscar.energy)  // OK
}

It's because of multiple threads could access the global variable at the same time. In the case of a local variable, that variable exists once per execution of the function. If multiple threads run someFunction() simultaneously, each thread has its own "oscar" variable, so there is no chance that thread 1's "oscar" variable access thread 2's oscar variable.

Swift - ARC

Naveen Ragul B — Thu, 07 Apr 2022 07:56:09 +0000

Swift uses Automatic Reference Counting (ARC) to track and manage your app’s memory usage. ARC automatically frees up the memory used by class instances when those instances are no longer needed.

Reference counting applies only to instances of classes. Structures and enumerations are value types, not reference types, and aren’t stored and passed by reference.

whenever you assign a class instance to a property, constant, or variable, that property, constant, or variable makes a strong reference to the instance.
ARC tracks how many properties, constants, and variables are currently referring to each class instance. ARC will not deallocate an instance as long as at least one active reference to that instance still exists.

example :

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

var reference1, reference2, reference3: Person?

reference1 = Person(name: "John Appleseed") // John Appleseed is being initialized
reference2 = reference1
reference3 = reference1

reference1 = nil
reference2 = nil
reference3 = nil // John Appleseed is being deinitialized

Strong Reference Cycles Between Class Instances

ARC is able to track the number of references to a class instance.
However, it’s possible to write code in which an instance of a class never gets to a point where it has zero strong references. This can happen if two class instances hold a strong reference to each other, such that each instance keeps the other alive. This is known as a strong reference cycle.
Strong reference cycles can be resolved by defining some of the relationships between classes as weak or unowned references instead of as strong references.

Strong reference cycle between class instance - example 1 :

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") }
}

var john: Person?
var unit4A: Apartment?

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

john = nil
unit4A = nil

Resolving Strong Reference Cycles Between Class Instances

Weak and unowned references enable one instance in a reference cycle to refer to the other instance without keeping a strong hold on it. The instances can then refer to each other without creating a strong reference cycle.

Use a weak reference when the other instance has a shorter lifetime.
Use an unowned reference when the other instance has the same lifetime or a longer lifetime.

Weak References

A weak reference is a reference that doesn’t keep a strong hold on the instance it refers to, and so doesn’t stop ARC from disposing of the referenced instance.
weak reference can be created by placing the weak keyword before a property or variable declaration.
ARC automatically sets a weak reference to nil when the instance that it refers to is deallocated. Therefore the weak reference should be optional variable.

Property observers aren’t called when ARC sets a weak reference to nil.

example :

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") }
}

var john: Person?
var unit4A: Apartment?

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

john!.apartment = unit4A
unit4A!.tenant = john

john = nil // Prints "John Appleseed is being deinitialized"
unit4A = nil // Prints "Apartment 4A is being deinitialized"

Unowned References

An unowned reference doesn’t keep a strong hold on the instance it refers to.
An unowned reference is used when the other instance has the same lifetime or a longer lifetime. You indicate an unowned reference by placing the unowned keyword before a property or variable declaration.
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.

example :

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") }
}

var john: Customer?
john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

john = nil

// Prints "John Appleseed is being deinitialized"
// Prints "Card #1234567890123456 is being deinitialized"

Strong Reference Cycles for Closures

Closures and Functions are reference type in swift.
A strong reference cycle can also occur a closure is assigned to a property of a class instance, and the body of that closure captures the instance.

Strong Reference Cycles for Closures - example :

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()) // "<p>hello, world</p>"

paragraph = nil. //neither the HTMLElement instance nor its closure are deallocated, because of the strong reference cycle.

Resolving Strong Reference Cycles for Closures

You resolve a strong reference cycle between a closure and a class instance by defining a capture list as part of the closure’s definition.
A capture list defines the rules to use when capturing one or more reference types within the closure’s body.
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.

example :

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

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.

If the captured reference will never become nil, it should always be captured as an unowned reference, rather than a weak reference.

example :

class HTMLElement {

    let name: String
    let text: String?

    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")
    }

}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
paragraph = nil  // Prints "p is being deinitialized"

Swift - Opaque Type

Naveen Ragul B — Thu, 07 Apr 2022 05:29:34 +0000

Opaque Type

A function or method with an opaque return type hides its return value’s type information.

Unlike returning a value whose type is a protocol type, opaque types preserve type identity—the compiler has access to the type information, but clients of the module don’t.
To declares a function/method's return type as opaque use some keyword.

example :

protocol Shape {
    func draw() -> String
}

struct Triangle: Shape {
    var size: Int
    func draw() -> String {
        var result: [String] = []
        for length in 1...size {
            result.append(String(repeating: "*", count: length))
        }
        return result.joined(separator: "\n")
    }
}

struct Square: Shape {
    var size: Int
    func draw() -> String {
        let line = String(repeating: "*", count: size)
        let result = Array<String>(repeating: line, count: size)
        return result.joined(separator: "\n")
    }
}

let smallTriangle = Triangle(size: 3)

struct FlippedShape<T: Shape>: Shape {
    var shape: T
    func draw() -> String {
        let lines = shape.draw().split(separator: "\n")
        return lines.reversed().joined(separator: "\n")
    }
}

struct JoinedShape<T: Shape, U: Shape>: Shape {
    var top: T
    var bottom: U
    func draw() -> String {
        return top.draw() + "\n" + bottom.draw()
    }
}

func flip<T: Shape>(_ shape: T) -> some Shape {
    return FlippedShape(shape: shape)
}
func join<T: Shape, U: Shape>(_ top: T, _ bottom: U) -> some Shape {
    JoinedShape(top: top, bottom: bottom)
}

let opaqueJoinedTriangles = join(smallTriangle, flip(smallTriangle))
print(opaqueJoinedTriangles.draw())
// *
// **
// ***
// ***
// **
// *

If a function with an opaque return type returns from multiple places, all of the possible return values must have the same type. For a generic function, that return type can use the function’s generic type parameters, but it must still be a single type.

example - compile error:

func makeShape(shape : String) ->  some Shape { // Function declares an opaque return type, but the return statements in its body do not have matching underlying types
    if(shape == "square"){
        print("here")
        return Square(size : 4)
    }else{
        return Triangle(size : 4)
    }


}

let shape =  makeShape(shape: "square")

Differences Between Opaque Types and Generic Types

Generic types let the code that calls a function pick the type for that function’s parameters and return value in a way that’s abstracted away from the function implementation
An opaque type lets the function implementation pick the type for the value it returns in a way that’s abstracted away from the code that calls the function.

Differences Between Opaque Types and Protocol Types

An opaque type refers to one specific type, although the caller of the function isn’t able to see which type.
A protocol type can refer to any type that conforms to the protocol.
Swift can infer associated types, which lets you use an opaque return value in places where a protocol type can’t be used as a return value.

Swift - Generics

Naveen Ragul B — Wed, 06 Apr 2022 12:16:09 +0000

Generic code enables you to write flexible, reusable(avoids duplication) functions and types that can work with any type, subject to requirements that you define.

Array, Set and Dictionary are Generic types in Swift.

Generic Functions

Generic functions can work with any type. The generic version of the function uses a placeholder type name instead of an actual type name. The actual type to use in place of placeholder is determined each time when generic function is called.

Type parameters specify and name a placeholder type, and are written immediately after the function’s name, between a pair of matching angle brackets (such as <T>). Multiple type parameters separated by comma can be specified.

example :

func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

Generic Types

These are custom classes, structures, and enumerations that can work with any type.

example :

struct Stack<Element> {
    var items: [Element] = []
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
}

var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")

When you extend a generic type, you don’t provide a type parameter list as part of the extension’s definition. Instead, the type parameter list from the original type definition is available within the body of the extension.

example :

extension Stack {
    var topItem: Element? {
        return items.isEmpty ? nil : items[items.count - 1]
    }
}

Extensions of a generic type can also include requirements that instances of the extended type must satisfy in order to gain the new functionality using generic where clause.

Type Constraints

Type constraints specify that a type parameter must inherit from a specific class, or conform to a particular protocol or protocol composition.

synatx :

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) { // function body goes here }

Here parameters have type constraints :

T to be a subclass of SomeClass
U to conform to the protocol SomeProtocol

example :

func findIndex<T: Equatable>(of valueToFind: T, in array:[T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

Associated Types

An associated type gives a placeholder name to a type that’s used as part of the protocol. The actual type to use for that associated type isn’t specified until the protocol is adopted.

Associated types are specified with the associatedtype keyword.

example :

protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

struct Stack<Element>: Container {
    // original Stack<Element> implementation
    var items: [Element] = []
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
    // conformance to the Container protocol
    mutating func append(_ item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}

Existing type can be extended to add conformance to a protocol.

example :

extension Array: Container {}

type constraints can be added to an associated type in a protocol to require that conforming types satisfy those constraints. example :

protocol Container {
    associatedtype Item: Equatable
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

A protocol can appear as part of its own requirements. example :

protocol SuffixableContainer: Container {
    associatedtype Suffix: SuffixableContainer where Suffix.Item == Item
    func suffix(_ size: Int) -> Suffix
}

Suffix has two constraints: It must conform to the SuffixableContainer protocol (the protocol currently being defined), and its Item type must be the same as the container’s Item type.

example :

extension Stack: SuffixableContainer {
    func suffix(_ size: Int) -> Stack {
        var result = Stack()
        for index in (count-size)..<count {
            result.append(self[index])
        }
        return result
    }
    // Inferred that Suffix is Stack.
}
var stackOfInts = Stack<Int>()
stackOfInts.append(10)
stackOfInts.append(20)
stackOfInts.append(30)
let suffix = stackOfInts.suffix(2)

Generic Where Clauses

Type constraints used to define requirements on the type parameters associated with a generic function, subscript, or type.

To define requirements for associated types, define a generic where clause. A generic where clause enables you to require that

an associated type must conform to a certain protocol, or
certain type parameters and associated types must be the same.

example :

func allItemsMatch<C1: Container, C2: Container>
    (_ someContainer: C1, _ anotherContainer: C2) -> Bool
    where C1.Item == C2.Item, C1.Item: Equatable {

        // Check that both containers contain the same number of items.
        if someContainer.count != anotherContainer.count {
            return false
        }

        // Check each pair of items to see if they're equivalent.
        for i in 0..<someContainer.count {
            if someContainer[i] != anotherContainer[i] {
                return false
            }
        }

        // All items match, so return true.
        return true
}

var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")

var arrayOfStrings = ["uno", "dos", "tres"]

if allItemsMatch(stackOfStrings, arrayOfStrings) {
    print("All items match.")
} else {
    print("Not all items match.")
} // Prints "All items match."

Here even though the stack and the array are of a different type, they both conform to the Container protocol, and both contain the same type of values.

generic where clause as part of an extension.

example :

extension Stack where Element: Equatable {
    func isTop(_ item: Element) -> Bool {
        guard let topItem = items.last else {
            return false
        }
        return topItem == item
    }
}

Contextual Where Clauses

generic where clause can be included as part of a declaration that doesn’t have its own generic type constraints, when you’re already working in the context of generic types.

extension Container {
    func average() -> Double where Item == Int {
        var sum = 0.0
        for index in 0..<count {
            sum += Double(self[index])
        }
        return sum / Double(count)
    }
    func endsWith(_ item: Item) -> Bool where Item: Equatable {
        return count >= 1 && self[count-1] == item
    }
}

is same as

extension Container where Item == Int {
    func average() -> Double {
        var sum = 0.0
        for index in 0..<count {
            sum += Double(self[index])
        }
        return sum / Double(count)
    }
}
extension Container where Item: Equatable {
    func endsWith(_ item: Item) -> Bool {
        return count >= 1 && self[count-1] == item
    }
}

Associated Types with a Generic Where Clause

generic where clause can be included on an associated type.

example :

protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }

    associatedtype Iterator: IteratorProtocol where Iterator.Element == Item
    func makeIterator() -> Iterator
}

Generic Subscripts

Subscripts can be generic, and they can include generic where clauses.
example :

extension Container {
    subscript<Indices: Sequence>(indices: Indices) -> [Item]
        where Indices.Iterator.Element == Int {
            var result: [Item] = []
            for index in indices {
                result.append(self[index])
            }
            return result
    }
}

The generic where clause requires that the iterator for the sequence must traverse over elements of type Int. This ensures that the indices in the sequence are the same type as the indices used for a container.

Swift - Protocol

Naveen Ragul B — Wed, 06 Apr 2022 09:17:11 +0000

A protocol defines a blueprint of methods, properties, and other requirements that can be adopted by a class, structure, or enumeration to provide an actual implementation of those requirements. Any type that satisfies the requirements of a protocol is said to conform to that protocol.

A Protocol can be extended to implement some of the requirement specified by itself or Implement additional functionality.

Protocol can specify the following requirement :

Property requirement
Method Requirement
Mutating Method Requirement
Initializer Requirement (incl Failable Initializer)

Property Requirements

A protocol can require any conforming type to provide an instance property or type property with a particular name and type.
It specifies whether each property must be gettable or gettable and settable.
doesn’t specify whether the property should be a stored property or a computed property (Conforming type can implement it as either)

If a protocol requires a property to be :

gettable and settable - conforming type cannot use constant stored property or a read-only computed property.
only gettable - conforming type can use any kind of property.

Property requirements are always declared as variable properties, prefixed with the var keyword. But conforming type can declare the property as constant if required.

example :

protocol someProtocol{
    var property : Int { get }
}

class someClass : someProtocol{
    let property : Int

    init( _ property : Int){
        self.property = property
    }
}

For type property, use static keyword in requirement.

Method Requirements

A protocol can require any conforming type to implement an instance methods and type methods.

Default values can’t be specified for method parameters within a protocol’s definition.
For type method, use static keyword in requirement.

example :

protocol RandomNumberGenerator {
    func random() -> Double
}

Mutating Method Requirements

A protocol can require any conforming type to implement an mutating method by marking the method with the mutating keyword as part of the protocol’s definition.

example :

protocol Togglable {
    mutating func toggle()
}

enum OnOffSwitch: Togglable {
    case off, on
    mutating func toggle() {
        switch self {
        case .off:
            self = .on
        case .on:
            self = .off
        }
    }
}
var lightSwitch = OnOffSwitch.off
lightSwitch.toggle()

Mutating keyword is not required when writing an implementation of that method for a class.

Initializer Requirements

A protocol can require any conforming type to implement specific initializers.

A type can conform protocol initializer requirement as designated initializer or convenience initailizer. In both the cases required modifier should be prefixed.
required modifier ensures that you provide an explicit or inherited implementation of the initializer requirement on all subclasses of the conforming class.
required modifier is not needed for classes that are marked with the final modifier, because that cannot be subclassed.
If a subclass overrides a designated initializer from superclass and also implements a matching initializer requirement from a protocol, use both the required and override modifiers:

example :

protocol SomeProtocol {
    init()
}

class SomeSuperClass {
    init() {
        // initializer implementation goes here
    }
}

class SomeSubClass: SomeSuperClass, SomeProtocol {
    required override init() {
        // initializer implementation goes here
    }
}

Protocols can define failable initializer requirements for conforming types.
A failable initializer requirement can be satisfied by a failable or nonfailable initializer on a conforming type. A nonfailable initializer requirement can be satisfied by a nonfailable initializer or an implicitly unwrapped failable initializer.

Protocols as Types

You can use a protocol as a type in many places where other types are allowed, including:

As a parameter type or return type in a function, method, or initializer.
As the type of a constant, variable, or property.
As the type of items in an array, dictionary, or other container.

A protocol type can be downcasted to an underlying type in the same way superclass downcast to a subclass.

Adding Protocol Conformance with an Extension

Existing type can be extended to adopt and conform to a new protocol, even if you don’t have access to the source code for the existing type.
Existing instances of a type automatically adopt and conform to a protocol when that conformance is added to the instance’s type in an extension.

Conditionally Conforming to a Protocol

A generic type may be able to satisfy the requirements of a protocol only under certain conditions, such as when the type’s generic parameter conforms to the protocol.

A generic type conditionally conform to a protocol by listing constraints when extending the type by including generic where clause

example :

class Dice {
    let sides: Int
    let generator: RandomNumberGenerator
    init(sides: Int, generator: RandomNumberGenerator) {
        self.sides = sides
        self.generator = generator
    }
    func roll() -> Int {
        return Int(generator.random() * Double(sides)) + 1
    }
}

var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator())

protocol TextRepresentable {
    var textualDescription: String { get }
}

extension Dice: TextRepresentable {
    var textualDescription: String {
        return "A \(sides)-sided dice"
    }
}

let d12 = Dice(sides: 12, generator: LinearCongruentialGenerator())

extension Array: TextRepresentable where Element: TextRepresentable {
    var textualDescription: String {
        let itemsAsText = self.map { $0.textualDescription }
        return "[" + itemsAsText.joined(separator: ", ") + "]"
    }
}
let myDice = [d6, d12]
print(myDice.textualDescription) // Prints "[A 6-sided dice, A 12-sided dice]"

Declaring Protocol Adoption with an Extension

If a type already conforms to all of the requirements of a protocol, but hasn’t yet stated that it adopts that protocol, you can make it adopt the protocol with an empty extension:

example :

struct Hamster {
    var name: String
    var textualDescription: String {
        return "A hamster named \(name)"
    }
}
extension Hamster: TextRepresentable {}

Adopting a Protocol Using a Synthesized Implementation

Swift can automatically provide the protocol conformance for Equatable, Hashable, and Comparable in many simple cases.

Swift provides a synthesized implementation of Equatable for the following kinds of custom types:

Structures that have only stored properties that conform to the Equatable protocol
Enumerations that have only associated types that conform to the Equatable protocol
Enumerations that have no associated types

Swift provides a synthesized implementation of Hashable for the following kinds of custom types:

Structures that have only stored properties that conform to the Hashable protocol
Enumerations that have only associated types that conform to the Hashable protocol
Enumerations that have no associated types

Swift provides a synthesized implementation of Comparable for :

Enumerations that don’t have a raw value.
If the enumeration has associated types, they must all conform to the Comparable protocol.

A protocol can inherit one or more other protocols and can add further requirements on top of the requirements it inherits.
You can limit protocol adoption to class types (and not structures or enumerations) by adding the AnyObject protocol to a protocol’s inheritance list.

example :

protocol SomeClassOnlyProtocol: AnyObject, SomeInheritedProtocol {
    // class-only protocol definition goes here
}

Protocol Composition - multiple protocols can be combined into a single requirement by separating them with ampersands (&).

example :

protocol Named {
    var name: String { get }
}
protocol Aged {
    var age: Int { get }
}
struct Person: Named, Aged {
    var name: String
    var age: Int
}
func wishHappyBirthday(to celebrator: Named & Aged) {
    print("Happy birthday, \(celebrator.name), you're \(celebrator.age)!")
}

Optional Protocol Requirements

Optional requirements can be defined for protocols. These requirements don’t have to be implemented by types that conform to the protocol. Optional requirements are prefixed by the optional modifier
Optional requirements are available so that you can write code that interoperates with Objective C. Both the protocol and the optional requirement must be marked with the @objc attribute. Note that @objc protocols can be adopted only by classes that inherit from Objective C classes or other @objc classes. They can’t be adopted by structures or enumerations.
An optional protocol requirement can be called with optional chaining.

example :

@objc protocol CounterDataSource {
    @objc optional func increment(forCount count: Int) -> Int
    @objc optional var fixedIncrement: Int { get }
}

class ThreeSource: NSObject, CounterDataSource {
    let fixedIncrement = 3
}

class TowardsZeroSource: NSObject, CounterDataSource {
    func increment(forCount count: Int) -> Int {
        if count == 0 {
            return 0
        } else if count < 0 {
            return 1
        } else {
            return -1
        }
    }
}

class Counter {
    var count = 0
    var dataSource: CounterDataSource?
    func increment() {
        if let amount = dataSource?.increment?(forCount: count) {
            count += amount
        } else if let amount = dataSource?.fixedIncrement {
            count += amount
        }
    }
}

var counter = Counter()
counter.dataSource = ThreeSource()
counter.increment(). // 3
counter.dataSource = TowardsZeroSource()
counter.increment(). // 2

Protocol Extensions

Protocols can be extended to provide method, initializer, subscript, and computed property implementations to conforming types.

example :

protocol RandomNumberGenerator {
    func random() -> Double
}

extension RandomNumberGenerator {
    func randomBool() -> Bool {
        return random() > 0.5
    }
}

Protocol extensions can add implementations to conforming types but can’t make a protocol extend or inherit from another protocol.
Constraints can be specified for the conforming types to satisfy before the methods and properties of the extension are available using generic where clause.

example :

extension Collection where Element: Equatable {
    func allEqual() -> Bool {
        for element in self {
            if element != self.first {
                return false
            }
        }
        return true
    }
}

If a conforming type satisfies the requirements for multiple constrained extensions that provide implementations for the same method or property, Swift uses the implementation corresponding to the most specialized constraints.

Swift - Extensions

Naveen Ragul B — Tue, 05 Apr 2022 10:36:50 +0000

Extensions add new functionality to an existing class, structure, enumeration, or protocol type.

Extensions in Swift can:

Add computed instance properties and computed type properties
Define instance methods and type methods
Provide new initializers
Define subscripts
Define and use new nested types
Make an existing type conform to a protocol

Extensions can add new functionality to a type, but they can’t override existing functionality.

example Protocol :

extension SomeType: SomeProtocol, AnotherProtocol {
    // implementation of protocol requirements goes here
}

example Computed Property - extension:

extension Double {
    var km: Double { return self * 1_000.0 }
    var m: Double { return self }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1_000.0 }
    var ft: Double { return self / 3.28084 }
}
let oneInch = 25.4.mm
print("One inch is \(oneInch) meters")
// Prints "One inch is 0.0254 meters"
let threeFeet = 3.ft
print("Three feet is \(threeFeet) meters")
// Prints "Three feet is 0.914399970739201 meters"

Extensions can add new convenience initializers to a class, but they can’t add new designated initializers or deinitializers to a class.
If you use an extension to add an initializer to a value type that provides default values for all of its stored properties and doesn’t define any custom initializers, you can call the default initializer and memberwise initializer for that value type from within your extension’s initializer.
If you use an extension to add an initializer to a structure that was declared in another module, the new initializer can’t access self until it calls an initializer from the defining module.

example Initializer - extension:

struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
}

extension Rect {
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}

example Method - extension:

extension Int {
    func repetitions(task: () -> Void) {
        for _ in 0..<self {
            task()
        }
    }
}

3.repetitions {
    print("Hello!")
}

example Subscript - extension :

extension Int {
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..<digitIndex {
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}

example Nested Type - extension :

extension Int {
    enum Kind {
        case negative, zero, positive
    }
    var kind: Kind {
        switch self {
        case 0:
            return .zero
        case let x where x > 0:
            return .positive
        default:
            return .negative
        }
    }
}

Swift - Nested Types

Naveen Ragul B — Tue, 05 Apr 2022 09:56:29 +0000

enumerations, classes, and structures can be nested within the definition of the type they support. Nested types are purely for use within the context of a more complex type.

example :

struct BlackjackCard {

    // nested Suit enumeration
    enum Suit: Character {
        case spades = "♠", hearts = "♡", diamonds = "♢", clubs = "♣"
    }

    // nested Rank enumeration
    enum Rank: Int {
        case two = 2, three, four, five, six, seven, eight, nine, ten
        case jack, queen, king, ace
        struct Values {
            let first: Int, second: Int?
        }
        var values: Values {
            switch self {
            case .ace:
                return Values(first: 1, second: 11)
            case .jack, .queen, .king:
                return Values(first: 10, second: nil)
            default:
                return Values(first: self.rawValue, second: nil)
            }
        }
    }

    // BlackjackCard properties and methods
    let rank: Rank, suit: Suit
    var description: String {
        var output = "suit is \(suit.rawValue),"
        output += " value is \(rank.values.first)"
        if let second = rank.values.second {
            output += " or \(second)"
        }
        return output
    }
}

let heartsSymbol = BlackjackCard.Suit.hearts.rawValue  // "♡"

Swift - Type Casting

Naveen Ragul B — Tue, 05 Apr 2022 09:38:16 +0000

Type casting is a way to treat instance of a type as a different superclass or subclass and to check the type of an instance, implemented with the as and is operators.

It can be also used to check whether a type conforms to a protocol.

Checking Type

is operator is used to check whether an instance is of a certain type or it's subclass type.

example :

class MediaItem {
    var name: String
    init(name: String) {
        self.name = name
    }
}

class Movie: MediaItem {
    var director: String
    init(name: String, director: String) {
        self.director = director
        super.init(name: name)
    }
}

class Song: MediaItem {
    var artist: String
    init(name: String, artist: String) {
        self.artist = artist
        super.init(name: name)
    }
}

let library = [
    Movie(name: "Casablanca", director: "Michael Curtiz"),
    Song(name: "Blue Suede Shoes", artist: "Elvis Presley"),
    Movie(name: "Citizen Kane", director: "Orson Welles"),
    Song(name: "The One And Only", artist: "Chesney Hawkes"),
    Song(name: "Never Gonna Give You Up", artist: "Rick Astley")
]

var movieCount = 0
var songCount = 0

for item in library {
    if item is Movie {
        movieCount += 1
    } else if item is Song {
        songCount += 1
    }
}

Downcasting

A constant or variable of a certain class type may actually refer to an instance of a subclass using type cast operator (as? or as!).

as?, returns an optional value
as!, attempts the downcast and force-unwraps the result

Use as! when you are sure that downcast will succeed and as? when you are not sure.

example :

for item in library {
    if let movie = item as? Movie {
        print("Movie: \(movie.name), dir. \(movie.director)")
    } else if let song = item as? Song {
        print("Song: \(song.name), by \(song.artist)")
    }
}

Type Casting for Any and AnyObject

Swift provides two special types for working with nonspecific types:

Any can represent an instance of any type at all, including function types.
AnyObject can represent an instance of any class type.

var things: [Any] = []

things.append(0)
things.append(0.0)
things.append(3.14159)
things.append("hello")
things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman"))

The Any type represents values of any type, including optional types. Swift gives you a warning if you use an optional value where a value of type Any is expected. If you really do need to use an optional value as an Any value, you can use the as operator to explicitly cast the optional to Any.

example :

let optionalNumber: Int? = 3
things.append(optionalNumber)        // Warning
things.append(optionalNumber as Any) // No warning

To discover the specific type of a constant or variable that’s known only to be of type Any or AnyObject, you can use an is or as pattern in a switch statement’s cases.

example :

for thing in things {
    switch thing {
    case 0 as Int:
        print("zero as an Int")
    case 0 as Double:
        print("zero as a Double")
    case let someInt as Int:
        print("an integer value of \(someInt)")
    case let someDouble as Double where someDouble > 0:
        print("a positive double value of \(someDouble)")
    case is Double:
        print("some other double value that I don't want to print")
    case let someString as String:
        print("a string value of \"\(someString)\"")
    case let (x, y) as (Double, Double):
        print("an (x, y) point at \(x), \(y)")
    case let movie as Movie:
        print("a movie called \(movie.name), dir. \(movie.director)")
    case let stringConverter as (String) -> String:
        print(stringConverter("Michael"))
    default:
        print("something else")
    }
}

Swift - Concurrency

Naveen Ragul B — Tue, 05 Apr 2022 08:57:07 +0000

Asynchronous code - can be suspended and resumed later.
Parallel code - multiple pieces of code run simultaneously.
A program that uses parallel and asynchronous code carries out multiple operations at a time; it suspends operations that are waiting for an external system, and makes it easier to write this code in a memory-safe way.
concurrency to refer to this common combination of asynchronous and parallel code.

Asynchronous Functions

synchronous functions and methods, which either run to completion, throw an error, or never return.
Asynchronous function or method still does one of those three things, but that can be suspended while it’s partway through execution.
To indicate that a function or method is asynchronous, you write the async keyword in its declaration.
When calling an asynchronous method, execution suspends until that method returns. Use await in front of the call to mark the possible suspension point

example :

func listPhotos(inGallery name: String) async -> [String] {
    let result = // some asynchronous networking code
    return result
}

let photoNames = await listPhotos(inGallery: "Summer Vacation")
let sortedNames = photoNames.sorted()
let name = sortedNames[0]
let photo = await downloadPhoto(named: name)
show(photo)

Places in your program can call asynchronous functions or methods:

Code in the body of an asynchronous function, method, or property.
Code in the static main() method of a structure, class, or enumeration that’s marked with @main.
Code in an unstructured child task

In above example, Instead of returning whole array at once after all of the array’s elements are ready, wait for one element of the collection at a time using an asynchronous sequence using for-await-in loop.

example :

import Foundation

let handle = FileHandle.standardInput
for try await line in handle.bytes.lines {
    print(line)
}

for-await-in loop can be used for any types that conforms to the AsyncSequence protocol. Similarly for-in for Sequence.

Calling Asynchronous Functions in Parallel

Calling an asynchronous function with await runs only one piece of code at a time.
To call an asynchronous function and let it run in parallel with code around it, write async in front of let when you define a constant, and then write await each time you use the constant.

example :

async let firstPhoto = downloadPhoto(named: photoNames[0])
async let secondPhoto = downloadPhoto(named: photoNames[1])
async let thirdPhoto = downloadPhoto(named: photoNames[2])

let photos = await [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

Call asynchronous functions with await when the code on the following lines depends on that function’s result. This creates work that is carried out sequentially.
Call asynchronous functions with async-let when you don’t need the result until later in your code. This creates work that can be carried out in parallel.

Structured Concurrency

A task is a unit of work that can be run asynchronously as part of your program. All asynchronous code runs as part of some task.

Task can be added as a child to a Task Group.
async-let syntax creates a child task.
Each task in a task group has the same parent task, and each task can have child tasks. Because of the explicit relationship between tasks and task groups, this approach is called structured concurrency

Unstructured Concurrency

Unstructured task doesn’t have a parent task.
To create an unstructured task that runs on the current actor, call the Task.init(priority:operation:) initializer.
To create an unstructured task that’s not part of the current actor, known more specifically as a detached task, call the Task.detached(priority:operation:) class method.

Actors

Actors are reference types.
Unlike classes, actors allow only one task to access their mutable state at a time, which makes it safe for code in multiple tasks to interact with the same instance of an actor.
You create an instance of an actor using the same initializer syntax as structures and classes. When you access a property or method of an actor, you use await to mark the potential suspension point.

example :

actor TemperatureLogger {
    let label: String
    var measurements: [Int]
    private(set) var max: Int

    init(label: String, measurement: Int) {
        self.label = label
        self.measurements = [measurement]
        self.max = measurement
    }
}

let logger = TemperatureLogger(label: "Outdoors", measurement: 25)
print(await logger.max)

Swift - Error Handling, Assertions and PreConditions

Naveen Ragul B — Tue, 05 Apr 2022 05:15:17 +0000

Error handling can be used to respond to error conditions your program may encounter during execution.

A function indicates that it can throw an error by including the throws keyword in its declaration. When you call a function that can throw an error, you prepend the try keyword to the expression. Swift automatically propagates errors out of their current scope until they’re handled by a catch clause.
A do statement creates a new containing scope, which allows errors to be propagated to one or more catch clauses.

syntax :

do {
    try canThrowAnError()
    // no error was thrown
} catch {
    // an error was thrown
}

Errors are represented by values of types that conform to the Error protocol. This empty protocol indicates that a type can be used for error handling.
Enumerations are well suited to modelling a group of related error conditions, with associated values allowing for additional information about the nature of an error to be communicated. throw statement can be used to throw an error.

example :

enum VendingMachineError: Error {
    case invalidSelection
    case insufficientFunds(coinsNeeded: Int)
    case outOfStock
}

throw VendingMachineError.insufficientFunds(coinsNeeded: 5)

Handling Errors

There are four ways to handle errors in Swift:

Propagate the error from a function to the code that calls that function.
Handle the error using a do-catch statement.
Handle the error as an optional value.
Assert that the error will not occur.

Propagating Errors Using Throwing Functions

Throwing function, method, initializer should be marked with throws.
Only throwing functions can propagate errors. Any errors thrown inside a nonthrowing function must be handled inside the function.

example :

struct Item {
    var price: Int
    var count: Int
}

class VendingMachine {
    var inventory = [
        "Candy Bar": Item(price: 12, count: 7),
        "Chips": Item(price: 10, count: 4),
        "Pretzels": Item(price: 7, count: 11)
    ]
    var coinsDeposited = 0

    func vend(itemNamed name: String) throws {
        guard let item = inventory[name] else {
            throw VendingMachineError.invalidSelection
        }

        guard item.count > 0 else {
            throw VendingMachineError.outOfStock
        }

        guard item.price <= coinsDeposited else {
            throw VendingMachineError.insufficientFunds(coinsNeeded: item.price - coinsDeposited)
        }

        coinsDeposited -= item.price

        var newItem = item
        newItem.count -= 1
        inventory[name] = newItem

        print("Dispensing \(name)")
    }
}

vend(itemNamed:) method propagates any errors it throws, any code that calls this method must either handle the errors—using a do-catch statement, try?, or try!—or continue to propagate them.

Handling Errors Using Do-Catch

do-catch statement can be used to handle errors by executing a block of code. If an error is thrown by the code in the do clause, it’s matched against the catch clauses to determine which one of them can handle the error.

example :

var vendingMachine = VendingMachine()
vendingMachine.coinsDeposited = 8
do {
    try buyFavoriteSnack(person: "Alice", vendingMachine: vendingMachine)
    print("Success! Yum.")
} catch VendingMachineError.invalidSelection {
    print("Invalid Selection.")
} catch VendingMachineError.outOfStock {
    print("Out of Stock.")
} catch VendingMachineError.insufficientFunds(let coinsNeeded) {
    print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
} catch {
    print("Unexpected error: \(error).")
}

If none of the catch clauses handle the error, the error propagates to the surrounding scope. However, the propagated error must be handled by some surrounding scope.
In a nonthrowing function, an enclosing do-catch statement must handle the error.
In a throwing function, either an enclosing do-catch statement or the caller must handle the error.
If the error propagates to the top-level scope without being handled, you’ll get a runtime error.

example :

func nourish(with item: String) throws {
    do {
        try vendingMachine.vend(itemNamed: item)
    } catch is VendingMachineError {
        print("Couldn't buy that from the vending machine.")
    }
}

do {
    try nourish(with: "Beet-Flavored Chips")
} catch {
    print("Unexpected non-vending-machine-related error: \(error)")
}

Converting Errors to Optional Values

try? can be used to handle an error by converting it to an optional value. If an error is thrown while evaluating the try? expression, the value of the expression is nil.

example :

func someThrowingFunction() throws -> Int {
    // ...
}

let x = try? someThrowingFunction()

Disabling Error Propagation

If you are sure that a throwing function or method won’t throw an error at runtime, then write try! before the expression to disable error propagation. If an error actually is thrown, you’ll get a runtime error.

example :

let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")

Specifying Cleanup Actions

Use a defer statement to execute a set of statements just before code execution leaves the current block of code. This statement lets you do any necessary cleanup that should be performed regardless of how execution leaves the current block of code—whether it leaves because an error was thrown or because of a statement such as return or break.

The deferred statements may not contain transfer control statements, such as a break or a return statement, or by throwing an error.

-Deferred actions are executed in the reverse of the order that they’re written in your source code. That is, the code in the first defer statement executes last, the code in the second defer statement executes second to last, and so on.

example:

func processFile(filename: String) throws {
    if exists(filename) {
        let file = open(filename)
        defer {
            close(file)
        }
        while let line = try file.readline() {
            // Work with the file.
        }
    }
}

Assertions and Preconditions

Assertions and preconditions are checks that happen at runtime. You use them to make sure an essential condition is satisfied before executing any further code. If the Boolean condition in the assertion or precondition evaluates to true, code execution continues as usual. If the condition evaluates to false, the current state of the program is invalid; code execution ends, and your app is terminated.

assertions and preconditions aren’t used for recoverable or expected errors. Because a failed assertion or precondition indicates an invalid program state, there’s no way to catch a failed assertion.
They are used to Stop the execution as soon as an invalid state is detected also helps to limit the damage caused by that invalid state.
Assertions are checked only in debug builds, but preconditions are checked in both debug and production builds.
Assertions help you find mistakes and incorrect assumptions during development, and preconditions help you detect issues in production.

example :

let age = -3
assert(age >= 0, "A person's age can't be less than zero.")

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age >= 0 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than zero.")
}

precondition(index > 0, "Index must be greater than zero.")

Swift - Optional Chaining

Naveen Ragul B — Mon, 04 Apr 2022 13:40:15 +0000

Optional chaining is a process for querying and calling properties, methods, and subscripts on an optional that might currently be nil.
If the optional contains a value, the property, method, or subscript call succeeds; if the optional is nil, the property, method, or subscript call returns nil.
This is very similar to (!) forced unwrapping of its value. The main difference is that optional chaining fails gracefully when the optional is nil, whereas forced unwrapping triggers a runtime error when the optional is nil.
The result of an optional chaining call is always an optional value, even if the property, method, or subscript you are querying returns a non-optional value.

example :

class Person {
    var residence: Residence?
}

class Residence {
    var rooms: [Room] = []
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        get {
            return rooms[i]
        }
        set {
            rooms[i] = newValue
        }
    }
    func printNumberOfRooms() {
        print("The number of rooms is \(numberOfRooms)")
    }
    var address: Address?
}

class Room {
    let name: String
    init(name: String) { self.name = name }
}

class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if let buildingNumber = buildingNumber, let street = street {
            return "\(buildingNumber) \(street)"
        } else if buildingName != nil {
            return buildingName
        } else {
            return nil
        }
    }
}

if let beginsWithThe =
    john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
    if beginsWithThe {
        print("John's building identifier begins with \"The\".")
    } else {
        print("John's building identifier doesn't begin with \"The\".")
    }
}