let catsMaximumNumberOfLives = 9 // constant
var catsCurrentDeathCount = 0 // variable
catsCurrentDeathCount = 3
catsMaximumNumberOfLives = 10 // this would generate a compiler error

// multiple constants or variables on a single line:
var variable1 = 0.0, variable2 = 1.2, variable3 = 5.6

var welcomeMessage: String = "Welcome!"
var red: Double = 1.0
var someNumber: Int = 9

let sameLineGuru = "Same Liner"; print("This is Mr. \(sameLineGuru)")

// Int is usually used, it's the same size as `Int32` on 32-bit platform and same size as `Int64` on 64-bit platform
let integer: Int
let integer8: Int8 = 8 // signed 8-bit integer, UInt8 for unsigned
let integer16: Int16 = 16 // signed 16-bit integer, UInt16 for unsigned
let integer32: Int32 = 32 // signed 32-bit integer, UInt32 for unsigned
let integer64: Int64 = 64 // signed 64-bit integer, UInt64 for unsigned

print("maximum value of UInt16 is \(UInt16.max) which is (2^16)-1 = \(Int(pow(2.0, 16.0) - 1))")
print("minimum value of Int8 is \(Int8.min) which is -(2^(8-1)) = \(-Int(pow(2.0, 8.0 - 1.0)))")
print("maximum value of Int32 is \(Int32.max) which is (2^(32-1))-1 = \(Int(pow(2.0, 32.0 - 1.0)) - 1)")

let youth = 3
// inferred to be type `Int`

let feelingOfYouth = 0.14
// inferred to be type `Double`

let pi = 3 + 0.1415926
// Inferred to be type `Double`

let anotherPi = youth + feelingOfYouth
// error: binary operator '+' cannot be applied to operands of type 'Int' and 'Double'

let alsoPi = Double(youth) + feelingOfYouth
let werePi = Int(alsoPi) // lost precision

typealias Mood = UInt8
print("mood: happy = \(Mood.max) sad = \(Mood.min)")

let fake = false
let truth = true

var b = 10
var a = 5
a = b // a is now equal to 10
let (x, y) = (1, 2) // x is 1 and y is 2

1 + 2       // addition (+)
5 - 3       // subtraction (-)
2 * 3       // multiplication (*)
10.0 / 2.5  // division (/)
9 % 4       // remainder (%)
-5          // unary minus
+6          // unary plus

a = 1
a += 2
a -= 5
a *= 3
a /= 2

1 == 1  // equal to
2 != 1  // not equal to
2 > 1   // greater than
1 < 2   // less than
1 >= 1  // greater than or equal to
2 <= 1  // less than or equal to

(1, "zebra") < (2, "apple")
// 1 is less than 2 and "zebra" and "apple" are not compared

(3, "apple") < (3, "orange")
// 3 is equal to 3 and "apple" is less than "orange"

(4, "dog") == (4, "dog")
// all equal

let someCoordinates: (Int, Int) = (3, 6)
let someOtherCoordinates = (21, 97)
// type inference without type `(Int, Int)`

// access value by index:
print("some coordinate is (\(someCoordinates.0), \(someCoordinates.1))");

// access value by name:
let someCoordinatesNamed = (x: 71, y: 89)
print("some coordinate has x = \(someCoordinatesNamed.x) and y = \(someCoordinatesNamed.y)")

let someArray = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(someArray[5...]) // [6, 7, 8, 9]
print(someArray[...3]) // [1, 2, 3, 4]

let isOnePlusOneEqualThree = (1 + 1) == 3
false, `==` equality comparison

let isFake = isOnePlusOneEqualThree == false

if isFake == true {
    print("The truth is fake.")
}

let isGovernmentGreaterThanItsPeople = "government" > "people"
if isGovernmentGreaterThanItsPeople && 1 + 1 == 2 {
    // because the first condition is false
    // there's no need to check the second condition even if it's true
    print("People should be afraid of their government.")
} else {
    print("Government should be afraid of its people.")
}
// Result: Government should be afraid of its people.

let someoneIsDrunk = true
let divorceAgreementReadyToSign = true

if someoneIsDrunk || divorceAgreementReadyToSign == false {
    // even if the divorce agreement is ready to sign
    // since the person is drunk, ie. first condition is true
    // there's no need to check the second condition
    print("Let's decide later.")
}

let weightOfMountain = 9
let weightOfFeather = 1
let onesLife = 0
let anotherOnesLife = 10

var lifeDescription = onesLife < weightOfFeather ? "lighter than a feather" : "more than a feather"
print("Someone's life is \(lifeDescription).")
// Someone's life is lighter than a feather.

lifeDescription = anotherOnesLife > weightOfMountain ? "heavier than a mountain" : "less than a mountain"
print("Someone's life is \(lifeDescription).")
// Someone's life is heavier than a mountain.

let weekendStarts = 6
var today = 1
while today < weekendStarts {
    print("Day \(today): start the day with a smile, after that you can be your nasty lazy but true self again.")
    today += 1
}
print("Day \(today): finally weekend")

var waterInCup = 5

repeat {
    if (waterInCup > 0) {
        print("Like this cup, you are full of opinions and speculations.\nTo see the light of wisdom, you first must empty your cup before adding more.")
        waterInCup -= 1
    }
} while waterInCup > 0

let totalVersions = 5
for currentVersion in 1...totalVersions {
    print("Current version: \(currentVersion)")
}

let versionNumberOfBadLuck = 4
for currentVersion in 1...totalVersions where currentVersion != versionNumberOfBadLuck {
    print("Current version: \(currentVersion)")
}

for currentVersion in 1...totalVersions {
    if currentVersion == versionNumberOfBadLuck {
        print("We skip version \(currentVersion) to avoid bad luck.")
        continue // start next loop and ignore the remaining loop code
    }
    print("Current version: \(currentVersion)")
}
// output:
// Current version: 1
// Current version: 2
// Current version: 3
// We skip version 4 to avoid bad luck.
// Current version: 5

let numberOfLovers = 3
let datesPerLover = 2
let wifesFriend = 2
let datingWithWife = 1

lover: for currentLover in 1...numberOfLovers {
    date: for currentDate in 1...datesPerLover {
        print("lover \(currentLover) date \(currentDate)")
        if currentLover == wifesFriend {
            print("Do not date if lover is also wife's friend.")
            continue lover
        } else if currentDate == datingWithWife {
            print("Go dating with wife instead.")
            continue date
        }
        print("Dating with lover.")
    }
}

