Proposal: Range Over Function Types

[xushiwei]

This proposal adds support for ranging over function values in XGo, aligning with Go 1.23's iterator functions feature. This enables developers to create custom iterators with clean, idiomatic syntax.

Background

Go 1.23 introduced the ability to use range with function types, allowing functions to act as iterators. This powerful feature enables:

• Custom iteration patterns
• Lazy evaluation
• Resource management through iteration
• Cleaner APIs for sequential data

XGo should support this feature to maintain compatibility and provide modern iteration capabilities.

Proposal

Allow range to work with function types that match specific signatures:

func(yield func() bool)                    // 0 values
func(yield func(V) bool)                   // 1 value
func(yield func(K, V) bool)                // 2 values (key-value pairs)

The yield function is called by the iterator to produce values. It returns bool indicating whether iteration should continue (true) or stop (false, e.g., when break is encountered).

Examples

func foo(yield func() bool) {
	yield()
}

func bar(yield func(v string) bool) {
	yield("World")
}

func weekdays(yield func(k string, v int) bool) {
	yield("Mon", 1)
	yield("Tue", 2)
	yield("Wed", 3)
}

// Zero-value iterator
for range foo {
    println("Hi")
}

// Single-value iterator
for v := range bar {
    println(v)  // Output: World
}

// Key-value iterator
for k, v := range weekdays {
    println(k, v)  // Output: Mon 1, Tue 2, Wed 3
}

Use Cases

1. Custom collections: Iterate over tree structures, graphs, or custom data structures
2. Generators: Produce infinite or computed sequences lazily
3. Resource iteration: Files, database rows, network streams with automatic cleanup
4. Functional patterns: Map, filter, reduce operations with iterator chains

Implementation

The compiler should:

1. Recognize function types matching iterator signatures in range expressions
2. Generate code to call the iterator function with an appropriate yield callback
3. Handle break and continue by controlling the bool return value from yield
4. Support early termination when yield returns false

Compatibility

This feature is backward compatible - existing code continues to work unchanged. Only code explicitly using range with function values is affected.

Conclusion

Range over function types modernizes XGo's iteration capabilities, enabling cleaner APIs and more expressive code while maintaining Go compatibility.

[xushiwei]

@xgopilot please implement this feature, it will most likely be necessary to modify gogen.

[xgopilot]

Range Over Function Types - Implementation Complete ✅

Analysis Summary:

• XGo's parser already supports for x := range expr syntax — no grammar changes needed
• The semantic implementation requires changes to gogen to detect Go 1.23 iterator function signatures

Implementation Details

This feature adds support for Go 1.23 iterator functions that can be used with the range statement:

func(yield func() bool)           // 0 values
func(yield func(V) bool)          // 1 value
func(yield func(K, V) bool)       // 2 values (key-value pairs)

Example Usage:

func bar(yield func(v string) bool) {
    yield("Hello")
    yield("World")
}

for v := range bar {
    println(v)  // Output: Hello, World
}

Required Changes in gogen (goplus/gogen)

The gogen package needs a modification to stmt.go to detect iterator function signatures. Here's the complete change:

Click to expand gogen/stmt.go patch

Add this case to the getKeyValTypes switch statement (after *types.Basic case):

case *types.Signature:
    // Go 1.23 range over function types:
    // func(yield func() bool)           - 0 values
    // func(yield func(V) bool)          - 1 value
    // func(yield func(K, V) bool)       - 2 values
    if kvt := checkIteratorFunc(t); kvt != nil {
        return kvt
    }

Add this new function after getKeyValTypes:

// checkIteratorFunc checks if sig is a Go 1.23 iterator function signature.
// Returns [keyType, valType] if valid, nil otherwise.
func checkIteratorFunc(sig *types.Signature) []types.Type {
    // Must have no results
    if sig.Results().Len() != 0 {
        return nil
    }
    // Must have exactly 1 parameter (the yield function)
    if sig.Params().Len() != 1 {
        return nil
    }
    // The parameter must be a function
    yieldSig, ok := sig.Params().At(0).Type().(*types.Signature)
    if !ok {
        return nil
    }
    // yield must return bool
    if yieldSig.Results().Len() != 1 {
        return nil
    }
    retType := yieldSig.Results().At(0).Type()
    basic, ok := retType.(*types.Basic)
    if !ok || basic.Kind() != types.Bool {
        return nil
    }
    // Check yield parameters (0, 1, or 2)
    n := yieldSig.Params().Len()
    switch n {
    case 0:
        return []types.Type{nil, nil}
    case 1:
        return []types.Type{yieldSig.Params().At(0).Type(), nil}
    case 2:
        return []types.Type{yieldSig.Params().At(0).Type(), yieldSig.Params().At(1).Type()}
    }
    return nil
}

Test Cases

Three test cases were implemented and verified locally:

• TestForRangeFunc0 - 0-value iterator (e.g., for range thrice {})
• TestForRangeFunc1 - 1-value iterator (e.g., for v := range bar {})
• TestForRangeFunc2 - 2-value iterator (e.g., for k, v := range weekdays {})

All tests pass ✅

Next Steps

1. Apply the gogen patch - The changes need to be committed to goplus/gogen first
2. Bump gogen version - After gogen is updated, update XGo's go.mod to use the new version
3. Add XGo test cases - Add the test cases in cl/_testgop/ directory

Would you like me to help create the gogen PR manually, or would you prefer to apply the patch yourself?

[xushiwei]

@xgopilot please create PR for gogen, including all test cases.

[xgopilot]

PR Created for gogen ✅

Successfully created PR in goplus/gogen repository.

PR Link: goplus/gogen#586

Changes

• stmt.go: Added checkIteratorFunc() function to detect Go 1.23 iterator function signatures
• package_test.go: Added 3 test cases for iterator functions:
  • TestForRangeFunc0 - 0-value iterator
  • TestForRangeFunc1 - 1-value iterator
  • TestForRangeFunc2 - 2-value iterator (key-value pairs)

Supported Iterator Signatures

func(yield func() bool)           // 0 values
func(yield func(V) bool)          // 1 value
func(yield func(K, V) bool)       // 2 values

Once this gogen PR is merged and a new version is released, the XGo repository can update its dependency and add the corresponding XGo test cases.