Optional chaining in swift with arbitrary operations?

Question

Apple supplies an example of succinct optional chaining

class Person {
  var residence: Residence?
}

class Residence {
  var numberOfRooms = 1
}

let john = Person()

if let roomCount = john.residence?.numberOfRooms {
  println("John's residence has \(roomCount) room(s).")
} else {
  println("Unable to retrieve the number of rooms.")
}

Imagine trying to adjust the condition with some arithmetic operations. This results in a compiler error as the modulo operator doesn't support optionals.

if john.residence?.numberOfRooms % 2 == 0 { 
  // compiler error: Value of optional type Int? not unwrapped
  println("John has an even number of rooms")
} else {
  println("John has an odd number of rooms")
}

Of course you could always do something like the following, but it lacks the simplicity and succinctness of optional chaining.

if let residence = john.residence {
  if residence.numberOfRooms % 2 == 0  {
    println("John has an even number of rooms")
  }else{
    println("John has an odd number of rooms")
  }
} else {
  println("John has an odd number of rooms")
}

Are there any Swift language features which might provide a better solution?

Answer 1

I think what you are looking for is generally called a monad in functional programming.

It is not directly available in swift, but by using some of the language features, you can implement monads yourself in a generic way. (And also define a nice looking infix operator that makes it look like the monads in Haskell)

A quick google search for "monad swift" turned up some promising looking code at https://gist.github.com/cobbal/7562875ab5bfc6f0aed6

Answer 2

Pattern matching is quite powerful, and can work in situations like this:

switch john.residence?.numberOfRooms {
case .Some(let x) where x % 2 == 0:
    println("Even number of rooms")
default:
    println("Odd number of rooms")
}