// output:
// lover 1 date 1
// Go dating with wife instead.
// lover 1 date 2
// Dating with lover.
// lover 2 date 1
// Do not date if lover is also wife's friend.
// lover 3 date 1
// Go dating with wife instead.
// lover 3 date 2
// Dating with lover.

let occupied = true, unoccupied = false
var gender = "boy" // try changing it to "girl"
var toiletOccupancy = (male: occupied, female: unoccupied) // try changing occupied and unoccupied

switch toiletOccupancy {
case let (male, female) where male != female:
    print("At least one toilet is empty")
fallthrough // continue the statements below
case (male: true, _) where gender == "boy":
    // male toilet is empty
    // and boys do not care about female toilet
    print("boy can use toilet now")
case (_, female: true) where gender == "girl":
    // female toilet is empty
    // and girls do not care about male toilet
    print("girl can use toilet now")
case (male: true, female: false) where gender == "girl":
    print("girl has to use boy's toilet if urgent")
case (male: false, female: true) where gender == "boy":
    print("boy has to use girl's toilet if urgent")
default:
    // **exhaustive**: every possible value of the control expression’s type
    // must match the value of at least one pattern of a case
    // `default case` can be used to satisfy this if it's not feasible.
    break;
}

var schoolYear = 3 // try changing it to something within 1...12
switch schoolYear {
case 1...3:
    print("You don't know you don't know.")
case 4...6:
    print("You know you don't know.")
case 7...9:
    print("You don't know you know.")
case 10...12:
    print("You know you know.")
default:
    // exhaustive: “every possible value of the control expression’s type
    // must match the value of at least one pattern of a case”
    // `default case` can be used to satisfy this if it's not feasible.
    break
}

func add(a: Int, b: Int) -> Int {
    return x + y
}

func sayHi(to person: String) {
    print("Hi, \(person)!")
}

sayHi(to: "future")

func sayHi(_ person: String) {
    print("Hi, \(person)!")
}

sayHi("people")

let vampiresAppetite = 0.4
func payTax(for income: inout Double) {
    income *= (1.0 - vampiresAppetite)
}

var income = 100.00
payTax(for: &income)

print("After tax, income becomes \(income)")
// Prints "After tax, income becomes 60.0"

func makeMoneyDeductor(with percentage: Double) -> ((Double) -> Double) {
    // define and return another function:
    func bloodSuckingVampire(bloodQuantity: Double) -> Double {
        return bloodQuantity * (1 - percentage)
    }
    return bloodSuckingVampire
}

let taxOffice = makeMoneyDeductor(with: 0.3)
let laywer = makeMoneyDeductor(with: 0.2)
let dentist = makeMoneyDeductor(with: 0.1)

income = 10_000.00
print("Start with income \(income)")
income = taxOffice(income)
income = laywer(income)
income = dentist(income)
print("After tax, laywer and dentist, now it becomes \(income)")
// output:
// Start with income 10000.0
// After tax, laywer and dentist, now it becomes 5040.0

func oneInfiniteLoop() -> Never {
    print("DO NOT CALL THIS FUNCTION OR:")
    while true {
        print("Falling apple on your head.")
    }
}

/// Returns a substitution of something.
/// - Parameters:
///   - something: a string value of something
/// - Returns: "lie" if something is "truth", a very poor substitute, but the only one discovered to date; returns the same thing otherwise
func substitution(of something: String) -> String {
    if something == "truth" {
        return "lie"
    }
    return something
}

var errorCode: Int?
errorCode = 404
errorCode = nil

let optionalDrink: String? = "Beer"
print("\(String(describing: optionalDrink))")
// output: Optional("Beer")
if let drink = optionalDrink {
    print("\(drink)") // Beer
}

errorCode = 500
print("Error code is \(errorCode!)")

var someNumbers = [Int]()

someNumbers.append(9)
someNumbers = [] // type has been provided as `Int`

var threeFloats = Array(repeating: 1.2, count: 3)
result: [1.2, 1.2, 1.2]

let threePowers = ["Executive", "Legislative", "Judicial"]
let twoPowers = ["Supervision Audit", "Examination"]
let fivePowers = threePowers + twoPowers

var shoppingList = ["Wine", "Coffee", "Cigarette"]
print("Shopping list has \(shoppingList.count) items")

if shoppingList.isEmpty {
    print("Shopping list is empty")
} else {
    print("Shopping list isn't empty")
}

shoppingList.append("Panado")
shoppingList += ["Meat", "Tea"]

var firstItem = shoppingList[0]

shoppingList[3] = "Egg"
shoppingList[3...4] = ["Energy Drink"]
shoppingList: ["Wine", "Coffee", "Cigarette", "Energy Drink", "Tea"]

shoppingList.insert("Honey", at: 0)
let honey = shoppingList.remove(at: 0)

for item in shoppingList {
    print("Shopping list item: \(item)")
}

// iterating with index
for (index, item) in shoppingList.enumerated() {
    print("Shopping list item \(index): \(item)")
}

var letters = Set<Character>()
letters.insert("a")
letters = []

var someColors: Set<String> = ["Blue", "White", "Red"]
var someOtherColors: Set = ["Sunset", "Autumn", "Zen"]

print("Other colors have \(someOtherColors.count) colors")

if someOtherColors.isEmpty {
    print("No color, is the real color.")
} else {
    print("There are a few colors in it.")
}

someColors.insert("Cyan")
if let removedColor = someColors.remove("Yellow") {
    print("\(removedColor) removed from someColors")
} else {
    print("someColors does not have Yellow in it")
}

func twoSum(numbers: [Int], _ target: Int) -> Bool {
    var set = Set<Int>()

    for number in numbers {
        if set.contains(target - number) {
            return true
        }
        set.insert(number)
    }
    
    return false
}

func twoSumIndices(numbers: [Int], _ target: Int) -> (Int, Int)? {
    var dict = [Int: Int]()
    for (index, number) in numbers.enumerated() {
        if let lastIndex = dict[target - number] {
            return (lastIndex, index)
        } else {
            dict[number] = index
        }
    }
    return nil
}

// creating empty dictionary:
var meaningsOfAges = [String: String]()
meaningsOfAges["eighteen"] = "By which the acquired collection of prejudices become common sense"

if meaningsOfAges.isEmpty == false {
    print("At least one age has some meaning")
}

meaningsOfAges["four"] = "at which we know all the questions"
meaningsOfAges["eighteen"] = "at which we know all the answers"

if let meaningOf18 = meaningsOfAges["eighteen"] {
    print("The meaning of age 18:\n\(meaningOf18)")
}
// output:
// Meaning of eighteen: at which we know all the answers

