types: add iterators to each of the container types defined in the module.

Signed-off-by: Patrick Jakubowski <patrick.jakubowski@strongdm.com>

Author: patjakdev

internal/eval/evalers.go

@@ -670,15 +670,12 @@ func (n *containsAllEval) Eval(env Env) (types.Value, error) {
 	if err != nil {
 		return zeroValue(), err
 	}
-	result := true
-	rhs.Iterate(func(e types.Value) bool {
+	for e := range rhs.All() {
 		if !lhs.Contains(e) {
-			result = false
-			return false
+			return types.Boolean(false), nil
 		}
-		return true
-	})
-	return types.Boolean(result), nil
+	}
+	return types.Boolean(true), nil
 }
 
 // containsAnyEval
@@ -702,15 +699,12 @@ func (n *containsAnyEval) Eval(env Env) (types.Value, error) {
 	if err != nil {
 		return zeroValue(), err
 	}
-	result := false
-	rhs.Iterate(func(e types.Value) bool {
+	for e := range rhs.All() {
 		if lhs.Contains(e) {
-			result = true
-			return false
+			return types.Boolean(true), nil
 		}
-		return true
-	})
-	return types.Boolean(result), nil
+	}
+	return types.Boolean(false), nil
 }
 
 // isEmptyEval
@@ -950,15 +944,14 @@ func entityInOne(env Env, entity types.EntityUID, parent types.EntityUID) bool {
 			if fe.Parents.Contains(parent) {
 				return true
 			}
-			fe.Parents.Iterate(func(k types.EntityUID) bool {
+			for k := range fe.Parents.All() {
 				p, ok := env.Entities.Get(k)
 				if !ok || p.Parents.Len() == 0 || k == entity || known.Contains(k) {
-					return true
+					continue
 				}
 				todo = append(todo, k)
 				known.Add(k)
-				return true
-			})
+			}
 		}
 		if len(todo) == 0 {
 			return false
@@ -979,15 +972,14 @@ func entityInSet(env Env, entity types.EntityUID, parents mapset.Container[types
 			if fe.Parents.Intersects(parents) {
 				return true
 			}
-			fe.Parents.Iterate(func(k types.EntityUID) bool {
+			for k := range fe.Parents.All() {
 				p, ok := env.Entities.Get(k)
 				if !ok || p.Parents.Len() == 0 || k == entity || known.Contains(k) {
-					return true
+					continue
 				}
 				todo = append(todo, k)
 				known.Add(k)
-				return true
-			})
+			}
 		}
 		if len(todo) == 0 {
 			return false
@@ -1016,17 +1008,12 @@ func doInEval(env Env, lhs types.EntityUID, rhs types.Value) (types.Value, error
 		return types.Boolean(entityInOne(env, lhs, rhsv)), nil
 	case types.Set:
 		query := mapset.Make[types.EntityUID](rhsv.Len())
-		var err error
-		rhsv.Iterate(func(rhv types.Value) bool {
-			var e types.EntityUID
-			if e, err = ValueToEntity(rhv); err != nil {
-				return false
+		for rhv := range rhsv.All() {
+			e, err := ValueToEntity(rhv)
+			if err != nil {
+				return zeroValue(), err
 			}
 			query.Add(e)
-			return true
-		})
-		if err != nil {
-			return zeroValue(), err
 		}
 		return types.Boolean(entityInSet(env, lhs, query)), nil
 	}

internal/mapset/immutable.go

@@ -2,6 +2,7 @@ package mapset
 
 import (
 	"encoding/json"
+	"iter"
 )
 
 type ImmutableMapSet[T comparable] MapSet[T]
@@ -22,10 +23,17 @@ func (h ImmutableMapSet[T]) Intersects(o Container[T]) bool {
 
 // Iterate the items in the set, calling callback for each item. If the callback returns false, iteration is halted.
 // Iteration order is undefined.
+//
+// Deprecated: Use All() instead.
 func (h ImmutableMapSet[T]) Iterate(callback func(item T) bool) {
 	MapSet[T](h).Iterate(callback)
 }
 
+// All returns an iterator over elements in the set. Iteration order is undefined.
+func (h ImmutableMapSet[T]) All() iter.Seq[T] {
+	return MapSet[T](h).All()
+}
+
 func (h ImmutableMapSet[T]) Slice() []T {
 	return MapSet[T](h).Slice()
 }

internal/mapset/immutable_test.go

@@ -73,26 +73,24 @@ func TestImmutableMapSet(t *testing.T) {
 	t.Run("iterate", func(t *testing.T) {
 		s1 := Immutable(1, 2, 3)
 
-		var items []int
+		s2 := Make[int]()
 		s1.Iterate(func(item int) bool {
-			items = append(items, item)
+			s2.Add(item)
 			return true
 		})
 
-		testutil.Equals(t, s1.Equal(Immutable(items...)), true)
+		testutil.Equals(t, s1.Equal(s2), true)
 	})
 
 	t.Run("iterate break early", func(t *testing.T) {
 		s1 := Immutable(1, 2, 3)
 
-		i := 0
 		var items []int
 		s1.Iterate(func(item int) bool {
-			if i == 2 {
+			if len(items) == 2 {
 				return false
 			}
 			items = append(items, item)
-			i++
 			return true
 		})
 
@@ -103,6 +101,35 @@ func TestImmutableMapSet(t *testing.T) {
 		testutil.Equals(t, s1.Contains(items[1]), true)
 	})
 
+	t.Run("all", func(t *testing.T) {
+		s1 := Immutable(1, 2, 3)
+
+		s2 := Make[int]()
+		for item := range s1.All() {
+			s2.Add(item)
+		}
+
+		testutil.Equals(t, s1.Equal(s2), true)
+	})
+
+	t.Run("all break early", func(t *testing.T) {
+		s1 := Immutable(1, 2, 3)
+
+		var items []int
+		for item := range s1.All() {
+			if len(items) == 2 {
+				break
+			}
+			items = append(items, item)
+		}
+
+		// Because iteration order is non-deterministic, all we can say is that the right number of items ended up in
+		// the set and that the items were in the original set.
+		testutil.Equals(t, len(items), 2)
+		testutil.Equals(t, s1.Contains(items[0]), true)
+		testutil.Equals(t, s1.Contains(items[1]), true)
+	})
+
 	t.Run("intersection with overlap", func(t *testing.T) {
 		s1 := Immutable(1, 2, 3)
 		s2 := Immutable(2, 3, 4)

internal/mapset/mapset.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"iter"
 	"slices"
 
 	"golang.org/x/exp/maps"
@@ -92,6 +93,8 @@ func (h MapSet[T]) Intersects(o Container[T]) bool {
 
 // Iterate the items in the set, calling callback for each item. If the callback returns false, iteration is halted.
 // Iteration order is undefined.
+//
+// Deprecated: Use All() instead.
 func (h MapSet[T]) Iterate(callback func(item T) bool) {
 	for item := range h.m {
 		if !callback(item) {
@@ -100,6 +103,17 @@ func (h MapSet[T]) Iterate(callback func(item T) bool) {
 	}
 }
 
+// All returns an iterator over elements in the set. Iteration order is undefined.
+func (h MapSet[T]) All() iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for item := range h.m {
+			if !yield(item) {
+				return
+			}
+		}
+	}
+}
+
 func (h MapSet[T]) Slice() []T {
 	if h.m == nil {
 		return nil

internal/mapset/mapset_test.go

@@ -109,14 +109,12 @@ func TestMapSet(t *testing.T) {
 	t.Run("iterate break early", func(t *testing.T) {
 		s1 := FromItems(1, 2, 3)
 
-		i := 0
 		var items []int
 		s1.Iterate(func(item int) bool {
-			if i == 2 {
+			if len(items) == 2 {
 				return false
 			}
 			items = append(items, item)
-			i++
 			return true
 		})
 
@@ -127,6 +125,35 @@ func TestMapSet(t *testing.T) {
 		testutil.Equals(t, s1.Contains(items[1]), true)
 	})
 
+	t.Run("all", func(t *testing.T) {
+		s1 := FromItems(1, 2, 3)
+
+		s2 := Make[int]()
+		for item := range s1.All() {
+			s2.Add(item)
+		}
+
+		testutil.Equals(t, s1.Equal(s2), true)
+	})
+
+	t.Run("all break early", func(t *testing.T) {
+		s1 := FromItems(1, 2, 3)
+
+		var items []int
+		for item := range s1.All() {
+			if len(items) == 2 {
+				break
+			}
+			items = append(items, item)
+		}
+
+		// Because iteration order is non-deterministic, all we can say is that the right number of items ended up in
+		// the set and that the items were in the original set.
+		testutil.Equals(t, len(items), 2)
+		testutil.Equals(t, s1.Contains(items[0]), true)
+		testutil.Equals(t, s1.Contains(items[1]), true)
+	})
+
 	t.Run("intersection with overlap", func(t *testing.T) {
 		s1 := FromItems(1, 2, 3)
 		s2 := FromItems(2, 3, 4)

types.go

@@ -43,6 +43,24 @@ type Wildcard = types.Wildcard
 type EntityGetter = types.EntityGetter
 type Value = types.Value
 
+type Request = types.Request
+type Decision = types.Decision
+type Diagnostic = types.Diagnostic
+type DiagnosticReason = types.DiagnosticReason
+type DiagnosticError = types.DiagnosticError
+
+const (
+	Allow = types.Allow
+	Deny  = types.Deny
+)
+
+type Effect = types.Effect
+
+const (
+	Permit = types.Permit
+	Forbid = types.Forbid
+)
+
 //   ____                _              _
 //  / ___|___  _ __  ___| |_ __ _ _ __ | |_ ___
 // | |   / _ \| '_ \/ __| __/ _` | '_ \| __/ __|

types/entity.go

@@ -18,10 +18,9 @@ type Entity struct {
 // SDK's behavior.
 func (e Entity) MarshalJSON() ([]byte, error) {
 	parents := make([]ImplicitlyMarshaledEntityUID, 0, e.Parents.Len())
-	e.Parents.Iterate(func(p EntityUID) bool {
+	for p := range e.Parents.All() {
 		parents = append(parents, ImplicitlyMarshaledEntityUID(p))
-		return true
-	})
+	}
 	slices.SortFunc(parents, func(a, b ImplicitlyMarshaledEntityUID) int {
 		if cmp := strings.Compare(string(a.Type), string(b.Type)); cmp != 0 {
 			return cmp

types/record.go

@@ -5,6 +5,7 @@ import (
 	"encoding/binary"
 	"encoding/json"
 	"hash/fnv"
+	"iter"
 	"slices"
 	"strconv"
 
@@ -53,6 +54,8 @@ func (r Record) Len() int {
 type RecordIterator func(String, Value) bool
 
 // Iterate calls iter for each key/value pair in the record. Iteration order is non-deterministic.
+//
+// Deprecated: Use All(), Keys(), or Values() instead.
 func (r Record) Iterate(iter RecordIterator) {
 	for k, v := range r.m {
 		if !iter(k, v) {
@@ -61,6 +64,39 @@ func (r Record) Iterate(iter RecordIterator) {
 	}
 }
 
+// All returns an iterator over the keys and values in the Record. Iteration order is non-deterministic.
+func (r Record) All() iter.Seq2[String, Value] {
+	return func(yield func(String, Value) bool) {
+		for k, v := range r.m {
+			if !yield(k, v) {
+				break
+			}
+		}
+	}
+}
+
+// Keys returns an iterator over the keys in the Record. Iteration order is non-deterministic.
+func (r Record) Keys() iter.Seq[String] {
+	return func(yield func(String) bool) {
+		for k := range r.m {
+			if !yield(k) {
+				break
+			}
+		}
+	}
+}
+
+// Values returns an iterator over the keys in the Record. Iteration order is non-deterministic.
+func (r Record) Values() iter.Seq[Value] {
+	return func(yield func(Value) bool) {
+		for _, v := range r.m {
+			if !yield(v) {
+				break
+			}
+		}
+	}
+}
+
 // Get returns (v, true) where v is the Value associated with key s, if Record contains key s. Get returns (nil, false)
 // if Record does not contain key s.
 func (r Record) Get(s String) (Value, bool) {

types/record_internal_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/cedar-policy/cedar-go/internal/testutil"
 )
 
-func TestRecord(t *testing.T) {
+func TestRecordInternal(t *testing.T) {
 	t.Parallel()
 
 	t.Run("hash", func(t *testing.T) {