later

An Either<L,R> multiplatform serializable datatype

License

License

Categories

Categories

JavaScript Languages
GroupId

GroupId

tz.co.asoft
ArtifactId

ArtifactId

later-js
Last Version

Last Version

0.0.3
Release Date

Release Date

Type

Type

klib
Description

Description

later
An Either<L,R> multiplatform serializable datatype
Project URL

Project URL

https://github.com/aSoft-Ltd/later
Source Code Management

Source Code Management

https://github.com/aSoft-Ltd/later

Download later-js

Dependencies

compile (3)

Group / Artifact Type Version
org.jetbrains.kotlin : kotlin-stdlib-js jar 1.4.21
org.jetbrains.kotlinx : kotlinx-coroutines-core-js jar 1.4.2
org.jetbrains.kotlin : kotlin-stdlib-common jar 1.4.21

Project Modules

There are no modules declared in this project.

Later

badge badge badge badge badge

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

tz.co.asoft

asoft

Versions

Version
0.0.3
0.0.2
0.0.1