feat: restructure docs into "chapters" (#12)

* feat(docker, k8s): create containers folder and kubernetes notes

docs/languages/swift/swift.md

@@ -0,0 +1,538 @@
+# 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
+}
+```