Some of the issues is "I want this function to be suspendable, but I don't to mark it suspend" ->...

# announcements

[LeoColman]

Some of the issues is "I want this function to be suspendable, but I don't to mark it suspend" -> Inline it so it will use whichever context it is in.

[serebit]

That’s not how suspend works

[serebit]

If you don’t mark it suspend, it won’t suspend the coroutine it’s called from, regardless of whether it’s inline or not. The only difference is that making it inline takes away one function call

[LeoColman]

It does work in the following fashin

[LeoColman]

(I don't want it to suspend, just to accept suspension)

[LeoColman]

suspend fun foo(other: suspend () -> Unit) { }

fun boo(func: () -> Unit) { }

[LeoColman]

I'm not able to do something like foo { boo { foo { } } }

[LeoColman]

When boo is inlined, the func will """""take"""" the context from the outside foo, and I'll be able to suspend anything inside it, due to the external foo giving me the suspend context

[LeoColman]

Maybe I expressed myself wrong

[LeoColman]

My point is: Is it ok to always inline boo, wherever it's possible? (Consider a big amount of functions similar to boo in the codebase I'm working with)

[LeoColman]

Or is it going to cause any kind of issues?

[Dico]

I think it's worth trying to limit the number of calls to the block to 1 statement, as well as limiting the other code, for example by moving it to another function

[Dico]

Inlining too many things can have performance drawbacks because inlined functions cant be individually targeted by the jvm's JIT

[Dico]

Obviously if theres a code block, it will generally lead to better performance, especially if inlining avoids boxing primitives or inline classes.

[LeoColman]

So if the IDE doesn't complain, perhaps it's ok? hahah

[LeoColman]

I'm not minding too much on performance. This is for testing code, and generally we're aiming for comfort to write > performance

[louiscad]

Inline with functions parameters is perfectly fine. Just try to extract big chunks of code that do not directly deal with lambdas to book inline functions for code reuse (and avoid counterproductive compiled code duplication).