@konsoletyper: I can’t tell right now if your code is ok, because I have some strange JS syntax error now

Will dig more

usage of native declaration will generate something like

new Promise….

but our imported Promise in var with qualified name _.package.Promise

@jw has left the channel

Probably I know another workaround: 1. In prefix.js:

var Promise = require("promise");

var new_Promise = function(callback) {
     return new Promise(callback)
};

2. In Kotlin:

@native fun new_Promise(callback: ((Any), (Any)) -> Unit)

Not very beautiful, though simple smile

hackish solution:

@native
fun new(d: dynamic): dynamic = noImpl

var foo = new(Promise)({ … })

@bashor: Hm… Looks like it’ll work for all JS `new`s...

@igorlukanin: you can remove

new_Promise

from prefix.js and use declaration from @konsoletyper

In prefix.js:

var Promise = require("promise”);

kotlin:

kotlin
@native class Promise<T>(f: (resolve: (T) -> Unit, reject: (dynamic) -> Unit) -> Unit) {
    fun then(onFulfilled: (T) -> Unit, onRejected: (dynamic) -> Unit = { }): Promise<T> = noImpl
}

//….
var foo = new Promise<Int>({ …. })

unfortunately right now we don’t have good solution for that, but we going to fix it

Thanks. Will try!

By the way, what may be the possible solution for calling platform `new`s in a convenient way? I’m just curious simple smile

In the next version of my talk I will modify https://github.com/sdeleuze/geospatial-messenger/ to share domain classes and validation logic between client and server.

(and I will finish to fix the Kotlin client side code)

https://kotlinlang.slack.com/archives/javascript/p1458922770000308 Note: it’s actual only for dynamic. For example we can introduce some “magic” function dynamicNew, and traslate

dynamicNew(dyn, arg1, arg2)

to

new dyn(arg1, arg2)

actually this function can be implemented in pure Kotlin:

fun dynamicNew(dyn: dynamic, vararg args: dynamic): dynamic {
        val instance = js("Object.create(dyn.prototype)")
        dyn.apply(instance, args)
        return instance
    }

Or in non-generic way but w/o runtime overheads:

inline fun dynamicNew2(dyn: dynamic, arg1: dynamic): dynamic {
    return js("new dyn(arg1)")
}

inline fun dynamicNew2(dyn: dynamic, arg1: dynamic, arg2: dynamic): dynamic {
    return js("new dyn(arg1, arg2)")
}

@bashor: Thanks! Will use.

@bashor: Hey, will the errors we found while working on Geopatial Messenger, like the Intellij corruption issue one, be fixed in Kotlin 1.0.2 ?

FYI I will give the talk multiple other times and will continue what you have began to have a Kotlin frontend on master branch

exceptiosn should be fixed

Ok nice thanks

you’re welcome

@ylemoigne has left the channel

@debug has left the channel

I think I already raised a question close to this one, but what about a Kotlin -> LLVM toolchain that could be used to generate WebAssembly code (https://github.com/WebAssembly/design/blob/master/FAQ.md#which-compilers-can-i-use-to-build-webassembly-programs) and JavaScript code ?

Kotlin -> LLVM -> WebAssembly -> JavaScript

In order to support WebAssembly natively or choosing what level of JS you want to generate

@sdeleuze: does WASM support, for example, GC write barriers?