for (age, meaning) in meaningsOfAges {
    print("Meaning of \(age): \(meaning)")
}
// output:
// Meaning of four: at which we know all the questions
// Meaning of eighteen: at which we know all the answers

let matters = ["🥚", "🐓"]
let sortedMatters = matters.sorted(by: { (m1: String, m2: String) -> Bool in
    m1 < m2
})
print("first there's \(String(describing: sortedMatters.first!))")
print("then there comes \(String(describing: sortedMatters.last!))")

matters.sorted { (m1, m2) -> Bool in
    m1 > m2
}

matters.sorted { (m1, m2) in m1 > m2 }

matters.sorted { $0 > $1 }

matters.sorted(by: >)

var executionGround: [() -> Void] = []

func executionSuspended(prisonerExecution: @escaping () -> Void) {
    executionGround.append(prisonerExecution)
}

func executionImmediate(prisonerExecution: () -> Void) {
    prisonerExecution() // execute immediately
}

executionSuspended {
    print("Summer is here, will autumn be far away?")
}

executionImmediate {
    print("Don't laugh if I lay drunken on the battleground, how many warriors ever came back safe and sound?")
    // only this is executed
}

var toBeInDinnerPlate = ["Chicken", "Duck", "Fish", "Pork"]
print(toBeInDinnerPlate.count) // Prints "4"

let dinnerProvider = { toBeInDinnerPlate.remove(at: 0) }
print(toBeInDinnerPlate.count) // Prints "4"

print("Now serving \(dinnerProvider())!")
// Prints "Now serving Chicken!"
print(toBeInDinnerPlate.count) // Prints "3"

// parameter: () -> String
// argument is auto converted to a closure
func serve(dinner provider: @autoclosure () -> String) {
    print("Now serving \(provider())!")
}

// now can pass a String
serve(dinner: "Vegetable")
// "Vegetable" will be converted to a closure that returns this string
// which is only evaluated when being called

func ||(left: Bool, right: Bool) -> Bool {
    if left {
        return true
    } else {
        return right
    }
}

func ||(left: Bool, right: @autoclosure () -> Bool) -> Bool {
    if left {
        return true
    } else {
        return right()
    }
}

(0...10).map { $0 * $0 }.filter { $0 % 2 == 0 }

func unique(_ array: [Int]) -> [Int] {
    return array.reduce(into: []) { (result, number) in
        if result.contains(number) == false {
            result.append(number)
        }
    }
}

func even(_ array: [Int]) -> [Int] {
    return array.filter { $0 % 2 == 0 }
}

func square(_ array: [Int]) -> [Int] {
    return array.map { $0 * $0 }
}

precedencegroup Group { associativity: left }
infix operator >>> : Group
func >>><T, U, V>(left: @escaping (T) -> U, right: @escaping (U) -> V) -> ((T) -> V) {
    return { right(left($0)) }
}

let testIntArray = [1, 2, 3, 4, 5, 6, 7, 8, 9]
var resultArray = (unique >>> even >>> square)(testIntArray)
print("result: \(resultArray)")

let numberOfMonks = [1, 2, 3]
let hasWaterToDrink: [(Int, Bool)] = numberOfMonks.map { monks in
    return (monks, monks < 3)
}
hasWaterToDrink.forEach { (numberOfMonks, hasWater) in
    print("\(numberOfMonks) monks, water to drink? \(hasWater ? "YES" : "NO")")
}
// output:
// 1 monks, water to drink? YES
// 2 monks, water to drink? YES
// 3 monks, water to drink? NO

let couldBeNumbers = ["1", "3", "five", "12"]
let compactedNumbers = couldBeNumbers.compactMap { Int($0) }
print(compactedNumbers)
// result: [1, 3, 12]
let mappedNumbers = couldBeNumbers.map { Int($0) }
print(mappedNumbers)
// result: [Optional(1), Optional(3), nil, Optional(12)]

let bloodTemperatureByGroup = ["A": [0, 36, 48], "B": [12, 32, 39]]
let temperaturesMapped = bloodTemperatureByGroup.map { $0.value }
print(temperaturesMapped)
// output: [[12, 32, 39], [0, 36, 48]]
let temperaturesFlatened = bloodTemperatureByGroup.flatMap { $0.value }
print(temperaturesFlatened)
// output: [12, 32, 39, 0, 36, 48]

let quotationSingleLine = "There be light."
let quotationMultiLine = """

And God said, \
Let there be light:
and there was light.

"""

var emptyString = ""
var anotherEmptyString = String()

if emptyString.isEmpty {
    print("Unfortunately the emptiness of a string can't be derived from its name.")
}

emptyString += "no longer empty"

for character in "Dog🐶Inside!" {
    print(character)
}

let nethackCharacters: [Character] = ["T", "h", "e", " ", "n", "e", "w", "t", " ", "b", "i", "t", "e", "s"]
var nethackString = String(nethackCharacters)
print(nethackString)
// Prints "The newt bites"

nethackString += "!"

let eAcute: Character = "\u{E9}"
// é

let combinedEAcute: Character = "\u{65}\u{301}"
// e followed by  ́ (the thing above e)

var word = "cafe"
word.count // 4
word += "\u{301}"
word.count // word is now "café" but count is still 4

let science = "ABCDEFGHIJKMNPQRTVWXYZ"
print(science[science.startIndex]) // A
print(science[science.index(before: science.endIndex)]) // Z
print(science[science.index(after: science.startIndex)]) // B
let index7 = science.index(science.startIndex, offsetBy: 7)
print(science[index7]) // H

var indexS: String.Index? = science.firstIndex(of: "S")
var indexO: String.Index? = science.firstIndex(of: "O")
var indexU: String.Index? = science.firstIndex(of: "U")
var indexL: String.Index? = science.firstIndex(of: "L")

if (indexS == nil && indexO == nil && indexU == nil && indexL == nil) {
    print("science has no SOUL")
}

var sentence = "you understand"
sentence.insert(contentsOf: "could ", at: sentence.startIndex)
sentence.insert(contentsOf: "?", at: sentence.endIndex)
print(sentence)
// Print: "could you understand?"

let range1 = sentence.range(of: "oul")!
sentence.replaceSubrange(range1, with: "ulo")
let range2 = sentence.range(of: "nderstan")!
sentence.replaceSubrange(range2, with: "redntsna")
print(sentence)
// Prints: "culod you uredntsnad?"

let englishForDummy = "therapist"
let indexOfR = englishForDummy.firstIndex(of: "r")!
let firstWord = englishForDummy[..<indexOfR]
let lastWord = englishForDummy[indexOfR...]
print("Have you ever realised the word \"\(englishForDummy)\" is made up by \"\(String(firstWord))\" and \"\(String(lastWord))\"?")
// output:
// Have you ever realised the word "therapist" is made up by "the" and "rapist"?

