Part 2 : Control Flow with Kotlin
Published: 2022-07-18 21:47:23

## Motivation
This article is written for more advanced developers which are looking to get a quick grasp on the Kotlin Language for work or for some interesting projects.

We cover installation, basic syntax and a quick introduction to functions in this article which is Part 2 in a long series.

- Part 1 : [Getting Started with Kotlin](https://dev.to/ivanleomk/getting-started-with-kotlin-8fm)
- Part 2 : **Control Flow in Kotlin** 
- Part 3 : Loops and Exceptions in Kotlin ( Coming Soon )

> **Note** : I do use a For-Loop in this article to simulate  draws from a finite sequence from 0 to 10 but the syntax is relatively similar to other languages.

## Control Flow in Kotlin

In Kotlin, we have two main constructs that we can use when it comes to making decisions.

### If-Else

The first is the `if-else` construct which we can see an example below.

```kotlin
fun main(){
    val controlling:Int = 3;

    if(controlling < 4){
        println("The Value is less than 4")
    }
    else{
        println("The value is larger than 4")
    }
}
```

This doesn't seem very useful, so let's perhaps do a quick example where we randomly generate 4 numbers instead using kotlin's `random` package.

```kotlin
import kotlin.random.Random

fun main(){
    var controlling:Int;
    for( i in 1..4){
        controlling = (0..10).random()
        if(controlling < 4){
            println("The Value of $controlling is less than 4")
        }
        else{
            println("The value of $controlling is larger than 4")
        }
    }
}
```

which we can further simplify into

```
import kotlin.random.Random

fun main(){
    var controlling:Int;
    for( i in 1..4){
        controlling = (0..10).random()
        println(
            "The value of $controlling is ${
                if(controlling > 4) "greater" else "less"
            } than 4"
        )
    }
}
```

This in turn gives the same output of

```
The value of 7 is greater than 4
The value of 10 is greater than 4
The value of 5 is greater than 4
The value of 8 is greater than 4
```

### When to use When? :)

Another potential way of expressing this logic is by using a `when` construct.

```kotlin
import kotlin.random.Random


fun main(){
    var controlling:Int;
    for( i in 1..4){
        controlling = (0..10).random()
        when(controlling){
            in 0..4 -> println("$controlling is less than or equal to 4")
            in 5..10 -> println("$controlling is greater than 4")
            else -> println("Unsupported Number")
        }
    }
}
```

Let's walk through this logic a little bit

1. We know that `(0...10).random()` will yield us a number within the range of `0` to `10`. This is an inclusive range which means we can get `0` and `10`. **Therefore, we know that we only need to match against numbers that lie within this range. **

2. We want to print "less than 4" if we obtain a number less than or equal to 4 otherwise we print "greater than 4". This means that we are essentially breaking our number into two disjoint sets or groups.

These are the two groups

1,2,3,4 ( expressed as 1..4 )
5,6,7,8,9,10 ( expressed as 5..10)

3. Therefore, we can simply rewrite using the `when` loop to check membership in either side.

> In general, I find that `When` is more useful when you have more than two or three choices to make. 

Some useful shorthand syntax to remember when using `When` can be seen below

1. Finite number of distinct options

Let us first rewrite our original example above to take advantage of the `,` syntax. **Notice that we now do not utilise the `in` keyword**.

```
import kotlin.random.Random


fun main(){
    var controlling:Int;
    for( i in 1..4){
        println(i)
        controlling = (0..10).random()
        when(controlling){
            0,1,2,3,4 -> println("$controlling is less than or equal to 4")
            5,6,7,8,9,10 -> println("$controlling is greater than 4")
            else -> println("Unsupported Number")
        }
    }
}
```

Eg 2. Multiple Conditions

Let's write a short snippet that helps us check if a user can log in based on a given username or password. 

> **Note** : We could easily replace the following with an if-else loop if you prefer. Personally, I think this boils down to a matter of preference, `When` is just cleaner in general to me.

```

fun main(){
    val correct_username = "john.smith"
    val correct_password = "applebees"

    val username_attempts = listOf(
        "antique","john.smith","john.smith"
    )

    val password_attempts = listOf(
        "applebees","apples","applebees"
    )

    for(i in 0..2){

        when{
            correct_password == password_attempts[i] && correct_username == username_attempts[i] -> println("Login Succesful")
            correct_username != username_attempts[i] -> println("Wrong Username")
            correct_password != password_attempts[i] -> println("Wrong Password")
            else -> println("Horrible Attempt")
        }
    }
}
```


## Conclusion

Kotlin provides two useful constructs which help us to be able to deal with user-input and implement logic in our code. In the next article, we'll look at how we can reduce redundant code by using Loops!