Swift Functional Programming - Second Edition

Swift has a modern syntax that eliminates the verbosity of programming languages such as Objective-C. For instance, the following code example shows an Objective-C class with a property and method. Objective-C classes are defined in two separate files (interface and implementation). The VerboseClass.h file defines an interface as a subclass of the NSObject class. It defines a property, ourArray, and a method, aMethod.

The implementation file imports the header class and provides an implementation for aMethod, as shown in the following code:

//  VerboseClass.h 
@interface VerboseClass: NSObject 
@property (nonatomic, strong) NSMutableArray *ourArray; 
- (void)aMethod:(NSMutableArray*)anArray; 
@end 

//  VerboseClass.m 
#import "VerboseClass.h" 

@implementation VerboseClass 
- (void)aMethod:(NSMutableArray*)anArray { 
    self.ourArray = [[NSMutableArrayalloc] initWithArray: @[@"One",      
    @"Two", @"Three"]]; 
} 

A similar functionality in Swift can be achieved as follows:

class ASwiftClass { 
    var ourArray: [String] = [] 

    func aMethod(anArray: [String]) { 
        self.ourArray  = anArray 
    } 
} 

let aSwiftClassInstance = ASwiftClass() 
aSwiftClassInstance.aMethod(anArray: ["one", "Two", "Three"]) 
print(aSwiftClassInstance.ourArray) 

As seen from this example, Swift eliminates a lot of unnecessary syntax and keeps code very clean and readable.

Swift has a strong emphasis on types. Classes, enums, structs, protocols, functions, and closures can become types and be used in program composition.

Swift is a type-safe language, unlike languages such as Ruby and JavaScript. As opposed to type-variant collections in Objective-C, Swift provides type-safe collections. Swift automatically deducts types by the type-inference mechanism, a mechanism that is present in languages such as C# and C++ 11. For instance, constString in the following example is inferred as String during compile time, and it is not necessary to annotate the type:

let constString = "This is a string constant" 

Swift makes it easy to define immutable values--in other words, constants--and empowers FP, as immutability is one of the key concepts in FP. Once constants are initialized, they cannot be altered or mutated. Although it is possible to achieve immutability in languages such as Java, it is not as easy as Swift. To define any immutable type in Swift, the let keyword can be used no matter if it is a custom type, collection type, or a Struct/enum type.

Swift provides very powerful structures and enumerations that are passed by values and can be stateless, and, therefore, very efficient. Stateless programming simplifies the concurrency and multithreading, as pointed out in previous sections of this chapter.

Functions are first-class types in Swift, just as in languages such as Ruby, JavaScript, and Go, and can be stored, passed, and returned. First-class functions empower the FP style in Swift.

Higher-order functions can receive other functions as their parameters. Swift provides higher-order functions such as map, filter, and reduce. Also, in Swift, we can develop our own higher-order functions and DSLs.

Closures are blocks of codes that can be passed around. Closures capture the constants and variables of the context in which they are defined. Swift provides closures with a simpler syntax than Objective-C blocks.

Swift provides subscripts that are shortcuts to access members of collections, lists, sequences, or custom types. Subscripts can be used to set and get values by an index without needing separate methods for the setting and getting.

Pattern matching is the ability to de-structure values and match different switch cases based on correct value matches. Pattern matching capabilities exist in languages such as Scala, Erlang, and Haskell. Swift provides powerful switch cases and if cases with where clauses as well.

Swift provides generics that make it possible to write code that is not specific to a type and can be utilized for different types.

Swift provides optional types that can have some or none values. Swift also provides optional chaining to use optionals safely and efficiently. Optional chaining empowers us to query and call properties, methods, and subscripts on optional types that may be nil.

Swift provides extensions that are similar to categories in Objective-C. Extensions add new functionality to an existing class, structure, enumeration, or protocol type, even if it is closed-source.

