Author background

generator syntax is built into many popular languages, such as JavaScript, python, kotlin; In Go, to implement such a similar function requires the help of coroutines, which makes the code very cumbersome, and it is not possible to automatically garbage collect the coroutines where the generator is located as other languages do, and if you forget to close the coroutine, it will cause the coroutine to leak.

I think the new generator syntax may be able to learn from JavaScript's generator syntax, which can be used without Coroutines and can be used for automatic garbage collection.

• Would you consider yourself a novice, intermediate, or experienced Go programmer?
• What other languages do you have experience with?

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Generator

https://docs.python.org/3/reference/expressions.html?highlight=yield#yield-expressions

https://kotlinlang.org/docs/sequences.html#from-chunks

function* InOrderIterator(root/*: TreeNode | null*/)/*: Generator<number> */{
    if (!root) return;
    yield* InOrderIterator(root.left);
    yield (root.val);
    yield* InOrderIterator(root.right);
}

func* InOrderIterator(root *TreeNode ) *genIter[int] {
  if root == nil {

			return
		}
    yield* InOrderIterator(root.Right);
    yield (root.Val);
    yield* InOrderIterator(root.Left);
}

fun main() {
    val oddNumbers = sequence {
        yield(1)
        yieldAll(listOf(3, 5))
        yieldAll(generateSequence(7) { it + 2 })
    }
    println(oddNumbers.take(5).toList())
}

function* gen() {
  yield 1;
  yield 2;
  yield 3;
}

let g = gen();
// "Generator { }"

def echo(value=None):
    print("Execution starts when 'next()' is called for the first time.")
    try:
        while True:
            try:
                value = (yield value)
            except Exception as e:
                value = e
    finally:
        print("Don't forget to clean up when 'close()' is called.")

generator = echo(1)
print(next(generator))


print(next(generator))

print(generator.send(2))

generator.throw(TypeError, "spam")

generator.close()

Related proposals

• Has this idea, or one like it, been proposed before?
  • If so, how does this proposal differ?
• Does this affect error handling?
  • If so, how does this differ from previous error handling proposals?
• Is this about generics?
  • If so, how does this relate to the accepted design and other generics proposals?

Proposal

• What is the proposed change?
• Who does this proposal help, and why?
• Please describe as precisely as possible the change to the language.
• What would change in the language spec?
• Please also describe the change informally, as in a class teaching Go.
• Is this change backward compatible?
  • Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit.
    Show example code before and after the change.
  • Before
  • After
• Orthogonality: how does this change interact or overlap with existing features?
• Is the goal of this change a performance improvement?
  • If so, what quantifiable improvement should we expect?
  • How would we measure it?

Costs

• Would this change make Go easier or harder to learn, and why?
• What is the cost of this proposal? (Every language change has a cost).
• How many tools (such as vet, gopls, gofmt, goimports, etc.) would be affected?
• What is the compile time cost?
• What is the run time cost?
• Can you describe a possible implementation?
• Do you have a prototype? (This is not required.)