I have a suspend function: ```private suspend fun ...

# coroutines

[Mike Speed]

I have a suspend function:

private suspend fun getThing(){...}

How can I set a minimum return time on this? So it will only return if at least 2000ms have passed, for example?

[Paul Woitaschek]

using a delay

[Mike Speed]

literally just
delay(2000) ?

[Paul Woitaschek]

Rather this?

suspend fun getThing() {
  val start = System.currentTimeMillis()

  doStuff()

  val elapsed = System.currentTimeMillis() - start
  delay(2000 - elapsed)
}

[Mike Speed]

That’ll do it! Thanks a lot 🙂

[Mike Speed]

Unless there’s a way to do it in fewer lines? I’m all ears 😄

[Chris Miller]

Maybe something like

delay(2000 - measureTimeMillis { doStuff() })

[Paul Woitaschek]

suspend fun getThing() : Int {
  return iWillReturnEarliestInTwoSeconds {
    doStuff()
  }
}

suspend inline fun <T> iWillReturnEarliestInTwoSeconds(action: () -> T): T {
  val start = System.currentTimeMillis()

  val result = action()

  val elapsed = System.currentTimeMillis() - start
  delay(2000 - elapsed)

  return result
}

[Mike Speed]

very nice @Chris Miller. I think this measureTimeMillis{} is basically doing what you have written here @Paul Woitaschek?

[Chris Miller]

Yes - have a look at the source code for it

[Mike Speed]

thanks both

[Paul Woitaschek]

That measure thing doesn't have a return value. Usually getThing indicates that there is a thing to get

[Mike Speed]

yeah true but in my case getThing just updates a LiveData, it’s not returning a value 🙂

[Joffrey]

You have measureTimedValue for getting the elapsed time + the return value (if you need it some other time)

[Paul Woitaschek]

Here we go 😛

suspend inline fun <T> iWillReturnEarliestInTwoSeconds(action: () -> T): T {
  val (result, elapsed) = measureTimedValue(action)
  delay(Duration.seconds(2) - elapsed)
  return result
}

[Paul Woitaschek]

I can make it even more cryptic 🙈

suspend inline fun <T> iWillReturnEarliestInTwoSeconds(action: () -> T): T = measureTimedValue(action)
  .also {
    delay(Duration.seconds(2) - it.duration)
  }.value

[ephemient]

just launch a delay, due to how structured concurrency works you won't return until all children are done

private suspend fun getThing() {
    launch { delay(2000) }
    // do other stuff

[uli]

Not exactly. You need a scope

private suspend fun getThing() = coroutineScooe {
    launch { delay(2000) }
    // do other stuff
}

[Paul Woitaschek]

That is technically correct but probably I wouldn't write it as most of the devs wouldn't understand it

[uli]

They better learn it 😉

[uli]

Seriously scope is fundamental in coroutines. And waiting for it's children is a key feature of scopes. That's all this method is for.

[uli]

But if you don't like it, feel free to just join launch's job. Might be a bit more expressive i agree

[uli]

private suspend fun getThing() {
    val delayJob = launch { delay(2000) }
    // do other stuff
    delayJob.join()