Programming in Swift: Functions and Types · More Switch Statements |

This is a companion discussion topic for the original entry at

Hi :slight_smile:

How come we can use .max just like that? The number is greater than
.max / 2 of what? I think I don’t understand this instruction (line 9) :frowning:

func getDescription(for number: Int) → String {
switch number {
case 0:
return “Zero”
case 1…9:
return “Between 1 and 9”
case let negativeNumber where negativeNumber < 0:
return “Negative”
case _ where number > .max / 2:
return “Very large!”
return “No Description”

1 Like

@szarik The max property is defined as a static one for the Int type, so you normally call it as a type property using its type name explicitly like this: Int.max.

You can read even more about the whole thing over here:

You can write the corresponding switch case as follows in this case:

case _ where number > Int.max / 2: return "Very large!"

You can also use type inference since the number parameter in the getDescription(for:) method is declared as an Int argument, so you definitely know that you are comparing two Int values in the associated switch case.

.max uses the Int type implicitly under the hood, so it is simply syntactic sugar and shorthand dot syntax for Int.max.

This is how things are actually done in the video tutorial:

case _ where number > .max / 2: return "Very large!"

This is exactly the default behaviour for enumeration cases too.

You can read even more about this over here:

The min property is defined as a static one for the Int type as well.

You can read even more about it over here:

You can easily write a min switch case too which would be very similar actually to the max one either by using the Int type explicitly like this:

case _ where number < Int.min / 2: return "Very small!"

Or by using type inference implicitly instead as follows:

case _ where number < .min / 2: return "Very small!"

Please let me know if you have any more questions or other issues about the whole thing when you get a chance.

Thank you!

1 Like

Thanks @shogunkaramazov ! Now it is much simpler! :slight_smile:
Still being surprised how many things Swift infer…


As an old FORTRAN programmer, floating point (and Double) values should never be compared for equality. In the example y == x * x could easily be false for values that should be true. This is because the binary representation of base 10 decimal numbers is not always exact.

For example, in the coin purse exercise I had one of each in my coin purse – totalling 0.41. However when I print the value the reduce function calculates it is 0.41000000000000003. If I try to equate 0.41 to this, the answer - which should be true - is false.

If you are unaware of this it could create a bug that will cause you a lot of grief and may be hard to find.