Bridging headers empower us to mix Swift with Objective-C in our projects. This functionality makes it possible to use our previously written Objective-C code in Swift projects and vice versa.

Swift handles memory management through Automatic Reference Counting (ARC), like Objective-C and unlike languages such as Java and C#, which utilize garbage collection. ARC is used to initialize and de-initialize the resources, thereby releasing memory allocations of the class instances when they are no longer required. ARC tracks, retains, and releases in the code instances to manage the memory resources effectively.

Xcode provides the Read Eval Print Loop (REPL) command-line environment to experiment with the Swift programming language without the need to write a program. Also, Swift provides Playgrounds, which enable us to test Swift code snippets quickly and see the results in real time via a visual interface. Source codes for the first ten chapters of this book are provided as Playgrounds in the GitHub repo and Packt Publishing website.

Types are designated units of composition in Swift. Classes, structs, enums, functions, closures, and protocols can become types.

Swift is a type-safe language. This means that we cannot change the type of a constant, variable, or expression once we define it. Also, the type-safe nature of Swift empowers us to find type mismatches during compile time.

Swift provides type inference. Swift infers the type of a variable, constant, or expression automatically, so we do not need to specify the types while defining them. Let's look at the following example:

let pi = 3.14159 
var primeNumber = 691 
let name = "my name" 

In this example, Swift infers pi as Double, primeNumber as Int, and name as String. If we need special types such as Int64, we will need to annotate the type.

In Swift, it is possible to annotate types, or in other words, explicitly specify the type of a variable or expression. Let's look at the following example:

let pi: Double = 3.14159 
let piAndPhi: (Double, Double) = (3.14159, 1.618) 
func ourFunction(a: Int) { /* ... */ } 

In this example, we define a constant (pi) annotated as Double, a tuple named piAndPhi annotated as (Double, Double), and a parameter of ourFunction as Int.

Type aliases define an alternative name for an existing type. We define type aliases with the typealias keyword. Type aliases are useful when we want to refer to an existing type by a name that is contextually more appropriate, such as when working with data of a specific size from an external source. For instance, in the following example, we provide an alias for an unsigned 32-bit integer that can be used later in our code:

typealias UnsignedInteger = UInt32 

The typealias definitions can be used to simplify the closure and function definitions as well.

Type casting is a way to check the type of an instance and/or deal with that instance as if it is a different superclass or subclass from somewhere else in its class hierarchy. There are two types of operator to check and cast types as the following:

Type safety, type inference, annotation, aliases and type casting will be covered in detail in Chapter 3, Types and Type Casting.

Swift makes it possible to define variables as mutable and immutable. The let keyword is used for immutable declarations and the var keyword is used for mutable declarations. Any variable that is declared with the let keyword will not be open to change. In the following examples, we define aMutableString with the var keyword so that we will be able to alter it later on; in contrast, we will not be able to alter aConstString that is defined with the let keyword:

var aMutableString = "This is a variable String" 
let aConstString = "This is a constant String" 

In FP, it is recommended to define properties as constants or immutables with let as much as possible. Immutable variables are easier to track and less error-prone. In some cases, such as CoreData programming, the software development kit (SDK) requires mutable properties; however, in these cases, it is recommended to use mutable variables.

Immutability and stateless programming will be covered in detail in Chapter 9, Importance of Immutability.

Swift provides tuples so that they can be used to group multiple values/types into a single compound value. Consider the following example:

let http400Error = (400, "Bad Request") 
// http400Error is of type (Int, String), and equals (400, "Bad Request") 

// Decompose a Tuple's content 
let (requestStatusCode, requestStatusMessage) = http400Error 

Tuples can be used as return types in functions to implement multi-return functions as well.

Swift provides optionals so they can be used in situations where a value may be absent. An optional will have some or none values. The ? symbol is used to define a variable as optional. Consider the following example:

// Optional value either contains a value or contains nil 
var optionalString: String? = "A String literal" 
optionalString = nil 

