The last chapter gave us the basic types that form the building blocks of the Swift language. Now we will build on top of this knowledge to create more complex structures using functionalities provided by the Swift standard library.

All the code for this chapter can be found in the GitHub repository at https://github.com/SwiftProgrammingCookbook/BuildingOnTheBuildingBlocks.

A tuple is a combination of two or more values that can be treated as one. If you have ever wished you could return more than one value from a function or method, you should find tuples very interesting.

Create a new playground and add the following statement:

import Foundation 

This example uses one function from Foundation. We will delve into Foundation in more detail in Chapter 5, Beyond the Standard Library, but for now, we just need to import it.

Let's say that we are building an app that pulls together...

In this chapter, and the last, we were introduced to many different Swift constructs: classes, structs, enums, closures, protocols, and tuples. Yet, rarely will we be dealing with these on their own; we will likely have many instances of these constructs, and we need a way to collect multiple instances in useful data structures. We will examine three collection data structures provided by Swift: arrays, sets, and Dictionaries (often called hash tables in other languages):

In the next few recipes, we'll look at how to use them to store and access elements, and examine their relative characteristics.

First, let's investigate arrays, which are an ordered list of elements...

The next collection type we will look at is a set. Sets differ from arrays in two important ways. The elements in a set are stored unordered, and each unique element is only held once. In this recipe, we will look at how we can create and manipulate sets.

Let's take a look at the following steps:

1. First, let's look at how sets only store unique elements:

let fibonacciArray: Array<Int> = [1, 1, 2, 3, 5, 8, 13, 21, 34] 
let fibonacciSet: Set<Int> = [1, 1, 2, 3, 5, 8, 13, 21, 34] 
print(fibonacciArray.count) // 10 
print(fibonacciSet.count) // 9 

2. Elements can be inserted and removed, and you can check whether a set contains an element using the following:

var...

The last collection type we will look at is the Dictionary, which is a familiar construct in programming languages, where it is sometimes referred to as a hash table. A dictionary holds a collection of pairings between a key and a value. The key can be any element that conforms to the Hashable protocol (just like elements in a set), and the value can be any type. The contents of a Dictionary are not stored in order, unlike an array; instead, the key is used both when storing a value and as a lookup when retrieving a value.

In this recipe, we will use a Dictionary to store details of people at a place of work. We need to store and retrieve a person's information based...

From the last few recipes on collection types, we have seen, that their elements are accessed through subscripts. However, it's not just collection types that can have subscripts; your own custom types can provide subscript functionality too.

Let's create a simple game of tic-tac-toe, also known as Noughts and Crosses. To do this, we need a three-by-three grid of positions, with each position being filled by either a nought from Player 1, a cross from Player 2, or nothing. We can store these positions in an array of arrays.

The initial game setup code uses the constructs we covered earlier, so we won't go into its implementation. Enter the following code into a new playground...

The typealias declaration allows you to create an alias for a type; it does exactly what it says on the tin. You can specify a name that can be used in place of any given type definition. If this type is quite complex, a typealias can be a useful way to simplify its use.

Let's take look at the following steps to understand how to use typealias:

1. First, let's create something to store in an array--in this instance, a Pug struct:

struct Pug { 
    let name: String 
} 

2. Now we can create an array that will contain instances of a Pug struct:

let pugs = [Pug]() 

You may often find that you would like to know when a property changes its value; maybe you want to update the value of another property, or inform a delegate. In Objective-C, this was often accomplished by writing your own getter and setter, or using Key-Value observing (KVO), but we have native support for property observers in Swift.

To examine property observers, we should create an object with a property that we want to observe. Let's create an object to manage users and a property to hold the current user's name:

class UserManager { 
    var currentUserName: String = "Emmanuel Goldstein" 
} 

We want to present some friendly...

Swift provides fine-grained access control, allowing you to specify the visibility that your code has to the other areas of code. This enables you to be explicit about the interface you provide to other parts of the system, encapsulating implementation logic and helping to separate the areas of concern.

Swift has five access levels:

• Private: Only accessible within the existing scope (defined by curly brackets) or extensions in the same file
• File private: Accessible to anything in the same file, but nothing outside the file
• Internal: Accessible to anything in the same module, but nothing outside the module
• Public: Accessible both inside and outside the module, but cannot be subclassed or overwritten outside of the defining module
• Open: Accessible everywhere, with no restrictions on its use

These can be applied to types, properties, and functions...

Extensions let us add functionalities to the existing classes, structs, enums, and protocols. This can be especially useful when the original type is provided by an external framework, and therefore you aren't able to add a functionality directly.

Imagine that we often need to obtain the first word from a given string. Rather than repeatedly writing the code to split the string into words and then retrieving the first word, we can extend the functionality of String to provide its own first word.