Kotlin - Context Receivers

# .grey[**Context receivers**]

## Kotlin's new secret sauce

---

# 🧩 Context receivers

New Kotlin feature in 1.6.20 and 1.7

---

# 🧩 Context receivers

**Coolest** Kotlin feature in 1.6.20 and 1.7

## Lots of use cases .grey[Cross-cutting concerns]

🪢 Dependency injection      ❥ Nested configurations 
🧬 Detached interfaces 
⚡ Effect scopes      ❥ Describing typed errors

---

# 📒 Logging

Prime example of .grey[cross-cutting concern]

- It's **never** part of the **main** domain
- If explicit, it pollutes the code
  - We want to **hide** any boilerplate around it
- Usually **re-used** across several domains or modules within the same application

---

# 📒 Logging

Prime example of .grey[cross-cutting concern]

```kotlin
interface Logger {
  suspend fun log(
    level: LogLevel, 
    subject: String, 
    message: String
  )
}
```

---

# 🧩 Context receivers in use

1️⃣ Add to the signature where needed

2️⃣ The interface is available in the body

.code70[
```kotlin
  request(url).also {
    when(it) {
      null -> log(LogLevel.CRITICAL, ..., ...)
    }
  }?.let { parseInfo(it) }
```
]

---

# 🧩 Context receivers in use

3️⃣ You can call other functions with the same context without further boilerplate

.code70[
```kotlin
context(Logger)
suspend fun initializeApp(): App? {
  downloadData(App.DATA_URL)?.let {
    downloadAvatar(it.avatarImage)
  }
}
```
]

---

# 🧩 Context receivers in use

4️⃣ Inject — provide an impl. — using `with`

suspend fun main() {
  with(ConsoleLogger()) {
    config = initializeApp()
    ...
  }
}
```
]

---

# 📩 Implicit receivers

## What is `this`?

Answers the need of implicit supporting values

.code80[
```kotlin
class Database {             // ← dispatch
  context(Logger)            // ← context
  suspend fun User.save() {  // ← extension
    // if you need to refer to one
    this@Logger.log(...)
  }
}
```
]

---

# 📩 Implicit receivers

## What is `this`?

Answers the need of implicit supporting values

.code80[
```kotlin
class Database {             // ← dispatch
  context(Logger)            // ← context
  suspend fun User.save() {  // ← extension
    // in the body, this has type
    // Database & Logger & User
  }
}
```
]

---

# 📩 Implicit receivers

## What is `this`?

Answers the need of implicit supporting values

.code80[
```kotlin
class Database {             // ← dispatch
  context(logger@Logger)     // ← context
  suspend fun User.save() {  // ← extension
    // you can use context tags
    logger.log(...)
  }
}
```
]

---

# 📩 Implicit receivers

## What is `this`?

**Dispatch**: where the method is declared    non-existing for top-level functions

**Extension**: introduce with `fun Type.name(...)`    adds the ability to call with `.`

**Context**: extensions on steroids    values come from `with`    syntax with `.` not available

---

# 🪢 Dependency injection

---

# 🪢 Dependency injection

## .grey[Basic use case for context receivers]

.code70[
```kotlin
context(Logger, HttpService)
fun login(usr: String, pass: String): User? {
  ... // compute password hash
  val params = mapOf("username" to usr, 
                     "password" to hash)
  val r = httpPost("/login", params).getOrNull()
  return r?.let { result ->
    log(LogLevel.INFO, "login", "successful")
    parseUser(result)
  }
}
```
]

---

# 🪢 Dependency injection

## .grey[Basic use case for context receivers]

Those two rules provide many benefits over dependency injection frameworks

---

# 🧶 Declare the services you require

The required services become part of the function signature with `context`

- The compiler can check good usage
- The IDE can help you diagnosing problems
- Explicit documentation about what the function may do

---

# 🧶 Declare the services you require

Some contexts may depend on others

This imposes _ordering_ at injection time

---