JarCastingLater
Introduction
Heavily inspired by javascript promises, Later(s) are mainly here to ease the bridge between kotlin coroutines for multiplatform and their respective platforms.
Problem Statement
While it is true that kotlin can compile down to (js,jvm or native). Usually there are some limitations. One of the heaviest ones are usually trying to call suspend functions from other platforms (mostly Java and Javascript).
A Later, comes in handy as it lets you work with suspend functions from kotlin, promises from javascript and also Futures from Java. All you have to do is return a Later object and you are good to go.
Samples
In Kotlin you can do something like this
class TokenService(val scope: CoroutineScope) {
fun getToken(id: String) = scope.later { // this is a suspending labda
delay(100) // simulating heavy work
getUserTokenFromServer() // returned result will be the valued that will be Later delivered to you upon completion
}
}
Notice that getToken doesn't have to be a suspend function. Which means, it is callable from Java and Javascript. Even C
In Javascript, a Later is a Thenable
meaning you can chain then, catch and finally methods as you would
const tokenService = require('your-published-shared-lib');
tokenService.getUser("user-1")
.then(result => doSomethingElse(result))
.then(newResult => doThirdThing(newResult))
.catch(failureCallback)
.finally(finalState => {
console.log(`Got the final result: ${finalState}`);
});
But since a Thenable is never really fully a Promise, We have provided a way that you can easily convert a Later to a Promise like so
const tokenService = require('your-published-shared-lib');
tokenService.getUser("user-1").asPromise() // notice asPromise() here
.then(result => doSomethingElse(result))
.then(newResult => doThirdThing(newResult))
.catch(failureCallback)
.then(finalResult => {
console.log(`Got the final result: ${finalResult}`);
});
Using the same kotlin code in java, is piece of cake
import your.published.shared.lib.TokenService;
class Test {
TokenService tokenService = TokenService.getDefault();
public static void testLater() {
tokenService.getToken("user-1")
.then(result -> doSomethingElse(result))
.then(newResult -> doThirdThing(newResult))
.error(failureCallback) // notice it is error instead of catch (catch is a reserved keyword in java)
.complete(finalState -> {
console.log("Got the final result: " + finalState);
return null;
});
}
}
as normal, if you are well versed to using CompletableFutures and like that, there is a convenient method asCompletableFuture() that returns a CompletableFuture backed by the Later
Setup
dependencies {
implementation("tz.co.asoft:later-core:0.0.40")
implementation("tz.co.asoft:later-ktx:0.0.40") // if using with kotlinx coroutines
}
Extensions
Later is being made to extend into any Deferred data type. It even has built in integration with Deferred support from kotlinx coroutines
Conclusion
Now, go and build real multiplatform code, that can be shared across mobile (android only for now), web and server (jvm or node)
Coming soon
ios/macos support
