Hey, all. What are your naming conventions for suspending variations of non-suspending functions? •

doThing()

◦

doThingAsync()

◦

doThingSuspending()

◦

doThingSuspended()

◦ etc?

ideally, •

fun doThingBlocking()

◦

suspend fun doThing()

if both need to exist, otherwise only the latter

My specific use case is a

fold

function where the closure invokes a suspending function, like so:

fun parse(input: String): Result<Parsed, Error>

parse(inputString).fold(
    { value -> suspendingNetworkCall(value) },
    { error -> suspendingLoggingCall(error) }
)

if it's a higher-order function, it may make sense to make it

inline

, and then it works the same regardless of whether the lambdas suspend or not

Interesting, because that's what I have and though I though it would work, it's not. I'll fiddle with the modifiers and report back.

and if it really needs to be non-inline, overloading should work fine, e.g.

fun Result<Parsed, Error>.fold(
    onSuccess: (Parsed) -> R,
    onError: (Error) -> R,
)
suspend fun Result<Parsed, Error>.fold(
    onSuccess: suspend (Parsed) -> R,
    onError: suspend (Error) -> R,
)

Removing

crossinline

fixed my issue. Thanks.