pub struct Range[T] {
pub:
    from      T
    to        T
    inclusive bool
pub mut:
    step T = T(1)
    i    T
mut:
    started bool
}

pub fn (mut r Range[T]) next[T]() ?T {
    if !r.started {
        r.started = true
        assert r.step > 0
        if r.from > r.to {
            r.step = -r.step
        }
        r.i = r.from
    }
    i := r.i
    next_i := i + r.step
    if r.inclusive {
        if r.step < 0 && i < r.to {
            return none
        }
        if r.step > 0 && i > r.to {
            return none
        }
    } else {
        if r.step < 0 && i <= r.to {
            return none
        }
        if r.step > 0 && i >= r.to {
            return none
        }
    }
    r.i = next_i
    return i
}

pub interface Iterator[T] {
mut:
    next() ?T
}

pub struct Zip[A, B] {
mut:
    a Iterator[A]
    b Iterator[B]
}

pub struct Pair[A, B] {
    a A
    b B
}

pub fn (mut z Zip[A, B]) next[A, B]() ?Pair[A, B] {
    a := z.a.next()?
    b := z.b.next()?
    return Pair[A, B]{a, b}
}

fn test_main() {
    mut r1 := Range{
        from: 5
        to:   10
    }
    _ := Iterator[int](r1)

    mut r2 := Range{
        from: 10
        to:   5
    }
    _ := Iterator[int](r2)

    _ := Zip[int, int]{}
}