Die idiomatischen Möglichkeit zur Implementierung von Generatoren (yield) in Golang für rekursive Funktionen

I. Alternativen

Vorwort: werde ich ein viel einfacher generator, denn das problem betrifft nicht den generator Komplexität, sondern die Signale, die zwischen generator und Verbraucher und den Ruf der Verbraucher selbst. Dieser einfache generator erzeugt die zahlen von 0 zu 9.

1. Eine Funktion, mit der Wert -

Erstellen-consumer-pattern ist viel sauberer mit einem einfachen Verbraucher Funktion übergeben, die hat auch den Vorteil, dass es einen Wert zurück melde, wenn die Abtreibung oder jede andere Maßnahme erforderlich ist.

Und da im Beispiel nur ein Ereignis signalisiert werden ("abort"), die Verbraucher-Funktion haben bool zurück geben, Signalisierung, wenn der Abbruch wird erforderlich.

Also sehen dieses einfache Beispiel mit einem Verbraucher-Funktion übergebenen Wert an den generator:

func generate(process func(x int) bool) {
    for i := 0; i < 10; i++ {
        if process(i) {
            break
        }
    }
}

func main() {
    process := func(x int) bool {
        fmt.Println("Processing", x)
        return x == 3 //Terminate if x == 3
    }
    generate(process)
}

Ausgang (versuchen Sie es auf die Gehen Spielplatz):

Processing 0
Processing 1
Processing 2
Processing 3

Hinweis, dass der Verbraucher (process) muss nicht sein, ein "local" - Funktion, es kann deklariert werden, außerhalb von main(), z.B. es kann eine Globale Funktion oder eine Funktion aus einem anderen Paket.

Den potenziellen Nachteil dieser Lösung ist, dass es verwendet nur 1 goroutine sowohl für die Erzeugung und Konsum-Werte.

2. Mit Kanälen

Wenn Sie wollen immer noch, es zu tun mit den Kanälen, Sie können. Beachten Sie, dass seit der Kanal ist, durch den generator erzeugt wird, und da die Verbraucher durchläuft in einer Schleife die Werte aus den empfangenen Kanal (idealerweise mit for ... range Konstrukt), es ist der generator der Verantwortung, schließen Sie den Kanal. Die Abrechnung mit den dieser ermöglicht es Ihnen auch, um wieder eine " receive-only channel.

Und ja, die Schließung des zurückgegebenen Kanal in der generator ist am besten als eine latente Aussage, auch wenn der generator Panik, der Verbraucher wird nicht blockiert. Aber beachten Sie, dass diese latente schließen, ist nicht in der generate() Funktion, sondern in der anonymen Funktion gestartet von generate() und ausgeführt, als einer neuen goroutine; sonst ist der Kanal geschlossen werden würde, bevor es zurück generate() - überhaupt nicht nützlich...

Und wenn Sie wollen, um ein signal-generator von dem Verbraucher (z.B. um den Vorgang abzubrechen und keine weiteren Werte), die Sie verwenden können, z.B. einen anderen Kanal, der an den generator. Da der generator nur "hören" auf diesem Kanal, es können auch erklärt werden, wie eine receive-channel nur auf den generator. Wenn Sie nur brauchen, um zu signalisieren ein Ereignis (Abbruch in unserem Fall), keine Notwendigkeit, senden Sie alle Werte, die auf diesem Kanal, eine einfache in der Nähe wird es tun. Wenn Sie brauchen, um das signal mehrere Ereignisse, es kann getan werden, indem Sie wirklich Wert senden auf diesem Kanal, wird das Ereignis /die Aktion durchgeführt werden soll (wo Abbrechen kann eines von mehreren Ereignissen).

Und Sie können die select - Anweisung wie die idiomatischen Weg zu senden die Werte auf den zurückgegebenen Kanal und beobachten Sie die Kanal geleitet, um die generator.

Hier ist eine Lösung mit einem abort Kanal:

func generate(abort <-chan struct{}) <-chan int {
    ch := make(chan int)
    go func() {
        defer close(ch)
        for i := 0; i < 10; i++ {
            select {
            case ch <- i:
                fmt.Println("Sent", i)
            case <-abort: //receive on closed channel can proceed immediately
                fmt.Println("Aborting")
                return
            }
        }
    }()
    return ch
}

func main() {
    abort := make(chan struct{})
    ch := generate(abort)
    for v := range ch {
        fmt.Println("Processing", v)
        if v == 3 { //Terminate if v == 3
            close(abort)
            break
        }
    }
    //Sleep to prevent termination so we see if other goroutine panics
    time.Sleep(time.Second)
}

Ausgang (versuchen Sie es auf die Gehen Spielplatz):

Sent 0
Processing 0
Processing 1
Sent 1
Sent 2
Processing 2
Processing 3
Sent 3
Aborting

