Swift Academy · Lesson

In-Out Parameters and Multiple Returns

Mutating arguments with inout and returning multiple values via tuples.

In-Out Parameters and Multiple Returns is a free Swift Academy lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

Swift functions normally work with copies of values. `inout` parameters let a function mutate the caller's variable directly. Tuples let functions return multiple values at once.

The inout Keyword

Mark a parameter `inout` to mutate the original: ```swift func doubleInPlace(_ value: inout Int) { value *= 2 } var x = 5 doubleInPlace(&x) print(x) // 10 ``` The `&` prefix at the call site signals the variable may be mutated.

inout with Structs

```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) ```

inout Restrictions

• Constants (`let`) cannot be passed as `inout` • Literals cannot be passed as `inout` • Subscripts and computed properties can be `inout` if they have setters ```swift let c = 5 doubleInPlace(&c) // ❌ cannot pass let as inout ```

Returning Multiple Values with Tuples

Return several values by wrapping them in a tuple: ```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 ```

Named vs Unnamed Tuple Elements

Named elements make tuples self-documenting: ```swift let named: (width: Int, height: Int) = (1920, 1080) print(named.width) // 1920 let unnamed = (1920, 1080) print(unnamed.0) // 1920 ``` Prefer names for tuples returned from functions.

Destructuring Tuple Returns

Unpack a tuple return into multiple variables: ```swift let (minimum, maximum) = minMax(of: [5, 3, 8]) print(minimum) // 3 print(maximum) // 8 ``` Use `_` to discard unwanted elements: `let (minimum, _) = minMax(of: arr)`.

Optional Tuple Returns

Return nil for failure cases: ```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) } ```

swap With inout

The classic swap using 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 ``` Swift's stdlib provides `swap(_:_:)` already — no need to write your own.

When to Use inout vs Return

Prefer returning a new value over mutating 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() } ```

Quick Check

What prefix is required at the call site when passing a variable to an `inout` parameter?

Recap

Key takeaways: • `inout` allows functions to mutate caller variables; pass with `&` • Cannot pass `let` constants or literals as inout • Tuples return multiple values neatly; name elements for clarity • Destructure tuples: `let (a, b) = f()` • Prefer returning new values; use inout only when mutation is the API contract Next: functions as first-class values.

Frequently asked questions

Is the “In-Out Parameters and Multiple Returns” lesson free?

Yes — the full text of “In-Out Parameters and Multiple Returns” is free to read here on the web, and the Swift Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

What will I learn in “In-Out Parameters and Multiple Returns”?

Mutating arguments with inout and returning multiple values via tuples. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “In-Out Parameters and Multiple Returns” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Swift Academy