feat: add LongArray#fold and ScanResult#column

fold(identity, LongBinaryOperator) enables zero-boxing
aggregation (sum, min, max) without the long[]{0} trick.
column(name) returns a typed array via inferred generic,
throwing VortexException on unknown column names.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dfa1

core/src/main/java/io/github/dfa1/vortex/core/array/LongArray.java

@@ -7,6 +7,7 @@
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.ValueLayout;
 import java.nio.ByteOrder;
+import java.util.function.LongBinaryOperator;
 import java.util.function.LongConsumer;
 
 /// Concrete [Array] for I64/U64 primitive columns. Hoists a single
@@ -70,4 +71,14 @@ public void forEachLong(LongConsumer c) {
 			c.accept(buf.getAtIndex(LAYOUT, i));
 		}
 	}
+
+	public long fold(long identity, LongBinaryOperator op) {
+		MemorySegment buf = buffer;
+		long n = length;
+		long result = identity;
+		for (long i = 0; i < n; i++) {
+			result = op.applyAsLong(result, buf.getAtIndex(LAYOUT, i));
+		}
+		return result;
+	}
 }

core/src/test/java/io/github/dfa1/vortex/core/array/LongArrayTest.java

@@ -0,0 +1,76 @@
+package io.github.dfa1.vortex.core.array;
+
+import io.github.dfa1.vortex.core.ArrayStats;
+import io.github.dfa1.vortex.core.DType;
+import io.github.dfa1.vortex.core.PType;
+import org.junit.jupiter.api.Test;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+import java.nio.ByteOrder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LongArrayTest {
+
+	private static final ValueLayout.OfLong LE_LONG =
+			ValueLayout.JAVA_LONG_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
+
+	private static LongArray of(long... values) {
+		MemorySegment seg = Arena.ofAuto().allocate((long) values.length * 8, 8);
+		for (int i = 0; i < values.length; i++) {
+			seg.setAtIndex(LE_LONG, i, values[i]);
+		}
+		DType dtype = new DType.Primitive(PType.I64, false);
+		return new LongArray(dtype, values.length, seg, ArrayStats.empty());
+	}
+
+	@Test
+	void fold_sum_returnsCorrectTotal() {
+		// Given
+		LongArray sut = of(1L, 2L, 3L, 4L, 5L);
+
+		// When
+		long result = sut.fold(0L, Long::sum);
+
+		// Then
+		assertThat(result).isEqualTo(15L);
+	}
+
+	@Test
+	void fold_max_returnsLargestValue() {
+		// Given
+		LongArray sut = of(3L, 1L, 4L, 1L, 5L, 9L, 2L);
+
+		// When
+		long result = sut.fold(Long.MIN_VALUE, Math::max);
+
+		// Then
+		assertThat(result).isEqualTo(9L);
+	}
+
+	@Test
+	void fold_min_returnsSmallestValue() {
+		// Given
+		LongArray sut = of(3L, 1L, 4L, 1L, 5L, 9L, 2L);
+
+		// When
+		long result = sut.fold(Long.MAX_VALUE, Math::min);
+
+		// Then
+		assertThat(result).isEqualTo(1L);
+	}
+
+	@Test
+	void fold_emptyArray_returnsIdentity() {
+		// Given
+		LongArray sut = of();
+
+		// When
+		long result = sut.fold(42L, Long::sum);
+
+		// Then
+		assertThat(result).isEqualTo(42L);
+	}
+}

reader/src/main/java/io/github/dfa1/vortex/scan/ScanResult.java

@@ -1,6 +1,7 @@
 package io.github.dfa1.vortex.scan;
 
 import io.github.dfa1.vortex.core.Array;
+import io.github.dfa1.vortex.core.VortexException;
 
 import java.util.Map;
 
@@ -9,4 +10,12 @@ public record ScanResult(
 		long rowCount,
 		Map<String, Array> columns
 ) {
+	@SuppressWarnings("unchecked")
+	public <T extends Array> T column(String name) {
+		Array arr = columns.get(name);
+		if (arr == null) {
+			throw new VortexException("unknown column: " + name);
+		}
+		return (T) arr;
+	}
 }

writer/src/test/java/io/github/dfa1/vortex/writer/VortexWriterTest.java

@@ -3,6 +3,7 @@
 import io.github.dfa1.vortex.core.Array;
 import io.github.dfa1.vortex.core.DType;
 import io.github.dfa1.vortex.core.PType;
+import io.github.dfa1.vortex.core.array.LongArray;
 import io.github.dfa1.vortex.encoding.CodecRegistry;
 import io.github.dfa1.vortex.encoding.PrimitiveCodec;
 import io.github.dfa1.vortex.io.VortexReader;
@@ -138,6 +139,48 @@ void writeAndRead_idValues_decodedCorrectly(@TempDir Path tmp) throws IOExceptio
 		}
 	}
 
+	@Test
+	void scanResult_column_returnsTypedArray(@TempDir Path tmp) throws IOException {
+		// Given
+		Path file = tmp.resolve("typed.vtx");
+		long[] ids = {10L, 20L, 30L};
+
+		try (var ch = FileChannel.open(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+		     var sut = VortexWriter.create(ch, SCHEMA, WriteOptions.defaults())) {
+			sut.writeChunk(Map.of("id", ids, "value", new double[]{1.0, 2.0, 3.0}));
+		}
+
+		// When
+		var registry = primitiveRegistry();
+		try (var vf = VortexReader.open(file, registry)) {
+			List<ScanResult> results = scanAll(vf, ScanOptions.all());
+			LongArray idArray = results.get(0).column("id");
+
+			// Then
+			assertThat(idArray.fold(0L, Long::sum)).isEqualTo(60L);
+		}
+	}
+
+	@Test
+	void scanResult_column_unknownName_throwsVortexException(@TempDir Path tmp) throws IOException {
+		// Given
+		Path file = tmp.resolve("unknown.vtx");
+
+		try (var ch = FileChannel.open(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+		     var sut = VortexWriter.create(ch, SCHEMA, WriteOptions.defaults())) {
+			sut.writeChunk(Map.of("id", new long[]{1L}, "value", new double[]{1.0}));
+		}
+
+		// When / Then
+		var registry = primitiveRegistry();
+		try (var vf = VortexReader.open(file, registry)) {
+			List<ScanResult> results = scanAll(vf, ScanOptions.all());
+			ScanResult sut = results.get(0);
+			assertThatThrownBy(() -> sut.column("nonexistent"))
+					.hasMessageContaining("unknown column: nonexistent");
+		}
+	}
+
 	@Test
 	void writeAndRead_columnProjection_returnsOnlyRequestedColumns(@TempDir Path tmp)
 			throws IOException {