13

I ran into this code which is part of a Swift implementation of a linked list in the Swift Algorithm Club. Throughout the implementation the author uses case let following a while statement right before unwrapping an optional. I've never seen the case keyword used outside of the context of a switch statement, and I'm wondering what exactly it does? Does it somehow cast the let next? = node.next part to true or false, maybe depending on whether next? becomes nil or not?

public var last: Node? {
    if var node = head {
        while case let next? = node.next {
            node = next
        }
        return node
    } else {
        return nil
    }
}
paxdiablo
  • 854,327
  • 234
  • 1,573
  • 1,953
Keith Grout
  • 899
  • 11
  • 30
  • Related: http://stackoverflow.com/questions/30720289/swift-2-pattern-matching-in-if. – Martin R Jun 10 '16 at 02:20
  • Also related: http://stackoverflow.com/questions/36880109/what-are-the-advantages-use-cases-of-optional-patterns-introduced-in-swift-2/36881836#36881836 – jtbandes Jun 10 '16 at 02:35

2 Answers2

15

This is the Optional Pattern. It tests and unwraps an Optional, executing the conditional only if the Optional is non-nil.

The keyword case is needed because it follows from the original switch...case syntax. The case tests a pattern and if it matches then the following statement is executed. In your example the let next? is the pattern. If the value is unwrapped and assigned then the case matches and your code is executed.

From the documentation:

Optional Pattern

An optional pattern matches values wrapped in a Some(Wrapped) case of an Optional or ImplicitlyUnwrappedOptional enumeration. Optional patterns consist of an identifier pattern followed immediately by a question mark and appear in the same places as enumeration case patterns.

Because optional patterns are syntactic sugar for Optional and ImplicitlyUnwrappedOptional enumeration case patterns, the following are equivalent:

let someOptional: Int? = 42
// Match using an enumeration case pattern
if case .Some(let x) = someOptional {
    print(x)
}

// Match using an optional pattern
if case let x? = someOptional {
    print(x)
}

The optional pattern provides a convenient way to iterate over an array of optional values in a for-in statement, executing the body of the loop only for non-nil elements.

let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]
// Match only non-nil values
for case let number? in arrayOfOptionalInts {
    print("Found a \(number)")
}
// Found a 2
// Found a 3
// Found a 5
  • 6
    This seems to me to explain (quite well) what an optional pattern is, but *not* why the `case` is needed, desirable, or even possible. That is, after all, what the question was asking for. – paxdiablo Jun 10 '16 at 01:47
  • 4
    Optionals in swift are (generic) enums behind the scenes, and each possible value an enum can take is named a `case` (in accordance to the `switch` statement commonly used to select one of many possible values). The two cases of the optional are `.None` (when `nil`) and `.Some` (when non-nil, with the wrapped value as the associated value of the enum case). I guess that it why this syntax uses the keyword `case`, even though it is not a `switch` statement. – Nicolas Miari Jun 10 '16 at 02:10
  • The link I gave does explain the "why", there was just too much to quote from it. I added a simple explanation as to "why" the keyword is needed but the documentation goes into more detail. –  Jun 10 '16 at 02:13
4

Swift 2 took the pattern paradigm from switch/case statements and allowed it to be used in other contexts (if, while and so on).

So now, rather than just simple comparisons, you can use these pattern matching comparisons in conditionals as well.

As one example, rather than:

if (a >= 0) and (a <= 255)

you can instead use:

if case 0...255 = a

That's a trivial example but it can become much more useful once you realise the rather large number of pattern matching options available to you.

paxdiablo
  • 854,327
  • 234
  • 1,573
  • 1,953
  • I think `0...255 =~ a` is preferred in this case. You'd probably only use `case` for `Range` containment in a `switch-case`. – BallpointBen Jul 16 '17 at 01:22
  • @BallpointBen I think you mean `0...255 ~= a`, at least as of Swift 5.1. More info here: https://docs.swift.org/swift-book/ReferenceManual/Patterns.html – CyberMew Sep 05 '19 at 01:17