func reverse<T>(_ things: inout [T], _ start: Int, _ end: Int) {
    var startIndex = start, endIndex = end
    while startIndex < endIndex {
        (things[startIndex], things[endIndex]) = (things[endIndex], things[startIndex])
        startIndex += 1
        endIndex -= 1
    }
}

func reverseWords(_ s: String?) -> String? {
    guard let s = s else {
        return nil
    }
    
    var mutableString = Array(s), start = 0
    reverse(&mutableString, 0, mutableString.count - 1)
    
    for i in 0..<mutableString.count {
        if i == mutableString.count - 1 || mutableString[i + 1] == " " {
            reverse(&mutableString, start, i)
            start = i + 2
        }
    }
    
    return String(mutableString)
}

reverseWords("what the f**k")
// output:
// f**k the what

let raw1 = #"Eating "raw" fish will not \(interpolate) the string including slash \"#
let raw2 = ##"Use # in raw string is also possible as long as the open and close hashes match!"##
let raw3 = #"You can also use raw in raw: \#(raw1)"#

enum PlanetVertical {
    case mercury
    case venus
    case earth
    case mars
    case jupiter
    case saturn
    case uranus
    case neptune
}

enum PlanetHorizontal {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

enum Direction {
    case north
    case west
    case south
    case east
}

var lostDirection: Direction = .north
var nextDirection = Direction.east

lostDirection = .north
nextDirection = .west

switch lostDirection {
case .north, .west, .south:
    print("Lost in the wild")
case .east:
    print("You need a pilot")
}

switch nextDirection {
case .east:
    print("Be prepared.")
default:
    print("Why not heading east?")
}

enum DailyAttendence {
    case attended
    case unattended(execuse: String, realReason: String)
}

func teacherEvaluate(_ attendence: DailyAttendence) {
    switch attendence {
    case .attended:
        print("Keep up")
    case .unattended(_, let realReason):
        // teacher know your execuse and only care about real reason
        print("I need to talk to your parents regarding \(realReason)")
    }
}

func managerEvaluate(_ attendence: DailyAttendence) {
    switch attendence {
    case .attended:
        print("Keep up")
    case .unattended(let execuse, _):
        print("I'm fine with \(execuse)")
    }
}

func selfEvaluate(_ attendence: DailyAttendence) {
    switch attendence {
    case .attended:
        print("A boring day")
    case let .unattended(execuse, realReason):
        print("I have \"\(execuse)\" as execuse for the real reason of \"\(realReason)\"")
    }
}

let jackyAttendence: DailyAttendence = DailyAttendence.unattended(execuse: "alarm clock stopped working", realReason: "late sleep watching TV")
teacherEvaluate(jackyAttendence)
// I need to talk to your parents regarding late sleep watching TV

let goodsonAttendence: DailyAttendence = DailyAttendence.attended
teacherEvaluate(goodsonAttendence)
// keep up

let mrUnsatisiable: DailyAttendence = DailyAttendence.unattended(execuse: "sick", realReason: "job interview")
managerEvaluate(mrUnsatisiable)
// I'm fine with sick

selfEvaluate(mrUnsatisiable)
// I have "sick" as execuse for the real reason of "job interview"

enum Month : Int {
    case january = 1
    case feburary // 2
    case march // 3
    case april // 4
    case may // 5
    case june // 6
    case july // 7
    case august // 8
    case september // 9
    case october // 10
    case november // 11
    case december // 12
}

print("September has a value of \(Month.september.rawValue)")
// Print "September has a value of 9"

enum SomeNames : String {
    case michael
    case tom
    case jack
}

print("case tom has raw value of \(SomeNames.tom.rawValue)")
// Print "case tom has raw value of tom"

var monthNumber = 7
if let month = Month(rawValue: monthNumber) {
    switch month {
    case .july:
        print("Month of examination, graduation and boy/girl-friend breaking up.")
    default:
        print("Some other month")
    }
} else {
    print("Cannot recognize month number")
}

enum Trap {
    case rightWayOut
    indirect case wayOut(Trap)
}

let eternity = Trap.wayOut(Trap.rightWayOut)
let love = Trap.wayOut(eternity)

func escape(from trap: Trap) {
    switch trap {
    case .rightWayOut:
        print("Found the right way out")
    case .wayOut(let anotherTrap):
        print("Fall into another trap")
        escape(from: anotherTrap)
    }
}

escape(from: love)
// Fall into another trap
// Fall into another trap
// Found the right way out

enum Season: String, CustomStringConvertible {

    case spring
    case summer
    case autumn
    case winter

    mutating func next() {
        switch self {
        case .spring:
            self = .summer
        case .summer:
            self = .autumn
        case .autumn:
            self = .winter
        case .winter:
            self = .spring
        }
    }
    
    var description: String {
        return "It's \(self.rawValue) now."
    }
}

var currentSeason = Season.spring
print(currentSeason)
currentSeason.next()
print(currentSeason)

// output:
// It's spring now.
// It's autumn now.

enum StageOfLove: String {
    case acquaint
    case inLove
    case marriage
    case accustomed
    case bored
    case stranger
    case separate
    case lost
}

extension StageOfLove {
    func next() -> StageOfLove {
        guard self != .lost else {
            preconditionFailure("love ends here!")
        }
        
        switch self {
        case .acquaint:
            return .inLove
        case .inLove:
            return .marriage
        case .marriage:
            return .accustomed
        case .accustomed:
            return .bored
        case .bored:
            return .stranger
        case .stranger:
            return .separate
        case .separate:
            return .lost
        default:
            preconditionFailure()
        }
    }
}

extension StageOfLove: CustomStringConvertible {

