Parámetros in-out y múltiples valores de retorno

Normalmente, las funciones de Swift trabajan con copias de los valores. Los parámetros `inout` permiten que una función modifique directamente la variable de quien la llama. Las tuplas permiten que las funciones devuelvan varios valores a la vez.

Marque un parámetro como `inout` para modificar el original: ```swift func doubleInPlace(_ value: inout Int) { value *= 2 } var x = 5 doubleInPlace(&x) print(x) // 10 ``` El prefijo `&` en el sitio de llamada indica que la variable puede modificarse.

```swift struct Point { var x: Double; var y: Double } func translate(_ p: inout Point, dx: Double, dy: Double) { p.x += dx p.y += dy } var origin = Point(x: 0, y: 0) translate(&origin, dx: 3.0, dy: 4.0) // origin is now (3.0, 4.0) ```

• Las constantes (`let`) no se pueden pasar como `inout` • Los literales no se pueden pasar como `inout` • Los subíndices y las propiedades calculadas pueden usarse como `inout` si tienen setters ```swift let c = 5 doubleInPlace(&c) // ❌ cannot pass let as inout ```

Devuelva varios valores agrupándolos en una tupla: ```swift func minMax(of array: [Int]) -> (min: Int, max: Int) { (array.min()!, array.max()!) } let result = minMax(of: [3, 1, 7, 2]) print(result.min, result.max) // 1 7 ```

Los elementos con nombre hacen que las tuplas se documenten por sí mismas: ```swift let named: (width: Int, height: Int) = (1920, 1080) print(named.width) // 1920 let unnamed = (1920, 1080) print(unnamed.0) // 1920 ``` Prefiera los nombres en las tuplas que devuelven las funciones.

Desestructure el valor devuelto por una tupla en varias variables: ```swift let (minimum, maximum) = minMax(of: [5, 3, 8]) print(minimum) // 3 print(maximum) // 8 ``` Use `_` para descartar los elementos que no necesite: `let (minimum, _) = minMax(of: arr)`.

Devuelva nil en los casos de error: ```swift func parse(_ s: String) -> (Int, Int)? { let parts = s.split(separator: ",") guard parts.count == 2, let a = Int(parts[0]), let b = Int(parts[1]) else { return nil } return (a, b) } ```

El intercambio clásico con inout: ```swift func swap(_ a: inout T, _ b: inout T) { let temp = a a = b b = temp } var m = 1, n = 2 swap(&m, &n) print(m, n) // 2 1 ``` La biblioteca estándar de Swift ya proporciona `swap(_:_:)`; no necesita escribir su propia implementación.

Prefiera devolver un valor nuevo en lugar de modificar un parámetro `inout`: ```swift // Prefer: func normalised(_ v: SIMD3) -> SIMD3 { v / v.magnitude } // Use inout only when mutation is expected API contract, e.g. algorithms on large arrays func sort(_ arr: inout [Int]) { arr.sort() } ```

Puntos clave: • `inout` permite que las funciones modifiquen las variables de quien las llama; páselas con `&` • No puede pasar constantes `let` ni literales como `inout` • Las tuplas devuelven varios valores de forma ordenada; asigne nombres a los elementos para mayor claridad • Desestructure las tuplas: `let (a, b) = f()` • Prefiera devolver valores nuevos; use `inout` solo cuando la mutación forme parte del contrato de la API Siguiente: funciones como valores de primera clase.