Ist es möglich, in Kotlin einen rekursiven Funktionstyp zu erstellen?

Question

Ich habe Funktionen, die Schritte in einem Prozess darstellen. Jede Funktion kennt auch den nächsten Schritt, falls es einen gibt. Ich möchte in der Lage sein, etwas zu tun wie:

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

Diese Funktionen von einer zentralen Dispatching-Funktion aufgerufen werden, die Code ein bisschen wie folgt enthält:

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

Beachten Sie, dass die Logik in einem bestimmten Schritt bestimmt auch den nächsten Schritt, wenn es sogar einen gibt.

Ich dachte, ich Step wie definieren könnte: So ein Step eine Funktion ist

typealias Step =() -> Step? 

, die eine andere Step zurückgibt, oder null. Das kompiliert jedoch nicht mit:

Kotlin: Recursive type alias in expansion: Step 

Ich kann umgehen, indem Sie die Funktion in einem Objekt umschließen. zB:

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

und meine Funktionssignaturen entsprechend ändern.

Leider bedeutet dies, dass ich nicht nur Funktionsliteralen (zB: ::barStep), sondern wickeln, um sie in einem StepWrapper:

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

(Ich habe auch meine Dispatch Schleife ändern sich entsprechend.)

Ich möchte die Notwendigkeit vermeiden, diese Wrapper-Objekte zu erstellen, wenn möglich. Gibt es eine Möglichkeit, dies in Kotlin zu tun?

Answer 1

Sie können definieren, indem Sie eine generische Schnittstelle:

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 
} 

Wo Step Ihre rekursive Funktion Typ ist.

Answer 2

Hier ist, wie Sie es funktioniert, obwohl ich wirklich bin nicht sicher, was Sie versuchen, mit ihm zu erreichen:

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") } 
} 

Answer 3

Verwenden Sie ein Enum den Zustand Muster mit endlichen Zuständen zu implementieren und zu bevorzugen Rückgabe von Nicht-Null-Werten Eine Enumeration kann von einer Funktion erben.

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() 
    } 
}