I have a long computation in a non-suspending function which consists of several transformations (map, reduce etc.) on a

Sequence

. How do I make this computation properly cancelable? All the Sequence functions are non-suspending, and the coroutine context is not available in a non-suspending function, so I can’t check for

isActive

. Can I capture the coroutine context in the outermost (suspend) function and pass it into all the (non-suspending) sequence functions?

Is it an option for you to make this non-suspending function

suspend

? That would probably be the easiest way. Making it

suspend

and adding

yield()

at the points where you want to check for cancellation (and allow interlacing with other suspend functions)

I can make the main function itself suspend, sure. The problem is with the sequence functions. It looks like this:

fun compute(input: Sequence<T>){
    return input
       .map{ ... }
       .reduce{ ... }
       .groupBy{ ... }
       // etc
}

Which terminal operator are you using? Usually the terminal operator is

inline

, so you can use suspend functions inside

Hmm

Same goes with

reduce

, which is also a terminal operator. Basically non-terminal operators like

map

don't take any time because they just build a new Sequence with the given non-inlined lambda. So you can't call suspend functions there, but it's ok anyway because nothing really runs there. However, when you use terminal operators like

reduce

or

forEach

they actually iterate the sequence and take time, but they are also inline - so you can use

yield()

in them

map

can take time, if the mapping function itself is a long computation

map

itself doesn't take any time, but its lambda does when it's called, and it's only called when a terminal operator is called on the sequence. My point is that you only really need

yield()

within loops (or any terminal operator) between each element, and that can be done by inserting it within the terminal operators' lambdas.

I understand, but in my case the lambda I pass to

map

takes time.

If I understand correctly, you mean that allowing interlacing and cancellation between each element is not sufficient for you, and you would like to cancel between each operation even on the same element? If you do:

input
       .map { longTransform1(it) }
       .map { longTransform2(it) }
       .forEach {
           doStuffWith(it)
           yield()
       }

What will happen is the following:

for (e in input) {
    val intermediate1 = longTransform1(e)
    val intermediate2 = longTransform1(intermediate1)
    doStuffWith(intermediate2)
    yield()
}

Are you saying you would prefer to have cancellability even between each of those transformations? Like this:

for (e in input) {
    val intermediate1 = longTransform1(e)
    yield()
    val intermediate2 = longTransform1(intermediate1)
    yield()
    doStuffWith(intermediate2)
    yield()
}

Even inside

longTransform

Then I think you should just use

Flow

instead of

Sequence

, which is meant for this - same properties as sequences but with suspendable transformations

Interesting idea

I mean, if you even need cancellability in the transform functions, probably you should make those transform functions

suspend

and use flows

yes, you’re right

Yep exactly

and make the computations suspend functions with

yield

inside