Is there a reason we can't have one for Throwable instead of just Exception? For example, Vert.x always types their exceptions callback handlers with Throwable, so would have to wrap every exception otherwise.

If you move the main code down into a submodule, we can do pull request for things like a dispatcher based on disruptor. And still keep all the code together.

One strength Kotlin really has going for it now is a low number of class/method points which is important in environments like Android where you have a set limit. The cases where you have combine could easily be vararg instead of fixed parameters, with lists of things instead of set individual first, second, third, fourth, etc.

Plus your code becomes littered with variations of all these classes that must be kept in sync.

Simplify, it is really a list of things to combine, so treat it as such instead of hard set parameters and fields. Otherwise your library will go unused in environments such as Android (which may not be important to you, but it is a key driver helping Kotlin thrive right now, so let's all help that continue)

Hi all, I have using kovenant framework with some questions I would like to fetch a table of contents and fetch the content of the table simultaneously, then output a mixed list with table content title and content itself.

But I faced the problems for coding with kovenant.

For example, I have MySubject and MySubjectDetails class.

class MySubject {
    var id: String = ""
    var name: String = ""
}

class MySubjectDetails {
    var id: String = ""
    var name: String = ""
    var data: List<String> = ArrayList()
}

and APICalls class (part of code is pseudo code),

object APICalls {
    fun getSubjects(): Promise<List<MySubject>, Exception> {
        val deferred = deferred<List<MySubject>, Exception>()
        // ... API calls ...
        return deferred.promise
    }

    fun getSubjectById(id: String): Promise<MySubjectDetail, Exception> {
        val deferred = deferred<MySubjectDetail, Exception>()
        // ... API calls ...
        return deferred.promise
    }
}

I may fetch the data like is:

APICalls.getSubjects().then { subjects ->
    val promises = subjects.map {
        APICalls.getSubjectById(it.id)
    }
    all(promises)
}.then { promise: Promise<List<MySubjectDetail>, Exception> ->
    //       ^~~~~~ What's this?
}

I will get a result with Promise<List<MySubjectDetail>, Exception> type then I can't continue the code. I expected it will be a combined list (List<MySubjectDetail>) but it comes up a Promise<List<MySubjectDetail>, Exception> object thats confused me.

How can I do or fix the code? Thanks.

How can you use a deferred promise int he middle of a chain? The only way I can see doing it right now is.

task { setup1() } then { setup2() } then { deffered() } then { promise -> val result = promise ?: throw(error) if result.isError() { throw(error) } else { it.get() } } fail { }

Unwrap doesn't seem to exist like is suggested.

Hey there,

kovenant is a great library. I love to use it. However, there is a small feature I like I wish you can provide is "unwrap the return Promise of then"

For example, I have two methods

fun method1() : Promise<String, Exception>{}
fun method2() : Promise<String, Exception>{}

// current
val p: Promise<Promise<String, Exception>, Exception> = method1().then{ method2() }
// can it just be 
val p: Promise<String, Exception> = method1().then{ method2() }

Now, I added these extensions in my project to achieve it, but I don't know whether it is a good way to do it and it is a little unclear to use thenFlat instead of then.

infix fun <V, R> Promise<V, Exception>.thenFlat(bind: (V) -> Promise<R, Exception>): Promise<R, Exception> {
    val deferred = deferred<R, Exception>(context)
    success {
        try {
            bind(it).success(deferred::resolve).fail(deferred::reject)
        } catch (e: Exception) {
            deferred.reject(ApiError(e))
        }
    }.fail(deferred::reject)
    
    return deferred.promise
}

// so it can be
val p: Promise<String, Exception> = method1().thenFlat{ method2() }

Call from this function

private fun loginWithFacebookAccessToken(accessToken: AccessToken) {
        promiseOnUi {
            mvpView?.showLoggingProgress()
        } then {
            loginManager.loginWithFacebook(accessToken).get() //Call from this side
		} alwaysUi {
            mvpView?.hideLoggingProgress()
        } successUi {
            mvpView?.navigateToMainScreen()
        } failUi { error ->
			mvpView?.showMessage(error.localizedMessage)
        }
    }

To this function

    fun loginWithFacebook(fbAccessToken: AccessToken): Promise<Unit, Exception> {
		ti { "KOVENANT In Function" }
        return task {
			ti { "KOVENANT In task" }
        } then {
			ti { "KOVENANT In then" }
        }
    }

Hi I have a problem in the last function, my call is block in the task { .. } My application is deploy on a SAMSUNG S4 MINI API 19 Version 4.4.2 And the logcat only show : "KOVENANT In Function"

I was trying to chain long processes but it wasn't working. All the long processes were returning deferredPromises.

I thought this was working not too long ago but the update to AndroidStudio 3.1 seems to have broken something. I was seeing pending promises fall through. It was something like.

renewToken() then { getData() } successUI { broadcast update }

The broad cast update was happening while getData was pending. I have worked around by doing:

all(renewToken(), getData()) successUI { }

It appears though that the then is not working at all. Its just falling through. I had another case where this was falling through when trying to log out then show login screen when logout was complete.