dev-notes/docs/languages/swift/swift.md

# Swift / SwiftUI

- Statically Typed

[Building for Mac with VBox](https://medium.com/@twister.mr/installing-macos-to-virtualbox-1fcc5cf22801)

## Basics

### Macro

```swift
#if DEBUG

// contents compiled only if in DEBUG build

#endif
```

### Comments

```swift
// single line comment

/*  
multi line comment
*/
```

### Variables

```swift
var variable = value  // implicit variable init (auto-determine type)
var variable: Type = value  // explicit variable init
var variable: Type? = value  // explicit nullable variable init
```

### Constants

```swift
let CONSTANT = value  // constant init (value can be assigned at runtime)
```

### Console Output

```swift
print()  // empty line
print(variable)
print("string")
```

## Strings

```swift
var string "Text: \(<expr>)"  // string interpolation
var string = "Hello" + "There"  // string concatenation

var multilineString = """Use double quotes trice
to make a string span multiple lines"""
```

## Array

```swift
var array = ["firstItem", "secondItem", ...]
var array = [Type()]  // init empty homogeneous array

array[index]  // value access
array[index] = value  // value update

array.append(item)  // add item to the end
array.contains(item)  // membership check
array.sort()  // in place sort


// Heterogeneous Array
var list: Any = ["string", 47, ...]  // cannot access with [index]
var list: Any = []  // init empty heterogeneous array
```

## Tuple

A **tuple** type is a comma-separated list of types, enclosed in parentheses.

It's possible to use a tuple type as the return type of a function to enable the function to return a single tuple containing multiple values.
It's possible to name the elements of a tuple type and use those names to refer to the values of the individual elements.
An element name consists of an identifier followed immediately by a colon (:).

```swift
var tuple: (Type, Type) = (value, value)  // explicit type
var tuple = (value, value)  // implicit type
tuple.0  // item access

// named elements
var tuple = (name1: value1, name2: value2, ...)  // tuple init
tuple = (value1, value2)  // names are inferred
tuple.name1  // item access
```

### Tuple Decomposition

```swift
var tuple = (value1, value2)
var (var1, var2) = tuple  // var1 = value1, var2 = value2
```

## Type Identifier

```swift
typealias Point = (Int, Int)
var origin: (0, 0)
```

## Dictionary

```swift
var dict = [
    "key": "value",
    ...
]

var dict = [Type: Type]()  // init empty dict

dict[key]  // value access
dict[key] = value // value update
```

## Expressions & Operators

### Primary Expressions

| Syntax              | Operation                                                           |
|---------------------|---------------------------------------------------------------------|
| x`.`m               | access to member `m` of object `x` ("." --> member access operator) |
| x`(...)`            | method invocation ("()" --> method invocation operator)             |
| x`[...]`            | array access and indicization                                       |
| `new` T(...)        | object instantiation                                                |
| `x!`                | declare x as not nil                                                |

### Unary Operators

| Operator  | Operation       |
| --------- | --------------- |
| `+`x      | identity        |
| `-`x      | negation        |
| `!`x      | logic negation  |
| `~`x      | binary negation |
| `++`x     | pre-increment   |
| `--`x     | pre-decrement   |
| x`++`     | post-increment  |
| x`--`     | post decrement  |
| `(type)`x | explicit casting |

### Mathematical Operators

| Operator | Operation                                             |
| -------- | ----------------------------------------------------- |
| x `+` y  | addition, string concatenation                        |
| x `-` y  | subtraction                                           |
| x `*` y  | multiplication                                        |
| x `/` y  | integer division, **always** returns an `int`         |
| x `%` y  | modulo, remainder                                     |
| x `<<` y | left bit shift                                        |
| x `>>` y | right bit shift                                       |

### Relational Operators

| Operator | Operation                              |
|----------|----------------------------------------|
| x `<=` y | less or equal to                       |
| x `>` y  | greater than                           |
| x `>=` y | greater or equal to                    |
| x `is` T | `true` if `x` is an object of type `T` |
| x `==` y | equality                               |
| `!`x     | inequality                             |

### Logical Operators

| Operator     | Operation                                             | Name             |
|--------------|-------------------------------------------------------|------------------|
| `~`x         | bitwise NOT                                           |
| x `&` y      | bitwise AND                                           |
| x `^` y      | bitwise XOR                                           |
| x `|` y      | bitwise OR                                            |
| x `&&` y     | evaluate `y` only if `x` is `true`                    |
| x `||` y     | evaluate `y` only if `x` is `false`                   |
| x `??` y     | evaluates to `y` only if `x` is `nil`, `x` otherwise  | nil coalescing  |
| x`?.`y       | stop if `x == nil`, evaluate `x.y` otherwise          | nil conditional |

### Assignment

| Operator  | Operation              |
|-----------|------------------------|
| x `+=` y  | x = x + y              |
| x `-=` y  | x = x - y              |
| x `*=` y  | x = x * y              |
| x `/=` y  | x = x / y              |
| x `%=` y  | x = x % y              |
| x `<<=` y | x = x << y             |
| x `>>=` y | x = x >> y             |
| x `&=` y  | x = x & y              |
| x `|=` y  | x = x | y              |
| x `^=` y  | x = x ^ y              |
| x `??=` y | if (x == nil) {x = y} |

### Conditional Operator

`<condition> ? <return_if_condition_true> : <return_if_condition_false>;`

### Nil Checks

```swift
variable ?? value
// same as
if(variable == nil) { variable = value }
```

## If-Else

```swift
if condition {
    // code here
} else if condition {
    //code here
} else {
    // code here
}

if let var0 = var1 { /* statements */ }
// same as
let var0 = var1
if var0 != nil { /* statements */ }
```

### Switch

```swift
switch <value> {
    case <pattern/key>:
        // code here
        break  // can be implicit

    case key where <condition_on_key>:
        // code here
        break

    default:
        // code here
        break
}
```

## Loops

### For Loop

```swift
// range based for
for i in start...end { /* statements */ }  // end included
for i in start..<end { /* statements */ }  // end excluded
for _ in start...end

for item in sequence {
    // code here
}

for (key, value) in dict {
    // code here
}
```

### While Loop

```swift
while condition {
    // code here
}

// "do"..while
repeat {
    // code here
} while condition
```

## Functions

```swift
// "void function"
func funcName(param: Type, ...) {
    // code here
}

func funcName(param: Type = defaultValue, ...) -> Type {
    //code here
    return <expression>
}

func funcName(param: Type) -> Type {
    <expression>  // implicit return
}

// func call MUST have parameter's names
funcName(param: value, ...)

// multiple return values
func funcMultipleParameters(param: Type) -> (retVal1: Type, retVal2: Type) {
    //code here

    return (<expression>, <expression>)
}

var result = funcMultipleReturns(param: value)
result.retVal1  // access to tuple components

// argument labels (only first label can be omitted)
func funcWithLabels(_ param: Type, label param: Type, ...) -> Type { }
funcWithLabels(value, label: value, ...)
```

### Passing Functions as Parameters

```swift
func f(param: Type) -> Type {}
func g(f: (Type) -> Type) {}  // (Type) -> Type are the passed func input and output types
```

### Functions Returning Functions

```swift
func f() -> ((Type) -> Type) {
    func g(param: Type) -> type {}

    return g
}
```

## [Closure](https://docs.swift.org/swift-book/LanguageGuide/Closures.html) (`{ .. }`)

**Closures** are self-contained blocks of functionality that can be passed around and used in code.
Closures in Swift are similar to blocks in C and Objective-C and to lambdas in other programming languages.

```swift
{ (parameters: Type) -> Type in
    // statements
}

{ parameters in return <expression> }  // type inference from context
{ $0 > $1 }  // $<n> identifies the n-th argument, IN can be omitted if closure has only the body
```

## [Enums](https://docs.swift.org/swift-book/LanguageGuide/Enumerations.html)

### Enum Definition

```swift
enum EnumName {
    case key1
    case key2
    case ...
}

EnumName.key1 // key1
```

### Enum with Raw Values

```swift
enum EnumName: Type {
    case key1 = value
    case key2 = value
    case ...
}

EnumName.key1.rawValue  // value

enum IntegerEnum: Int {
    // the value of each case is one more then the previous case
    case one = 1
    case two, three, four
    case ...
}
```

### Matching Enumeration Values with a Switch Statement

```swift
enum Rank: Int {
    case ace = 1, two, three, four, five, six, seven, eight, nine, ten
    case jack, queen, king

    func getValue() -> String {
        switch self {

        case .jack:
            return "jack"

        case .queen:
            return "queen"

        case .king:
            return "king"

        default:
            return String(self.rawValue)
        }
    }
}

Rank.jack.getValue() // "jack"
Rank.jack.rawValue // 11
```

## Struct (Value Type)

```swift
struct StructName {
    var attribute = value  // instance variable
    private var _attribute: Type  // backing field for property

    var property: Type {
        get { return _attribute }

        set { _attribute = newValue }  // newValue contains the passed value
        // OR
        set(param) { _attribute = param }
    }

    // constructor
    init(param: Type) {
        self.attribute = param  // attribute valorization
    }

    // de-initializer (free memory containing obj?)
    deinit {
        // empty the attributes
    }

    // overloading
    func method() -> Type { }
    func method(param: Type, ...) -> Type { }
}

var structure = StructName()  // struct instantiation
```

## Classes (Reference Type)

### Class Definition & Instantiation

```swift
class ClassName {
    var attribute = value  // instance variable
    private var _attribute: Type  // backing field for property

    var property: Type {
        get { return _attribute }

        set { _attribute = newValue }  // newValue contains the passed value
        // OR
        set(param) { _attribute = param }
    }

    // constructor
    init(param: Type) {
        self.attribute = param  // attribute valorization
    }

    // de-initializer (free memory containing obj?)
    deinit {
        // empty the attributes
    }

    // overloading
    func method() -> Type { }
    func method(param: Type, ...) -> Type { }
}

var obj = ClassName()  // obj instantiation
```

### Property Observers `willSet` & `didSet`

Do actions before/after modifying a property value.

> **Note**: `willSet` and `didSet` do not *set* the value of the property.

```swift
class ClassName {

    var _attribute: Type

    var property {
        get { return _attribute }
        set{ _attribute = newValue }

        willSet {
            // act before setting the property value
        }

        didSet {
            // act after setting the property value
        }
    }
}
```

### Inheritance

```swift
class Derived: SuperClass {

    var attribute: Type

    init(param1: Type, param2: Type) {
        self.attribute = param1
        super.init(param: param2 )  // superclass init (NEEDED)
    }

    // overriding
    override func method() {}
}
```

### Exception Handling

```swift
guard let variable = <expression>
else {
    /* statements */
    // throw or return to exit code branch
}


do {
    try <throwing expression>
} catch <pattern> {
    // statements
}
```