The ! symbol can be used to forcefully unwrap the value from an optional. For instance, the following example forcefully unwraps the optionalString variable:

optionalString = "An optional String" 
print(optionalString!) 

Force unwrapping the optionals may cause errors if the optional does not have a value, so it is not recommended to use this approach as it is very hard to be sure if we are going to have values in optionals in different circumstances. The better approach would be to use the optional binding technique to find out whether an optional contains a value. Consider the following example:

let nilName: String? = nil 
if let familyName = nilName { 
    let greetingfamilyName = "Hello, Mr. \(familyName)" 
} else { 
    // Optional does not have a value 
} 

Optional chaining is a process to query and call properties, methods, and subscripts on an optional that might currently be nil. Optional chaining in Swift is similar to messaging nil in Objective-C, but in a way that works for any type and can be checked for success or failure. Consider the following example:

class Residence { 
    var numberOfRooms = 1 
} 

class Person { 
    var residence: Residence? 
} 

let jeanMarc = Person() 
// This can be used for calling methods and subscripts through optional chaining too 
if let roomCount = jeanMarc.residence?.numberOfRooms { 
    // Use the roomCount 
} 

In this example, we were able to access numberOfRooms, which was a property of an optional type (Residence) using optional chaining.

Optionals and optional binding and chaining will be covered in detail in Chapter 7, Dealing with Optionals.

In Swift, String is an ordered collection of characters. String is a structure and not a class. Structures are value types in Swift; therefore, any String is a value type and passed by values, not by references.

Strings can be defined with let for immutability. Strings defined with var will be mutable.

String literals can be used to create an instance of String. In the following code example, we define and initialize aVegetable with the String literal:

let aVegetable = "Arugula" 

Empty Strings can be initialized as follows:

// Initializing an Empty String 
var anEmptyString = "" 
var anotherEmptyString = String() 

These two strings are both empty and equivalent to each other. To find out whether a String is empty, the isEmpty property can be used as follows:

if anEmptyString.isEmpty { 
    print("String is empty") 
} 

Strings and characters can be concatenated as follows:

let string1 = "Hello" 
let string2 = " Mr" 
var welcome = string1+string2 

var instruction = "Follow us please" 
instruction += string2 

let exclamationMark: Character = "!" 
welcome.append(exclamationMark) 

String interpolation is a way to construct a new String value from a mix of constants, variables, literals, and expressions by including their values inside a String literal. Consider the following example:

let multiplier = 3 
let message = "\(multiplier) times 7.5 is \(Double (multiplier) * 7.5)" 
// message is "3 times 2.5 is 22.5" 

Strings can be compared with == for equality and != for inequality.

The hasPrefix and hasSuffix methods can be used for prefix and suffix equality checking.

Swift provides typed collections such as array, dictionaries, and sets. In Swift, unlike Objective-C, all elements in a collection will have the same type, and we will not be able to change the type of a collection after defining it.

We can define collections as immutable with let and mutable with var, as shown in the following example:

// Arrays and Dictionaries 
var cheeses = ["Brie", "Tete de Moine", "Cambozola", "Camembert"] 
cheeses[2] = "Roquefort" 
var cheeseWinePairs = [ 
    "Brie":"Chardonnay", 
    "Camembert":"Champagne", 
    "Gruyere":"Sauvignon Blanc" 
] 

cheeseWinePairs ["Cheddar"] = "Cabarnet Sauvignon" 
// To create an empty array or dictionary 
let emptyArray = [String]() 
let emptyDictionary = Dictionary<String, Float>() 
cheeses = [] 
cheeseWinePairs = [:] 

The for-in loops can be used to iterate over the items in collections.

Swift provides for and for-in loops. We can use the for-in loop to iterate over items in a collection, a sequence of numbers such as ranges, or characters in a string expression. The following example presents a for-in loop to iterate through all items in an Int array:

