Swift Typealias

In Swift, we can use typealias to define an alias name for an existing type. This makes the code more readable and easier to understand, especially when dealing with complex types.

Here's how to define a type alias in Swift:

1typealias NewType = ExistingType

Here, NewType is the new alias name we want to define and ExistingType is the type we want to create an alias for.

Let's look at some examples to understand how typealias works.

Example 1: Defining a typealias for an existing type

1typealias Distance = Double
2
3let distance: Distance = 5.5
4print(distance)

In this example, we define a new type alias Distance for the existing type Double. We then declare a constant distance of type Distance and initialize it with a value of 5.5. Finally, we print the value of distance which outputs 5.5.

Example 2: Defining a typealias for a complex type

1typealias Person = (name: String, age: Int)
2
3func printPersonDetails(person: Person) {
4    print("Name: \(person.name), Age: \(person.age)")
5}
6
7let employee: Person = ("William", 30)
8printPersonDetails(person: employee)

In this example, we define a new type alias Person for a complex type which is a tuple with two elements, name and age. We then define a function printPersonDetails which takes a Person parameter and prints the name and age of the person. Finally, we declare a constant employee of type Person and initialize it with a tuple value of ("William", 30). We then call the printPersonDetails function with the employee constant as the parameter which outputs Name: William, Age: 30.

Example 3: Using typealias with Generics

1typealias DictionaryWithIntKeys<T> = Dictionary<Int, T>
2
3var users: DictionaryWithIntKeys<String> = [1: "William", 2: "Alice"]
4print(users)

In this example, we define a new type alias DictionaryWithIntKeys which is a generic type that takes a parameter T. We then create a dictionary of type DictionaryWithIntKeys<String> with integer keys and string values. Finally, we print the users dictionary which outputs [1: "William", 2: "Alice"].

Example 4: Using typealias with closures

1typealias Operation = (Int, Int) -> Int
2
3func calculate(operation: Operation, a: Int, b: Int) -> Int {
4    return operation(a, b)
5}
6
7let add: Operation = { $0 + $1 }
8let result = calculate(operation: add, a: 5, b: 3)
9print(result)

In this example, we define a new type alias Operation for a closure that takes two integers as input parameters and returns an integer value. We then define a function calculate which takes an Operation closure, a and b integer parameters and returns an integer value. We declare a closure add which adds two integers and assigns it to Operation. Finally, we call the calculate function with the add closure and integer values 5 and 3 as parameters which outputs 8.