    var description: String {
        switch self {
        case .acquaint, .inLove, .marriage, .accustomed:
            return "You are the one"
        case .bored, .stranger, .separate:
            return "Memory fades as time goes by, we got seperated as we were pacing."
        case .lost:
            return "The moment I turned round, I found that you were not there. Suddenly, I was flustered."
        }
    }
}

var currentStage = StageOfLove.acquaint
var nextStage = currentStage.next()
print("\(currentStage.rawValue) becomes \(nextStage.rawValue)")

currentStage = nextStage
nextStage = currentStage.next()

print("\(currentStage.rawValue) becomes \(nextStage.rawValue)")

currentStage = nextStage
nextStage = currentStage.next()

print("\(currentStage.rawValue) becomes \(nextStage.rawValue)")

currentStage = nextStage
nextStage = currentStage.next()

print("\(currentStage.rawValue) becomes \(nextStage.rawValue)")

currentStage = nextStage
nextStage = currentStage.next()

print("\(currentStage.rawValue) becomes \(nextStage.rawValue)")

currentStage = nextStage
nextStage = currentStage.next()

print("\(currentStage.rawValue) becomes \(nextStage.rawValue)")

currentStage = nextStage
nextStage = currentStage.next()

print(currentStage)
print(nextStage)

// output:
// acquaint becomes inLove
// inLove becomes marriage
// marriage becomes accustomed
// accustomed becomes bored
// bored becomes stranger
// stranger becomes separate
// Memory fades as time goes by, we got seperated as we were pacing.
// The moment I turned round, I found that you were not there. Suddenly, I was flustered.

enum Response<SuccessType, ErrorType> {
    case success(SuccessType)
    case failure(ErrorType)
}

let response1 = Response<String, Int>.success("valid response")
let response2 = Response<String, Int>.failure(404)

func print(response: Response<String, Int>) {
    switch response {
    case .success(let message):
        print("success message: \(message)")
    case .failure(let errorCode):
        print("error code: \(errorCode)")
    }
}

print(response1)
print(response2)

class Love { // class name
    // <statements>
    // }

