New Keyword to Support Iteration Through Generators

[tclesius]

Description:

Currently, C3 lacks a convenient way to iterate through custom generator types that implement next and has_next methods. To address this, I propose adding a new keyword: fornext, which would allow developers to iterate through these generators in a simple and intuitive manner.

The fornext loop would automatically invoke the has_next() method to check if there are more items to iterate over. On each iteration, it would call the next() method to retrieve the next value, assigning it to the loop variable.

Additionally, the fornext loop could optionally support an index variable, making it easier to track the position within the iteration.

Proposed Syntax:

struct Generator
{
    int i;
}

fn int Generator.next()
{
    i += 1; 
    return i;
}

fn bool Generator.has_next()
{
    return true;
}

void main()
{
    Generator g;

    // Simple iteration over generator
    fornext(x: g)
    {
        if(x >= 100) 
        {
            break;
        }
        io::printfn("%d", x); 
    }
    
    // Iteration with index variable
    fornext(ix, x: g)
    {
        if(x >= 100) 
        {
            break;
        }
        io::printfn("%d %d", ix, x); 
    }
}

[lerno]

There is a working pattern for this. Rather than implementing next and has_next implement a next which returns an optional.

struct Generator
{
   int i;
   int max;
}

fn int! Generator.next()
{
   if (i < max) return i++;
   return IteratorResult.NO_MORE_ELEMENT?;
}

fn void main()
{
   Generator g = { .max = 100 };
   while (try i = g.next())
   {
      io::printn(i);
   }  
}

I found this pattern so powerful that I didn't extend foreach to include generators, as this is more flexible than foreach would be.

[tclesius]

I really like its simplicity. I’ll definitely be using it from now on. Thank you!