¿Es posible crear un tipo de function recursiva en Kotlin?

Tengo funciones que representan pasos en un process. Cada function también conoce el siguiente paso, si hay uno. Me gustaría poder hacer algo como:

fun fooStep() : Step? { ... do something ... return ::barStep // the next step is barStep } 

Estas funciones se llaman desde una function central de despacho, que contiene un código como este:

• Retrofit 2 RequestBody Content Length Mayor que File Size
• ¿Cómo invocar explícitamente el bloque de inicio de un object?
• consultas de múltiples dominios de Android con RXJava
• RxJava2 Publicado
• ¿Cómo puedo get un número aleatorio en Kotlin?

 var step = startStep while (step != null) { step = step() } 

Tenga en count que la lógica en un paso particular también determina el siguiente paso, si es que hay uno.

Pensé que podría definir Step como:

 typealias Step = () -> Step? 

Entonces un Step es una function que devuelve otro Step o nulo. Sin embargo, esto no se puede comstackr con:

 Kotlin: Recursive type alias in expansion: Step 

Puedo evitar esto envolviendo la function en un object. p.ej:

 data class StepWrapper(val step: () -> StepWrapper?) 

y cambiando mis firmas de funciones en consecuencia.

Desafortunadamente, esto significa que no puedo usar ::barStep funciones (por ej .: ::barStep ), sino que tengo que envolverlas en un StepWrapper :

 fun fooStep() : StepWrapper? { ... do something ... return StepWrapper(::barStep) } 

(También tengo que cambiar mi ciclo de envío, en consecuencia).

Me gustaría evitar la necesidad de crear estos objects de envoltura, si es posible. ¿Hay alguna manera de hacer esto en Kotlin?

 interface StepW<out T> : ()->T? interface Step : StepW<Step> class Step1 : Step { override fun invoke(): Step? = Step2() } class Step2 : Step { override fun invoke(): Step? = null } 

 typealias Fun<T> = () -> T typealias Step<T> = () -> (T) typealias Step1 = Step<Fun<Step2>> typealias Step2 = Step<Fun<Step3>> typealias Step3 = Step<Unit> fun step1(): Step1 { return { println("step 1") ::step2 } } fun step2(): Step2 { return { println("step 2") ::step3 } } fun step3(): Step3 { return { println("done") } } 

 enum class Step : () -> Step { Step1 { override fun invoke() = Step2 }, Step2 { override fun invoke() = End }, End { override fun invoke() = this } } fun work() { var step = Step.Step1 while (step !== Step.End) { step = step() } }