lazily-evaluated Iterator.unfoldRight (#3112)

Co-authored-by: Egor Tsinko <egort@innova-power.com>

Author: pivovarit

vavr/src/main/java/io/vavr/collection/Iterator.java

@@ -1326,17 +1326,18 @@ static <T, U> Iterator<U> unfoldLeft(T seed, Function<? super T, Option<Tuple2<?
     static <T, U> Iterator<U> unfoldRight(T seed, Function<? super T, Option<Tuple2<? extends U, ? extends T>>> f) {
         Objects.requireNonNull(f, "the unfold iterating function is null");
         return new AbstractIterator<U>() {
-            private Option<Tuple2<? extends U, ? extends T>> nextVal = f.apply(seed);
+            private Lazy<Option<Tuple2<? extends U, ? extends T>>> nextVal = Lazy.of(() -> f.apply(seed));
 
             @Override
             public boolean hasNext() {
-                return nextVal.isDefined();
+                return nextVal.get().isDefined();
             }
 
             @Override
             public U getNext() {
-                final U result = nextVal.get()._1;
-                nextVal = f.apply(nextVal.get()._2);
+                Tuple2<? extends U, ? extends T> tuple = nextVal.get().get();
+                final U result = tuple._1;
+                nextVal = Lazy.of(() -> f.apply(tuple._2));
                 return result;
             }
         };
@@ -1865,11 +1866,10 @@ public boolean hasNext() {
                 public U getNext() {
                     if (isFirst) {
                         isFirst = false;
-                        return acc;
                     } else {
                         acc = operation.apply(acc, that.next());
-                        return acc;
                     }
+                    return acc;
                 }
             };
         }
@@ -2014,7 +2014,7 @@ public boolean hasNext() {
                             queue = queue.dequeue()._2;
                         }
                     }
-                    return queue.length() > 0;
+                    return !queue.isEmpty();
                 }
 
                 @Override

vavr/src/test/java/io/vavr/collection/IteratorTest.java

@@ -30,6 +30,7 @@
 import java.util.Spliterator;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collector;
@@ -39,7 +40,13 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
-import static io.vavr.collection.Iterator.*;
+import static io.vavr.collection.Iterator.concat;
+import static io.vavr.collection.Iterator.continually;
+import static io.vavr.collection.Iterator.from;
+import static io.vavr.collection.Iterator.iterate;
+import static io.vavr.collection.Iterator.narrow;
+import static io.vavr.collection.Iterator.rangeBy;
+import static io.vavr.collection.Iterator.rangeClosedBy;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
@@ -716,6 +723,39 @@ public void shouldPartitionLazily() {
 
     // -- unfoldRight()
 
+    @Test
+    void shouldUnfoldRightLazily() {
+        AtomicInteger calls = new AtomicInteger();
+
+        Iterator<Integer> it = Iterator.unfoldRight(1, i -> {
+            calls.incrementAndGet();
+            return i <= 3 ? Option.some(Tuple.of(i, i + 1)) : Option.none();
+        });
+
+        assertThat(calls.get()).isZero();
+
+        assertThat(it.hasNext()).isTrue();
+        assertThat(calls.get()).isEqualTo(1);
+
+        assertThat(it.next()).isEqualTo(1);
+        assertThat(calls.get()).isEqualTo(1);
+
+        assertThat(it.hasNext()).isTrue();
+        assertThat(calls.get()).isEqualTo(2);
+
+        assertThat(it.next()).isEqualTo(2);
+        assertThat(calls.get()).isEqualTo(2);
+
+        assertThat(it.hasNext()).isTrue();
+        assertThat(calls.get()).isEqualTo(3);
+
+        assertThat(it.next()).isEqualTo(3);
+        assertThat(calls.get()).isEqualTo(3);
+
+        assertThat(it.hasNext()).isFalse();
+        assertThat(calls.get()).isEqualTo(4);
+    }
+
     @Test
     public void shouldUnfoldRightToEmpty() {
         assertThat(Iterator.unfoldRight(0, x -> Option.none())).isEqualTo(empty());