    // by default, love cannot persist
    static let defaultPersistency = false

var name: String?
let thorny = true // constant
    
// inferred boolean variable
var isPersistent = defaultPersistency
var looksPretty: Bool // variable

// computed property must be variable
var tastesGood: Bool {
    return !looksPretty
}

lazy var complexity: Int = { [unowned self] in
    if let name = self.name {
        return name.lengthOfBytes(using: .utf8)
    } else {
        return 0
    }
}()

// non-optional properties must be initialized before use
init(looksPretty: Bool, name: String? = nil) {
    self.looksPretty = looksPretty
    self.name = name
}

func printDescription() {
    Love.printNotes(about: self)
}

// `final` indicates cannot be overwritten
final func displayName() -> String {
    return self.name ?? self.defaultName()
}

func defaultName() -> String {
    return "love"
}

// called when no reference to the instance, ie. reference counter reaches 0
deinit {
    print("\(self.displayName()) disappeared in a puff of logic")
}

static func printNotes(about love: Love) {
    let displayName = love.displayName()
    print("Notes about \(love.defaultName()):")

    if let name = love.name {
        print("\(love.defaultName()) has a name of \"\(name)\"")
    } else {
        print("\(love.defaultName()) has noname")
    }

    if love.thorny {
        print("\(displayName) is thorny")
    }

    if love.isPersistent {
        print("\(displayName) lasts forever")
    } else {
        print("\(displayName) \(Love.defaultPersistency ? "lasts forever" : "doesn't last long") by default")
    }

    let look = love.looksPretty ? "looks pretty" : "looks ugly"
    let taste = love.tastesGood ? "tastes good" : "tastes bad"

    if love.looksPretty == love.tastesGood {
        print("\(displayName) \(look) and \(taste)")
    } else {
        print("\(displayName) \(look) but \(taste)")
    }
}

    var notes: String? {
        willSet {
            if let newNotes = newValue {
                print("Notes will be \(newNotes)")
            }
        }
        didSet {
            if let notes = self.notes, let oldNotes = oldValue {
                print("Notes has been set to \(notes) from \(oldNotes)")
            }
        }
    }

let someLove = Love(looksPretty: false)
someLove.printDescription()
let someHate = Love(looksPretty: true, name: "Hate")
someHate.isPersistent = true
someHate.printDescription()

struct Address {
    
    // type constant
    static let format = "British"
    
    var nickName: String
    var streetNumber: String
    var streetName: String
    var suburb: String
    var state: String
    var postcode: String
    var country: String
    
    var fullAddress: String {
        return "\(streetNumber) \(streetName), \(suburb), \(state) \(postcode), \(country)"
    }
    
    mutating func updateNickName(_ nickName: String) {
        self.nickName = nickName
    }
}

print("Using \(Address.format) format")

// default struct-wise initializer
let address = Address(nickName: "Beehive", streetNumber: "123", streetName: "Straight Street", suburb: "Curveless", state: "XYZ", postcode: "1234", country: "Unobtainable")
print(address.fullAddress)
// output:
// Using British format
// 123 Straight Street, Curveless, XYZ 1234, Unobtainable

// hate is a kind of love
class Hate: Love {

    init() {
        super.init(looksPretty: false, name: "exclusive love")
        self.isPersistent = true
    }
    
    // `override` keyword used here
    override func defaultName() -> String {
        return "hate"
    }
}

let moreHate = Hate()
moreHate.printDescription()

let fakeLove = someLove
print("someLove is fakeLove? \(someLove === fakeLove)")

var shortTermLove: Love? = Love(looksPretty: true)
shortTermLove = nil
// output:
// love disappears in a puff of logic

protocol Rescuable {
    
    // method:
    func rescue()
    
    // property:
    var distanceToGod: UInt { get set }
    var hasBeenSaved: Bool { get }
    
    // initializer
    init?(initialDistanceToGod: UInt)
}

class Person: Rescuable {
    
    var distanceToGod: UInt
    
    // satisfied by a `required` initializer in non-final class
    required init?(initialDistanceToGod: UInt) {
        if initialDistanceToGod == 0 {
            print("Already rescued, not a human anymore")
            return nil
        }
        self.distanceToGod = initialDistanceToGod
    }
    
    func rescue() {
        if distanceToGod > 0 {
            distanceToGod -= 1
        }
    }
    
    var hasBeenSaved: Bool {
        return distanceToGod == 0
    }
}

protocol Evil {
    func fulfilDesire()
}

extension Person: Evil {
    func fulfilDesire() {
        self.distanceToGod += 1
    }
}

func commentary(of thing: Rescuable & Evil) {
    print("Something that is evil but rescuable")
    
    if thing.hasBeenSaved {
        print("God saved you")
    } else {
        print("distance to God: \(thing.distanceToGod)")
        thing.fulfilDesire()
        print("desire makes the distance to God becomes \(thing.distanceToGod)")
        thing.rescue()
        print("after rescue, distance to God becomes \(thing.distanceToGod)")
    }
}

let person = Person(initialDistanceToGod: 20)!
commentary(of: person)

let distance = person.distanceToGod
for _ in 1...distance {
    person.rescue()
}

commentary(of: person)
// output: "God saved you"

protocol ClassOnlyProtocol: AnyObject {
    func someMethodHere()
}

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

var humanWorld = ""
var hell = "full of evil"
swapValues(&humanWorld, &hell)
// `hell` is now empty, `humanWorld` is now "full of evil"

struct Universe<Matter> {
    var matters = [Matter]()
    mutating func create(_ matter: Matter) {
        self.matters.append(matter)
    }
    mutating func reject() -> Matter {
        return matters.removeLast()
    }
}

struct Planet {
    let name: String
}

var solarSystem = Universe<Planet>()
solarSystem.create(Planet(name: "Mercury"))
solarSystem.create(Planet(name: "Pluto"))
solarSystem.create(Planet(name: "Venus"))

print("Last planet being rejected by solar system: \(solarSystem.reject())")
// output:
// Last planet being rejected by solar system: Planet(name: "Venus")

func fight<G: GoodProtocol, E: EvilProtocol>(somethingGood: G, somethingEvil: E)

func fight(somethingGood: GoodProtocol, somethingEvil: EvilProtocol)

func exists(object: Equatable, in array: [Equatable]) -> Bool {
    return array.contains(object)
}

func exists<T: Equatable>(object: T, in array: [T]) -> Bool {
    return array.contains(object)
}

protocol Generator {
    associatedtype InputType
    associatedtype OutputType
    func generate(input: InputType) -> OutputType
}

protocol Transformable {
    associatedtype TransformType
    func transform() -> TransformType
}

protocol ChainedGenerator: Generator {
    associatedtype InputProvider: Generator where InputProvider.OutputType == InputType
    associatedtype OutputConsumer: Generator where OutputConsumer.InputType == OutputType
    func generate(input: InputProvider, consumer: OutputConsumer) -> OutputConsumer.OutputType
}

protocol Photosynthate {
    // photosynthate: n. the product of photosynthesis
    init()
    func emit()
}

class Photosynthesizer<T: Transformable, P: Photosynthate>: Generator where T.TransformType == P {
    func generate(input: T) -> P {
        return input.transform()
    }
}

struct CO2<P: Photosynthate>: Transformable {
    func transform() -> P {
        print("transforming CO2…")
        return P()
    }
}

struct Oxygen: Photosynthate {
    init() {}
    func emit() {
        print("emitting oxygen…")
    }
}

// Define a green plant that is a `Photosynthesizer` (thus a `Generator`), its input is CO2 (a `Transformable`) that can transform to `Oxygen`
let greenPlant = Photosynthesizer<CO2<Oxygen>, Oxygen>()
greenPlant.generate(input: CO2<Oxygen>()).emit()
// print:
// transforming CO2…
// emitting oxygen…

class DefaultGenerator<T: Transformable, O>: Generator where O == T.TransformType {
    func generate(input: T) -> O {
        return input.transform()
    }
}

class TransformBasedGenerator<T: Transformable>: Generator {
    func generate(input: T) -> T.TransformType {
        return input.transform()
    }
}

struct Conscience: Transformable {
    func transform() -> String {
        return "transforming conscience into opinions"
    }
}

let junkyard = TransformBasedGenerator<Conscience>()
print(junkyard.generate(input: Conscience()))
// print: transforming conscience into opinions

func compareTransform<T1: Transformable, T2: Transformable>(_ transformable1: T1, _ transformable2: T2) -> Bool where T1.TransformType == T2.TransformType, T1.TransformType: Equatable {
    let transformed1 = transformable1.transform()
    let transformed2 = transformable2.transform()
    return transformed1 == transformed2
}

struct Statement: CustomStringConvertible {
    let sentence: String
    let isTruth: Bool
    var description: String {
        return "This is a \(isTruth ? "true" : "false") statement."
    }
}

let statement1 = Statement(sentence: "The following statement is true", isTruth: true)
let statement2 = Statement(sentence: "The previous statement is false", isTruth: false)

let statements = [statement1, statement2]

extension Array where Element == Statement {
    var hasTrueStatement: Bool {
        return self.contains(where: { $0.isTruth })
    }
}

print("Has true statement? \(statements.hasTrueStatement ? "Y" : "N")")

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

let partialStatements = statements[[1, 0]]
print(partialStatements)

public class PublicPool {}
internal class InternalChangeRoom {}
fileprivate class MaleFilePrivateBath {}
private class PrivateLocker {}

public var publicFeedback = "Good"
internal let internalComments = "Not great"
fileprivate func someFilePrivateFunction() {}
private func privateFunctionRoom() {}

let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits // equals 11110000

let partialTruth: UInt8 = 0b11111000
let missingTruth: UInt8 = 0b00111001
let theRealTruth = partialTruth & missingTruth // equals 00111000

let upperTeeth: UInt8 = 0b01010101
let lowerTeeth: UInt8 = 0b10101010
let bite = upperTeeth | lowerTeeth // equals 11111111

let boysAndGirls: UInt8 = 0b00010100
let girlsAndBoys: UInt8 = 0b00000101
let nextGenerationExistence = boysAndGirls ^ girlsAndBoys
 // equals 00010001

var unsignedOverflow = UInt8.max // 255
// unsignedOverflow += 1 would cause an error
unsignedOverflow = unsignedOverflow &+ 1 // 0

2 + 3 % 4 * 5 // equals 17
2 + ((3 % 4) * 5) // equals 17

struct Characteristic {
    var spirit = false
    var material = false
}

infix operator &|
infix operator |&
prefix operator ...

extension Characteristic {
    
    static func && (left: Characteristic, right: Characteristic) -> Characteristic {
        return Characteristic(spirit: left.spirit && right.spirit, material: left.material && right.material)
    }
    
    static func || (left: Characteristic, right: Characteristic) -> Characteristic {
        return Characteristic(spirit: left.spirit || right.spirit, material: left.material || right.material)
    }
    
    static func &| (left: Characteristic, right: Characteristic) -> Characteristic {
        return Characteristic(spirit: left.spirit && right.spirit, material: left.material || right.material)
    }
    
    static func |& (left: Characteristic, right: Characteristic) -> Characteristic {
        return Characteristic(spirit: left.spirit || right.spirit, material: left.material && right.material)
    }
    
    static prefix func ... (c: Characteristic) -> String {
        switch (c.spirit, c.material) {
        case (true, false):
            return "Spirit without matter"
        case (false, true):
            return "Souless materialist"
        case (false, false):
            return "Neither spirit or material, initial void"
        case (true, true):
            return "Ordinary people, mind and body"
        }
    }
}

let spiritual = Characteristic(spirit: true, material: false)
let material = Characteristic(spirit: false, material: true)

let human = spiritual || material
let evil = spiritual &| material
let divine = spiritual |& material

print("Human: \(...human)")
print("Evil: \(...evil)")
print("Divine: \(...divine)")

let somethingImportant = "Don't struggle which side of bread you spread butter on - you eat both sides."
for _ in 1...3 {
    // repeat three times
    print(somethingImportant)
}

let someValue = 123

let point = (1, 9, 3)
switch point {
case let (x, 9, _):
    print("At y-coordinate 9, x-coordinates of \(x), there's something on the z-plane.")
default:
    break
}

let (goodNews, badNews): (Int, Int) = (2, 3)

let newsGoodBadPerDay = [(1, 0), (3, 2), (5, 7)]
for (goodNews, _) in newsGoodBadPerDay {print("ignore bad news, number of good news on the day: \(goodNews)")}

let someonesAge = 1
let (sometowsAge) = 2
let (somethreesAge): Int = 3

let kingsClothes: Int? = nil
if case .some(let x) = kingsClothes {
    print(x)
} else {
    print("Kid: the King has no clothes!")
}

if case let x? = kingsClothes {
    print(x)
} else {
    print("Kid: the King has no clothes!")
}

let spaceDust = (102, 57, 81)
switch spaceDust {
case (0, 0, 0):
    print("Origin")
case (-10...10, -10...10, -10...10):
    print("Around origin")
default:
    print("Somewhere else")
}

func ~=(pattern: String, value: Int) -> Bool {
    return pattern == "\(value)"
}

switch spaceDust {
case ("0", "0", "0"):
    print("Space dust starts from origin")
default:
    print("Space dust has gone from origin")
}

enum SorrowOfLife: Error {
    case birth(msg: String)
    case aging(msg: String)
    case sickness(msg: String)
    case death(msg: String)
    case separationOfLovers(msg: String)
    case hatred(msg: String)
    case unsatisfiableDesire(msg: String)
}

enum LifeTarget {
    case human, god
}

func rollDiceOfLife(for target: LifeTarget) throws -> String {
    guard target == .human else {
        return "silent, calm and harmony"
    }
    
    let sorrows: [SorrowOfLife] = [.birth(msg: "sin entered the world through one's birth"),
                                   .aging(msg: "there was a face in the mirror like a face out of time"),
                                   .sickness(msg: "if we got sick, at least we didn't die"),
                                   .death(msg: "death through sin, so death came to all people, because all sinned"),
                                   .separationOfLovers(msg: "over the sea grows the moon bright; We gaze on it far, far apart. Lovers complain of long, long night."),
                                   .hatred(msg: "why then when people part, is the moon full and bright?"),
                                   .unsatisfiableDesire(msg: "happiness lies in contentment")]
    
    let number = arc4random_uniform(UInt32(sorrows.count + 1))
    if number < sorrows.count {
        throw sorrows[Int(number)]
    }
    
    return "there is still hope"
}

do {
    let diceResult = try rollDiceOfLife(for: .human)
    print("dice result: \(diceResult)")
} catch SorrowOfLife.birth(let msg) {
    print("sorrow of life: \(msg)")
} catch SorrowOfLife.aging(let msg) {
    print("sorrow of life: \(msg)")
} catch SorrowOfLife.sickness(let msg) {
    print("sorrow of life: \(msg)")
} catch SorrowOfLife.death(let msg) {
    print("sorrow of life: \(msg)")
} catch SorrowOfLife.separationOfLovers(let msg) {
    print("sorrow of life: \(msg)")
} catch SorrowOfLife.hatred(let msg) {
    print("sorrow of life: \(msg)")
} catch SorrowOfLife.unsatisfiableDesire(let msg) {
    print("sorrow of life: \(msg)")
} catch _ {
    print("something unexpected in life")
}

if let onesLife = try? rollDiceOfLife(for: .human) {
    print("One's life: \(onesLife)")
} else {
    print("One's life thrown error.")
}

let divineLife = try! rollDiceOfLife(for: .god)
print("Divine's life: \(divineLife)")

func encode(to: Encoder) throws

// creates a new instance by decoding from given decoder
init(from decoder: Decoder) throws

typealias Codable = Encodable & Decodable

struct Fool: Codable {
    var id: String
    var name: String
    var tool: Tool
    
    // renaming properties
    enum CodingKeys: String, CodingKey {
        case id = "identifier"
        case name
        case tool
    }
}

struct Tool: Codable {
    var name: String
}

var tool = Tool(name: "Too")
var fool = Fool(id: "007", name: "Foo", tool: tool)

let jsonEncoder = JSONEncoder()
let jsonData = try! jsonEncoder.encode(fool)
let jsonString = String(data: jsonData, encoding: .utf8)!
print(jsonString)

let jsonDecoder = JSONDecoder()
fool = try! jsonDecoder.decode(Fool.self, from: jsonData)

struct AnotherFool {
    var id: String
    var name: String
    var tool: Tool
    
    // renaming properties
    enum CodingKeys: String, CodingKey {
        case id = "identifier"
        case name
        case toolInHand
    }
}

extension AnotherFool: Encodable {
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(id, forKey: .id)
        try container.encode(name, forKey: .name)
        try container.encode(tool.name, forKey: .toolInHand)
    }
}

extension AnotherFool: Decodable {
    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        id = try values.decode(String.self, forKey: .id)
        name = try values.decode(String.self, forKey: .name)
        let toolInHand = try values.decode(String.self, forKey: .toolInHand)
        tool = Tool(name: toolInHand)
    }
}

var pokemon = "Pikachu"
var closure = { print("Let's catch \(pokemon)") }
pokemon = "Zoobat"
closure()
// Print: "Let's catch Zoobat"

pokemon = "Pikachu"
closure = { [pokemon] in print("Let's catch \(pokemon)") }
pokemon = "Zoobat"
closure()
// Print: "Let's catch Pikachu"

class Book {
    
