vector: replace KindOf function with Any.Kind method (#6568)

nwt · web-flow · commit d51dae1c7380 · 2026-01-27T18:28:10.000-05:00
diff --git a/runtime/vam/expr/arith.go b/runtime/vam/expr/arith.go
@@ -31,18 +31,18 @@ func (a *Arith) Eval(val vector.Any) vector.Any {
 func (a *Arith) eval(vecs ...vector.Any) (out vector.Any) {
 	lhs := enumToIndex(vector.Under(vecs[0]))
 	rhs := enumToIndex(vector.Under(vecs[1]))
-	if k := vector.KindOf(lhs); k == vector.KindNull || k == vector.KindError {
+	if k := lhs.Kind(); k == vector.KindNull || k == vector.KindError {
 		return lhs
 	}
-	if k := vector.KindOf(rhs); k == vector.KindNull || k == vector.KindError {
+	if k := rhs.Kind(); k == vector.KindNull || k == vector.KindError {
 		return rhs
 	}
 	lhs, rhs, errVal := coerceVals(a.sctx, lhs, rhs)
 	if errVal != nil {
 		return errVal
 	}
-	kind := vector.KindOf(lhs)
-	if kind != vector.KindOf(rhs) {
+	kind := lhs.Kind()
+	if kind != rhs.Kind() {
 		panic(fmt.Sprintf("vector kind mismatch after coerce (%#v and %#v)", lhs, rhs))
 	}
 	if kind == vector.KindFloat && a.opCode == vector.ArithMod {
diff --git a/runtime/vam/expr/compare.go b/runtime/vam/expr/compare.go
@@ -47,8 +47,8 @@ func (c *Compare) eval(vecs ...vector.Any) vector.Any {
 		return vector.NewConst(super.False, vecs[0].Len(), nulls)
 	}
 	//XXX need to handle overflow (see sam)
-	kind := vector.KindOf(lhs)
-	if kind != vector.KindOf(rhs) {
+	kind := lhs.Kind()
+	if kind != rhs.Kind() {
 		panic("vector kind mismatch after coerce")
 	}
 	switch kind {
diff --git a/runtime/vam/expr/function/math.go b/runtime/vam/expr/function/math.go
@@ -141,7 +141,7 @@ type Log struct {
 func (l *Log) Call(args ...vector.Any) vector.Any {
 	arg := vector.Under(args[0])
 	if !super.IsNumber(arg.Type().ID()) {
-		if vector.KindOf(arg) == vector.KindError {
+		if arg.Kind() == vector.KindError {
 			return arg
 		}
 		return vector.NewWrappedError(l.sctx, "log: not a number", arg)
diff --git a/runtime/vam/expr/function/string.go b/runtime/vam/expr/function/string.go
@@ -17,7 +17,7 @@ type Concat struct {
 func (c *Concat) Call(args ...vector.Any) vector.Any {
 	args = underAll(args)
 	for _, arg := range args {
-		switch vector.KindOf(arg) {
+		switch arg.Kind() {
 		case vector.KindError:
 			return arg
 		case vector.KindString:
diff --git a/runtime/vam/expr/function/types.go b/runtime/vam/expr/function/types.go
@@ -115,7 +115,7 @@ type IsErr struct{}
 
 func (IsErr) Call(args ...vector.Any) vector.Any {
 	vec := vector.Under(args[0])
-	if vector.KindOf(vec) != vector.KindError {
+	if vec.Kind() != vector.KindError {
 		return vector.NewConst(super.False, vec.Len(), bitvec.Zero)
 	}
 	nulls := vector.NullsOf(vec)
diff --git a/runtime/vam/expr/index.go b/runtime/vam/expr/index.go
@@ -28,7 +28,7 @@ func (i *Index) eval(args ...vector.Any) vector.Any {
 	this := args[0]
 	container := vector.Under(i.container.Eval(this))
 	index := vector.Under(i.index.Eval(this))
-	switch vector.KindOf(container) {
+	switch container.Kind() {
 	case vector.KindArray, vector.KindSet:
 		return indexArrayOrSet(i.sctx, container, index, i.base1)
 	case vector.KindRecord:
diff --git a/runtime/vam/expr/logic.go b/runtime/vam/expr/logic.go
@@ -154,7 +154,8 @@ func orError(err, vec vector.Any) vector.Any {
 func evalBool(sctx *super.Context, fn func(...vector.Any) vector.Any, vecs ...vector.Any) vector.Any {
 	return vector.Apply(false, func(vecs ...vector.Any) vector.Any {
 		for i, vec := range vecs {
-			if vec := vector.Under(vec); vec.Type() == super.TypeBool || vector.KindOf(vec) == vector.KindError {
+			vec := vector.Under(vec)
+			if k := vec.Kind(); k == vector.KindBool || k == vector.KindError {
 				vecs[i] = vec
 			} else {
 				vecs[i] = vector.NewWrappedError(sctx, "not type bool", vec)
diff --git a/runtime/vam/expr/search.go b/runtime/vam/expr/search.go
@@ -29,7 +29,7 @@ func NewSearch(s string, val super.Value, e Evaluator) Evaluator {
 	}
 	eq := NewCompare(super.NewContext() /* XXX */, "==", nil, nil)
 	vectorPred := func(vec vector.Any) vector.Any {
-		if net.IsValid() && vector.KindOf(vec) == vector.KindIP {
+		if net.IsValid() && vec.Kind() == vector.KindIP {
 			out := vector.NewFalse(vec.Len())
 			for i := range vec.Len() {
 				if ip, null := vector.IPValue(vec, i); !null && net.Contains(ip) {
diff --git a/runtime/vam/expr/slice.go b/runtime/vam/expr/slice.go
@@ -53,7 +53,7 @@ func (s *sliceExpr) eval(vecs ...vector.Any) vector.Any {
 			return vector.NewStringError(s.sctx, "slice index is not a number", to.Len())
 		}
 	}
-	switch vector.KindOf(container) {
+	switch container.Kind() {
 	case vector.KindArray, vector.KindSet:
 		return s.evalArrayOrSlice(container, from, to, s.base1)
 	case vector.KindBytes, vector.KindString:
@@ -116,7 +116,7 @@ func (s *sliceExpr) evalArrayOrSlice(vec, fromVec, toVec vector.Any, base1 bool)
 	}
 	var out vector.Any
 	inner = vector.Pick(inner, innerIndex)
-	if vector.KindOf(vec) == vector.KindArray {
+	if vec.Kind() == vector.KindArray {
 		out = vector.NewArray(vec.Type().(*super.TypeArray), newOffsets, inner, nullsOut)
 	} else {
 		out = vector.NewSet(vec.Type().(*super.TypeSet), newOffsets, inner, nullsOut)
diff --git a/vector/any.go b/vector/any.go
@@ -7,6 +7,7 @@ import (
 
 type Any interface {
 	Type() super.Type
+	Kind() Kind
 	Len() uint32
 	Serialize(*scode.Builder, uint32)
 }
diff --git a/vector/array.go b/vector/array.go
@@ -19,6 +19,10 @@ func NewArray(typ *super.TypeArray, offsets []uint32, values Any, nulls bitvec.B
 	return &Array{Typ: typ, Offsets: offsets, Values: values, Nulls: nulls}
 }
 
+func (*Array) Kind() Kind {
+	return KindArray
+}
+
 func (a *Array) Type() super.Type {
 	return a.Typ
 }
diff --git a/vector/bool.go b/vector/bool.go
@@ -35,6 +35,10 @@ func NewTrue(length uint32) *Bool {
 	return NewBool(bitvec.NewTrue(length), bitvec.Zero)
 }
 
+func (*Bool) Kind() Kind {
+	return KindBool
+}
+
 func (b *Bool) Type() super.Type {
 	return super.TypeBool
 }
diff --git a/vector/bytes.go b/vector/bytes.go
@@ -26,6 +26,10 @@ func (b *Bytes) Append(v []byte) {
 	b.table.Append(v)
 }
 
+func (*Bytes) Kind() Kind {
+	return KindBytes
+}
+
 func (b *Bytes) Type() super.Type {
 	return super.TypeBytes
 }
diff --git a/vector/const.go b/vector/const.go
@@ -1,6 +1,8 @@
 package vector
 
 import (
+	"fmt"
+
 	"github.com/brimdata/super"
 	"github.com/brimdata/super/runtime/sam/expr/coerce"
 	"github.com/brimdata/super/scode"
@@ -22,6 +24,33 @@ func NewConst(val super.Value, len uint32, nulls bitvec.Bits) *Const {
 	return &Const{val: val, len: len, Nulls: nulls}
 }
 
+func (c *Const) Kind() Kind {
+	// c.val must be a primitive.
+	switch id := c.val.Type().ID(); {
+	case super.IsUnsigned(id):
+		return KindUint
+	case super.IsSigned(id):
+		return KindInt
+	case super.IsFloat(id):
+		return KindFloat
+	case id == super.IDBool:
+		return KindBool
+	case id == super.IDBytes:
+		return KindBytes
+	case id == super.IDString:
+		return KindString
+	case id == super.IDIP:
+		return KindIP
+	case id == super.IDNet:
+		return KindNet
+	case id == super.IDType:
+		return KindType
+	case id == super.IDNull:
+		return KindNull
+	}
+	panic(fmt.Sprintf("%#v\n", super.TypeUnder(c.val.Type())))
+}
+
 func (c *Const) Type() super.Type {
 	return c.val.Type()
 }
diff --git a/vector/dynamic.go b/vector/dynamic.go
@@ -29,6 +29,10 @@ func NewDynamic(tags []uint32, values []Any) *Dynamic {
 	return &Dynamic{Tags: tags, Values: values}
 }
 
+func (*Dynamic) Kind() Kind {
+	return KindInvalid
+}
+
 func (*Dynamic) Type() super.Type {
 	panic("can't call Type() on a vector.Dynamic")
 }
diff --git a/vector/enum.go b/vector/enum.go
@@ -17,4 +17,6 @@ func NewEnum(typ *super.TypeEnum, vals []uint64, nulls bitvec.Bits) *Enum {
 	}
 }
 
+func (*Enum) Kind() Kind { return KindEnum }
+
 func (e *Enum) Type() super.Type { return e.Typ }
diff --git a/vector/error.go b/vector/error.go
@@ -20,6 +20,10 @@ func NewError(typ *super.TypeError, vals Any, nulls bitvec.Bits) *Error {
 	return &Error{Typ: typ, Vals: vals, Nulls: nulls}
 }
 
+func (*Error) Kind() Kind {
+	return KindError
+}
+
 func (e *Error) Type() super.Type {
 	return e.Typ
 }
diff --git a/vector/float.go b/vector/float.go
@@ -26,6 +26,10 @@ func (f *Float) Append(v float64) {
 	f.Values = append(f.Values, v)
 }
 
+func (*Float) Kind() Kind {
+	return KindFloat
+}
+
 func (f *Float) Type() super.Type {
 	return f.Typ
 }
diff --git a/vector/int.go b/vector/int.go
@@ -27,6 +27,10 @@ func (i *Int) Append(v int64) {
 	i.Values = append(i.Values, v)
 }
 
+func (*Int) Kind() Kind {
+	return KindInt
+}
+
 func (i *Int) Type() super.Type {
 	return i.Typ
 }
diff --git a/vector/ip.go b/vector/ip.go
@@ -19,6 +19,10 @@ func NewIP(values []netip.Addr, nulls bitvec.Bits) *IP {
 	return &IP{Values: values, Nulls: nulls}
 }
 
+func (*IP) Kind() Kind {
+	return KindIP
+}
+
 func (i *IP) Type() super.Type {
 	return super.TypeIP
 }
diff --git a/vector/kind.go b/vector/kind.go
@@ -2,8 +2,6 @@ package vector
 
 import (
 	"fmt"
-
-	"github.com/brimdata/super"
 )
 
 type Kind int
@@ -25,6 +23,9 @@ const (
 	KindSet     = 12
 	KindMap     = 13
 	KindRecord  = 14
+	KindBool    = 15
+	KindUnion   = 16
+	KindEnum    = 17
 )
 
 const (
@@ -34,47 +35,6 @@ const (
 	FormConst = 3
 )
 
-//XXX might not need Kind...
-
-func KindOf(v Any) Kind {
-	switch v := v.(type) {
-	case *Array:
-		return KindArray
-	case *Int:
-		return KindInt
-	case *Uint:
-		return KindUint
-	case *Float:
-		return KindFloat
-	case *Bytes:
-		return KindBytes
-	case *String:
-		return KindString
-	case *Error:
-		return KindError
-	case *IP:
-		return KindIP
-	case *Net:
-		return KindNet
-	case *TypeValue:
-		return KindType
-	case *Map:
-		return KindMap
-	case *Record:
-		return KindRecord
-	case *Set:
-		return KindSet
-	case *Dict:
-		return KindOf(v.Any)
-	case *View:
-		return KindOf(v.Any)
-	case *Const:
-		return KindOfType(v.Value().Type())
-	default:
-		return KindInvalid
-	}
-}
-
 func KindFromString(v string) Kind {
 	switch v {
 	case "Int":
@@ -102,38 +62,6 @@ func KindFromString(v string) Kind {
 	}
 }
 
-func KindOfType(typ super.Type) Kind {
-	switch super.TypeUnder(typ).(type) {
-	case *super.TypeOfInt16, *super.TypeOfInt32, *super.TypeOfInt64, *super.TypeOfDuration, *super.TypeOfTime:
-		return KindInt
-	case *super.TypeOfUint16, *super.TypeOfUint32, *super.TypeOfUint64:
-		return KindUint
-	case *super.TypeOfFloat16, *super.TypeOfFloat32, *super.TypeOfFloat64:
-		return KindFloat
-	case *super.TypeOfString:
-		return KindString
-	case *super.TypeOfBytes:
-		return KindBytes
-	case *super.TypeOfIP:
-		return KindIP
-	case *super.TypeOfNet:
-		return KindNet
-	case *super.TypeOfType:
-		return KindType
-	case *super.TypeOfNull:
-		return KindNull
-	case *super.TypeArray:
-		return KindArray
-	case *super.TypeSet:
-		return KindSet
-	case *super.TypeMap:
-		return KindMap
-	case *super.TypeRecord:
-		return KindRecord
-	}
-	return KindInvalid
-}
-
 func FormOf(v Any) (Form, bool) {
 	switch v.(type) {
 	case *Int, *Uint, *Float, *Bytes, *String, *TypeValue: //XXX IP, Net
diff --git a/vector/map.go b/vector/map.go
@@ -20,6 +20,10 @@ func NewMap(typ *super.TypeMap, offsets []uint32, keys Any, values Any, nulls bi
 	return &Map{Typ: typ, Offsets: offsets, Keys: keys, Values: values, Nulls: nulls}
 }
 
+func (*Map) Kind() Kind {
+	return KindMap
+}
+
 func (m *Map) Type() super.Type {
 	return m.Typ
 }
diff --git a/vector/net.go b/vector/net.go
@@ -19,6 +19,10 @@ func NewNet(values []netip.Prefix, nulls bitvec.Bits) *Net {
 	return &Net{Values: values, Nulls: nulls}
 }
 
+func (*Net) Kind() Kind {
+	return KindNet
+}
+
 func (n *Net) Type() super.Type {
 	return super.TypeNet
 }
diff --git a/vector/record.go b/vector/record.go
@@ -19,6 +19,10 @@ func NewRecord(typ *super.TypeRecord, fields []Any, length uint32, nulls bitvec.
 	return &Record{Typ: typ, Fields: fields, len: length, Nulls: nulls}
 }
 
+func (*Record) Kind() Kind {
+	return KindRecord
+}
+
 func (r *Record) Type() super.Type {
 	return r.Typ
 }
diff --git a/vector/set.go b/vector/set.go
diff --git a/vector/string.go b/vector/string.go
diff --git a/vector/type.go b/vector/type.go
diff --git a/vector/uint.go b/vector/uint.go
diff --git a/vector/union.go b/vector/union.go

Original file line number	Diff line number	Diff line change
`@@ -31,18 +31,18 @@ func (a *Arith) Eval(val vector.Any) vector.Any {`
`31`	`31`	`func (a *Arith) eval(vecs ...vector.Any) (out vector.Any) {`
`32`	`32`	`lhs := enumToIndex(vector.Under(vecs[0]))`
`33`	`33`	`rhs := enumToIndex(vector.Under(vecs[1]))`
`34`		`- if k := vector.KindOf(lhs); k == vector.KindNull \|\| k == vector.KindError {`
	`34`	`+ if k := lhs.Kind(); k == vector.KindNull \|\| k == vector.KindError {`
`35`	`35`	`return lhs`
`36`	`36`	`}`
`37`		`- if k := vector.KindOf(rhs); k == vector.KindNull \|\| k == vector.KindError {`
	`37`	`+ if k := rhs.Kind(); k == vector.KindNull \|\| k == vector.KindError {`
`38`	`38`	`return rhs`
`39`	`39`	`}`
`40`	`40`	`lhs, rhs, errVal := coerceVals(a.sctx, lhs, rhs)`
`41`	`41`	`if errVal != nil {`
`42`	`42`	`return errVal`
`43`	`43`	`}`
`44`		`- kind := vector.KindOf(lhs)`
`45`		`- if kind != vector.KindOf(rhs) {`
	`44`	`+ kind := lhs.Kind()`
	`45`	`+ if kind != rhs.Kind() {`
`46`	`46`	`panic(fmt.Sprintf("vector kind mismatch after coerce (%#v and %#v)", lhs, rhs))`
`47`	`47`	`}`
`48`	`48`	`if kind == vector.KindFloat && a.opCode == vector.ArithMod {`
Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,8 @@ func (c *Compare) eval(vecs ...vector.Any) vector.Any {`
`47`	`47`	`return vector.NewConst(super.False, vecs[0].Len(), nulls)`
`48`	`48`	`}`
`49`	`49`	`//XXX need to handle overflow (see sam)`
`50`		`- kind := vector.KindOf(lhs)`
`51`		`- if kind != vector.KindOf(rhs) {`
	`50`	`+ kind := lhs.Kind()`
	`51`	`+ if kind != rhs.Kind() {`
`52`	`52`	`panic("vector kind mismatch after coerce")`
`53`	`53`	`}`
`54`	`54`	`switch kind {`
Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ type Log struct {`
`141`	`141`	`func (l *Log) Call(args ...vector.Any) vector.Any {`
`142`	`142`	`arg := vector.Under(args[0])`
`143`	`143`	`if !super.IsNumber(arg.Type().ID()) {`
`144`		`- if vector.KindOf(arg) == vector.KindError {`
	`144`	`+ if arg.Kind() == vector.KindError {`
`145`	`145`	`return arg`
`146`	`146`	`}`
`147`	`147`	`return vector.NewWrappedError(l.sctx, "log: not a number", arg)`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ type IsErr struct{}`
`115`	`115`
`116`	`116`	`func (IsErr) Call(args ...vector.Any) vector.Any {`
`117`	`117`	`vec := vector.Under(args[0])`
`118`		`- if vector.KindOf(vec) != vector.KindError {`
	`118`	`+ if vec.Kind() != vector.KindError {`
`119`	`119`	`return vector.NewConst(super.False, vec.Len(), bitvec.Zero)`
`120`	`120`	`}`
`121`	`121`	`nulls := vector.NullsOf(vec)`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ func NewSearch(s string, val super.Value, e Evaluator) Evaluator {`
`29`	`29`	`}`
`30`	`30`	`eq := NewCompare(super.NewContext() /* XXX */, "==", nil, nil)`
`31`	`31`	`vectorPred := func(vec vector.Any) vector.Any {`
`32`		`- if net.IsValid() && vector.KindOf(vec) == vector.KindIP {`
	`32`	`+ if net.IsValid() && vec.Kind() == vector.KindIP {`
`33`	`33`	`out := vector.NewFalse(vec.Len())`
`34`	`34`	`for i := range vec.Len() {`
`35`	`35`	`if ip, null := vector.IPValue(vec, i); !null && net.Contains(ip) {`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ func (s *sliceExpr) eval(vecs ...vector.Any) vector.Any {`
`53`	`53`	`return vector.NewStringError(s.sctx, "slice index is not a number", to.Len())`
`54`	`54`	`}`
`55`	`55`	`}`
`56`		`- switch vector.KindOf(container) {`
	`56`	`+ switch container.Kind() {`
`57`	`57`	`case vector.KindArray, vector.KindSet:`
`58`	`58`	`return s.evalArrayOrSlice(container, from, to, s.base1)`
`59`	`59`	`case vector.KindBytes, vector.KindString:`
`@@ -116,7 +116,7 @@ func (s *sliceExpr) evalArrayOrSlice(vec, fromVec, toVec vector.Any, base1 bool)`
`116`	`116`	`}`
`117`	`117`	`var out vector.Any`
`118`	`118`	`inner = vector.Pick(inner, innerIndex)`
`119`		`- if vector.KindOf(vec) == vector.KindArray {`
	`119`	`+ if vec.Kind() == vector.KindArray {`
`120`	`120`	`out = vector.NewArray(vec.Type().(*super.TypeArray), newOffsets, inner, nullsOut)`
`121`	`121`	`} else {`
`122`	`122`	`out = vector.NewSet(vec.Type().(*super.TypeSet), newOffsets, inner, nullsOut)`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ import (`
`7`	`7`
`8`	`8`	`type Any interface {`
`9`	`9`	`Type() super.Type`
	`10`	`+ Kind() Kind`
`10`	`11`	`Len() uint32`
`11`	`12`	`Serialize(*scode.Builder, uint32)`
`12`	`13`	`}`