if case let in Swift defined – Donny Wals

In Swift, we will use. the case key phrase in a number of locations. Mostly, a case is utilized in switched however because you’re right here, you may need seen a case together with an if assertion.

On this publish, we’ll discover completely different locations the place e can use the case key phrase to carry out one thing referred to as sample matching in Swift.

Sample matching is a robust characteristic of Swift that enables us to carry out extremely elegant checks to see if a given kind matches a sure worth.

On this publish, we’ll discover a selected form of sample matching in Swift; the if case let method of sample matching.

Understanding sample matching

The syntax for if case let is considerably complicated. So let’s begin with a fast code pattern that demonstrates how one can write an if assertion that makes an attempt to match an enum case:

enum ShapeType {
  case rectangle, triangle, circle
}

let myShape = ShapeType.rectangle

if case .rectangle = myShape {
  print("myShape is a rectangle")
}

Now, let me begin by saying we didn’t want to make use of the case syntax right here. We may have simply as properly written the next:

if myShape == .rectangle {
  print("myShape is a rectangle")
}

Nonetheless, I like the sooner instance as a result of it introduces the case syntax in a fairly clear approach.

Now, earlier than I dig in to indicate you the case let syntax I’d like to check out the type of sample matching in Swift that’s probably the one you’re most acquainted with:

change myShape {
case .rectangle:
  print("myShape is a rectangle")
case .triangle:
  break
case .circle:
  break
}

A change in programming permits us to jot down an inventory of patterns that we need to evaluate a given worth to. That is far more handy that writing a bunch of if / else statements.

The case key phrase in Swift doesn’t carry out any particular magic. As an alternative, it invokes a particular operator that compares our sample (no matter we write after case) to a price (the worth we’re switching over in a change).

So… how does that assist you to perceive if case let syntax?

Understanding if case let

As soon as you understand that if case .rectangle = myShape invokes a comparability between .rectangle and myShape the next out of the blue makes a bit of extra sense:

enum LoadingState {
  case inProgress(Job<String, By no means>)
  case loaded(String)
}

let state = LoadingState.loaded("Hi there, world")

if case .loaded(let string) = state {
  print("Loaded string is (string)")
}

// or

if case let .loaded(string) = state {
  print("Loaded string is (string)")
}

In each comparisons, we evaluate our enum case of .loaded and we assign its related worth to a continuing. I desire case .loaded(let string) myself as a result of it appears rather less unusual that case let .loaded(string) however they’re functionally equal.

And in a change, you’d use the identical patterns to match towards which all the time helps me to recollect:

change state {
case .inProgress(let process):
  break
case .loaded(let string):
  print("Loaded string is (string)")
}

Once more, the sample right here is that we evaluate our case to a worth. In a change this appears much more pure than it does in an if assertion however they’re the identical underneath the hood they usually each use the underlying ~= comparator.

That mentioned, writing if case .loaded(let string) = state once you’re solely inquisitive about a single case is definitely extra handy than writing a full blown change once you’re solely inquisitive about a single case.