let scores = [65, 75, 92, 87, 68] 
var teamScore = 0 

for score in scores { 
    if score > 70 { 
        teamScore = teamScore + 3 
    } else { 
        teamScore = teamScore + 1 
    } 
} 

and over dictionaries:

for (cheese, wine) in cheeseWinePairs{ 
    print("\(cheese): \(wine)") 
} 

As C styles for loops with incrementers/decrementers are removed from Swift 3.0, it is recommended to use for-in loops with ranges instead, as follows:

var count = 0 
for i in 0...3 { 
    count + = i 
} 

Swift provides while and repeat-while loops. A while or repeat-while loop performs a set of expressions until a condition becomes false. Consider the following example:

var n = 2 
while n < 100 { 
    n = n * 2 
} 
var m = 2 
repeat { 
    m = m * 2 
} while m < 100 

The while loop evaluates its condition at the beginning of each iteration. The repeat-while loop evaluates its condition at the end of each iteration.

stride functions enable us to iterate through ranges with a step other than one. There are two stride functions: the stride to function, which iterates over exclusive ranges, and stride through, which iterates over inclusive ranges. Consider the following example:

let fourToTwo = Array(stride(from: 4, to: 1, by: -1)) // [4, 3, 2] 
let fourToOne = Array(stride(from:4, through: 1, by: -1)) // [4, 3, 2, 1] 

Swift provides if to define conditional statements. It executes a set of statements only if the condition statement is true. For instance, in the following example, the print statement will be executed because anEmptyString is empty:

var anEmptyString = "" 
if anEmptyString.isEmpty { 
    print("An empty String") 
} else { 
    // String is not empty. 
} 

Swift provides the switch statement to compare a value against different matching patterns. The related statement will be executed once the pattern is matched. Unlike most other C-based programming languages, Swift does not need a break statement for each case and supports any value types. Switch statements can be used for range matching, and where clauses in switch statements can be used to check for additional conditions. The following example presents a simple switch statement with additional conditional checking:

let aNumber = "Four or Five" 
switch aNumber { 
    case "One": 
        let one = "One" 
    case "Two", "Three": 
        let twoOrThree = "Two or Three" 
    case let x where x.hasSuffix("Five"): 
        let fourOrFive = "it is \(x)" 
    default: 
    let anyOtherNumber = "Any other number" 
} 

A guard statement can be used for early exits. We can use a guard statement to require that a condition must be true in order for the code after the guard statement to be executed. The following example presents the guard statement usage:

func greet(person: [String: String]) { 
    guard let name = person["name"] else { 
        return 
    } 
    print("Hello Ms\(name)!") 
} 

In this example, the greet function requires a value for a person's name; therefore, it checks whether it is present with the guard statement, otherwise it will return and not continue to execute. As can be seen from the example, the scope of the guarded variable is not only the guard code block, so we were able to use name after the guard code block in our print statement.

Closures are self-contained blocks of code that provide a specific functionality and can be stored, passed around, and used in the code. Closures are the equivalent of blocks in C and Objective-C. Closures can capture and store references to any constants and variables from the context in which they are defined. Nested functions are special cases of closures.

Closures are reference types that can be stored as variables, constants, and type aliases. They can be passed to and returned from functions.

The following examples present different declarations of closures in Swift from the website, http://goshdarnclosuresyntax.com:

// As a variable: 
var closureName: (parameterTypes) -> (returnType) 

//As a type alias: 
typealias closureType = (parameterTypes) -> (returnType) 

//As an argument to a function call: 
func Name({ (ParameterTypes) -> (ReturnType) in statements }) 

Closures and first-class, higher-order, and pure functions will be covered in detail in Chapter 2, Functions and Closures.

Swift provides map, filter, and reduce functions, which are higher-order functions.

The map function is a higher-order function that solves the problem of transforming the elements of an array using a function. Consider the following example:

let numbers = [10, 30, 91, 50, 100, 39, 74] 
var formattedNumbers: [String] = [] 

