Tailrec function in Kotlin - kotlin

Question

I'm trying to convert a tail-recursive piece of code that uses Arrow Try, Either and achieve what it does functionally.
The function evaluates the function that was passed in as the argument. If the result is successful, it returns a value of type T. If the evaluation results in a failure, it returns the throwable.
Here is the original function -
private tailrec fun <T> eventuallyAux(
startTime: LocalTime,
timeout: Duration,
retryInterval: Duration,
function: () -> T
): T {
val result = Try { function() }.toEither()
return when (result) {
is Either.Right -> result.b
is Either.Left -> {
throwEventuallyExceptionIfTimedOut(startTime, timeout, result.a)
Thread.sleep(retryInterval.toMillis())
eventuallyAux(startTime, timeout, retryInterval, function)
}
}
}
This is what I have managed to scrape up using Result in kotlin std-lib instead of toEither():
private tailrec fun <T> eventuallyAux(
startTime: LocalTime,
timeout: Duration,
retryInterval: Duration,
function: () -> T
): T {
return runCatching(function)
.onSuccess { it.right() }
.onFailure {
throwEventuallyExceptionIfTimedOut(startTime, timeout, it)
Thread.sleep(retryInterval.toMillis())
eventuallyAux(startTime, timeout, retryInterval, function)
}
}
The compiler complains that a value is being returned with the type Result<T> instead of T. How do I get around this and return T if the evaluation is successful and pass the throwable to the tailrec function if it is a failure?
Thanks

Answer 1

runCatching wraps your return value in a Result, that's why the return type is Result<T>. onSuccess etc just perform an action on the wrapped value, but return the Result itself
That's also why it's not tail-recursive - that requires the recursive call to be the last thing you do in the function, so there's nothing else to do in there, and the current function call can be popped off the stack. No need to backtrack through it when there's nothing to do in there! The result can just be passed to whatever comes before that on the stack. It's like removing the call and starting a new one, like iteration, instead of nesting them.
But because your onFailure code before the Result itself is returned, there's still code to execute in that call, still work to do. So your recursive call isn't a tail call - it's not the last thing, so the current function call can't be removed from the call stack yet. So you end up with regular recursion because it can't be optimised.
Unfortunately you can't do tail calls inside a try/catch either because that's not supported. You need to basically replicate the approach in the original code, which is:
call the function and get the Result
if it's a success, return the unwrapped value
otherwise, return the result of a recursive call
That way, the last thing you do is make the tail call, and the result of that is passed directly back to the original caller. You should be able to do it like this:
private tailrec fun <T> eventuallyAux(
startTime: LocalTime,
timeout: Duration,
retryInterval: Duration,
function: () -> T
): T {
val result = runCatching(function)
return if (result.isSuccess) result.getOrThrow()
else {
throwEventuallyExceptionIfTimedOut(startTime, timeout, it)
Thread.sleep(retryInterval.toMillis())
// last thing that happens, nothing else to do but return the result of this
eventuallyAux(startTime, timeout, retryInterval, function)
}
}
You can't use result.getOrElse because the else block is a lambda - I'm assuming it's because it gets converted to a Function object and calling that isn't handled for tail recursion optimisation, but I haven't looked into it. Doing it this way, with the most basic if/else structure, lets you control exactly what happens when and make sure it gets optimised