Rename iterator methods

Author: tomas-novotny

CHANGELOG.md

@@ -6,7 +6,17 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 
-## [Unreleased](https://github.com/gravitton/grid/compare/v1.1.0...master)
+## [Unreleased](https://github.com/gravitton/grid/compare/v1.2.0...master)
+
+
+## [v1.2.0 (2026-05-12)](https://github.com/gravitton/grid/compare/v1.1.0...v1.2.0)
+### Added
+- `Array.Values` — iterator over all values (`iter.Seq[*T]`), completing the `Keys` / `Values` / `All` trio
+
+### Changed
+- `Array.Iter` renamed to `Array.Keys` — aligns with Go 1.23 iterator conventions (`iter.Seq[K]` iterators are named `Keys`)
+- `Array.Iter2` renamed to `Array.All` — aligns with Go 1.23 iterator conventions (`iter.Seq2[K, V]` iterators are named `All`)
+- `IterConfig` renamed to `IterOptions`
 
 
 ## [v1.1.0 (2026-05-09)](https://github.com/gravitton/grid/compare/v1.0.0...v1.1.0)
@@ -29,7 +39,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Added
 - `Grid[T]` — generic 2D grid with configurable layout, spatial mapping, and graph operations
 - `Cell[T]` — single grid cell with value access, spatial info (`Center`, `Bounds`, `Polygon`), and graph methods (`Neighbors`, `DistanceTo`, `Range`, `PathTo`)
-- `Array[T]` — low-level flat 2D array with `Get`, `Set`, `Fill`, `Clear`, `Clone`, `Iter`, `Iter2`
+- `Array[T]` — low-level flat 2D array with `Get`, `Set`, `Fill`, `Clear`, `Clone`, `Iter`, `All`
 - `NewRectGrid[T]` — rectangular grid with 4-directional (cardinal) movement
 - `NewIsometricRectGrid[T]` — isometric (diamond-projection) rectangular grid
 - `RectGridOpts.DiagonalMovement()` — option to enable 8-directional movement on rectangular grids

README.md

