A modern programming language that makes developers happier.

kotlinlang

doing it blocking is trivial, but if you reentrantly call into the main thread, as you saw with runBlocking, it never completes

would it work by changing this? <https://github.com/arrow-kt/arrow/blob/master/modules/effects/arrow-effects-data/src/main/kotlin/arrow/effects/typeclasses/suspended/FxSyntax.kt#L50>

to something like?

```
  fun &lt;A&gt; CoroutineContext.effect(continueOn: CoroutineContext = EmptyCoroutineContext, f: suspend () -&gt; A): Kind&lt;F, A&gt; =
    asyncOp { defer(this@effect) { f.effect() }.continueOn(continueOn) }
```

I mean I just tried on arrow but got an error  xD

```
Cause: Cannot serialize error type: [ERROR : Unknown type parameter 1]
File being compiled at position: file:///Users/aballano/workspace/arrow/modules/effects/arrow-effects-data/src/main/kotlin/arrow/effects/typeclasses/ConcurrentCancellableContinuations.kt
The root cause was thrown at: SerializerExtension.kt:83
```

shall I create a PR and continue the discussion there?

this change would basically allow this <https://kotlinlang.slack.com/archives/C8UK6RTHU/p1554465378024800>

there are a couple of potential complications with that approach, because we'd be clearing the CoroutineContext

the design of the thing requires that to override the Dispatcher you need the pre-existing context

this is a problem through the library -.-

so this means it might be improved, right? That's even better since this right now would essentially be saving the implementation client to manually `continueOn(UI)` after doing the effect anyway, no? So worst case scenario we save the client one line :ok_hand: and best we even improve over what they would do manually otherwise :+1:

or would that `.continueOn(EmptyCoroutineContext)` break something for the caller in case they don't specify the `CoroutineContext`? In such case we could just if-else and not call `continueOn` at all :thinking_face:

```
  fun &lt;A&gt; CoroutineContext.effect(
          continueOn: CoroutineContext = EmptyCoroutineContext, 
          f: suspend () -&gt; A
  ): Kind&lt;F, A&gt; =
    asyncOp { defer(this@effect) { f.effect() }.apply {
        if (continueOn != EmptyCoroutineContext) continueOn(continueOn)
    } }
```

I suggest adding a new API instead of modifying this one and matching on type

that way the additional parameter is unmissable, and the API name specifies what it does

<https://github.com/arrow-kt/arrow/pull/1395>