0Pricing
Swift Academy · Lesson

In-out params & basic error handling (throws)

Mutate arguments with in-out parameters and handle recoverable failures using throws, try, and do/catch.

In-out params & basic error handling (throws) is a free Swift Academy lesson on CoddyKit — lesson 3 of 3. 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 3 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Intro

This lesson covers in-out parameters (mutate the caller's variable) and basic error handling with throws, try, and do/catch.

inout basics

inout lets a function modify the caller's variable. Call with &name.

func increment(_ value: inout Int) {
    value += 1   // mutate caller's variable
}
var count = 0
increment(&count)
print("count =", count)  // 1

When to use

Use inout sparingly:

  • Good for simple mutations (e.g., counters).
  • Prefer returning new values for clarity and testability.

throws + do/catch

Mark functions that can fail with throws. Use do/try/catch to handle errors.

enum FileError: Error { case notFound, unreadable }

func readFile(named: String) throws -> String {
    if named.isEmpty { throw FileError.notFound }
    return "contents of \\(named)"
}

// Calling a throwing function
do {
    let text = try readFile(named: "notes.txt")
    print(text)
} catch {
    print("Failed:", error)
}

try? vs try!

try? turns errors into nil (optional). try! will crash on error—avoid unless absolutely certain.

// try? converts errors to nil (optional)
let maybeText = try? readFile(named: "")
print(maybeText as Any)  // nil

// try! crashes on error—only use when you are sure
// let forcedText = try! readFile(named: "")  // avoid in production

Throwing helpers

You can throw from helpers. Prefer small enums for custom errors; avoid raw NSError unless needed.

func parseInt(_ s: String) throws -> Int {
    if let n = Int(s) { return n }
    else { throw NSError(domain: "Parse", code: 1) }
}

do {
    let n = try parseInt("10")
    print("n =", n)
} catch {
    print("parse error")
}

inout question

Quick check: What does inout mean for a parameter?

Recap

Recap: Use inout for direct mutation (sparingly). Handle failures with throws, try, do/catch; prefer try? for optional results and avoid try! in production.

Frequently asked questions

Is the “In-out params & basic error handling (throws)” lesson free?

Yes — the full text of “In-out params & basic error handling (throws)” is free to read here on the web, and the Swift Academy course includes 3 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 params & basic error handling (throws)”?

Mutate arguments with in-out parameters and handle recoverable failures using throws, try, and do/catch. 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 3, so you can start here or from the beginning and move at your own pace.

How long does the “In-out params & basic error handling (throws)” 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

  1. Defining functions, parameters, labels, default/variadic
  2. Return values & multiple returns via tuples
  3. In-out params & basic error handling (throws)
← Back to Swift Academy