CODEWITHSUNDEEP
swiftfunctionscope
Marc
Marc

Reputation: 3070

How to exit a function scope from inner function using Swift?

With return it is possible to exit the scope of the current function but is it also possible to exit the scope of the outer function that is calling the inner function?

func innerFunction() {
  guard 1 == 2 else {
    // exit scope of innerFunction and outerFunction
  }
}

func outerFunction() {
  innerFunction()
  print("should be unreachable")
}

There could be one approach using a return value of the inner function that we can check for:

func innerFunction() -> Bool {
  guard 1 == 2 else {
    return false
  }
  return true
}

func outerFunction() {
  guard innerFunction() else {
    return
  }
  print("should be unreachable")
}

The problem with this approach is that it can clutter your code pretty quickly if the functions become more complicated and you have to use them over and over again.

Consider applying this approach with XCTest. It would look like this:

func testFoobar() {
  guard let unwrappedObject = helperFunction() else {
    XCTFail("A failure message that can change with each helperFunction call")
    return
  }
  print("should be unreachable when helperFunction already failed")
}

I'd like to have something similar to this:

func testFoobar() {
  let unwrappedObject = helperFunction()
  print("should be unreachable when helperFunction already failed")
}

Upvotes: 1

Views: 619

Answers (1)

jscs
jscs

Reputation: 64002

This is basically what Swift's error handling does:

func outer() throws
{
    try inner()
    print("Unreachable")
}

struct DoNotContinue : Error {}

func inner() throws
{
    throw DoNotContinue()
}

do { try outer() }
catch _ { print("Skipped the unreachable") }

Note, of course, that the caller still has control over this: it could catch the thrown error itself instead of just exiting.

problem with this approach is that it can clutter your code

There's a much more serious problem with allowing callees to directly exit their callers, and that is that the flow of control very quickly becomes incomprehensible. Imagine that you have a couple of layers of this. Reading the top-level function, you no longer have any clear idea what can happen. You must yourself recurse into every callee's callee to make sure that the original code will continue on its course.

Upvotes: 3

Related Questions