Is it possible to use the coroutine context to h

Question

< elizarov> Is it possible to use the coroutine context to hold other information such as a database connection that follows a request through the server I can think of several instances where it would be nice to to use a coroutine context to intrinsically hold certain pieces of data to follow an async request

gildor · Answer

Sure coroutine context is created exactly for this you can pass any information

spierce7 · Answer

How do I pass information into the coroutine context Am I creating my own coroutine context class and using `is` checks to pull data or is there another way I see there is a CoroutineContext Key What about the same information being available in the child coroutine contexts as well

gildor · Answer

Yes you creating own coroutine context

gildor · Answer

gt and using `is` checks to pull data No you can just use Key for that and when you get request by Key it will be already casted to your context class

gildor · Answer

gt What about the same information being available in the child coroutine contexts as well The same as now you can pass parent context explicitly most of primitives just getting parent context and merge with some own like `CoroutineScope` context will be used for all child coroutines or `withContext` merges passed context with parent and so on

gildor · Answer

< spierce7> See CoroutineName context implementation as a simple example of custom context just 1 additional field

gildor · Answer

gildor · Answer

And to retrieve it on any coroutine just call ```val coroutineName = coroutineContext CoroutineName name```

gildor · Answer

As you can see context is always nullable but casted for you because Key is also type information of context

dave08 · Answer

What s the advantage over passing these things in from the outer scope And also what conceptual relationship would these things have to the coroutineContext which as far as I understand is just for tracking coroutine state

gildor · Answer

gt which as far as I understand is just for tracking coroutine state this is not true coroutineContext is for any coroutine related metadata

gildor · Answer

it s like ThreadLocal

dave08 · Answer

Practically speaking what would be an example of a good use case

gildor · Answer

I don t think that some every day usage cases are suitable but for framework library writers it can be very useful in some cases

gildor · Answer

like in case of kotlinx coroutines

dave08 · Answer

Thanks for the ThreadLocal hint wink I started looking into it and found a few nice articles

spierce7 · Answer

< gildor> You end up helping me out a lot Thanks for that Do you work for JB

spierce7 · Answer

I m still not understanding The following example fails The actual type is a `CombinedContext` Would I need to override some additional methods ``` Test fun coroutineTest = runBlocking TestScope launch assertEquals CoroutineName class coroutineContext class join object TestScope CoroutineScope override val coroutineContext CoroutineContext get = CoroutineName Blah data class CoroutineName val name String AbstractCoroutineContextElement CoroutineName companion object Key CoroutineContext Key lt CoroutineName gt override fun toString String = CoroutineName $name ```

gildor · Answer

No I m not working for JB or Kotlin team

gildor · Answer

Nono you shouldn t just check class of context instead get context by key because coroutines add own context items

gildor · Answer

< spierce7> See

gildor · Answer

The reason why you test is fails because `coroutineContext` is not only your item it s merged with other default contexts just add `println coroutineContext ` in `launch` to check what is there most obvious thing is Job because you use launch

spierce7 · Answer

Ok that works

spierce7 · Answer

If I remove `companion object Key CoroutineContext Key lt CoroutineName gt ` it stops working Is reflection being used to retrieve the key for the context How does that work

gildor · Answer

No reflections are not used

gildor · Answer

Just something similar to map where Key is key of map but also Key is parametrized by context type so you getting context of correct type

spierce7 · Answer

But how does the coroutine context know which key to associate with a specific context

spierce7 · Answer

If I remove `companion object Key CoroutineContext Key lt CoroutineName gt ` from the `CoroutineName` class it no longer works

gildor · Answer

gt If I remove `companion object Key CoroutineContext Key lt CoroutineName gt ` from the `CoroutineName` class it no longer works Of course because companion object used as a Key

gildor · Answer

see ```coroutineContext CoroutineName ``` It s actually the same as ```coroutineContext CoroutineName Key ``` Just implicit reference to companion object