@@ -64,7 +64,7 @@ path := g.Path(
 Iterating a viewport:
 
 ```go
-for cell := range g.Iter(&grid.IterConfig{Bounds: viewport}) {
+for cell := range g.Iter(&grid.IterOptions{Bounds: viewport}) {
 	draw(cell)
 }
 ```
@@ -147,7 +147,7 @@ g.Clear()
 g.Clone() *Grid[T]
 
 // Iteration (draw order resolved automatically from grid type)
-g.Iter(config *IterConfig) iter.Seq[*Cell[T]] // config nil = full grid bounds
+g.Iter(config *IterOptions) iter.Seq[*Cell[T]] // config nil = full grid bounds
 ```
 
 ### Cell
@@ -193,8 +193,9 @@ a.Set(index ints.Point, value T)
 a.Fill(value T)
 a.Clear()
 a.Clone() Array[T]
-a.Iter() iter.Seq[ints.Point]
-a.Iter2() iter.Seq2[ints.Point, *T]
+a.Keys() iter.Seq[ints.Point]
+a.Values() iter.Seq[*T]
+a.All() iter.Seq2[ints.Point, *T]
 ```
 
 ### Spatial range

array.go

@@ -73,8 +73,8 @@ func (a Array[T]) Clone() Array[T] {
 	return Array[T]{a.size, data}
 }
 
-// Iter returns iterator over all points.
-func (a Array[T]) Iter() iter.Seq[ints.Point] {
+// Keys returns iterator over all points.
+func (a Array[T]) Keys() iter.Seq[ints.Point] {
 	return func(yield func(ints.Point) bool) {
 		for y := range a.Height() {
 			for x := range a.Width() {
@@ -86,10 +86,21 @@ func (a Array[T]) Iter() iter.Seq[ints.Point] {
 	}
 }
 
-// Iter2 returns an iterator over all (point, value) pairs.
-func (a Array[T]) Iter2() iter.Seq2[ints.Point, *T] {
+// Values returns an iterator over all values.
+func (a Array[T]) Values() iter.Seq[*T] {
+	return func(yield func(*T) bool) {
+		for i := range a.data {
+			if !yield(&a.data[i]) {
+				return
+			}
+		}
+	}
+}
+
+// All returns an iterator over all (point, value) pairs.
+func (a Array[T]) All() iter.Seq2[ints.Point, *T] {
 	return func(yield func(ints.Point, *T) bool) {
-		for pt := range a.Iter() {
+		for pt := range a.Keys() {
 			if !yield(pt, &a.data[a.index(pt)]) {
 				return
 			}

array_test.go

@@ -68,7 +68,7 @@ func TestArray_Clone_Independence(t *testing.T) {
 func TestArray_Iter_Order(t *testing.T) {
 	a := Arr[int](geom.Sz(3, 2))
 	var points []ints.Point
-	for p := range a.Iter() {
+	for p := range a.Keys() {
 		points = append(points, p)
 	}
 	assert.Equal(t, len(points), 6)
@@ -84,7 +84,7 @@ func TestArray_Iter2(t *testing.T) {
 	a.Set(geom.Pt(1, 0), 42)
 	count := 0
 	found := false
-	for p, v := range a.Iter2() {
+	for p, v := range a.All() {
 		count++
 		if p == geom.Pt(1, 0) {
 			assert.Equal(t, *v, 42)
@@ -98,7 +98,7 @@ func TestArray_Iter2(t *testing.T) {
 func TestArray_Iter_EarlyStop(t *testing.T) {
 	a := Arr[int](geom.Sz(5, 5))
 	count := 0
-	for range a.Iter() {
+	for range a.Keys() {
 		count++
 		if count == 3 {
 			break

iter.go

@@ -9,7 +9,7 @@ import (
 	"github.com/gravitton/geometry/types/ints"
 )
 
-// IterConfig configures bounds-based grid iteration.
+// IterOptions configures bounds-based grid iteration.
 // Pass a Bounds to restrict iteration to cells near the visible rectangle; one
 // extra row and column are included on every edge so partially visible tiles
 // are not culled. Border cells may lie outside the grid (cell.Valid() == false).
@@ -22,37 +22,37 @@ import (
 //     odd — so tiles in the same visual row are drawn back-to-front.
 //   - Hex pointy-top (HexPointyTop): row-major; the row offset is along X only,
 //     so a single pass is sufficient for correct draw order.
-type IterConfig struct {
+type IterOptions struct {
 	Bounds floats.Rectangle
 }
 
 // Iter returns an iterator over grid cells in draw order (painter's algorithm).
 // Pass nil to iterate every cell using the full grid bounds.
-// Pass an IterConfig to restrict iteration to a viewport subset.
+// Pass an IterOptions to restrict iteration to a viewport subset.
 // The iteration strategy is resolved automatically from the grid layout, so
 // tiles are always yielded back-to-front regardless of grid type.
 // Cells at the boundary of the bounds may lie outside the grid (cell.Valid() == false).
-func (g *Grid[T]) Iter(config *IterConfig) iter.Seq[*Cell[T]] {
-	if config == nil {
-		config = &IterConfig{}
+func (g *Grid[T]) Iter(options *IterOptions) iter.Seq[*Cell[T]] {
+	if options == nil {
+		options = &IterOptions{}
 	}
 
-	if config.Bounds.IsZero() {
-		config.Bounds = g.Bounds()
+	if options.Bounds.IsZero() {
+		options.Bounds = g.Bounds()
 	}
 
 	return func(yield func(*Cell[T]) bool) {
 		switch g.kind {
 		case kindDefault:
-			g.iterDefault(config.Bounds, yield)
+			g.iterDefault(options.Bounds, yield)
 		case kindIsometric:
-			g.iterIsometric(config.Bounds, yield)
+			g.iterIsometric(options.Bounds, yield)
 		case kindHexagonalFlatTop:
-			g.iterHexagonal(config.Bounds, yield, false, true)
+			g.iterHexagonal(options.Bounds, yield, false, true)
 		case kindHexagonalPointyTop:
-			g.iterHexagonal(config.Bounds, yield, false, false)
+			g.iterHexagonal(options.Bounds, yield, false, false)
 		default:
-			g.iterDefault(config.Bounds, yield)
+			g.iterDefault(options.Bounds, yield)
 		}
 	}
 

iter_test.go

@@ -50,7 +50,7 @@ func TestGrid_Iter_Bounds(t *testing.T) {
 	// Viewport covering only cells (0,0)–(1,1) centers plus half-cell padding.
 	viewport := geom.RectFromMinMax(geom.Pt(0.0, 0.0), geom.Pt(64.0, 64.0))
 	valid := 0
-	for cell := range g.Iter(&IterConfig{Bounds: viewport}) {
+	for cell := range g.Iter(&IterOptions{Bounds: viewport}) {
 		if cell.Valid() {
 			valid++
 		}