Mastering Kotlin Standard Library

Mastering
Kotlin Standard
Library
Nelson Glauber
@nglauber

• Provides the essential types, classes and functions for
everyday work with Kotlin.
• In version 1.3 it contains approximately 50 sub packages
organized in 4 categories:  
Common, JVM, JS and Native.
Kotlin Std Lib

• T.let { }
• T.apply { }
• T.also { }
• T.run { }
• run { }
• with(T) { }
Scope Functions

• It’s an extension function.

• Caller is represented by it.

• Returns the block’s last line.
• It’s commonly used for nullability checking.
public inline fun <T, R> T.let(block: (T) -> R): R {
return block(this)
}

fun deleteTempPhoto() {
var tempImageFile: File? = // ...
tempImageFile?.let {
if (it.exists()) it.delete()
}
}

var tempImageFile: File? = // ...
if (tempImageFile != null) {
if (tempImageFile.exists()) // thanks smart cast!
tempImageFile.delete()
}
}

class SomeClass {
var tempImageFile: File? = null
if (tempImageFile != null && tempImageFile.exists())
}
}

Smart cast to 'File' is impossible,
because 'tempImageFile' is a mutable
property that could have been changed
by this time
class SomeClass {
if (tempImageFile != null && tempImageFile.exists())
}
}

class SomeClass {
if (tempImageFile != null && tempImageFile?.exists() == true )
tempImageFile?.delete()
}
}
😒😱

class SomeClass {
tempImageFile?.let {
if (it.exists()) it.delete()
}
}
}

class SomeClass {
tempImageFile?.let { file ->
if (file.exists()) file.delete()
}
}
}
😎


• Caller is represented by this.

• Returns the caller itself (this).
• It’s commonly used for initializing and conﬁguring an
object.
public inline fun <T> T.apply(block: T.() -> Unit): T {
block()
return this
}

val chip = Chip(this)
chip.text = weatherType.name.capitalize()
chip.setChipBackgroundColorResource(R.color.colorAccent)
chip.isClickable = false
chip.isCheckable = false
chip.isCloseIconVisible = true
chip.setOnCloseIconClickListener {
if (viewModel.unselectWeatherType(weatherType)) {
chipGroup.removeView(it)
}
}
chipGroup.addView(chip)

val chip = Chip(this).apply {
text = weatherType.name.capitalize()
setChipBackgroundColorResource(R.color.colorAccent)
isClickable = false
isCheckable = false
isCloseIconVisible = true
setOnCloseIconClickListener {
}
}
}
chipGroup.addView(chip)


• Caller is represented by it.

• Returns the caller itself (this).
• It’s commonly used for chaining object initialization or
simple to separate one action from another.
public inline fun <T> T.also(block: (T) -> Unit): T {
block(this)
return this
}

Chip(this).apply {
text = weatherType.name.capitalize()
setChipBackgroundColorResource(R.color.colorAccent)
isClickable = false
isCheckable = false
isCloseIconVisible = true
setOnCloseIconClickListener {
}
}
}.also {
chipGroup.addView(it)
}


• Caller is represented by this.

• It’s commonly used to get the result of an operation
using an object.
public inline fun <T, R> T.run(block: T.() -> R): R {
return block()
}

public inline fun <R> run(block: () -> R): R {
return block()
}
• It’s not an extension function.

• There’s no reference to the caller (once it’s not an
extension function).

• It’s commonly used to get the result of an operation.

private fun getFavoriteCity(): String {
val prefs =
PreferenceManager.getDefaultSharedPreferences(this)
return prefs.getString("favCity", null) ?:
getString(R.string.pref_city_default)
}

private fun getFavoriteCity() =
PreferenceManager.getDefaultSharedPreferences(this).run {
getString("favCity", null)
} ?: run {
getString(R.string.pref_city_default)
}

• It’s not an extension function.

• The caller is passed as parameter and is referenced by
this.

• It’s commonly used when you want to remember Delphi.
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
return receiver.block()
}

val webView: WebView = loadWebView()
with(webView) {
settings.javaScriptEnabled = true
loadUrl("file:///android_asset/app_page.html")
}

val webView: WebView? = loadWebView()
with(webView) {
}

with(webView) {
}
Only safe (?.) or non-null asserted (!!.)
calls are allowed on a nullable receiver
of type WebView?

with(webView) {
this?.settings?.javaScriptEnabled = true
this?.loadUrl("file:///android_asset/app_page.html")
}
😩

webView?.let {
it.settings.javaScriptEnabled = true
it.loadUrl("file:///android_asset/app_page.html")
}
%