Der offensichtliche Vorteil dieser Lösung ist, dass es bereits verwendet 2 goroutines (1, die Werte generiert, 1, verbraucht/verarbeitet), und es ist sehr einfach zu erweitern ist zur Verarbeitung der generierten Werte mit einer beliebigen Anzahl von goroutines, wie der Kanal zurückgegeben, die durch den generator verwendet werden kann, aus mehreren goroutines gleichzeitig - Kanäle sicher zu sein, empfangen von gleichzeitig, data races nicht auftreten können, durch design; mehr Lesen: Wenn ich die Kanäle richtig muss ich Mutexe verwenden?

II. Antworten auf unadressierte Fragen

Einer "uncaught" Panik auf eine goroutine wird am Ende der Ausführung der goroutine aber nicht zu einem problem in Bezug auf Ressourcen-Leck. Aber wenn die Funktion ausgeführt als separates goroutine würden Ressourcen frei (in nicht-latente Aussagen) zugeordnet, indem es im Falle der nicht-Panik, dieser code wird offensichtlich nicht ausgeführt, und es werden Ursache-Ressource-Leck zum Beispiel.

Haben Sie nicht beobachtet, weil das Programm endet, wenn der Haupt-goroutine beendet (und es nicht warten, für andere nicht-Haupt-goroutines zu beenden - damit die anderen goroutines nicht die chance bekommen, in Panik zu geraten). Sehen Skillung: Programmausführung.

Aber wissen, dass panic() und recover() für außergewöhnliche Fälle, Sie sind nicht gedacht für solche Anwendungsfälle wie die Ausnahmen und try-catch Blöcke in Java. Panik sollte vermieden werden, die durch Fehler zurückgeben (und behandeln!) zum Beispiel, und Panik sollte auf jeden Fall nicht verlassen, die "Grenzen" der Pakete (z.B. panic() und recover() gerechtfertigt sein können, verwendet werden in einem Paket-Implementierung, aber in Panik Zustand sein sollte, "gefangen" in dem Paket und lassen Sie nicht aus ihm heraus).

Ich Stimme mit icza Antwort. Um zusammenzufassen, gibt es zwei alternativen:

1. mapping-Funktion: Verwenden Sie einen Rückruf zur Iteration über eine Sammlung. func myIterationFn(yieldfunc (myType)) (stopIterating bool). Dies hat den Nachteil, dass eine Abtretung der Ablaufsteuerung zu myGenerator Funktion. myIterationFn ist nicht ein Pythonic generator, da spielt es keine Rückkehr einer wiederholenden Sequenz.
2. Kanäle: einen Kanal Verwenden und vorsichtig sein, der undicht goroutines. Es ist möglich, zu transformieren myIterationFn in eine Funktion zurückgibt, die einen wiederholenden Sequenz. Der folgende code zeigt ein Beispiel einer solchen transformation.

myMapper := func(yield func(int) bool) {
    for i := 0; i < 5; i++ {
        if done := yield(i); done {
            return
        }
    }
}
iter, cancel := mapperToIterator(myMapper)
defer cancel() //This line is very important - it prevents goroutine leaks.
for value, ok := iter(); ok; value, ok = iter() {
    fmt.Printf("value: %d\n", value)
}

Hier ist ein vollständiges Programm als Beispiel. mapperToIterator hat die transformation von einem mapping-Funktion zu einem generator. Gehen fehlen von Generika erfordert eine Umwandlung von interface{} zu int.

package main

import "fmt"

//yieldFn reports true if an iteration should continue. It is called on values
//of a collection.
type yieldFn func(interface{}) (stopIterating bool)

//mapperFn calls yieldFn for each member of a collection.
type mapperFn func(yieldFn)

//iteratorFn returns the next item in an iteration or the zero value. The
//second return value is true when iteration is complete.
type iteratorFn func() (value interface{}, done bool)

//cancelFn should be called to clean up the goroutine that would otherwise leak.
type cancelFn func()

//mapperToIterator returns an iteratorFn version of a mappingFn. The second
//return value must be called at the end of iteration, or the underlying
//goroutine will leak.
func mapperToIterator(m mapperFn) (iteratorFn, cancelFn) {
    generatedValues := make(chan interface{}, 1)
    stopCh := make(chan interface{}, 1)
    go func() {
        m(func(obj interface{}) bool {
            select {
            case <-stopCh:
                return false
            case generatedValues <- obj:
                return true
            }
        })
        close(generatedValues)
    }()
    iter := func() (value interface{}, notDone bool) {
        value, notDone = <-generatedValues
        return
    }
    return iter, func() {
        stopCh <- nil
    }
}

func main() {
    myMapper := func(yield yieldFn) {
        for i := 0; i < 5; i++ {
            if keepGoing := yield(i); !keepGoing {
                return
            }
        }
    }
    iter, cancel := mapperToIterator(myMapper)
    defer cancel()
    for value, notDone := iter(); notDone; value, notDone = iter() {
        fmt.Printf("value: %d\n", value.(int))
    }
}