    var name = "Book"
    
    lazy var sageRetrieveContent: () -> String = {
        [unowned self] in
        return "\(self.name): reading helps us learn so much about beauty and truth that we can live a better life in our own ways."
    }
    
    lazy var ordinaryRetrieveContent: () -> String = {
        [unowned self] in
        return "\(self.name): as long as one studies hard, wealth and beautiful women will all come his way."
    }
}

let book = Book()
print(book.sageRetrieveContent())
print(book.ordinaryRetrieveContent())

extension Book {
    func checkWorm() {
        DispatchQueue.main.async {
            [weak self] in
            guard let strongSelf = self else {
                print("The book no longer exists.")
                return
            }
            let hasWorm = strongSelf.name.contains("worm")
            if hasWorm {
                print("The book has worm.")
            }
        }
    }
}

class Stack<T> {

    var stack = [T]()
    var isEmpty: Bool {
        return self.stack.isEmpty
    }
    var peek: T? {
        return self.stack.last
    }
    var size: Int {
        return self.stack.count
    }

    func push(_ thing: T) {
        self.stack.append(thing)
    }

    func pop() -> T? {
        guard self.isEmpty == false else {
            return nil
        }
        return self.stack.removeLast()
    }
}

class ListNode<T> {
    var value: T
    var next: ListNode<T>?