• T.let { } for nullability check.
• T.apply { } for object initialization.
• T.also { } for initialization chaining or a simple change of
scope.
• T.run { } to get a result from an object sequence of calls.
• run { } to get a result from a sequence of calls.
• with(T) { } for some reason you don’t know how to
explain… :)
Scope Functions - Summary

fun sayHello() {
println("Hello!")
}

fun sayHello() {
println("Hello!")
}
fun greetings(message: String = "Hello") {
println(message)
}

@Deprecated(
message = "This function is being replaced.",
replaceWith = ReplaceWith("greetings(message)"),
level = DeprecationLevel.WARNING)
fun sayHello() {
println("Hello!")
}
println(message)
}

@Deprecated(
message = "This function is being replaced.",
replaceWith = ReplaceWith("greetings(message)"),
level = DeprecationLevel.WARNING)
fun sayHello() {
println("Hello!")
}
println(message)
}
fun main() {
sayHello()
}

fun login(userName: String, password: String) {
// Do login
}

// Do login
}
data class AuthUser(val name: String, val password: String)
fun login(authUser: AuthUser) {
// New login with user
}

// Do login
}
@Experimental(Experimental.Level.WARNING)
annotation class NewApi
}

// Do login
}
@NewApi
@NewApi
}

// Do login
}
@NewApi
@NewApi
}
@UseExperimental(NewApi::class)
fun main() {
login(AuthUser("ngvl", "123"))
}

• JvmStatic
• JvmOverloads
• JvmName
• JvmField
• Throws
@Jvm* annotations

object UserRepository {
fun insertUser(user: User) {
// insert user
}
}

// insert user
}
}
public class MyJavaClass {
...
public void addUser() {
UserRepository.INSTANCE.insertUser(new User("Nelson"));
}
}

@JvmStatic
// insert user
}
}
...
UserRepository.INSTANCE.insertUser(new User("Nelson"));
}
}

@JvmStatic
// insert user
}
}
...
UserRepository.insertUser(new User("Nelson"));
}
}

class MyKotlinClass {
fun printName(name: String = "Anonymous") {
println("Hello $name!")
}
//...
}

}
//...
}
MyKotlinClass instance = new MyKotlinClass();
instance.printName("Nelson"); // Works!
instance.printName(); // Error!

@JvmOverloads
}
//...
}

@JvmOverloads
}
//...
}
MyKotlinClass instance = new MyKotlinClass();
instance.printName("Nelson");
instance.printName();

public class MyCustomView extends LinearLayout {
public MyCustomView(Context context) {
super(context);
}
public MyCustomView(Context context,
@Nullable AttributeSet attrs) {
super(context, attrs);
}
public MyCustomView(Context context,
@Nullable AttributeSet attrs,
int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
...
}

class MyCustomView : LinearLayout {
constructor(context: Context) : super(context) {
}
constructor(context: Context,
attrs: AttributeSet?
) : super(context, attrs) {
}
constructor(context: Context,
attrs: AttributeSet?,
defStyleAttr: Int
) : super(context, attrs, defStyleAttr) {
}

class MyCustomView @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null,
defStyleAttr: Int = 0
) : LinearLayout(context, attrs, defStyleAttr) {
...
}

class ToggleView {
private var onOff = false
fun switch() {
onOff = !onOff
}
}
ToggleView toggleView = new ToggleView();
toggleView.switch(); // error!

class ToggleView {
private var onOff = false
@JvmName("switchOnOff")
fun switch() {
onOff = !onOff
}
}
ToggleView toggleView = new ToggleView();
toggleView.switchOnOff();

// StringsExtensions.kt
package ngvl.kotlin.demo.string
fun String.shouldCapitalizeName() =
this !in listOf("da", "das", "de", "di", "do", "dos")
fun String.capitalizeName() =
this.split(" ")
.joinToString(" ") {
if (it.shouldCapitalizeName())
it.capitalize()
else it
}
// Some Java file...
String name = StringExtensionsKt.capitalizeName("nelson glauber");

@file:JvmName("StringExt")
this.split(" ")
it.capitalize()
else it
}
String name = StringExtensionsKt.capitalizeName("nelson glauber");

@file:JvmName("StringExt")
this.split(" ")
it.capitalize()
else it
}
String name = StringExt.capitalizeName("nelson glauber");

data class Product(
val id: String,
val description: String,
val price: Float = 0f
)
Product product = new Product("001", "Smartphone", 0f);
System.out.println(
product.getId() +" - "+
product.getDescription() +" = "+
product.getPrice()
);

System.out.println(
product.getId() +" - "+
product.getDescription() +" = "+
product.getPrice()
);
data class Product(
@JvmField val id: String,
@JvmField val description: String,
@JvmField val price: Float = 0f
)

