A modern programming language that makes developers happier.

kotlinlang

Something that came up yesterday when I was working with coroutines and thread locals: is there a way to use an inline higher-order function, but prevent its lambda parameter from suspending? Hypothetically something like:
```inline fun &lt;T&gt; foo(f: nosuspend () -&gt; T): T```

The use case is something like this:
```val threadLocal = ThreadLocal&lt;String&gt;()

inline fun &lt;T&gt; withFoo(f: () -&gt; T):T  = try {
    threadLocal.set("foo")
    f()
} finally {
    threadLocal.remove()
}

suspend fun bar() {}

suspend fun main() {
    withFoo { bar() } // I want this to be an error
}```
I don’t want to be able to call `bar()` inside `withFoo`, because it would be an error to set a thread local and then suspend

I know I can make a coroutine context element to get thread-local-like behaviour in a coroutine. And I know I can prevent the lambda parameter from suspending by making it not be inlined.

Thing is, the version of `withFoo` that I shared above is what I would write if coroutines didn’t exist. I want to be able to do that but ensure that nobody accidentally calls it with a suspending lambda. It’s as if the existence of coroutines is making my function signature unsafe :confused:

<https://youtrack.jetbrains.com/issue/KT-17260|https://youtrack.jetbrains.com/issue/KT-17260> no way currently

Thanks <@UJQB4DJF7> :bow: I feel validated knowing that a ticket exists :smile:

Unless you care about non-local returns, using the crossinline modifier on your lambda param is a decent workaround

<@UJQB4DJF7> <@U030S9809PH> As just told in the comment above, there is actually a way: the `crossinline` modifier.

that makes the function as useful as a non-inline fun

Not exactly, you still get no allocation for the function parameters.