Make context combination more explicit with `copy()`

Proposed changes:

• Add CoroutineContext.copy(....)
• Remove the optional parent parameter from coroutine builders
• (Possibly) deprecate CoroutineContext#plus(CoroutineContext) to use only in library code

Pros

• very explicit about what it does (e.i. copies the context)
• explicit about the non-commutativity of the operation (`context1 + context2 != context2 + context1)
• explicit about what parts of the context it changes (e.i. parent or name)

Cons

• harder to interact between libraries

Possible implementation

fun CoroutineContext.copy(
    parent: Job? = null, 
    name: String? = null,
    id: Long? = null,
    from: CoroutineContext? = null
) {
    var res = this  // not memory efficient!
    if(from != null) res = res + from  // should go first
    if(parent != null) res = res + parent
    if(name != null) res = res + CoroutineName(name)
    if(id != null) res = res + CoroutineId(id)
    return res
}

Usage example:

Before:

launch(context + job) {
   ...
}

launch(context, parent = job) {
   ...
}

launch(parent = job) {
   ...
}

launch(context + anotherContext) {
   ...
}

launch(context + job + anotherContext) {
   ...
}

After:

launch(context.copy(parent = job)) {
   ...
}

launch(context.copy(from = anotherContext)) {
   ...
}

launch(context.copy(parent = job, from = anotherContext)) {
   ...
}

[qwwdfsad]

Proposed change makes context combinations less readable, does not add any value, and copy name is kind of misleading because it does not copy anything. This discussion could have a place in the corresponding KEEP, but now it is too late anyway.

And commutativity is not a property of plus operator in general.

[jcornaz]

If I have to reuse context, I also put it in a property. But I build the context as usual with the + operator.

That being said, it is pretty rare. Most of the time it is easier, and more expressive to do it when the coroutine is started (that way the reader doesn’t have to guess what’s in the context).

I don’t think readability is incompatible with brevity. I know it is subjective, but I find the following fairly easy to read:

val wellNamedContext = dispatcher + exceptionHandler + job