gildor · Answer

Juse see implementation get operator of CombinedContext in stdlib <https github com JetBrains kotlin blob 1 3 20 libraries stdlib coroutines experimental src kotlin coroutines experimental CoroutineContextImpl kt L34 L45>

gildor · Answer

It s pretty simple Map like datastrcture

gildor · Answer

Also see how plus operator of context works it s just merge 2 contexts <https github com JetBrains kotlin blob 1 3 20 libraries stdlib src kotlin coroutines CoroutineContext kt L32 L45>

spierce7 · Answer

Right but how does it retrieve the key for a context if not through reflection

gildor · Answer

This is how kotlin companion object works

spierce7 · Answer

I understand that once the key is retrieved it s stored in a map like data structure

gildor · Answer

coroutineContext CoroutineName

gildor · Answer

CoroutineName is companion object

spierce7 · Answer

Please explain I think it s possible there is something for me to learn here

gildor · Answer

see imagine class `class Foo`

gildor · Answer

you cannot just use it as `Foo` there is no such syntax in Kotlin correct Like `val foo = Foo`

gildor · Answer

You will get compile error

spierce7 · Answer

right You d have to do Foo

gildor · Answer

but let s now add companion object to it ``` class Foo companion object ```

gildor · Answer

empty without interface without members

gildor · Answer

now this code is completely valid ``` val foo = Foo ```

gildor · Answer

and `foo` contains instance of companion object of Foo

spierce7 · Answer

I see I didn t realize the key was a companion object

spierce7 · Answer

I just thought it was an object inside of it What s the point of naming the companion object as type Key

gildor · Answer

Actually name `Key` is redundand it s just a convention

spierce7 · Answer

ic

gildor · Answer

but what is important is parent interface

gildor · Answer

`companion object CoroutineContext Key lt CoroutineName gt `

gildor · Answer

you see companion object implements interaface CoroutineContext Key and has generic type that equals to your context type

spierce7 · Answer

right

gildor · Answer

so Key is key of this map like context and has parameterized type so type check works on compile time no reflections

spierce7 · Answer

So I should be able to do something like `CoroutineName is CoroutineContext Key`

spierce7 · Answer

and that should return true

gildor · Answer

yes because `CoroutineName` is not a type but companion object instance

spierce7 · Answer

ic

spierce7 · Answer

one more piece of the puzzle is missing for me

spierce7 · Answer

so for a given `coroutineContext` how do I access it s companion object

gildor · Answer

companion object of coroutineContext what do you mean

gildor · Answer

you just lookup required context by key

gildor · Answer

```coroutineContext SomeCoroutineContextKey ```

spierce7 · Answer

so there has to be a way to programmatically access the companion object for a class instance for this all to work without reflection

spierce7 · Answer

somehow the `SomeCoroutineContextKey` has to be stored inside of the `coroutineContext` right

spierce7 · Answer

we never give it the key We only give it the coroutine context and so the coroutine library somehow grabs the Key

gildor · Answer

I see what you mean

gildor · Answer

check plus operator implementation

gildor · Answer

Your context should extend `AbstractCoroutineContextElement` or just implement Element

gildor · Answer

if you want to retrieve it by Key

spierce7 · Answer

lookinmg

gildor · Answer

Element just has `key` property with key

gildor · Answer

so you can get key of context

spierce7 · Answer

ah I see it now

spierce7 · Answer

`public abstract class AbstractCoroutineContextElement public override val key Key lt gt Element`

spierce7 · Answer

the Key companion object is fed into the constructor for `AbstractCoroutineContextElement`

spierce7 · Answer

I have a full understanding of it now Thanks slightly smiling face

gildor · Answer

Yes otherwise you have to implement get fold yourself

spierce7 · Answer

awesome slightly smiling face

spierce7 · Answer

thanks slightly smiling face

gildor · Answer

You are welcome +1