for number in numbers { 
    let formattedNumber = "\(number)$" 
    formattedNumbers.append(formattedNumber) 
} 

let mappedNumbers = numbers.map{ "\($0)$" } 

The filter function is a higher-order function that takes a function that, given an element in the array, returns Bool, indicating whether the element should be included in the resulting array. Consider the following example:

let evenNumbers = numbers.filter { $0 % 2 == 0 } 

The reduce function is a higher-order function that reduces an array to a single value. It takes two parameters: a starting value and a function, which takes a running total and an element of the arrays as parameters and returns a new running total. Consider the following example:

let total = numbers.reduce(0) { $0 + $1 } 

The map, filter, and reduce functions accept a closure as the last parameter, so we were able to use the trailing closure syntax. These higher-order functions will be covered in detail in Chapter 6, Map, Filter, and Reduce.

Consider creating a structure when one or more of the following conditions apply:

Examples of good candidates for structures include the following:

As classes are reference types, it is possible for multiple constants and variables to refer to the same single instance of class behind the scenes. To find out if two constants or variables refer to the same instance of a class exactly, Swift provides the following identity operators:

Property observers are used to respond to change in a property's value. Property observers are called every time a property's value is set, even if the new value is the same as the property's current value. We have the option to define either or both of the following observers on a property:

The willSet and didSet observers are not called when a property is set in an initializer before delegation takes place.

Methods are functions that are associated with a particular type. Instance methods are functions that are called on an instance of a particular type. Type methods are functions that are called on the type itself.

The following example presents a class containing a type method that is named someTypeMethod():

class AClass { 
    class func someTypeMethod() { 
        // type method body 
    } 
} 
// We can call this method as follows: 
AClass.someTypeMethod() 

Subscripts are shortcuts to access the member elements of a collection, list, sequence, or any custom type that implement subscripts. Consider the following example:

struct TimesTable { 
    let multiplier: Int 
    subscript(index: Int) ->Int { 
        return multiplier * index 
    } 
} 

let fiveTimesTable = TimesTable(multiplier: 5) 
print("six times five is \(fiveTimesTable[6])") 
// prints "six times five is 30" 

A class can inherit methods, properties, and other characteristics from another class:

class SomeSubClass: SomeSuperClass 

Swift classes do not inherit from a universal base class. Classes that we define without specifying a superclass automatically become base classes for us to build on. To override a characteristic that would otherwise be inherited, we prefix our overriding definition with the override keyword. An overridden method, property, or subscript can call the superclass version by calling super. To prevent overrides, the final keyword can be used.

The process of preparing an instance of a class, structure, or enumeration for use is called initialization. Classes and structures must set all of their stored properties to an appropriate initial value by the time an instance of that class or structure is created. Stored properties cannot be left in an intermediate state. We can modify the value of a constant property at any point during initialization as long as it is set to a definite value by the time initialization finishes. Swift provides a default initializer for any structure or base class that provides default values for all of its properties and does not provide at least one initializer itself. Consider the following example:

class ShoppingItem { 
    var name: String? 
    var quantity = 1 
    var purchased = false 
  } 
var item = ShoppingItem() 

The struct types automatically receive a member-wise initializer if we do not define any of our own custom initializers, even if the struct's stored properties do not have default values.

Swift defines two kinds of initializers for class types:

A de-initializer is called immediately before a class instance is deallocated. Swift automatically deallocates instances when they are no longer needed in order to free up resources.

weak var aWeakProperty 

class AClassWithLazyClosure { 
    lazy var aClosure: (Int, String) -> String = { 
      [unowned self] (index: Int, stringToProcess: String) -> String in 
      // closure body goes here 
        return "" 
    } 
} 

Swift provides two special type aliases to work with non-specific types:

