What are you trying to achieve by reading this book? Learning Swift can be fun, but most of us are trying to achieve something bigger. There is something we want to create, a career we want to follow, or maybe something else entirely. Whatever that goal is, I encourage you to keep it in mind as you read this book. It will be much easier for you to learn, from this or any other resource, if you can always relate it to your goal.

With that in mind, before we dive into learning Swift, we have to understand what it really is and how it will help us in achieving our goals. We also need to move forward with an effective learning technique and get a taste of what is to come. To do all of that, we will cover the following topics in this chapter:

One of the coolest things about programming is the way that concepts build on each other. If you've never programmed anything before, even the most basic app can seem very complex. The reality is that, if you analyze everything going on in an app down to the ones and zeros flowing through the processor, it is incredibly complex. However, every aspect of using a computer is an abstraction. When you use an app, the complexity of the programming is being abstracted away for you. Learning to program is just going one level deeper in making a computer work for you.

As you learn the basic concepts behind programming, they will become second nature and this will free your mind to grasp even more complex concepts. When you first learn to read, sounding out each word is challenging. However, eventually, you reach a level where you glance at a word and you know the meaning instantaneously. This frees you up to start looking for deeper meaning from the text.

In this chapter, we will build up your knowledge of the building blocks of programming in Swift. Each of these building blocks is exciting on its own and they will become even more exciting as we start to see the possibilities they open up. No matter how complex programming might seem to you now, I guarantee that one day you will look back and marvel at how all of these concepts have become second nature.

In this chapter, we will cover:

// Constant
let pi = 3.14

// Variable
var name = "Sarah"

var card = (color: "Red", suit: "Hearts", value: 7)

card.color // "Red"
card.suit // "Hearts"
card.value // 7

var diceRoll = (4, 6)
diceRoll.0 // 4
diceRoll.1 // 6

let (first, second) = diceRoll
first // 4
second // 6

diceRoll = (4, 5)
diceRoll.0 = 2

var invitees = ["Sarah", "Jamison", "Marcos", "Roana"]

invitees += ["Kai", "Naya"]

invitees = invitees + ["Kai", "Naya"]

invitees[2] // Marcos

var showsByGenre = [
   "Comedy": "Modern Family",
   "Drama": "Breaking Bad",
]

showsByGenre["Comedy"] // Modern Family

showsByGenre["Variety"] = "The Colbert Report"

In Chapter 2, Building Blocks – Variables, Collections, and Flow Control, we developed a very simple program that helped organize a party. Even though we separated parts of the code in a logical way, everything was written in a single file and our functions were all lumped together. As projects grow in complexity, this way of organizing code is not sustainable. In the same way we use functions to separate out logical components in our code at scale, we also need to be able to separate out the logical components of our functions and data. To do this, we can define code in different files and we can also create our own types that contain custom data and functionality. These types are commonly referred to as objects, as a part of the programming technique called object-oriented programming. In this chapter we will cover the following:

struct Contact {
    var firstName: String = "First"
    var lastName: String = "Last"
}

let someone = Contact()

struct Contact2 {
    var firstName: String
    var lastName: String
}

let someone2 = Contact2(firstName: "Sarah", lastName: "Smith")

print("\(someone.firstName) \(someone.lastName)")

struct Contact {
    static let UnitedStatesPhonePrefix = "+1" // "First Last"
}

print(Contact.UnitedStatesPhonePrefix) // "+1"

struct Ball {
    var radius: Double
    var color: String
    var elasticity: Double
}

Ball() // Missing argument for parameter 'radius' in call

struct Contact {
    var firstName: String = "First"
    var lastName: String = "Last"

    func printFullName() {
        print("\(self.firstName) \(self.lastName)")
    }
}

someone.printFullName()

struct Ball {
    var radius: Double
    var color: String
    var elasticity: Double

    func growByAmount(amount: Double) {
        // Error: Left side of mutating operator
        // isn't mutable: 'self' is immutable
        self.radius += amount
    }
}

mutating func growByAmount(amount: Double) {
    self.radius += amount
}

struct Contact {
    static let UnitedStatesPhonePrefix = "+1"

    static func printAvailablePhonePrefixes() {
        print(self.UnitedStatesPhonePrefix)
    }
}

Contact.printAvailablePhonePrefixes() // "+1"

func printFullName() {
    print("\(firstName) \(lastName)")
}

static func printAvailablePhonePrefixes() {
    print(UnitedStatesPhonePrefix)
}

