# 1. Introduction

Tuples in Swift are used to group multiple values into a single compound value. These values within tuples can be of any type, and they do not have to be of the same type as each other. Tuples are particularly useful when you need to return multiple values from a function.

# 2. Source Code Example

``````// Defining a tuple
var person: (name: String, age: Int, address: String) = ("John Doe", 30, "123 Apple St")

// Accessing elements of a tuple
print("Name is \(person.name)")
print("Age is \(person.age)")

// Ignoring tuple values using _
let (_, _, onlyAddress) = person

// Defining a tuple without naming elements
let product = ("iPhone", 999.99)
print("Product name is \(product.0) and price is \(product.1)")

// Using tuple in a function
func fetchPersonDetails() -> (name: String, age: Int, address: String) {
return ("Jane Doe", 28, "456 Orange Ave")
}

let details = fetchPersonDetails()
``````

### Output:

```Name is John Doe
Age is 30
Only address is 123 Apple St
Product name is iPhone and price is 999.99
Fetched name: Jane Doe, age: 28, address: 456 Orange Ave
```

# 3. Step By Step Explanation

1. A tuple named person is defined with three elements. Each element in the tuple is named: name, age, and address.

2. Elements of the tuple person are accessed using dot notation followed by the name of the element.

3. The underscore _ is used to ignore elements of a tuple during deconstruction. Here, only the address is extracted from the person tuple.

4. A tuple without named elements is defined. The values inside this tuple can be accessed using an index, starting from 0.

5. A function fetchPersonDetails is defined that returns a tuple. This function, when called, returns a tuple with details about a person named "Jane Doe".

6. The returned tuple from the function is stored in constant details and its elements are printed using dot notation.