The Any and AnyObject type aliases must be used only when we explicitly require the behavior and capabilities that they provide. Being precise about the types we expect to work with in our code is a better approach than using the Any and AnyObject types as they can represent any type and pose dynamism instead of safety. Consider the following example:

class Movie { 
    var director: String 
    var name: String 
    init(name: String, director: String) { 
        self.director = director 
        self.name = name 
    } 
} 

let objects: [AnyObject] = [ 
    Movie(name: "The Shawshank Redemption", director: "Frank Darabont"), 
    Movie(name: "The Godfather", director: "Francis Ford Coppola") 
] 

for object in objects { 
    let movie = object as! Movie 
    print("Movie: '\(movie.name)', dir. \(movie.director)") 
} 

// Shorter syntax 
for movie in objects as! [Movie] { 
    print("Movie: '\(movie.name)', dir. \(movie.director)") 
} 

Enumerations are often created to support a specific class or structure's functionality. Likewise, it can be convenient to declare utility classes and structures purely to use within the context of a complex type.

Swift enables us to declare nested types, whereby we nest supporting enumerations, classes, and structures within the definition of the type that they support. The following example, borrowed from The Swift Programming Language by Apple Inc., presents nested types:

struct BlackjackCard { 
    // nested Suit enumeration 
    enum Suit: Character { 
        case spades = "♠", 
        hearts = "♡", 
        diamonds = "♢", 
        clubs = "♣" 
    } 

    // nested Rank enumeration 
    enum Rank: Int { 
        case two = 2, three, four, five, six, seven, eight, nine, ten 
        case jack, queen, king, ace 

        // nested struct 
        struct Values { 
            let first: Int, second: Int? 
        } 

        var values: Values { 
            switch self { 
            case .ace: 
                return Values(first: 1, second: 11) 
            case .jack, .queen, .king: 
                return Values(first: 10, second: nil) 
            default: 
                return Values(first: self.rawValue, second: nil) 
            } 
        } 
    } 

    let rank: Rank, suit: Suit 

    var description: String { 
        var output = "suit is \(suit.rawValue)," 
        output += "value is \(rank.values.first)" 
        if let second = rank.values.second { 
            output += " or \(second)" 
        } 
        return output 
    } 
} 

Any protocol that we define will become a fully-fledged type to use in our code. We can use a protocol as follows:

Let's look at the following example:

protocol ExampleProtocol { 
    var simpleDescription: String { get } 
    mutating func adjust() 
} 

// Classes, enumerations and structs can all adopt protocols. 
class SimpleClass: ExampleProtocol { 
    var simpleDescription: String = "A very simple class example" 
    var anotherProperty: Int = 79799 

    func adjust() { 
        simpleDescription += "Now 100% adjusted..." 
    } 
} 

var aSimpleClass = SimpleClass() 
aSimpleClass.adjust() 
let aDescription = aSimpleClass.simpleDescription 

struct SimpleStructure: ExampleProtocol { 
    var simpleDescription: String = "A simple struct" 
    // Mutating to mark a method that modifies the structure - For      
    classes we do not need to use mutating keyword 
    mutating func adjust() { 
        simpleDescription += "(adjusted)" 
    } 
} 

var aSimpleStruct = SimpleStructure() 
aSimpleStruct.adjust() 
let aSimpleStructDescription = aSimpleStruct.simpleDescription 

Protocol extensions allow us to define behavior on protocols rather than in each type's individual conformance or global function. By creating an extension on a protocol, all conforming types automatically gain this method implementation without any additional modification. We can specify constraints that conforming types must satisfy before the methods and properties of the extensions are available when we define a protocol extension. For instance, we can extend our ExampleProtocol to provide default functionality as follows:

extension ExampleProtocol { 
    var simpleDescription: String { 
        get { 
            return "The description is: \(self)" 
        } 
        set { 
            self.simpleDescription = newValue 
        } 
    } 

    mutating func adjust() {
        self.simpleDescription = "adjusted simple description" 
    } 
}