data class Product(
@JvmField val id: String,
@JvmField val description: String,
@JvmField val price: Float = 0f
)
System.out.println(
product.id +" - "+
product.description +" = "+
product.price
);

companion object {
val CONSTANT_1 = 1
const val CONSTANT_2 = 2
@JvmField val CONSTANT_3 = 3
@JvmField val ROOT = User("root")
}
}
MyKotlinClass.Companion.getCONSTANT_1();
MyKotlinClass.CONSTANT_2;
MyKotlinClass.CONSTANT_3;
MyKotlinClass.ROOT;

@JvmStatic
if (user.name.length < 5)
throw NameTooShortException()
// insert user ...
}
}
UserRepository.insertUser(new User("ngvl"));

@JvmStatic
@Throws(NameTooShortException::class)
if (user.name.length < 5) {
}
// insert user ...
}
}

try {
} catch (NameTooShortException e) {
// handle name too short
}
@JvmStatic
@Throws(NameTooShortException::class)
if (user.name.length < 5) {
}
// insert user ...
}
}

data class Recipe(
var name: String? = null,
var ingredients: List<Ingredient> = mutableListOf()
)
data class Ingredient(
var description: String? = null,
var quantity: Int = 0,
var unity: String? = null
)

data class Recipe(
)
)
fun recipe(build: Recipe.() -> Unit) = Recipe().apply(build)
fun Recipe.ingredient(build: Ingredient.() -> Unit) {
ingredients += Ingredient().apply(build)
}
public inline fun <T> T.apply(block: T.() -> Unit): T {
block()
return this
}

}
val recipe = recipe {
name = "Chocolate Cake"
ingredient {
name = "Flour"
quantity = 3
unity = "cups"
}
}
println(recipe)
Recipe(name=Flour, ingredients=[
Ingredient(description=null, quantity=3, unity=cups)]
) 🤔

data class Recipe(
)
)
}

@DslMarker annotation class RecipeLang
@RecipeLang
data class Recipe(
)
@RecipeLang
)
}

ingredient {
name = "Flour"
quantity = 3
unity = "cups"
}
}
println(recipe)
}
Compile error: 'var name: String?'
can't be called in this context by
implicit receiver.
Use the explicit one if necessary

ingredient {
this@recipe.name = "Choc.Cake"
quantity = 3
unity = "cups"
}
}
println(recipe)
}

ingredient {
description = "Flour"
quantity = 3
unity = "cups"
}
}
println(recipe)
}
Recipe(name=Chocolate Cake, ingredients=[
Ingredient(description=Flour, quantity=3, unity=cups)]
) 😋

• @Deprecated and @Experimental help to document the
evolution of your code
• @Jvm* annotations help the integration with Java code.
• @DslMarker create scopes for your DSLs.
Annotations - Summary

abstract class Individual(
val name: String,
val surname: String,
val age: Int
)
class Student(
name: String,
surname: String,
age: Int,
val university: String
) : Individual(name, surname, age)
class Worker(
name: String,
surname: String,
age: Int,
val company: String
) : Individual(name, surname, age)

interface Individual {
val name: String
val surname: String
val age: Int
}
data class IndividualData(
override val name: String,
override val surname: String,
override val age: Int
) : Individual
data class Student(
val data: IndividualData,
) : Individual by data
data class Worker(
val company: String

interface Individual {
val name: String
val surname: String
val age: Int
}
data class IndividualData(
override val name: String,
override val surname: String,
override val age: Int
) : Individual
data class Student(
data class Worker(
val company: String
val student = Student(
IndividualData("Nelson", "Leal", 36), "Universo"
)
student.run {
println("$name $surname - $age - $university")
}
Nelson Leal - 36 - Universo

class Repository {
private val peopleDAO: PeopleDAO by lazy {
Database.getPeopleDAO()
}
fun insert(person: Person) {
peopleDAO.add(person)
}
fun all(): List<Person> = peopleDAO.list()
}

class Repository {
private val peopleDAO: PeopleDAO by lazy {
Database.getPeopleDAO()
}
fun insert(person: Person) {
peopleDAO.add(person)
}
fun all(): List<Person> = peopleDAO.list()
}
val repo = Repository()
repo.insert(Person("1", "Nelson"))
repo.insert(Person("2", "Glauber"))
repo.all().forEach(::printPerson)

Delegates.vetoable(0) { // it's an inline function
kprop, oldValue, newValue ->
newValue in 0..122 // Jeanne Calmen
}

val ageDelegate = {
Delegates.vetoable(0) {
newValue in 0..122
}
}
if you don't use it as a function, it will return
the last value for the new instance

val ageDelegate = {
newValue in 0..122
}
}
class Person(val id: String, val name: String) {
var age: Int by ageDelegate()
}

val ageDelegate = {
newValue in 0..122
}
}
class Person(val id: String, val name: String) {
var age: Int by ageDelegate()
}
val p = Person("3", "Nelson")
p.age = -1
printPerson(p)
p.age = 150
printPerson(p)
p.age = 35
printPerson(p)
3 - Nelson - 0
3 - Nelson - 0

3 - Nelson - 35

interface OnFilterCallback {
fun onFilterChanged(f: Filter)
}
class Filter {
var minBathNum: Int = 0
var minPrice: Float = 0f
private val callbacks = mutableSetOf<OnFilterCallback>()
fun addOnFilterChangedCallback(callback: OnFilterCallback) {
callbacks += callback
}
}

class Filter {
var minBathNum: Int = 0
var minPrice: Float = 0f
}
fun notifyObservers() {
callbacks.forEach{ it.onFilterChanged(this) }
}
}

