MyType.swift
MyType+MyProtocol.swift

prefer spaces to tabs
use xcode ctrl-I to automatically indent

var mutableAge = 35
let constantBirthYear = 1985
var myAge: Int = 35

// strongly typed, and inferred
// no automatic type converstion

assignment: a = b
arithmetic: +, -, *, /, %
compound assignment: +=, -=, *=, /=
comparison: ==, !=, >, <, >=, <=
logical: !, &&, ||

n/a

// single line commeng
/* multiline
   comment */
/// doc comment

i in 1...5   // includes 1 and 5
i in 1..<5   // includes 1, not 5

array[..<4]  // indexes 0 to 3
array[4...]  // indexes 4 to end

let httpError = (404, "Not found")
let (code, errMsg) = httpError
let code = httpError.0
let (_, errMsg) = httpError

// must be explicitly declared
"var optString: String?"

if let x = optString?.count { ... }
let x = optString?.count ?? 0
let x = optString?.count // x is optional
let x = optionalVar ?? otherVar

let x = optString!.count

let optString: String! = "Implicitly Unwrapped"
let x = optString   // no need for ? or !

mutableString += " me"

print("The value of myInt is \(myInt)")

let multiLineString = """
Multiline strings can "quote" 
parts of the content.
"""

let raw = #"use \(myVar) to print objects"#
let rawInterpolation = #"myVar: \#(myVar)"#

var laugh = "laughing emoji: 😆"
if let lastCharacter = laugh.last { ... }"

x > 5 ? print("True") : print("False")
let xLessThanFive = x > 5 ? true : false

for item in myArray { ... }
myArray.forEach { print($0) }

for i in 1...10 {
  continue  // move to next iteration of loop
  break     // end loop
}

while i < 10 { ... }

do { ... } while i < 10

var age = 35
switch age {
case 40:
  print("you are over the hill")
case 18, 21:
  print("you can now vote or drink")
case 1...17:
  print("you are a minor")
case 0:
  // case must have at least one statement
  break
default:
  print("you are an adult")
}

// Note:  switch statements end once a 
//        matching case is found
//        use keyword 'fallthrough' for 
//        C-like behavior"

if let index = mutableArray.firstIndex(of: "Two") {
  let a = mutableArray[index]
}

mutableArray.append("Three")
mutableArray.insert("Three", at: 1)
mutableArray += ["Three"]

mutableArray[1] = "Three"

mutableArray.remove(at: 1)
let poppedItem = mutableArray.removeLast()

let immutableSet: Set = [1, 2, 3, 2]  // [1, 2, 3]
var mutableSet: Set = ["One", "Two", "Three"]
var emptySet = Set<String>()

mutableSet.insert(4)

// returns item or nil
let optionalItem = mutableSet.remove(3)

mutableSet.removeAll()

setA.union(setB)
setA.intersection(setB)
setA.subtracting(setB)
setA.symmetricDifference(setB)

setA.isSubSet(of: setB)
setA.isSuperset(of: setB)
setA.isDisjoint(with: setB)

var personDict = ["first": "Joe", "last": "Smith"]
var emptyDict = [String: String]()

let name = personDict["first"]

personDict["middleInitial"] = "C"
let oldValue = personDict.updateValue("Blow", forKey: "last")

personDict["middleInitial"] = nil
let removedValue = personDict.removeValue(forKey: "first")

let numberOfElements = mutableArray.count
if myDictionary.isEmpty { ... } // faster check than .count

for item in myArray { ... }  // all collections
mySet.forEach { print($0) }  // all collections

// Array specific
for (index, item) in myArray.enumerated() { ... }

// Dictionary specific
for (key, value) in myDictionary { ... }
for key in myDictionary.keys { ... }
for value in myDictionary.values { ... }

let isTrue = myArray.contains("Cats")

let sortedSet = mySet.sorted() // Sets & Dicts have no order

// map, compactMap, flatMap
let numbers = [1, 2, 3]
let numberStrings = numbers.map {String($0)} // ["1", "2", "3"]

strings[1] = "Cars"
let optionalNumbers = strings.map { Int($0) }  // [1, nil, 3]
let onlyNumbers = strings.compactMap { Int($0) }  // [1, 3]

let optionalStrings: String? = ["1", nil, "3"]
let result = optionalStrings.map { Int($0) } 
// result is type [Int??]
let result = optionalString.flatMap { Int($0) } // [Int?]

let addClosure: (Int, Int) -> Int = { (a, b) in a + b }
let subtractClosure: (Int, Int) -> Int = { $0 - $1 }

enum Dessert: CaseIterable {
  case brownie, cookie, cake, port
}
let countOfDessertTypes = Dessert.allCases.count
for type in Dessert.allCases { ... }

enum State: String {
  case utah = "UT"
  case florida = "FL"
  case minnisota = "MN"
}
print("Abbreviation for Utah is \(State.utah.rawValue)")

enum Favorite {
  case color(String)
  case number(Int)
  case none
}
let lucky = Favorite.number(7)
switch lucky {
  case .none:
    print("No favorites")
  case .number(let value):
    print("Lucky Number \(value)!")
  case .color:
    print("So pretty")
}

let joe = Student(name: "Joe", class: 2019)
let graduationYear = joe.class

let cat = Animal(name: "Cat")

class Dog: Animal {
  var isMuddy = false
  
  override init(name: String = "Dog") {
    super.init(name: name)
    self.sound = "Bark"
  }

  override var needsBath: Bool {
    numberOfFleas > 10 && isMuddy
  }
}
let dog = Dog()

final class Flea: Animal { ... }  // can not subclass

// can be used with class, structures, enums, or protocols
extension Int {
  func squared() -> Int {
    return self * self
  }
}
let twoSquared = 2.squared()

let newFunction = try? writeCode()

let newCode: String?
do {
  newCode = try writeCode()
  // success
} catch ProgrammerError.needsCaffine {
  // get coffee
} catch {
  newCode = nil
}

let now = Date()
let formatter = DateFormatter()
formatter.dateStyle = .medium
formatter.timeStyle = .none
let nowString = formatter.string(from: now)

struct AccountInfo: Codable {
  let username: String
  let id: Int
  let lastLoginDate: String   // ISO 8601 string
}

// decode from json into swift objects
let jsonString = """
{ "username": "Joe", "id": 5, "lastLoginDate": "2019-04-23" }
"""
let jsonData = Data(jsonString.utf8)

let decoder = JSONDecoder()
let accountInfo = try? decoder.decode(AccountInfo.self, from:jsonData)

// encode from swift objects to json
let encoder = JSONEncoder()
if let accountInfoData = try? encoder.encode(accountInfo) {
  if let encodedJsonString = String(data: accountInfoData, encoding: .utf8) {
    print(encodedJsonString)
  }
}