Generics in Swift

Generics

Generics are an important concept in the Swift language. Generics are a powerful tool that allows the same code to work with different types, enhancing reusability. This feature enables the writing of generic functions, algorithms, or data structures that operate on various types. Generics also provide type safety and minimize runtime errors. I will introduce the basic concepts of generics in Swift and explain how they are used. By utilizing generics, you will expand your ability to write more flexible, reusable, and safe code.

Lets start

Let’s say we have an array and we want to sort the elements in that array. Without using generics, we would have to write separate sorting functions for each data type.

For example, we would need a separate function to sort an array of Int:

func sortIntArray(_ array: [Int]) -> [Int] {
    return array.sorted()
}

Similarly, we would need another function to sort an array of String:

func sortStringArray(_ array: [String]) -> [String] {
    return array.sorted()
}

However, by using generics, we can write a single function that can perform the same sorting logic on different types:

func sortArray<T: Comparable>(_ array: [T]) -> [T] {
    return array.sorted()
}

Here, the <T: Comparable> expression indicates that the sorting operation requires T to be comparable. When calling the function, a temporary type is substituted for T based on the type of the array we pass.

With this approach, instead of writing separate functions for each data type, we can use a single function to make our code simpler and more concise.

A slightly more complex example

Consider a scenario where you want to create a generic Pair struct that holds two values of any type. You also want to provide a method to compare two Pair instances…