class FilterDelegate<T>(initial: T) {
var internal: T = initial
operator fun getValue(thisRef: Filter, prop: KProperty<*>): T {
return internal
}
operator fun setValue(thisRef: Filter, prop: KProperty<*>, value: T) {
internal = value
thisRef.notifyObservers()
}
}

interface OnFilterCallback {
fun onFilterChanged(f: Filter)
}
class Filter {
var minBathNum: Int by FilterDelegate(0)
var minPrice: Float by FilterDelegate(0f)
}
fun notifyObservers() {
callbacks.forEach{ it.onFilterChanged(this) }
}
}

val filter = Filter()
filter.addOnFilterChangedCallback(object: OnFilterCallback {
override fun onFilterChanged(f: Filter) {
println("Observer #1")
println("MinPrice: ${f.minPrice} - Baths:${f.minBathNum}")
}
})
filter.addOnFilterChangedCallback(object : OnFilterCallback {
println("MinPrice: ${f.minPrice} - Baths:${f.minBathNum}")
}
})
filter.minBathNum = 2
filter.minPrice = 100_000f
filter.minPrice = 10f
Observer #1 | MinPrice: 0.0 - Baths:2

fun <T> Filter.filterDelegate(initialValue: T) =
Delegates.observable(initialValue) { prop, oldValue, newValue ->
println("old: $oldValue -> new: $newValue")
this.notifyObservers()
}

fun <T> Filter.filterDelegate(initialValue: T) =
Delegates.observable(initialValue) { prop, oldValue, newValue ->
println("old: $oldValue -> new: $newValue")
this.notifyObservers()
}
class Filter {
var minBathNum: Int by filterDelegate(0)
var minPrice: Float by filterDelegate(0f)
...
}

val filter = Filter()
filter.addOnFilterChangedCallback(object: OnFilterCallback {
println("Observer #1”)
}
})
filter.addOnFilterChangedCallback(object : OnFilterCallback {
}
})
filter.minPrice = 100_000f
filter.minPrice = 10f
old: 0 -> new: 2
Observer #1
Observer #2
old: 0.0 -> new: 100000.0
Observer #1
Observer #2
old: 2 -> new: 1
Observer #1
Observer #2
old: 100000.0 -> new: 10.0
Observer #1
Observer #2

• Interface delegation for composition.
• lazy for… lazy initialization.
• vetoable to deﬁne a validation to be reused.
• observable if you need both old and new value.
• Custom delegates for everything else.
Delegates - Summary

• Std Lib has a lot of functions to help you to write a more
simple, readable and concise code.
• Check it out the lib internals. You’ll learn a lot!
• Check it out the Kotlin Koans (https://play.kotlinlang.org/
koans). It’s a good place to start (or recap)!
• Write Kotlin code, enjoy the std lib and have fun! 😉
Wrap up!

• Kotlin Standard Functions 
https://medium.com/androiddevelopers/kotlin-standard-functions-
cheat-sheet-27f032dd4326
• Mastering Kotlin standard functions: run, with, let, also and apply 
https://medium.com/@elye.project/mastering-kotlin-standard-
functions-run-with-let-also-and-apply-9cd334b0ef84
• Java Friendly Kotlin 
https://codelabs.developers.google.com/codelabs/java-friendly-kotlin
• Simpler Kotlin class hierarchies using class delegation 
https://proandroiddev.com/simpler-kotlin-class-hierarchies-using-
class-delegation-35464106fed5
References

Gracias!
Nelson Glauber
@nglauber

Mastering Kotlin Standard Library

More Related Content

What's hot

Similar to Mastering Kotlin Standard Library

More from Nelson Glauber Leal

Recently uploaded

Mastering Kotlin Standard Library