but I suspect they use the wrapper, so you need to call

./gradlew

instead of

gradle

I think that the jitpack.io can be do

is there any method to cycle all tasks into throttle?

to cancell all?

no there is not

this is good

(prom as? CancelablePromise)?.cancel(Exception()) ??

yes

Hi Mark

however if I don't use throttle but single promise for each binding all work

yes probably but then you lose control over memory usage

try running your app in a memory restricted device and you probably hit an OME

mmm this is a problem...:)

Is there any specific rules I need to use in ProGuard for Android app if I use only kovenant-core?

I'm not familiar enough with proguard to answer that, maybe someone else in this channel had some experience with that.

It seems that

-dontwarn nl.komponents.kovenant.unsafe.**

is enough to silence ProGuard warnings about missing class

Is that something I should mention in the docs?

It's better for someone to confirm if it works as expected before documenting it simple smile ProGuard is usually used with Android apps in release builds (minifyEnabled option in build.gradle) and it fails builds when any warning is printed. In this case Kovenant uses sun.misc.unsafe stuff that is possibly different on Android - so ProGuard warns about it and then fails build.

In this case it’s safe to use the unsafe 😉

if it’s not there or couldn’t be loaded for some reason, there’s a fallback

Question about Java interoperability - is it possible to create task from Java that can throw exception?

Function0 Kotlin function does not throw exception and it seems that task method get exception argument from Function0 generic type, so replacing it with different functional interface does not seem to work

For now I workaround that by wrapping exception in RuntimeException

Good question, could you please file an issue. Don't know if it's solvable in a decent way, but let me at least look into it

@mplatvoet: issue filled here http://issues.komponents.nl/youtrack/issue/KOV-84 . Also found workaround - "erase" exception type using generics.

Thank you :)

What is the best way to implement i/o blocking code (that requires no upper limit per thread count)?

@n3o59hf: I think the best way is by using a separate

Context

for io since that tends to block, so something like this:

val ioContext = Kovenant.createContext {
    workerContext.dispatcher = buildDispatcher {
        concurrentTasks = 2 //whatever you prefer
    }
    //Use the default one
    callbackContext.dispatcher = Kovenant.context.callbackContext.dispatcher
}

fun <V> ioTask(body: () -> V) : Promise<V, Exception> {
    //execute the task on the io threads
    val promise = task(ioContext, body)

    //use default context for the rest of the work
    return promise.withContext(Kovenant.context)
}

fun main(args: Array<String>) {
    ioTask {
        File("path/to/file").readText()
    } then {
        it.replace(":)", "☺")
    } success {
        println(it)
    }
}

Thank you, it worked quite well (when concurrentTasks set to Int.MAX_VALUE)

@n3o59hf: you might want to consider to lower that upperbound. There comes a point (fairly quick with io operations) where adding threads doesn’t speed up the overall process but actually slows it down. For instance, a default tomcat instance limits the number of threads to 256. That’s a different use case but should give you some idea. Also you might consider using a blocking

pollstrategy

as described http://kovenant.komponents.nl/api/core_config/#builddispatcher as this keeps threads alive. Though you need to shutdown the context manually.