Can Applicative be implemented "nicely" in kotlin? - functional-programming

Question

I have defined a Result type like this:
sealed class BadResult {
data class Description(val description: String): BadResult()
data class Exception (val exception : Throwable): BadResult()
}
sealed class BadTree {
data class Leaf(val v: BadResult) : BadTree()
data class Fork(val l: BadTree, val r: BadTree) : BadTree()
}
sealed class Result<T> {
data class Good<T> (val good : T ) : Result<T>()
class Empty<T> : Result<T>()
data class Bad <T> (val badTree : BadTree ) : Result<T>()
}
fun <T> T.good() : Result<T> = Result.Good(this)
fun <T> empty() : Result<T> = Result.Empty()
fun <T> BadTree.bad() : Result<T> = Result.Bad<T>(this)
fun <T> String.bad() : Result<T> = BadTree.Leaf(BadResult.Description(this)).bad()
fun <T> Throwable.bad() : Result<T> = BadTree.Leaf(BadResult.Exception(this)).bad()
For this Result class I have defined the monadic bind:
infix fun <T, U> Result<T>.bind(uf: (T) -> Result<U>) : Result<U> {
return when(this) {
is Result.Good -> uf(this.good)
is Result.Empty -> empty()
is Result.Bad -> this.badTree.bad()
}
}
A very useful functional pattern is Applicative, if applied to Result this would allow me to invoke a function with arbritrary argument list if and only if all arguments are Good.
This is a technique that usually relies on partial application (aka currying) which AFAIK isn't supported out of the box in kotlin. I've seen some libraries try to do currying but it seems to me currying is not a commonly recognized idiom in kotlin.
What I ideally would like to write is something like this:
pure(::aFunctionThatTakes3Args) apply arg1 apply arg2 apply arg3
But I can't come up with how the signatures should look like.
I could make a lift function for each arity of the function but that quickly gets cumbersome.
lift(::aFunctionThatTakes3Args, arg1, arg2, arg3) // lift is overloaded for each arity
(This seems to be how funKTionale implements currying)
Any ideas welcome.