Introduction to Swift<T> Generics

Over the years, I have always been surprised with the number of developers that I have meet that do not use or understand generics. In this article, I would like to explain why developers should not only learn generics but take the time to truly understand them. While this article focuses on the Swift programming language, the concepts of why you should learn and use generics will apply to almost any language that have generics similar to Swift.

I will start off by demonstrating the problem that generics solve. Let’s say we are developing a new application and within this application we have the need to swap the value of two integer variables. To meet this need, in Swift, we could very easily write a function like this:

func swapInt(_ a: inout Int, _ b: inout Int) {
    let tmp = a
    a = b
    b = tmp
}

This function could then be used like this:

var one = 1
var two = 2
swapInt(&one, &two)

Now, a few days or weeks later, as we continue to write the application, we discover a need to swap the values of two string variables. We could then add another function to do this. The following code shows this new function:

func swapInt(_ a: inout String, _ b: inout String) {
    let tmp = a
    a = b
    b = tmp
}

As time goes by we may end up with several functions like the previous swap functions but with different parameter types. Instead of having all of these different functions, in the beginning we could have created one generic swap function like this:'

func swapGeneric<T>(_ a: inout T, _ b: inout T) {
    let tmp = a
    a = b
    b = tmp
}

Notice that the generic version of the swap function uses a placeholder, capital T, rather than the actual parameter type. This placeholder tells the compiler that we will define the type to use at runtime. Since the T placeholder is used for both parameters, they are required to be of the same type.

We would use this generic function exactly like we would use the non-generic swap functions. The following code illustrates this:

var one = 1
var two = 2
swapGeneric(&one, &two)

Now the parameters can be instances of any type as long as they are instances of the same type. We could swap the values of two string types like this:

var one = “one”
var two = “two”
swapGeneric(&one, &two)

Swapping values isn’t too exciting so let’s look at something that does a bit more by seeing how we could use generics to create a very basic queue type. The following code shows how to do this.

struct Queue<T> {
    private var items = [T]()
    
    public mutating func push(_ item: T) {
        items.append(item)
    }
    public mutating func pop() -> T? {
        if (items.count > 0) {
            return items.remove(at: 0)
        } else {
            return nil
        }
    }
}

We would use this queue type like this:

var queue = Queue<Int>()
queue.push(1)
queue.push(2)
print(queue.pop())
print(queue.pop())

One of the best things about this queue type is it is ready to accept any type. We could very easily create an instance of the Queue type that would store String values like this:

var queue = Queue<String>()

One of the questions that someone new to generics may ask is: Why don’t we just use the Any type rather than generics? In Swift, the Any type allows us to use instances of any type. The following code shows how we could create a Queue type that used the Any type:

struct QueueAny {
    private var items = [Any]()
    
    public mutating func push(_ item: Any) {
        items.append(item)
    }
    public mutating func pop() -> Any? {
        if (items.count > 0) {
            return items.remove(at: 0)
        } else {
            return nil
        }
    }
}

The QueueAny type lets us create a queue that can contain any type similar to the previous generic queue however there are several disadvantages to this method. The one disadvantage that we will focus on here is the ability to add any type to the queue. For example this code would be perfect ok with the QueueAny queue:

var queueAny = QueueAny()
queueAny.push(2)
queueAny.push("Hi")

Notice how we are able to add both an integer and a string to the same queue. The QueueAny type functions similar to how Arrays worked in Objective-C. Now if we popped an item off the queue we would need to typecast it before we used any of the methods or properties of the type. This does not allow us to have any compile time checks to make sure we are using the correct types in our queue and is prone to error, as any Objective-C developer can tell you.

With the generic Queue type, since we explicitly define the type of items stored in the queue, we are able to use the properties and methods of that type without the need to typecast. This gives us the compile time checks that ensures we are using the correct types.

The answer to the question about why you should learn generics is: Generics enable us to write very flexible and reusable code that is also very safe. In this article we only scratched the surface of generics. If you are unfamiliar with generics I would recommend taking the time to learn more about them.