Shortened guard statement for throwable functions that must succeed

[chrisbia]

Right now you have to do this:

guard let _=try? startRecording() else { return }
AVAudioPlayer.play(alert: AlertTones.startRecording)

What I would prefer to do is this:

guard try? startRecording()
AVAudioPlayer.play(alert: AlertTones.startRecording)

Which would just return if an error was thrown. Furthermore, you could also do this if you wanted to break instead:

guard try? startRecording() else break
AVAudioPlayer.play(alert: AlertTones.startRecording)

[xwu (Xiaodi Wu)]

This is a commonly rejected change:

Shorthand for guard else empty return statement

From the Swift Evolution common proposals document: Infer return for omitted guard body: It has been proposed many times to allow omission of the guard body for the sake of brevity. However, a core principle of Swift is to make control flow explicit and visible. For example, the try keyword exists solely to indicate to the human reader where thrown errors can happen. Implicit returns would violate this principle, favoring terseness over clarity in a way that isn't typical of Swift. F…

[intswift]

I know this topic has been done to death, but this example could be symptomatic of ergonomics with try...catch rather than guard.

Often I want to try a throwing function and act if it throws but I don't care what the actual error was. Instead of writing:

do
{
  try something()
}
catch
{
  // Respond in some way, perhaps throw another error or return nil.
}

it would be nice if it could just be:

try something() else { /* do something else */ }

which looks a lot like what the OP is wanting to do.

I'm rarely a fan of shorthand in programming languages, but this would remove some noise from the listing.

A related scenario is when wanting to try one thing, and only if that fails then try something else, perhaps trying two or three different fallbacks, and then only if all of them have failed then you do a final catch. Perhaps there's an idiomatic way of expressing such a chain succinctly, but the naive way seems to be lots of dos and catches.

[ibex10]

@intswift

try something() else { /* do something else */ }

try and catch combination feels more natural.

try something() catch { /* handle exception */ }

[anon9791410]

More on that from last week: Guard-Let-Catch (and If-Let-Catch) to avoid long (nested) do-blocks - #22

It doesn't help with the chains @intswift mentioned though. It would be better, but still a pyramid of doom with one fewer level of indentation:

do {
  try oneOfSeveralThrowingFunctions()
} catch {
  do {
    try oneOfSeveralThrowingFunctions()
  } catch {
    do {
      try oneOfSeveralThrowingFunctions()
    } catch {

    }
  }
}

try oneOfSeveralThrowingFunctions() catch {
  try oneOfSeveralThrowingFunctions() catch {
    try oneOfSeveralThrowingFunctions() catch {

    }
  }
}

Emulating an else if chain necessitates catch blocks being able to follow each other:

try oneOfSeveralThrowingFunctions() catch {
  try oneOfSeveralThrowingFunctions()
} catch {
  try oneOfSeveralThrowingFunctions()
} catch {
  
}

[tera]

@anon9791410

do {
  try oneOfSeveralThrowingFunctions()
} catch {
  do {
    try oneOfSeveralThrowingFunctions()
  } catch {
    do {
      try oneOfSeveralThrowingFunctions()
    } catch {

    }
  }
}

Interestingly we already have a precedent of simplifying a similar pyramid of doom with "if" statements. Following that precedent gets us to this alternative:

do { // as in "if"
    try oneOfSeveralThrowingFunctions()
} catch do { // as in "else if"
    try oneOfSeveralThrowingFunctions()
} catch do {
    try oneOfSeveralThrowingFunctions()
} catch { // as in "else"
    print(error)
}

I still like the simplicity of a simplified try foo() catch bar() without a do.