From e99aad384ea7875c4aa3fdcfd2d83f3ef7a77b81 Mon Sep 17 00:00:00 2001
From: Noah Treuhaft <noah.treuhaft@gmail.com>
Date: Wed, 17 Jun 2026 15:36:39 -0400
Subject: [PATCH] remove super.ErrNotContainer

It's only used within the super package.
---
 compiler/semantic/op.go          |  4 ++--
 runtime/sam/expr/function/len.go |  8 ++++----
 runtime/sam/expr/map.go          |  4 ++--
 runtime/sam/expr/slice.go        |  6 +++---
 sup/formatter.go                 |  6 +++---
 value.go                         | 19 +++++++++----------
 6 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/compiler/semantic/op.go b/compiler/semantic/op.go
index 7a05e7aba9..eb09d697c6 100644
--- a/compiler/semantic/op.go
+++ b/compiler/semantic/op.go
@@ -233,8 +233,8 @@ func (t *translator) fromConst(val super.Value, entity *ast.FromEval, args []ast
 		op, name := t.fromName(entity, val.AsString(), args)
 		return sem.Seq{op}, name
 	}
-	vals, err := val.Elements()
-	if err != nil {
+	vals, ok := val.Elements()
+	if !ok {
 		t.error(entity.Expr, fmt.Errorf("from expression requires a string but encountered %s", sup.String(val)))
 		return sem.Seq{badOp}, ""
 	}
diff --git a/runtime/sam/expr/function/len.go b/runtime/sam/expr/function/len.go
index 01257e0922..653b8c28ea 100644
--- a/runtime/sam/expr/function/len.go
+++ b/runtime/sam/expr/function/len.go
@@ -18,11 +18,11 @@ func (l *LenFn) Call(args []super.Value) super.Value {
 	case *super.TypeRecord:
 		length = len(typ.Fields)
 	case *super.TypeArray, *super.TypeSet, *super.TypeMap:
-		var err error
-		length, err = val.ContainerLength()
-		if err != nil {
-			panic(err)
+		n, ok := val.ContainerLength()
+		if !ok {
+			panic(val.Type())
 		}
+		length = n
 	case *super.TypeOfString:
 		length = utf8.RuneCount(val.Bytes())
 	case *super.TypeOfBytes, *super.TypeOfIP, *super.TypeOfNet:
diff --git a/runtime/sam/expr/map.go b/runtime/sam/expr/map.go
index f39c1b78f1..7240a3874d 100644
--- a/runtime/sam/expr/map.go
+++ b/runtime/sam/expr/map.go
@@ -26,8 +26,8 @@ func (a *mapCall) Eval(in super.Value) super.Value {
 	if val.IsNull() || val.IsError() {
 		return val
 	}
-	elems, err := val.Elements()
-	if err != nil {
+	elems, ok := val.Elements()
+	if !ok {
 		return a.sctx.WrapError("map: expected array or set value", in)
 	}
 	if len(elems) == 0 {
diff --git a/runtime/sam/expr/slice.go b/runtime/sam/expr/slice.go
index e892614746..4cf22f71c0 100644
--- a/runtime/sam/expr/slice.go
+++ b/runtime/sam/expr/slice.go
@@ -39,9 +39,9 @@ func (s *Slice) Eval(this super.Value) super.Value {
 	case *super.TypeOfString:
 		length = utf8.RuneCount(elem.Bytes())
 	case *super.TypeArray, *super.TypeSet:
-		n, err := elem.ContainerLength()
-		if err != nil {
-			panic(err)
+		n, ok := elem.ContainerLength()
+		if !ok {
+			panic(elem.Type())
 		}
 		length = n
 	default:
diff --git a/sup/formatter.go b/sup/formatter.go
index 5c872dcbd5..dc46b40b2a 100644
--- a/sup/formatter.go
+++ b/sup/formatter.go
@@ -379,9 +379,9 @@ func (f *formatter) formatRecord(indent int, typ *super.TypeRecord, bytes scode.
 
 func (f *formatter) formatElems(indent int, open, close string, inner super.Type, val super.Value, known bool) bool {
 	f.build(open)
-	n, err := val.ContainerLength()
-	if err != nil {
-		panic(err)
+	n, ok := val.ContainerLength()
+	if !ok {
+		panic(val.Type())
 	}
 	if n == 0 {
 		f.build(close)
diff --git a/value.go b/value.go
index 51e97e032a..d6d79437fc 100644
--- a/value.go
+++ b/value.go
@@ -16,7 +16,6 @@ import (
 
 var (
 	ErrMissingField = errors.New("record missing a field")
-	ErrNotContainer = errors.New("expected container type, got primitive")
 )
 
 var (
@@ -195,33 +194,33 @@ func (v Value) ArrayIndex(idx int64) (Value, error) {
 
 // Elements returns an array of Values for the given container type.
 // Returns an error if the element is not an array or set.
-func (v Value) Elements() ([]Value, error) {
+func (v Value) Elements() ([]Value, bool) {
 	innerType := InnerType(v.Type())
 	if innerType == nil {
-		return nil, ErrNotContainer
+		return nil, false
 	}
 	var elements []Value
 	for it := v.ContainerIter(); !it.Done(); {
 		elements = append(elements, NewValue(innerType, it.Next()))
 	}
-	return elements, nil
+	return elements, true
 }
 
-func (v Value) ContainerLength() (int, error) {
+func (v Value) ContainerLength() (int, bool) {
 	switch v.Type().(type) {
 	case *TypeSet, *TypeArray:
 		if v.IsNull() {
-			return 0, nil
+			return 0, true
 		}
 		var n int
 		for it := v.ContainerIter(); !it.Done(); {
 			it.Next()
 			n++
 		}
-		return n, nil
+		return n, true
 	case *TypeMap:
 		if v.IsNull() {
-			return 0, nil
+			return 0, true
 		}
 		var n int
 		for it := v.ContainerIter(); !it.Done(); {
@@ -229,9 +228,9 @@ func (v Value) ContainerLength() (int, error) {
 			it.Next()
 			n++
 		}
-		return n, nil
+		return n, true
 	default:
-		return -1, ErrNotContainer
+		return -1, false
 	}
 }