    init(_ value: T) {
        self.value = value
    }
}

class LinkedList<T> {
    var head: ListNode<T>?
    var tail: ListNode<T>?
}

extension LinkedList {
    func appendToTail(_ value: T) {
        if let tail = self.tail {
            tail.next = ListNode(value)
            self.tail = tail.next
        } else {
            self.tail = ListNode(value)
            self.head = self.tail
        }
    }
    
    func appendToHead(_ value: T) {
        if let head = self.head {
            let newHead = ListNode(value)
            newHead.next = head
            self.head = newHead
        } else {
            self.head = ListNode(value)
            self.tail = self.head
        }
    }
}

func printNode<T: CustomStringConvertible>(_ node: ListNode<T>?) {
    var current = node
    var values = [T]()
    while current != nil {
        values.append(current!.value)
        current = current!.next
    }
    print("Values in list nodes: \(values)")
}

let node1 = ListNode(2)
let node2 = ListNode(9)
let node3 = ListNode(7)
let node4 = ListNode(3)
node1.next = node2
node2.next = node3
node3.next = node4

printNode(node1)

func partition<T: Comparable>(_ head: ListNode<T>?, _ x: T) -> ListNode<T>? {
    var leftHead: ListNode<T>?
    var rightHead: ListNode<T>?
    var left: ListNode<T>?
    var right: ListNode<T>?
    var node = head

    while node != nil {
        if node!.value < x {
            if leftHead == nil {
                leftHead = node
                left = leftHead
            } else {
                left!.next = node
                left = node!
            }
        } else {
            if rightHead == nil {
                rightHead = node
                right = rightHead
            } else {
                right!.next = node
                right = node!
            }
        }
        node = node!.next
    }
    
    if let right = right {
        right.next = nil
    }
    if let left = left {
        left.next = rightHead
    }
    if leftHead != nil {
        return leftHead
    } else {
        return rightHead
    }
}

if let partitionedList = partition(node1, 5) {
    printNode(partitionedList)
}

// prints: Values in list nodes: [2, 3, 9, 7]

func hasCycle<T>(_ head: ListNode<T>?) -> Bool {
    var slow = head
    var fast = head

    while fast != nil && fast!.next != nil {
        slow = slow!.next
        fast = fast!.next!.next
        
        if slow === fast {
            return true
        }
    }

    return false
}

func removeNthFromEnd<T>(head: ListNode<T>?, _ n: Int) -> ListNode<T>? {
    guard let head = head else {
        return nil
    }
    
    var first: ListNode<T>? = head
    var second: ListNode<T>? = head

    for _ in 0 ..< n {
        if second == nil {
            break
        }
        second = second!.next
    }
    
    while second != nil && second!.next != nil {
        first = first!.next
        second = second!.next
    }
    
    first!.next = first!.next!.next
    return head
}

print("Existing list:")
printNode(node1)

print("List with 2nd last node removed:")
if let newHead = removeNthFromEnd(head: node1, 2) {
    printNode(newHead)
}

protocol Queue {
    associatedtype Element

    var isEmpty: Bool { get }
    var size: Int { get }
    var peek: Element? { get }

    mutating func enqueue(_ newElement: Element)
    mutating func dequeue() -> Element?
}

struct ArrayQueue<T>: Queue {

    var isEmpty: Bool {
        return self.left.isEmpty && self.right.isEmpty
    }
    
    var size: Int {
        return self.left.count + self.right.count
    }
    
    var peek: T? {
        return self.left.isEmpty ? self.right.first : self.left.last
    }
    
    private var left = [T]()
    private var right = [T]()
    
    mutating func enqueue(_ newElement: T) {
        self.right.append(newElement)
    }
    
    mutating func dequeue() -> T? {
        if self.left.isEmpty {
            self.left = self.right.reversed()
            self.right.removeAll()
        }
        return self.left.popLast()
    }
}

struct StackQueue<T>: Queue {

    var isEmpty: Bool {
        return self.stackA.isEmpty && self.stackB.isEmpty
    }
    
    var peek: T? {
        self.shift()
        return self.stackB.peek
    }
    
    var size: Int {
        return self.stackA.size + self.stackB.size
    }
    
    mutating func enqueue(_ newElement: T) {
        self.stackA.push(newElement)
    }
    
    func dequeue() -> T? {
        self.shift()
        return self.stackB.pop()
    }
    
    private func shift() {
        if self.stackB.isEmpty {
            while let fromA = self.stackA.pop() {
                self.stackB.push(fromA)
            }
        }
    }

    private var stackA = Stack<T>()
    private var stackB = Stack<T>()
}

func simplifyPath(_ path: String) -> String {
    var simplifiedPath = [String]()
    let pathComponents = path.components(separatedBy: "/")
    for component in pathComponents {
        guard component != "." else {
            continue
        }
        if component == ".." {
            if simplifiedPath.isEmpty == false {
                simplifiedPath.removeLast()
            }
        } else if component.isEmpty == false {
            simplifiedPath.append(component)
        }
    }
    
    let fullPath = simplifiedPath.reduce("") { (base, path) -> String in
        return "\(base)/\(path)"
    }
    
    return fullPath.isEmpty ? "/" : fullPath
}

let shortPath = "/home/username/Documents/../Picture/./Travel/"
let simplifiedPath = simplifyPath(shortPath)
print("Simplified path: \(simplifiedPath)")

class TreeNode<T> {
    var value: T
    var left: TreeNode<T>?
    var right: TreeNode<T>?

    init(_ value: T) {
        self.value = value
    }
}

func depthOfTree<T>(_ root: TreeNode<T>?) -> Int {
    guard let root = root else {
        return 0
    }
    return max(depthOfTree(root.left), depthOfTree(root.right)) + 1
}

func isValidBST<T: Comparable>(root: TreeNode<T>?) -> Bool {
    return isValidBSTNode(root, nil, nil)
}

func isValidBSTNode<T: Comparable>(_ node: TreeNode<T>?, _ min: T?, _ max: T?) -> Bool {
    guard let node = node else {
        return true
    }
    if let min = min, node.value <= min {
        return false
    }
    if let max = max, node.value >= max {
        return false
    }
    return isValidBSTNode(node.left, min, node.value) && isValidBSTNode(node.right, node.value, max)
}