What do I like about Kotlin?
Tags: kotlin, development, programming
Published: 2021-05-31 06:26:19

This year I've got to learn [Kotlin](https://kotlinlang.org/) because I wanted to develop a PhpStorm plugin. Kotlin was developed by Jetbrains and is open-sourced. The nice thing about it is that it can be easily mixed with Java and other languages.

Before I started getting into developing I've watched this [Kotlin for Java Developers](https://www.coursera.org/learn/kotlin-for-java-developers) course. It was pretty helpful even though I don't work with Java. Plugin development wasn't easy, but there were a few things I've liked about the language itself.

## Collections

Since I primarily work with Laravel (PHP) I was really happy to see a familiar concept of collections. All those nice `map`, `filter`, `distinct`, etc. methods are there. And I used them a lot 🙂

```kotlin
val numbers = listOf(null, 1, 2, null)

numbers.filterNotNull().forEach {
    println(it)
}

numbers.contains(1)

numbers.filterNotNull()
    .map { it + 1 }
    .filter { it < 3 }
    .forEach { println(it) }
```

## Lambdas

As you can see above it has some interesting syntax for `map` and `filter` for example. Such lambdas will always return the last statement which was something new to me. However, it makes sense and allows for very clean syntax for shorter methods.

`it` points to the current element of iteration. It is possible to change it when needed.

```kotlin
numbers.map { number ->
    number * 10
}
```

## Everything is an object?

Well, yes and no. Everything can have methods that we can call, but primitives have a special treatment and don't behave like objects (regarding reference). This sometimes allows a very expressive syntax. 

```kotlin
@JvmStatic
fun String.asPhpClass(project: Project): PhpClass? {
    return PhpIndex.getInstance(project).getClassesByFQN(this).firstOrNull()
}
```

In code, you may have places where you have a class fully qualified name and you need to find the class, just do this:

```kotlin
val classFQN = "\App\Models\User"

val class = calssFQN.asPhpClass(project)

// or even

"\App\Models\User".asPhpClass(project)
```

## Add methods to any objects

Because you can add methods to strings, integers, etc., you can also add them to library objects. This may sound daunting at first,  but it is actually very useful. For example, while building [Laravel Query](https://plugins.jetbrains.com/plugin/16309-laravel-query) plugin, I had to do a lot of checks of classes and methods. Here are a few examples:

```kotlin
fun PhpClass.isJoinOrRelation(): Boolean =
    this.fqn == LaravelClasses.JoinClause || this.fqn == LaravelClasses.Relation

fun PsiElement.selectsAllColumns(): Boolean =
    this.textContains('*')
```

## Overloadable operators

I haven't actually used this one myself but sounds very cool. In kotlin, you can overload operators and describe how 2 objects should be added, subtracted, etc. Here is one of their examples:

```kotlin
data class Point(val x: Int, val y: Int)

operator fun Point.unaryMinus() = Point(-x, -y)

val point = Point(10, 20)

fun main() {
   println(-point)  // prints "Point(x=-10, y=-20)"
}
```

However, what was mind-blowing initially for me is that things like `in`, `a[i]`, `a(i)` [are also operators](https://kotlinlang.org/docs/operator-overloading.html#binary-operations). So a lot of language features are simply operators and added functions.

This is a very short list, but you get the idea 🙂 There are some more little things to like, I invite you to try it and maybe build some cool plugins for PhpStorm 😅