func printFirstName() {
    let firstName = "Fake"
    print("\(self.firstName) \(firstName)") // "First Fake"
}

struct Ball {
    var radius: Double
    var diameter: Double {
        get {
            return self.radius * 2
        }
    }
}

var ball = Ball(radius: 2)
print(ball.diameter) // 4.0

var diameter: Double {
    get {
        return self.radius * 2
    }
    set {
        self.radius = diameter / 2
    }
}

var ball = Ball(radius: 2)
ball.diameter = 16
print(ball.radius) // 8.0

var volume: Double {
    return self.radius * self.radius * self.radius * 4/3 * 4.13
}

var radius: Double {
    willSet {
        print("changing from \(self.radius) to \(newValue)")
    }
    didSet {
        print("changed from \(oldValue) to \(self.radius)")
    }
}

struct Ball {
    var radius: Double {
        didSet {
            self.diameter = self.radius * 2
        }
    }
    var diameter: Double {
        didSet {
            self.radius = self.diameter /  2
        }
    }
}

struct MovieAssignment {
    var movies: [String:String]

    subscript(invitee: String) -> String? {
        get {
            return self.movies[invitee]
        }

        set {
            self.movies[invitee] = newValue
        }
    }
}

var assignment = MovieAssignment(movies: [:])
assignment["Sarah"] = "Modern Family"
print(assignment["Sarah"]) // "Modern Family"

struct MovieAssignment {
    var movies: [String:String]

    subscript(invitee: String) -> String? {
        return self.movies[invitee]
    }
}

struct MovieAssignment {
    subscript(param1: String, param2: Int) -> Int {
        return 0
    }
}

print(assignment["Sarah", 2])

init(contact: Contact) {
    self.firstName = contact.firstName
    self.lastName = contact.lastName
}

struct Contact4 {
    var firstName: String
    var lastName: String

    init(contact: Contact4) {
        self.firstName = contact.firstName
    }// Error: Return from initializer without
     // initializing all stored properties
}

struct Contact4 {
    var firstName: String
    var lastName: String = "Last"

    init(contact: Contact4) {
        self.firstName = contact.firstName
    }
}

struct Contact3 {
    var firstName: String
    var lastName: String

    init(contact: Contact3) {
        self.firstName = contact.firstName
        self.lastName = contact.lastName
    }

    init(firstName: String, lastName: String) {
        self.firstName = firstName
        self.lastName = lastName
    }
}
var sarah = Contact3(firstName: "Sarah", lastName: "Smith")
var sarahCopy = Contact3(contact: sarah)
var other = Contact3(firstName: "First", lastName: "Last")

init(contact: Contact4) {
    self.init(
        firstName: sarah.firstName,
        lastName: sarah.lastName
    )
}

init(contact: Contact4) {
    self.print()
    // Use of 'self' in delegating initializer
    // before self.init is called
    self.init(
        firstName: contact.firstName,
        lastName: contact.lastName
     )
}

init(contact: Contact4) {
    self.init(
        firstName: contact.firstName,
        lastName: contact.lastName
    )
    self.print()
}

As we discussed in Chapter 2, Building Blocks – Variables, Collections, and Flow Control, all variables and constants must always have a value before they are used. This is a great safety feature because it prevents you from creating a scenario where you forget to give a variable an initial value. It may make sense for some number variables, such as the number of sandwiches ordered to start at zero, but it doesn't make sense for all variables. For example, the number of bowling pins standing should start at 10, not zero. In Swift, the compiler forces you to decide what the variable should start at, instead of providing a default value that could be incorrect.

However, there are other scenarios where you will have to represent the complete absence of a value. A great example is if you have a dictionary of word definitions and you try to lookup a word that isn't in the dictionary. Normally, this will return a String, so you could potentially return an empty String, but what if you also need to represent the idea that a word exists without a definition? Also, for another programmer who is using your dictionary, it will not be immediately obvious what will happen when they look up a word that doesn't exist. To satisfy this need to represent the absence of a value, Swift has a special type called an optional.

In this chapter, we will cover the following topics:

var possibleString: String?
var possibleArray: [Int]?

var possibleInt: Int? = 10

var actualInt = 10
var possibleInt: Int? = 10
var nilInt: Int?
print(actualInt) // 10
print(possibleInt) // Optional(10)
print(nilInt) // nil

nilInt = 2
print(nilInt) // Optional(2)

nilInt = nil
print(nilInt) // nil