Basics: Constants, Variables and Types

let maximumLoginAttempts = 10
var currentLoginAttempt = 0

currentLoginAttempt += 1
// maximumLoginAttempts += 1   // error: cannot assign to a `let` constant

var x = 0, y = 0, z = 0        // multiple declarations on one line

var welcomeMessage: String            // annotation -- no initial value yet
welcomeMessage = "Hello"

var red, green, blue: Double          // one annotation covering three names

let inferredInt = 42                  // inferred as Int
let inferredDouble = 3.14             // inferred as Double

let name = "Ada"
let attempts = 3

print("Hello, \(name)!")                       // "Hello, Ada!"
print("Attempt \(attempts) of \(attempts * 2)") // expressions are allowed inside \(...)
print(name, attempts, separator: ", ", terminator: "\n")

let minValue = UInt8.min      // 0
let maxValue = UInt8.max      // 255

let int8Max = Int8.max        // 127

let pi: Double = 3.14159
let ratio: Float = 1.0 / 3.0

print(0.1 + 0.2 == 0.3)              // false -- binary floating point, same trap as every other language
print(Double.infinity, Double.nan)   // special values exist, as IEEE 754 requires
print(Double.nan == Double.nan)      // false -- compare with .isNaN instead

let decimal = 17
let binary = 0b10001          // 17
let octal = 0o21              // 17
let hexadecimal = 0x11        // 17

let hexFloat = 0xC.3p0        // 12.1875 -- hexadecimal floating-point, base-16 mantissa with a required `p` exponent

let paddedDouble = 000123.456
let justOverOneMillion = 1_000_000.000_000_1   // `_` is an ignored separator anywhere in a literal

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
// let twoThousandAndOne = twoThousand + one          // error: UInt16 and UInt8 don't mix
let twoThousandAndOne = twoThousand + UInt16(one)      // explicit conversion

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine       // Int -> Double, also explicit

let integerPi = Int(pi)          // 3 -- Double -> Int truncates toward zero, it does not round

typealias AudioSample = UInt16

var maxAmplitudeFound = AudioSample.min   // 0 -- AudioSample is just another name for UInt16

typealias JSONDictionary = [String: Any]

let orangesAreOrange = true
let turnipsAreDelicious = false

if turnipsAreDelicious {
    print("Mmm, tasty turnips!")
} else {
    print("Eww, turnips are horrible.")
}

let http404Error = (404, "Not Found")            // type is (Int, String)

let (statusCode, statusMessage) = http404Error   // decomposed into two constants
print("The status code is \(statusCode)")
print("The status message is \(statusMessage)")

let (justTheCode, _) = http404Error              // `_` ignores a component you don't need
print("The status code is \(justTheCode)")

print("The status code is \(http404Error.0)")    // access by index...
let http200Status = (statusCode: 200, description: "OK")
print("The status code is \(http200Status.statusCode)")   // ...or by name, when named at creation

let age = -3

// assert: checked only in debug builds (-Onone); compiled out entirely in -O release builds.
assert(age >= 0, "A person's age cannot be less than zero.")

// precondition: checked in both debug AND release builds -- use it for a violated
// condition that could genuinely corrupt program state if execution continued.
func indexIsValid(_ index: Int, count: Int) -> Bool { index >= 0 && index < count }
func element(at index: Int, in array: [Int]) -> Int {
    precondition(indexIsValid(index, count: array.count), "Index out of range")
    return array[index]
}

// fatalError: unconditionally stops execution, with no check -- for a code path that
// must never be reached, such as an unimplemented `required init` or an exhaustive
// switch's supposedly unreachable default.
func processedValue(for input: Int) -> Int {
    switch input {
    case let n where n >= 0: return n
    default: fatalError("Negative input is not supported by this API")
    }
}