How do I write a sequence of promises in Kotlin?

Question

Is it possible to write a sequence of promise (or tasks) using only Kotlin?

For example, a sequence promises in JavaScript is written as:

const SLEEP_INTERVAL_IN_MILLISECONDS = 200;

const alpha = function alpha (number) {
    return new Promise(function (resolve, reject) {
        const fulfill = function() {
            return resolve(number + 1);
        };

        return setTimeout(fulfill, SLEEP_INTERVAL_IN_MILLISECONDS);
    });
};

const bravo = function bravo (number) {
    return new Promise(function (resolve, reject) {
        const fulfill = function() {
            return resolve(Math.ceil(1000*Math.random()) + number);
        };
        return setTimeout(fulfill, SLEEP_INTERVAL_IN_MILLISECONDS);
    });
};

const charlie = function charlie (number) {
    return new Promise(function (resolve, reject) {
        return (number%2 == 0) ? reject(number) : resolve(number);
    });
};

function run() {
    return Promise.resolve(42)
        .then(alpha)
        .then(bravo)
        .then(charlie)
        .then((number) => {
            console.log('success: ' + number)
        })
        .catch((error) => {
            console.log('error: ' + error);
        });
}

run();

Each function also returns a Promise with asynchronous processing result, that would be resolved/rejected by the immediately following promise.

I know how to write this usingRxKotlin, but I am trying to figure out how to write it using coroutines library or any other standard feature.

Answer 1

As you mentioned, coroutines are the standard feature to go with.

You have to use the suspend keyword, if the function will be suspended, e.g. IO, or if you call another suspend function, e.g. delay.

The error handling can be done with the normal try-catch statement.

import kotlinx.coroutines.delay
import java.lang.Exception
import kotlin.math.ceil

const val SLEEP_INTERVAL_IN_MILLISECONDS = 200

suspend fun alpha(number: Int): Int {
    delay(SLEEP_INTERVAL_IN_MILLISECONDS)
    return number + 1
}

suspend fun bravo(number: Int): Int {
    delay(SLEEP_INTERVAL_IN_MILLISECONDS)
    return ceil(1000 * Math.random() + number).toInt()
}

fun charlie(number: Int): Int =
    number.takeIf { it % 2 == 0 } ?: throw IllegalStateException(number.toString())

suspend fun run() {
    try {
        val result = charlie(bravo(alpha(42)))
        println(result)
    } catch (e: Exception) {
        println(e)
    }
}

suspend fun main() {
    run()
}

If you like a more functional style for error handling, you can go with this:

suspend fun run() {
    runCatching { charlie(bravo(alpha(42))) }
        .onFailure { println(it) }
        .onSuccess { println(it) }
}