Object-oriented programming (OOP) looks very natural to most developers as it simulates a real-life situation of classes or, in other words, blueprints and their instances. However, it brings a lot of complexities and problems such as instance and memory management, complex multithreading, and concurrency programming.

Before OOP became mainstream, we were used to developing in procedural languages. In the C programming language, we did not have objects and classes, and we would use structs and function pointers. FP relies mostly on functions, just as procedural languages relied on procedures. We can develop very powerful programs in C without classes; in fact, most operating systems are developed in C. There are other multipurpose programming languages, such as Go by Google. This is not object-oriented and is getting very popular because of its performance and simplicity.

So, are we going to be able to write very complex applications without classes in Swift? We might wonder...

In this section, we will deep dive into Swift function and method syntax. Boring stuff alert! To make it a little more interesting, revisit or remember the function definition in mathematics and compare the functions and methods you write to math functions.

If you think that you already know the details or if it is not that interesting for you now, you can fast read or skip this first section, and go to the Return values from functions section of this chapter as it is directly related to FP.

Let's get it over with! We define functions or methods as the following:

accessControl methodForm func functionName(parameter: ParameterType) throws -> ReturnType { } 

As we know already, when functions are defined in objects they become methods.

The first step to define a method is to tell the compiler where it can be accessed. This concept is called access control in Swift and there are five levels of access control. We are going to explain them for methods as follows:

Pure functions are functions that do not possess any side effects; in other words, they do not change or alter any data or state outside of themselves. Additionally, they do not access any data or state except their provided parameters. Pure functions are like mathematical functions that are pure by nature.

Pure functions return a value that is only determined by its parameter values. Pure functions are easy to test as they rely only on their parameters and do not change or access any data or state outside of themselves. Pure functions are suitable for concurrency as they do not access and change global data or states.

The following list presents examples of pure and not pure functions:

Along with, classes, structs, enums, and protocols, functions can also be used as types in Swift. In this section, we will explore how we can define functions as types and how we can use function types. Let's first discover what the type of the function is and how it is defined.

A function parameter type along with its return type defines the type of the function. For instance, the function type for the following coding example is (Int, Double) -> String:

func functionName(firstParam: Int, secondParam: Double) -> String 

We will be able to use function types in the way we use other types. The following code example presents a function type:

var simpleMathOperator: (Double, Double) -> Double 

Here, simpleMathOperator is a variable of a function of the (Double, Double) -> Double type. In other words, simpleMathOperator stores a function that accepts two Double parameters and returns a Double value.

To make it a little easier to read, we could define typealias for the function...

In the Function types section of this chapter, we saw that we can define function types and store and pass functions around. In practice, this means that Swift treats functions as values. To explain this, we will need to examine a couple of examples:

let name: String = "Grace" 

In this code example, we create a constant of the String type name and store a value ("Grace") into it.

When we define a function, we need to specify the type of parameter, as follows:

func sayHello(name: String) { 
    print("Hello, \(name)") 
} 

In this example, our name parameter is of the String type. This parameter could be any other value type or reference type. Simply, it could be Int, Double, Dictionary, Array, Set, or it could be an object type such as an instance of class, struct, or enum.

Now, let's call this function:

sayHello(name: "Your name") // or 
sayHello(name: name) 

Here, we pass a value for this parameter. In other words, we pass one of the previously mentioned types with their respective...

As we have seen in the Defining and using function parameters and Function types sections of this chapter, functions can accept functions as parameters in Swift. Functions that can accept other functions as parameters are called higher-order functions. This concept, along with first-class functions, empowers FP and function decomposition.

As this topic is essential in FP, we will go through another simple example.

Suppose that we need to develop two functions that add and subtract two Int values as follows:

func subtractTwoValues(a: Int, b: Int) -> Int { 
    return a - b 
} 

func addTwoValues(a: Int, b: Int) -> Int { 
    return a + b 
} 

Also, we need to develop functions to calculate the square and triple of two Int values as follows:

func square(a: Int) -> Int { 
    return a * a 
} 

func triple(a: Int) -> Int { 
    return a * a * a // or return square(a) * a 
} 

Suppose we need another function that subtracts the two squared values:

func subtractTwoSquaredValues...

In the previous section, we saw an example of higher-order functions that could accept two different functions and execute them in a predefined order. This function was not so flexible in the sense that it would break if we wanted to combine two accepted functions differently. Function composition can solve this issue and make it even more flexible. To present this concept, we will examine an example of non-functional composition first, and then we will introduce functional composition.

Suppose that, in our application, we need to interact with a backend RESTful API and receive a String value that contains a list of prices in order. The backend RESTful API is being developed by a third-party and is not designed properly. Unfortunately, it returns a String with numbers in it separated by commas, as follows:

"10,20,40,30,80,60" 

We need to format the content that we receive before using it. We will extract elements from String and create an array, and then we will append...

Closures are great tools for FP as they are functions without the func keyword and name. Like functions, closures are self-contained blocks of code that provide a specific functionality and can be stored, passed around, and used in the code. Closures capture the constants and variables of the context in which they are defined. Although closures are the equivalent of blocks in Objective-C, they have a simpler syntax in Swift compared to the C and Objective-C block syntax. Nested functions, which we have covered in a previous section, 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.

 { (parameters) -> ReturnType in // body of closure }