hi, how do i approximate a functional parser framework that uses threadlocals .... so that a parser context that is declarative does not need to have explicit stackframe and input parameters clogging up the kotlin code?

Actually, it depends what you want to achieve (is it in suspend context or not, do you really need different dispatchers for particular calls or not etc)

can you make this sync to central happen ?

its kind of like i want to use a collection of dozens or possibly hundreds of lambdas which fire global events to indicate pass or fail in a grammar parse graph

I can’t find much documentation on coroutine cancellation, at least I don’t find anything in the coroutine KEEP, is there anything that documents it ?

will the llvm target support coroutines ?

Hi! Sometimes it takes very very long to get into a coroutine. For example:

<http://logger.info|logger.info>("command = start")
                    launch(CommonPool) {
                        <http://logger.info|logger.info>("in pool for start")

I get the

in pool for start

message minutes later than

command = start

message. Am I not using coroutines correctly? I am running a lot of stuff in these launch(CommonPool) blocks.

Is it correct to say that the execution order of multiple coroutines is non deterministic, while the execution within the coroutine lambda is deterministic?

anyone got news about this issue ? https://github.com/mockito/mockito/issues/1152 this is quite blocking to me.

how do i support a declarative syntax such as:

val terminal = any_of(seq(singleQuote, character, repeating(character), singleQuote), seq(doubleQuote, character, repeating(character), doubleQuote))

... and then wrap coroutines around the ctor params which are themselves functions which should be coroutines....

I'm experience that the

await()

on my coroutine doesn't wait to be done before it continue.

the example are I think confusing as they don’t show how you can write synchronous code with the select API, they just do print on the console

@stanislav.erokhin @cy @elizarov

as you know for java threads, even if you use synchronized block you need in volotile key world for variable

Hi all! I'm having trouble calling a function from a

Coroutine

that is inside a custom

ViewHolder

The function is not recognised, and when I put it in the

ViewHolder

class, of course I can't calll the `add`/`remove` functions anymore.. Could you point me in the right direction please? Here is the basic setup:

class MyAdapter() : RecyclerView.Adapter<MyViewHolder>()
{
    fun add() {}
    fun remove() {}
    [...]

    /* Custom ViewHolder */
    class MyViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView)
    {
        fun bind(item: Item) = with(itemView)
        {
            /* Handle long click event on row*/
            isLongClickable = true
            onLongClick { function() } // I'M HAVING TROUBLE HERE (Unresolved reference)
       
            [...]
        }
    }

    /* How to call this? */
    fun function() {
        add()
        remove()
    }

Thanks for the help! 🙂

Is producer coroutine still held in

CommonPool

even after it has called

close()

on itself? For example

fun doThings() : ProducerJob<Foo> = produce(CommonPool)
{
   println("I am do things!")
   delay(1000)
   send(Foo())
   close()
}

Perhaps I don’t know where to look, but I haven’t found any good info/indications about coroutines, and their use in production code, particularly in long-running services. I am aware that the 1.1 status of API is roughly “we don’t promise not to change”, but I am curious about the reliability and usage of it right now. Anybody have a clue, in the form of numbers, anecdotes, examples?

yeah, i am less worried about the question of having to update code, and more about the realities of coroutines in long running services; I have no idea how much they’re being used in prod, and in particular, how much in services, as opposed to android (or what the differing qualities would be there).

@dragas You are definitely inventing your own code style, which makes your code unnecessary harder to read (it occupies way more vertical space than it should for such a simple code). That is the first thing that meets an eye.

Am I doing this correctly? I am trying to catch the exception if there is any occur when getting data from remote

async(UI) {
    val fetchDataJob = bg {
        ColumnRepo.getFromRemote(22352581)
    }

    val data = fetchDataJob.await()
    info(data.id.toString())
    if (fetchDataJob.isCompletedExceptionally) {
        doSomeThingWithException(fetchDataJob.getCompletionException())
    }
}

You can just wrap

fetchDataJob.await()

to try/catch. If await fails (and will throw exception) your

fetchDataJob.isCompletedExceptionally

never be reached

is supporting suspending getters something on the horizon? also, is there any workaround or we must completely avoid properties if we want the to do some suspendable calculations (for the "property")?

@dragas Can you, please, add a self-contained example that crashes?

Hi! Cross-posting here from #kotlin-native : Any coroutine-gurus here than can help? I've wrapped a C-library method, that feeds values to a callback, in a kotlin method to capture the results (callback will be called multiple times) in a lambda. Basically called like this:

library.invoke(arg) { value -> doSomething(value) }

Now what I'd like to do is wrap this somehow so that instead of using a callback my wrapping method returns a Sequence (going from a push to a pull style API). My first attempt was to use buildSequence:

buildSequence { library.invoke(arg) { value -> yield(value) } }

But this gives

Suspension functions can be called only within coroutine body

. The Wrapping callbacks section in the documentation here looked promising: https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md#wrapping-callbacks But as far as I can tell this

suspendCoroutine

trick only works if the callback is called only once by the library. Mine is called many many times, and I want to have a sequence where I can consume items one by one and not have to gather them in a list first. Channels looks like a good approach but AFAIK they are only available in the

kotlinx.coroutines

package that does not work in Kotlin Native. Any suggestions? Are there any "out of the box" or idiomatic solutions for this that don't involve manually implementing a producer/consumer pattern using C/threading concurrency stuff?

does anyone have an example of starting a coroutine inside a suspendCoroutineOrReturn block?

It uses

Thread.sleep

though, so...

but when you do Observable.fromAsync (Rx1) or Observable.create(), you can set a cancellation callback. Seems a much cleaner way to get notified rather than having to check a flag in a loop for Kotlin coroutines

does JetBrains use coroutines in production already?

@edwardwongtl We’re building one. It’s been working for a while and we’re nearing release in a couple of months.