Functional Fun in Kotlin 47deg.com 

Who am I? 

Functional Fun in Kotlin Dependency Injection Side effects Typed Errors 

Dependency Injection interface Database { fun query(sql: String, vararg params: String): ResultRow } interface Logger { fun log(message: String): Unit fun error(throwable: Throwable, message: String): Unit } 

Dependency Injection fun fetchUser(id: Long, db: Database, logger: Logger): User { val user = db.query("SELECT * FROM users WHERE id = $1", id).toUser() logger.log("Query result: $user") return user } 

Dependency Injection fun fetchUser(id: Long, db: Database, logger: Logger): User { val user = db.query("SELECT * FROM users WHERE id = $1", id).toUser() logger.log("Query result: $user") return user } fun fetchAll(ids: List, db: Database, logger: Logger): List = ids.map { id -> fetchUser(id, db, logger) } 

Dependency Injection fun Context.fetchUser(id: Long): User 

Dependency Injection fun Context.fetchUser(id: Long): User where Context : Database, Context : Logger 

Dependency Injection fun Context.fetchUser(id: Long): User where Context : Database, Context : Logger { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } 

Dependency Injection fun Context.fetchUser(id: Long): User where Context : Database, Context : Logger { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } class Module(db: Database, logger: Logger): Database by db, Logger by logger 

Dependency Injection fun Context.fetchUser(id: Long): User where Context : Database, Context : Logger { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } class Module(db: Database, logger: Logger): Database by db, Logger by logger fun Context.fetchAll(ids: List): List where Context : Database, Context : Logger = ids.map { id -> fetchUser(id) } 

Dependency Injection context(Database, Logger) fun fetchUser(id: Long): User 

Dependency Injection context(Database, Logger) fun fetchUser(id: Long): User { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } 

Dependency Injection context(Database, Logger) fun fetchUser(id: Long): User { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } context(Database, Logger) fun fetchAll(ids: List): List = ids.map { id -> fetchUser(id) } 

Side effects Compile time tracked effects Composable Reason about code that performs side effects 

Side effects interface Database { fun query(sql: String, vararg params: String): ResultRow } interface Logger { fun log(message: String): Unit fun error(throwable: Throwable, message: String): Unit } 

Side effects interface Database { suspend fun query(sql: String, vararg params: String): ResultRow } interface Logger { suspend fun log(message: String): Unit suspend fun error(throwable: Throwable, message: String): Unit } 

Side effects context(Database, Logger) fun fetchUser(id: Long): User { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } 

Side effects context(Database, Logger) fun fetchUser(id: Long): User { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } Suspend function 'query' should be called only from a coroutine or another suspend function Suspend function 'log' should be called only from a coroutine or another suspend function 

Side effects context(Database, Logger) suspend fun fetchUser(id: Long): User { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } 

Suspend - Continuation Passing Style interface Continuation { val context: CoroutineContext fun resume(value: T) fun resumeWithException(exception: Throwable) } 

Suspend - Continuation Passing Style context(Database, Logger) fun fetchUser(id: Long, cont: Continuation): Unit { query("SELECT * FROM users WHERE id = $1", id, Continuation(cont.context) { res -> }) } 

Suspend - Continuation Passing Style context(Database, Logger) fun fetchUser(id: Long, cont: Continuation): Unit { query("SELECT * FROM users WHERE id = $1", id, Continuation(cont.context) { res -> res.fold({ resultRow -> val user = resultRow.toUser() log2("Query result: $user", Continuation(cont.context) { res -> }) }, cont::resumeWithException) }) } 

Suspend - Continuation Passing Style context(Database, Logger) fun fetchUser(id: Long, cont: Continuation): Unit { query("SELECT * FROM users WHERE id = $1", id, Continuation(cont.context) { res -> res.fold({ resultRow -> val user = resultRow.toUser() log2("Query result: $user", Continuation(cont.context) { res -> res.fold({ cont.resume(user) }, cont::resumeWithException) }) }, cont::resumeWithException) }) } 

Suspend - Continuation Passing Style context(Database, Logger) fun fetchUser(id: Long, cont: Continuation): Unit { query("SELECT * FROM users WHERE id = $1", id, Continuation(cont.context) { res -> res.fold({ resultRow -> val user = resultRow.toUser() log2("Query result: $user", Continuation(cont.context) { res -> res.fold({ cont.resume(user) }, cont::resumeWithException) }) }, cont::resumeWithException) }) } 

Side effects context(Database, Logger) suspend fun fetchUser(id: Long): User { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } 

Side effects context(Database, Logger) suspend fun fetchUser(id: Long): User { val user = query("SELECT * FROM users WHERE id = $1", id).toUser() log("Query result: $user") return user } context(Database, Logger) suspend fun fetchAll(ids: List): List = ids.map { id -> fetchUser(id) } 

Compile time tracking of expected errors Explicit in type signature Typed Errors 

Typed Errors context(Database, Logger) suspend fun fetchUser(id: Long): User? 

Typed Errors data class UserAlreadyExists(val error: PSQLException) context(Database, Logger) suspend fun insertUser(name: String, email: String): User 

Typed Errors data class UserAlreadyExists( val name: String, val email: String, val error: PSQLException ) context(Database, Logger) suspend fun insertUser(name: String, email: String): Either 

Typed Errors data class UserAlreadyExists( val name: String, val email: String, val error: PSQLException ) context(Database, Logger, Raise) suspend fun insertUser(name: String, email: String): User 

Typed Errors context(Database, Logger, Raise) suspend fun insertUser(name: String, email: String): User = catch({ query(""" INSERT INTO users VALUES ($1, $2) RETURNING user_id; """.trimIndent()).toUser() }) { error: PSQLException -> if (error.isUniqueViolation()) raise(UserAlreadyExists(name, email, error)) else throw error } 

Monadic DSLs context(Database, Logger, Raise) suspend fun insertUser(name: String, email: String): User = catch({ query(""" INSERT INTO users VALUES ($1, $2) RETURNING user_id; """.trimIndent()).toUser() }) { error: PSQLException -> if (error.isUniqueViolation()) raise(UserAlreadyExists(name, email, error)) else throw error } 

Arrow DSL based functional programming Idiomatic Kotlin syntax Kotlin Multiplatform ready 

Saga pattern context(SagaScope) suspend fun sagaOperation(): Result = saga({ action() }) { compensation() } 

Resource Safety context(ResourceScope, Logger) suspend fun custom(): CustomResource = install({ CustomResource. acquire() }) { res, exitCase -> log("Releasing $res due to $exitCase") res.release() } context(ResourceScope) suspend fun dataSource(config: HikariConfig): HikariDataSource = autoCloseable { HikariDataSource(config) } 

Thanks!