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

Recommended

More Related Content

What's hot (20)

Similar to Mastering Kotlin Standard Library (20)

More from Nelson Glauber Leal (20)

Recently uploaded (20)

Mastering Kotlin Standard Library