5 Hidden Gems of Swift: Tuples, Optional Chaining, Enumerations with Associated Values, Typealias, and Using Functions as Variables

Something You Did Not Know About Swift

Swift has become one of the most popular programming languages since its release in 2014. It is known for its simplicity, safety, and high performance, making it a top choice for iOS and macOS app development. However, there are still some lesser-known features and quirks of Swift that not all developers are aware of. In this article, we will explore some of these hidden gems and learn something new about Swift.

1. Tuples

One powerful but often overlooked feature of Swift is tuples. Tuples allow you to group multiple values together into a single compound value. They are similar to arrays or dictionaries, but with a fixed number of elements and different types allowed for each element.

Here’s an example of how you can use tuples in Swift:

let person = (name: "John Doe", age: 30, profession: "Engineer")
print(person.name) // Output: John Doe
print(person.age) // Output: 30
print(person.profession) // Output: Engineer

In the above example, we define a tuple called “person” with three elements: name, age, and profession. We can access each element of the tuple using dot notation.

2. Optional Chaining

In Swift, optionals allow you to represent a value that may or may not exist. Optional chaining is a powerful feature that lets you safely unwrap optional values and call methods or access properties on them, even if the value is nil.

Here’s an example of optional chaining:

class Person {
    var name: String?
    func printName() {
        if let name = name {
            print("Name: \(name)")
        } else {
            print("Name not available")

let person: Person? = Person()
person?.name = "John Doe"
person?.printName() // Output: Name: John Doe
person?.name = nil
person?.printName() // Output: Name not available

In the above example, we define a class called “Person” with a name property and a printName method. The name property is an optional string. We use optional chaining to safely access the name property and call the printName method even when the person object is nil.

3. Enumerations with Associated Values

Enums in Swift are not limited to just simple values. They can also have associated values, which allow you to attach additional data to the enum cases.

Here’s an example:

enum Result {
    case success(Int)
    case failure(String)

let success = Result.success(200)
let failure = Result.failure("Server error")

switch success {
case .success(let statusCode):
    print("Success with status code: \(statusCode)")
case .failure(let errorMessage):
    print("Failure with error message: \(errorMessage)")

In the above example, we define an enum called “Result” with two cases: success and failure. The success case has an associated value of type Int, representing a status code. The failure case has an associated value of type String, representing an error message.

We can create instances of the enum with associated values and switch on them to access the associated values using pattern matching.

4. Typealias

Swift’s typealias allows you to create a custom name for an existing type. It is especially useful when you have complex type signatures or when you want to make your code more readable.

Here’s an example:

typealias Coordinates = (latitude: Double, longitude: Double)

func getLocation() -> Coordinates {
    return (37.7749, -122.4194)

let location = getLocation()
print("Latitude: \(location.latitude), Longitude: \(location.longitude)")

In the above example, we define a typealias called “Coordinates” for a tuple with two Double values representing latitude and longitude. We then use the typealias in the getLocation function to make the return type more descriptive. Finally, we print the latitude and longitude values.

5. Using Functions as Variables

In Swift, functions are first-class citizens, which means you can assign functions to variables, pass them as arguments to other functions, and return them as values from functions.

Here’s an example:

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

let operation: (Int, Int) -> Int = add
let result = operation(2, 3)
print(result) // Output: 5

In the above example, we define a function called “add” that takes two integers and returns their sum. We then assign the “add” function to a variable called “operation” of type “(Int, Int) -> Int”, which is a function type that takes two integers and returns an integer. We can then call the “operation” variable as if it were a function, passing in the arguments and getting the result.


Swift is a powerful and feature-rich programming language, and there are always new things to discover. In this article, we explored some lesser-known features of Swift, such as tuples, optional chaining, enums with associated values, typealias, and using functions as variables. By leveraging these hidden gems, you can write more expressive and concise code in Swift.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Diese Seite verwendet Cookies, um die Nutzerfreundlichkeit zu verbessern. Mit der weiteren Verwendung stimmst du dem zu.