No elegant way to iterate over linked list in C-style loop?

[iperov]

pub struct List {
pub mut:
    front ?&ListNode
    back  ?&ListNode
}

pub struct ListNode {
pub mut:
    prev ?&ListNode
    next ?&ListNode
}

fn main() 
{  
	list := &List{}
	
	// elegant but 
	// error: cannot access fields of an Option, handle the error with `or {...}` or propagate it with `?`
	for node := list.front; node != none; node = node.next {
	}
	
	// a lot of words to do a simple thing :(
	mut current := list.front
    for current != none {
        node := current or { break }   
		
        current = node.next
    }
	
}

[Nickalus12]

Because V emphasizes safety and explicit error/none handling, the traditional C-style iteration is restricted to prevent unintentional access to none values. In V, any field access on an Option type requires explicit unwrapping.

Comparison of Approaches

Approach	Syntax	Pros/Cons
Manual Unwrapping	for curr := ...; ...	Pro: No extra methods. Con: High boilerplate; requires or { break } inside the loop.
Iterator Interface	for node in list.iter()	Pro: Cleanest syntax; reusable. Con: Requires a small helper struct and a next() method.
Recursive/Functional	list.map(...)	Pro: Declarative. Con: Harder to implement for custom linked lists without built-in support.

Recommendation: Iterator Interface

The most idiomatic "V-way" is to implement the Iterator Interface. By defining a next() method that returns an Option, you allow the compiler to handle the unwrapping and termination logic automatically using a standard for ... in loop.

Implementation

To make your List iterable, create a simple iterator struct that tracks the current node.

pub struct List {
pub mut:
    front ?&ListNode
    back  ?&ListNode
}

pub struct ListNode {
pub mut:
    val  int
    prev ?&ListNode
    next ?&ListNode
}

// 1. Define the iterator state
struct ListIter {
mut:
    curr ?&ListNode
}

// 2. Implement the next() method
// V recognizes any type with this signature as an iterator
fn (mut it ListIter) next() ?&ListNode {
    node := it.curr? // Returns none if curr is none, ending the loop
    it.curr = node.next
    return node
}

// 3. Helper method to start iteration
fn (l &List) iter() ListIter {
    return ListIter{ curr: l.front }
}

fn main() {
    // Example usage
    mut list := &List{
        front: &ListNode{ val: 1, next: &ListNode{ val: 2 } }
    }

    // Now you can use the elegant for-in syntax
    for node in list.iter() {
        println(node.val)
    }
}

Tip

Using it.curr? inside the next method uses V's option propagation. If it.curr is none, the method immediately returns none, which signals the for loop to terminate.

Does your specific use case require modifying the next pointers during iteration, or is it read-only?