Iterator design.

std-bits/table/src/main/java/org/enso/table/data/column/operation/map/numeric/arithmetic/NumericBinaryOpReturningBigDecimal.java

@@ -1,5 +1,7 @@
 package org.enso.table.data.column.operation.map.numeric.arithmetic;
 
+import static org.enso.table.data.column.operation.map.numeric.arithmetic.NumericBinaryOpImplementation.asBigDecimal;
+
 import java.math.BigDecimal;
 import org.enso.base.polyglot.NumericConverter;
 import org.enso.table.data.column.builder.Builder;
@@ -10,8 +12,6 @@
 import org.enso.table.data.column.storage.numeric.BigDecimalStorage;
 import org.enso.table.data.column.storage.numeric.BigIntegerStorage;
 
-import static org.enso.table.data.column.operation.map.numeric.arithmetic.NumericBinaryOpImplementation.asBigDecimal;
-
 public abstract class NumericBinaryOpReturningBigDecimal<
         T extends Number, I extends Storage<? super T>>
     extends BinaryMapOperation<T, I> {

std-bits/table/src/main/java/org/enso/table/data/column/operation/map/numeric/arithmetic/NumericBinaryOpReturningDouble.java

@@ -1,6 +1,5 @@
 package org.enso.table.data.column.operation.map.numeric.arithmetic;
 
-import java.math.BigDecimal;
 import java.math.BigInteger;
 import org.enso.base.polyglot.NumericConverter;
 import org.enso.table.data.column.builder.Builder;

std-bits/table/src/main/java/org/enso/table/data/column/operation/map/numeric/comparisons/NumericComparison.java

@@ -1,5 +1,8 @@
 package org.enso.table.data.column.operation.map.numeric.comparisons;
 
+import static org.enso.table.data.column.operation.map.numeric.arithmetic.NumericBinaryOpImplementation.asBigDecimal;
+import static org.enso.table.data.column.operation.map.numeric.arithmetic.NumericBinaryOpImplementation.asBigInteger;
+
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import org.enso.base.CompareException;
@@ -12,15 +15,11 @@
 import org.enso.table.data.column.storage.ColumnDoubleStorage;
 import org.enso.table.data.column.storage.ColumnLongStorage;
 import org.enso.table.data.column.storage.ColumnStorage;
-import org.enso.table.data.column.storage.ColumnStorageFacade;
 import org.enso.table.data.column.storage.Storage;
 import org.enso.table.data.column.storage.numeric.BigDecimalStorage;
 import org.enso.table.data.column.storage.numeric.BigIntegerStorage;
 import org.enso.table.data.column.storage.numeric.DoubleStorageFacade;
 
-import static org.enso.table.data.column.operation.map.numeric.arithmetic.NumericBinaryOpImplementation.asBigDecimal;
-import static org.enso.table.data.column.operation.map.numeric.arithmetic.NumericBinaryOpImplementation.asBigInteger;
-
 public abstract class NumericComparison<T extends Number, I extends Storage<? super T>>
     extends BinaryMapOperation<T, I> {
 
@@ -63,9 +62,12 @@ public Storage<Boolean> runBinaryMap(
     } else if (arg instanceof BigDecimal bigDecimal) {
       return switch (storage) {
         case BigDecimalStorage s -> runBigDecimalMap(s, bigDecimal, problemAggregator);
-        case BigIntegerStorage s -> runBigDecimalMap(asBigDecimal(s), bigDecimal, problemAggregator);
-        case ColumnDoubleStorage s -> runBigDecimalMap(asBigDecimal(s), bigDecimal, problemAggregator);
-        case ColumnLongStorage s -> runBigDecimalMap(asBigDecimal(s), bigDecimal, problemAggregator);
+        case BigIntegerStorage s -> runBigDecimalMap(
+            asBigDecimal(s), bigDecimal, problemAggregator);
+        case ColumnDoubleStorage s -> runBigDecimalMap(
+            asBigDecimal(s), bigDecimal, problemAggregator);
+        case ColumnLongStorage s -> runBigDecimalMap(
+            asBigDecimal(s), bigDecimal, problemAggregator);
         default -> throw newUnsupported(storage);
       };
     } else if (NumericConverter.isCoercibleToLong(arg)) {

std-bits/table/src/main/java/org/enso/table/data/column/storage/BoolStorage.java

@@ -2,6 +2,7 @@
 
 import java.util.BitSet;
 import java.util.List;
+import java.util.NoSuchElementException;
 import java.util.function.IntFunction;
 import org.enso.base.CompareException;
 import org.enso.base.polyglot.Polyglot_Utils;
@@ -323,6 +324,62 @@ public Storage<Boolean> slice(List<SliceRange> ranges) {
     return builder.seal();
   }
 
+  @Override
+  public ColumnBooleanStorageIterator iterator() {
+    return new BoolStorageIterator(this);
+  }
+
+  private static class BoolStorageIterator implements ColumnBooleanStorageIterator {
+    private final BoolStorage parent;
+    private int index = -1;
+
+    public BoolStorageIterator(BoolStorage parent) {
+      this.parent = parent;
+    }
+
+    @Override
+    public Boolean getItemBoxed() {
+      return parent.getItemBoxed(index);
+    }
+
+    @Override
+    public boolean getItemAsBoolean() {
+      return !parent.isNothing(index) && parent.getItemAsBoolean(index);
+    }
+
+    @Override
+    public boolean isNothing() {
+      return parent.isNothing(index);
+    }
+
+    @Override
+    public boolean hasNext() {
+      return index + 1 < parent.getSize();
+    }
+
+    @Override
+    public Boolean next() {
+      if (!hasNext()) {
+        throw new NoSuchElementException();
+      }
+      return parent.getItemBoxed(++index);
+    }
+
+    @Override
+    public long getIndex() {
+      return index;
+    }
+
+    @Override
+    public boolean moveNext() {
+      if (!hasNext()) {
+        return false;
+      }
+      index++;
+      return true;
+    }
+  }
+
   private static class BoolEq extends BinaryMapOperation<Boolean, BoolStorage> {
     public BoolEq() {
       super(Maps.EQ);

std-bits/table/src/main/java/org/enso/table/data/column/storage/ColumnBooleanStorage.java

@@ -3,4 +3,7 @@
 public interface ColumnBooleanStorage extends ColumnStorage<Boolean> {
   /** Gets the value at a given index. Throws ValueIsNothingException if the index is nothing. */
   boolean getItemAsBoolean(long index) throws ValueIsNothingException;
+
+  @Override
+  ColumnBooleanStorageIterator iterator();
 }

std-bits/table/src/main/java/org/enso/table/data/column/storage/ColumnDoubleStorage.java

@@ -3,4 +3,7 @@
 public interface ColumnDoubleStorage extends ColumnStorage<Double> {
   /** Gets the value at a given index. Throws ValueIsNothingException if the index is nothing. */
   double getItemAsDouble(long index) throws ValueIsNothingException;
+
+  @Override
+  ColumnDoubleStorageIterator iterator();
 }

std-bits/table/src/main/java/org/enso/table/data/column/storage/ColumnDoubleStorageIterator.java

@@ -0,0 +1,6 @@
+package org.enso.table.data.column.storage;
+
+public interface ColumnDoubleStorageIterator extends ColumnStorageIterator<Double> {
+  /** Gets the current item as a double. Note if the item isNothing value is undefined. */
+  double getItemAsDouble();
+}

std-bits/table/src/main/java/org/enso/table/data/column/storage/ColumnLongStorage.java

@@ -3,4 +3,7 @@
 public interface ColumnLongStorage extends ColumnStorage<Long> {
   /** Gets the value at a given index. Throws ValueIsNothingException if the index is nothing. */
   long getItemAsLong(long index) throws ValueIsNothingException;
+
+  @Override
+  ColumnLongStorageIterator iterator();
 }

std-bits/table/src/main/java/org/enso/table/data/column/storage/ColumnLongStorageIterator.java

@@ -0,0 +1,6 @@
+package org.enso.table.data.column.storage;
+
+public interface ColumnLongStorageIterator extends ColumnStorageIterator<Long> {
+  /** Gets the current item as a long. Note if the item isNothing value is undefined. */
+  long getItemAsLong();
+}

std-bits/table/src/main/java/org/enso/table/data/column/storage/ColumnStorage.java

@@ -3,7 +3,7 @@
 import org.enso.table.data.column.storage.type.StorageType;
 
 /** Basic interface of a column storage. */
-public interface ColumnStorage<T> {
+public interface ColumnStorage<T> extends Iterable<T> {
   /* Gets the size of the storage. */
   long getSize();
 
@@ -20,4 +20,7 @@ public interface ColumnStorage<T> {
 
   /* Gets the value at a given index. */
   T getItemBoxed(long index);
+
+  @Override
+  ColumnStorageIterator<T> iterator();
 }

std-bits/table/src/main/java/org/enso/table/data/column/storage/ColumnStorageFacade.java

@@ -33,4 +33,9 @@ public T getItemBoxed(long index) {
     S item = parent.getItemBoxed(index);
     return item == null ? null : converter.apply(item);
   }
+
+  @Override
+  public ColumnStorageIterator<T> iterator() {
+    return new Storage.StorageIterator<>(this);
+  }
 }

std-bits/table/src/main/java/org/enso/table/data/column/storage/ColumnStorageIterator.java

@@ -0,0 +1,18 @@
+package org.enso.table.data.column.storage;
+
+import java.util.Iterator;
+
+public interface ColumnStorageIterator<T> extends Iterator<T> {
+  // Gets the current item.
+  T getItemBoxed();
+
+  // Checks whether the value at idx is Nothing.
+  boolean isNothing();
+
+  // Gets the current index;
+  long getIndex();
+
+  // Moves to the next item.
+  // Returns true if not finished, false otherwise.
+  boolean moveNext();
+}

std-bits/table/src/main/java/org/enso/table/data/column/storage/SpecializedStorage.java

@@ -2,6 +2,7 @@
 
 import java.util.BitSet;
 import java.util.List;
+import java.util.NoSuchElementException;
 import org.enso.table.data.column.operation.CountNothing;
 import org.enso.table.data.column.operation.map.MapOperationProblemAggregator;
 import org.enso.table.data.column.operation.map.MapOperationStorage;
@@ -189,4 +190,55 @@ public SpecializedStorage<T> castIfSameType(SpecializedStorage<?> storage) {
       return null;
     }
   }
+
+  @Override
+  public ColumnStorageIterator<T> iterator() {
+    return new SpecializedStorageIterator<>(data);
+  }
+
+  private static class SpecializedStorageIterator<T> implements ColumnStorageIterator<T> {
+    private final T[] data;
+    private int index = -1;
+
+    public SpecializedStorageIterator(T[] data) {
+      this.data = data;
+    }
+
+    @Override
+    public T getItemBoxed() {
+      return data[index];
+    }
+
+    @Override
+    public boolean isNothing() {
+      return data[index] == null;
+    }
+
+    @Override
+    public boolean hasNext() {
+      return index + 1 < data.length;
+    }
+
+    @Override
+    public T next() {
+      if (!hasNext()) {
+        throw new NoSuchElementException();
+      }
+      return data[++index];
+    }
+
+    @Override
+    public long getIndex() {
+      return index;
+    }
+
+    @Override
+    public boolean moveNext() {
+      if (!hasNext()) {
+        return false;
+      }
+      index++;
+      return true;
+    }
+  }
 }

std-bits/table/src/main/java/org/enso/table/data/column/storage/Storage.java

@@ -3,6 +3,7 @@
 import java.util.BitSet;
 import java.util.HashMap;
 import java.util.List;
+import java.util.NoSuchElementException;
 import java.util.function.BiFunction;
 import org.enso.base.polyglot.Polyglot_Utils;
 import org.enso.table.data.column.builder.Builder;
@@ -437,4 +438,55 @@ public static Storage<?> fromRepeatedItem(
 
     return builder.seal();
   }
+
+  @Override
+  public ColumnStorageIterator<T> iterator() {
+    return new StorageIterator<>(this);
+  }
+
+  public static class StorageIterator<T> implements ColumnStorageIterator<T> {
+    protected final ColumnStorage<T> parent;
+    protected long index = -1;
+
+    public StorageIterator(ColumnStorage<T> parent) {
+      this.parent = parent;
+    }
+
+    @Override
+    public T getItemBoxed() {
+      return parent.getItemBoxed(index);
+    }
+
+    @Override
+    public boolean isNothing() {
+      return parent.isNothing(index);
+    }
+
+    @Override
+    public boolean hasNext() {
+      return index + 1 < parent.getSize();
+    }
+
+    @Override
+    public T next() {
+      if (!hasNext()) {
+        throw new NoSuchElementException();
+      }
+      return parent.getItemBoxed(++index);
+    }
+
+    @Override
+    public long getIndex() {
+      return index;
+    }
+
+    @Override
+    public boolean moveNext() {
+      if (!hasNext()) {
+        return false;
+      }
+      index++;
+      return true;
+    }
+  }
 }

std-bits/table/src/main/java/org/enso/table/data/column/storage/numeric/AbstractLongStorage.java

@@ -20,10 +20,7 @@
 import org.enso.table.data.column.operation.map.numeric.comparisons.LessComparison;
 import org.enso.table.data.column.operation.map.numeric.comparisons.LessOrEqualComparison;
 import org.enso.table.data.column.operation.map.numeric.isin.LongIsInOp;
-import org.enso.table.data.column.storage.BoolStorage;
-import org.enso.table.data.column.storage.ColumnLongStorage;
-import org.enso.table.data.column.storage.Storage;
-import org.enso.table.data.column.storage.ValueIsNothingException;
+import org.enso.table.data.column.storage.*;
 import org.enso.table.data.column.storage.type.IntegerType;
 import org.enso.table.data.column.storage.type.StorageType;
 import org.enso.table.data.mask.OrderMask;
@@ -282,4 +279,23 @@ protected Long computeItem(long idx) {
       }
     };
   }
+
+  @Override
+  public ColumnLongStorageIterator iterator() {
+    return new BaseLongStorageIterator(this);
+  }
+
+  /** Basic iterator for long storages. */
+  public static class BaseLongStorageIterator extends StorageIterator<Long>
+      implements ColumnLongStorageIterator {
+    public BaseLongStorageIterator(ColumnLongStorage parent) {
+      super(parent);
+    }
+
+    @Override
+    public long getItemAsLong() {
+      Long l = getItemBoxed();
+      return l == null ? 0 : l;
+    }
+  }
 }