Is there something similar to CopyableThreadContex...

# coroutines

[Exerosis]

Is there something similar to CopyableThreadContextElement that allows you to specify that a context should NOT BE included in child coroutines? For example if we want to make a reentrant lock:

class Reentrant : Key<Reentrant>, Element {
  val lock = Mutex()
  override val key get() = this

  suspend fun <Return> withLock(block: suspend () -> (Return)): Return {
   if (currentCoroutineContext()[this] != null) return block()
   return lock.withLock { withContext(this) { block() } }
  }
}

Or something along these lines... we do want to make sure that:

reentrant.withLock {
  GlobalScope.launch {
   reentrannt.withLock {}
  }
}

Is not considered recursive. I was thinking perhaps I could abuse CopyableThreadContextElement and make copyForChild return some kind of EmptyCopyableThreadContextElement. But maybe there is a better way? Seems like this might not even work because it always calls copy if the element is on the right side of newCoroutineContext

[ephemient]

why would that be recursive in the first place? there is no relation between the job outside and inside the GlobalScope.launch

[Exerosis]

Yes there is? They share context

[Exerosis]

For example:

fun main() {
    runBlocking {
        println("Name: ${currentCoroutineContext()[CoroutineName]}")
        withContext(CoroutineName("test")) {
            println("Name: ${currentCoroutineContext()[CoroutineName]}")
            launch {
                println("Name: ${currentCoroutineContext()[CoroutineName]}")
            }
        }
    }
}

Result:

Name: null
Name: CoroutineName(test)
Name: CoroutineName(test)

I need a context that doesn't make it into launch/async or any block that isn't executed sequentially.

[ephemient]

yes there is with launch, but not with GlobalScope.launch as in your original example

[Exerosis]

Ok sure, well either way what's the solution here?

[ephemient]

the solution to what?

[ephemient]

if you're following structured concurrency, all the blocks are nested so you can simply check the context to see if a lock is already acquired

[ephemient]

if you're not following structured concurrency, then you're not sharing context anyway

[Exerosis]

reentrant.withLock {
  launch {
   reentrannt.withLock {}
  }
}

[Exerosis]

Ok but that doesn't work, so how can this be resolved?

[ephemient]

https://pl.kotl.in/C_G19-jZ_ how doesn't it work?

[Exerosis]

Ah right, there aren't any builtins that go from currentCoroutineContext to CoroutineScope are there?

[Exerosis]

Also there isn't an unmanaged continuations library out there that you know of right?