This is a companion discussion topic for the original entry at https://www.raywenderlich.com/5429279-programming-in-swift-functions-and-types/lessons/24

This is a companion discussion topic for the original entry at https://www.raywenderlich.com/5429279-programming-in-swift-functions-and-types/lessons/24

Hi

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)

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!”

default:

return “No Description”

}

}

@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:

https://developer.apple.com/documentation/swift/int/1540171-max

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:

https://docs.swift.org/swift-book/LanguageGuide/Enumerations.html

The `min`

property is defined as a static one for the `Int`

type as well.

You can read even more about it over here:

https://developer.apple.com/documentation/swift/int/1539485-min

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!

Thanks @shogunkaramazov ! Now it is much simpler!

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.