diff --git a/cue/binop.go b/cue/binop.go
index 38dcdb1..a0e9d4f 100644
--- a/cue/binop.go
+++ b/cue/binop.go
@@ -268,9 +268,7 @@
 			if k == y.k {
 				return y
 			}
-			i := *y
-			i.k = k
-			return &i
+			return y.specialize(k)
 		}
 		src = mkBin(ctx, src.Pos(), op, x, other)
 		return ctx.mkErr(src, codeIncomplete, "%s with incomplete values", op)
@@ -446,40 +444,30 @@
 				//     a+1 if b-a == 2
 				//     _|_ if b <= a
 
+				n := newNum(src, k&numKind, a.rep|b.rep)
 				switch diff, err := d.Int64(); {
 				case err != nil:
 
 				case diff == 1:
 					if k&floatKind == 0 {
 						if x.op == opGeq && y.op == opLss {
-							n := *a
-							n.k = k & numKind
-							n.v.Set(&lo)
-							return &n
+							return n.set(&lo)
 						}
 						if x.op == opGtr && y.op == opLeq {
-							n := *b
-							n.k = k & numKind
-							n.v.Set(&hi)
-							return &n
+							return n.set(&hi)
 						}
 					}
 
 				case diff == 2:
 					if k&floatKind == 0 && x.op == opGtr && y.op == opLss {
 						_, _ = apd.BaseContext.Add(&d, d.SetInt64(1), &lo)
-						n := *a
-						n.k = k & numKind
-						n.v.Set(&d)
-						return &n
+						return n.set(&d)
+
 					}
 
 				case diff == 0:
 					if x.op == opGeq && y.op == opLeq {
-						n := *a
-						n.k = k & numKind
-						n.v.Set(&lo)
-						return &n
+						return n.set(&lo)
 					}
 					fallthrough
 
@@ -506,9 +494,7 @@
 			}
 			// Narrow down number type.
 			if y.k != k {
-				n := *y
-				n.k = k
-				return &n
+				return y.specialize(k)
 			}
 			return other
 
@@ -552,9 +538,7 @@
 			}
 			// Narrow down number type.
 			if y.k != k {
-				n := *y
-				n.k = k
-				return &n
+				return y.specialize(k)
 			}
 			return other
 
@@ -1024,7 +1008,14 @@
 		}
 	case *numLit:
 		k, _, _ := matchBinOpKind(op, x.kind(), y.kind())
-		n := newNumBin(k, x, y)
+		if k == bottomKind {
+			break
+		}
+		switch op {
+		case opLss, opLeq, opEql, opNeq, opGeq, opGtr:
+			return cmpTonode(src, op, x.v.Cmp(&y.v))
+		}
+		n := newNum(src.base(), k, x.rep|y.rep)
 		switch op {
 		case opUnify, opUnifyUnchecked:
 			if x.v.Cmp(&y.v) != 0 {
@@ -1037,8 +1028,6 @@
 				return n
 			}
 			return x
-		case opLss, opLeq, opEql, opNeq, opGeq, opGtr:
-			return cmpTonode(src, op, x.v.Cmp(&y.v))
 		case opAdd:
 			_, _ = ctx.Add(&n.v, &x.v, &y.v)
 		case opSub:
@@ -1140,19 +1129,13 @@
 		case opSub:
 			return &durationLit{binSrc(src.Pos(), op, x, other), x.d - y.d}
 		case opQuo:
-			n := &numLit{
-				numBase: newNumBase(nil, newNumInfo(floatKind, 0, 10, false)),
-			}
-			n.v.SetInt64(int64(x.d))
+			n := newFloat(src.base(), base10).setInt64(int64(x.d))
 			d := apd.New(int64(y.d), 0)
 			// TODO: check result if this code becomes undead.
 			_, _ = ctx.Quo(&n.v, &n.v, d)
 			return n
 		case opIRem:
-			n := &numLit{
-				numBase: newNumBase(nil, newNumInfo(intKind, 0, 10, false)),
-			}
-			n.v.SetInt64(int64(x.d % y.d))
+			n := newInt(src.base(), base10).setInt64(int64(x.d % y.d))
 			n.v.Exponent = -9
 			return n
 		}
@@ -1254,9 +1237,7 @@
 		switch v := y.len.(type) {
 		case *numLit:
 			// Closed list
-			ln := &numLit{numBase: v.numBase}
-			ln.v.SetInt64(int64(len(arcs)))
-			n.len = ln
+			n.len = newInt(v.base(), v.rep).setInt(len(arcs))
 		default:
 			// Open list
 			n.len = y.len // TODO: add length of x?
@@ -1290,9 +1271,7 @@
 		switch v := x.len.(type) {
 		case *numLit:
 			// Closed list
-			ln := &numLit{numBase: v.numBase}
-			ln.v.SetInt64(int64(len(arcs)))
-			n.len = ln
+			n.len = newInt(v.base(), v.rep).setInt(len(arcs))
 		default:
 			// Open list
 			n.len = x.len // TODO: multiply length?
diff --git a/cue/go.go b/cue/go.go
index 09c1ae6..468369b 100644
--- a/cue/go.go
+++ b/cue/go.go
@@ -210,7 +210,7 @@
 		return ctx.manifest(x.walk(v))
 
 	case *big.Int:
-		n := newNum(src, intKind)
+		n := newInt(src.base(), 0)
 		n.v.Coeff.Set(v)
 		if v.Sign() < 0 {
 			n.v.Coeff.Neg(&n.v.Coeff)
@@ -220,7 +220,7 @@
 
 	case *big.Rat:
 		// should we represent this as a binary operation?
-		n := newNum(src, numKind)
+		n := newNum(src, numKind, 0)
 		_, err := ctx.Quo(&n.v, apd.NewWithBigInt(v.Num(), 0), apd.NewWithBigInt(v.Denom(), 0))
 		if err != nil {
 			return ctx.mkErr(src, err)
@@ -231,13 +231,10 @@
 		return n
 
 	case *big.Float:
-		n := newNum(src, floatKind)
-		_, _, _ = n.v.SetString(v.String())
-		return n
+		return newFloat(src, 0).setString(v.String())
 
 	case *apd.Decimal:
-		n := newNum(src, floatKind|intKind)
-		n.v.Set(v)
+		n := newNum(src, numKind, 0).set(v)
 		if !n.isInt(ctx) {
 			n.k = floatKind
 		}
@@ -293,13 +290,9 @@
 	case uintptr:
 		return toUint(ctx, src, uint64(v))
 	case float64:
-		r := newNum(src, floatKind)
-		_, _, _ = r.v.SetString(fmt.Sprintf("%g", v))
-		return r
+		return newFloat(src, 0).setString(fmt.Sprintf("%g", v))
 	case float32:
-		r := newNum(src, floatKind)
-		_, _, _ = r.v.SetString(fmt.Sprintf("%g", v))
-		return r
+		return newFloat(src, 0).setString(fmt.Sprintf("%g", v))
 
 	case reflect.Value:
 		if v.CanInterface() {
@@ -446,15 +439,11 @@
 }
 
 func toInt(ctx *context, src source, x int64) evaluated {
-	n := newNum(src, intKind)
-	n.v.SetInt64(x)
-	return n
+	return newInt(src, 0).setInt64(x)
 }
 
 func toUint(ctx *context, src source, x uint64) evaluated {
-	n := newNum(src, intKind)
-	n.v.Coeff.SetUint64(x)
-	return n
+	return newInt(src, 0).setUInt64(x)
 }
 
 func convertGoType(r *Runtime, t reflect.Type) value {
diff --git a/cue/go_test.go b/cue/go_test.go
index b9d749e..b311a97 100644
--- a/cue/go_test.go
+++ b/cue/go_test.go
@@ -25,6 +25,8 @@
 	"github.com/cockroachdb/apd/v2"
 )
 
+func mkBigInt(a int64) (v apd.Decimal) { v.SetInt64(a); return }
+
 func TestConvert(t *testing.T) {
 	i34 := big.NewInt(34)
 	d34 := mkBigInt(34)
diff --git a/cue/kind.go b/cue/kind.go
index a2a7235..1f95d00 100644
--- a/cue/kind.go
+++ b/cue/kind.go
@@ -264,7 +264,11 @@
 		if u.isAnyOf(boolKind) {
 			return boolKind | catBits, swap, ""
 		}
-	case opEql, opNeq, opMat, opNMat:
+	case opMat, opNMat:
+		if u.isAnyOf(stringKind | bytesKind) {
+			return boolKind | catBits, false, ""
+		}
+	case opEql, opNeq:
 		if u.isAnyOf(fixedKinds) {
 			return boolKind | catBits, false, ""
 		}
diff --git a/cue/lit.go b/cue/lit.go
index 325f9e5..6f88baf 100644
--- a/cue/lit.go
+++ b/cue/lit.go
@@ -22,33 +22,24 @@
 	"github.com/cockroachdb/apd/v2"
 )
 
-type numInfo struct {
-	rep multiplier
-	k   kind
-}
-
-func newNumInfo(k kind, m multiplier, base int, sep bool) numInfo {
+func newRepresentation(m multiplier, base int, sep bool) multiplier {
 	switch base {
 	case 10:
 		m |= base10
 	case 2:
 		m |= base2
-		k = intKind
 	case 8:
 		m |= base8
-		k = intKind
 	case 16:
 		m |= base16
-		k = intKind
 	}
 	if sep {
 		m |= hasSeparators
 	}
-	return numInfo{m, k}
+	return m
 }
 
-func (n numInfo) isValid() bool          { return n.k != bottomKind }
-func (n numInfo) multiplier() multiplier { return n.rep & (hasSeparators - 1) }
+func (m multiplier) multiplier() multiplier { return m & (hasSeparators - 1) }
 
 type multiplier uint16
 
@@ -307,9 +298,7 @@
 		} else {
 			mul |= mulDec
 		}
-		n := &numLit{
-			numBase: newNumBase(p.node, newNumInfo(intKind, mul, 10, p.useSep)),
-		}
+		n := newInt(newExpr(p.node), newRepresentation(mul, 10, p.useSep))
 		n.v.UnmarshalText(p.buf)
 		p.ctx.Mul(&n.v, &n.v, mulToRat[mul])
 		cond, _ := p.ctx.RoundToIntegralExact(&n.v, &n.v)
@@ -331,13 +320,11 @@
 
 exit:
 	if isFloat {
-		f := &numLit{
-			numBase: newNumBase(p.node, newNumInfo(floatKind, 0, 10, p.useSep)),
-		}
+		f := newFloat(newExpr(p.node), newRepresentation(0, 10, p.useSep))
 		f.v.UnmarshalText(p.buf)
 		return f
 	}
-	i := &numLit{numBase: newNumBase(p.node, newNumInfo(intKind, 0, base, p.useSep))}
+	i := newInt(newExpr(p.node), newRepresentation(0, base, p.useSep))
 	i.v.Coeff.SetString(string(p.buf), base)
 	return i
 }
diff --git a/cue/lit_test.go b/cue/lit_test.go
index 41c1238..ff0d357 100644
--- a/cue/lit_test.go
+++ b/cue/lit_test.go
@@ -25,27 +25,17 @@
 	"github.com/google/go-cmp/cmp/cmpopts"
 )
 
-var defIntBase = newNumBase(&ast.BasicLit{}, newNumInfo(intKind, 0, 10, false))
-var defRatBase = newNumBase(&ast.BasicLit{}, newNumInfo(floatKind, 0, 10, false))
+var testBase = newExpr(&ast.BasicLit{})
 
 func mkInt(a int64) *numLit {
-	x := &numLit{numBase: defIntBase}
-	x.v.SetInt64(a)
-	return x
+	return newInt(testBase, base10).setInt64(a)
 }
 func mkIntString(a string) *numLit {
-	x := &numLit{numBase: defIntBase}
-	x.v.SetString(a)
-	return x
+	return newInt(testBase, base10).setString(a)
 }
 func mkFloat(a string) *numLit {
-	x := &numLit{numBase: defRatBase}
-	x.v.SetString(a)
-	return x
+	return newFloat(testBase, base10).setString(a)
 }
-func mkBigInt(a int64) (v apd.Decimal) { v.SetInt64(a); return }
-
-func mkBigFloat(a string) (v apd.Decimal) { v.SetString(a); return }
 
 var diffOpts = []cmp.Option{
 	cmp.Comparer(func(x, y big.Rat) bool {
@@ -60,8 +50,6 @@
 		stringLit{},
 		bytesLit{},
 		numLit{},
-		numBase{},
-		numInfo{},
 	),
 	cmpopts.IgnoreUnexported(
 		bottom{},
@@ -78,15 +66,9 @@
 
 func TestLiterals(t *testing.T) {
 	mkMul := func(x int64, m multiplier, base int) *numLit {
-		return &numLit{
-			newNumBase(&ast.BasicLit{}, newNumInfo(intKind, m, base, false)),
-			mkBigInt(x),
-		}
+		return newInt(testBase, newRepresentation(m, base, false)).setInt64(x)
 	}
-	hk := &numLit{
-		newNumBase(&ast.BasicLit{}, newNumInfo(intKind, 0, 10, true)),
-		mkBigInt(100000),
-	}
+	hk := newInt(testBase, newRepresentation(0, 10, true)).setInt64(100000)
 	testCases := []struct {
 		lit  string
 		node value
diff --git a/cue/types.go b/cue/types.go
index c019e11..9976180 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -985,10 +985,7 @@
 }
 
 func makeInt(v Value, x int64) Value {
-	n := &numLit{numBase: numBase{baseValue: v.path.v.base()}}
-	n.v.SetInt64(x)
-	n.k = intKind
-	return remakeValue(v, n)
+	return remakeValue(v, newInt(v.path.v.base(), base10).setInt64(x))
 }
 
 // Len returns the number of items of the underlying value.
diff --git a/cue/value.go b/cue/value.go
index 59c0ef1..f6e612e 100644
--- a/cue/value.go
+++ b/cue/value.go
@@ -216,9 +216,7 @@
 		return ctx.mkErr(x, "index %d out of bounds", i)
 	}
 	// TODO: this is incorrect.
-	n := newNum(x, intKind)
-	n.v.SetInt64(int64(x.b[i]))
-	return n
+	return newInt(x, 0).setUInt64(uint64(x.b[i]))
 }
 
 func (x *bytesLit) len() int { return len(x.b) }
@@ -302,28 +300,59 @@
 	return &stringLit{x.baseValue, string(runes[lox:hix]), nil}
 }
 
-type numBase struct {
+type numLit struct {
 	baseValue
-	numInfo
+	rep multiplier
+	k   kind
+	v   apd.Decimal
 }
 
-func newNumBase(n ast.Expr, info numInfo) numBase {
-	return numBase{newExpr(n), info}
-}
-
-func newNumBin(k kind, a, b *numLit) *numLit {
-	n := &numLit{
-		numBase: numBase{
-			baseValue: a.baseValue,
-			numInfo:   numInfo{a.rep | b.rep, k},
-		},
+func newNum(src source, k kind, rep multiplier) *numLit {
+	if rep&base2|base8|base10|base16 == 0 {
+		rep |= base10
 	}
+	if k&numKind == 0 {
+		panic("not a number")
+	}
+	return &numLit{baseValue: src.base(), rep: rep, k: k}
+}
+
+func newInt(src source, rep multiplier) *numLit {
+	return newNum(src, intKind, rep)
+}
+
+func newFloat(src source, rep multiplier) *numLit {
+	return newNum(src, floatKind, rep)
+}
+
+func (n numLit) specialize(k kind) *numLit {
+	n.k = k
+	return &n
+}
+
+func (n *numLit) set(d *apd.Decimal) *numLit {
+	n.v.Set(d)
 	return n
 }
 
-type numLit struct {
-	numBase
-	v apd.Decimal
+func (n *numLit) setInt(x int) *numLit {
+	n.v.SetInt64(int64(x))
+	return n
+}
+
+func (n *numLit) setInt64(x int64) *numLit {
+	n.v.SetInt64(x)
+	return n
+}
+
+func (n *numLit) setUInt64(x uint64) *numLit {
+	n.v.Coeff.SetUint64(x)
+	return n
+}
+
+func (n *numLit) setString(s string) *numLit {
+	_, _, _ = n.v.SetString(s)
+	return n
 }
 
 func (n *numLit) String() string {
@@ -342,7 +371,7 @@
 		Kind:  token.INT,
 		Value: s,
 	}
-	num := newNum(newExpr(n), k)
+	num := newInt(newExpr(n), 0)
 	_, _, err := num.v.SetString(s)
 	if err != nil {
 		panic(err)
@@ -355,7 +384,7 @@
 		Kind:  token.FLOAT,
 		Value: s,
 	}
-	num := newNum(newExpr(n), floatKind)
+	num := newFloat(newExpr(n), 0)
 	_, _, err := num.v.SetString(s)
 	if err != nil {
 		panic(err)
@@ -363,12 +392,6 @@
 	return num
 }
 
-func newNum(src source, k kind) *numLit {
-	n := &numLit{numBase: numBase{baseValue: src.base()}}
-	n.k = k
-	return n
-}
-
 var ten = big.NewInt(10)
 
 var one = parseInt(intKind, "1")
@@ -508,9 +531,7 @@
 
 // initLit initializes a literal list.
 func (x *list) initLit() {
-	n := newNum(x, intKind)
-	n.v.SetInt64(int64(len(x.elem.arcs)))
-	x.len = n
+	x.len = newInt(x, 0).setInt(len(x.elem.arcs))
 	x.typ = &top{x.baseValue}
 }
 
@@ -520,8 +541,7 @@
 	}
 	// A list is ground if its length is ground, or if the current length
 	// meets matches the cap.
-	n := newNum(x, intKind)
-	n.v.SetInt64(int64(len(x.elem.arcs)))
+	n := newInt(x, 0).setInt(len(x.elem.arcs))
 	if n := binOp(ctx, x, opUnify, n, x.len.evalPartial(ctx)); !isBottom(n) {
 		return &list{
 			baseValue: x.baseValue,
@@ -1908,8 +1928,7 @@
 
 	case *list:
 		for i := range src.elem.arcs {
-			idx := newNum(x, intKind)
-			idx.v.SetInt64(int64(i))
+			idx := newInt(x, 0).setInt(i)
 			v := fn.call(ctx, x, idx, src.at(ctx, i))
 			if err, ok := v.(*bottom); ok {
 				return err
diff --git a/cuego/examples_test.go b/cuego/examples_test.go
index 9e160a9..b56a323 100644
--- a/cuego/examples_test.go
+++ b/cuego/examples_test.go
@@ -42,7 +42,7 @@
 	//Output:
 	// completed: cuego_test.Sum{A:1, B:5, C:6} (err: <nil>)
 	// completed: cuego_test.Sum{A:2, B:6, C:8} (err: <nil>)
-	// empty disjunction: invalid operation null & {A: 2, B: 3, C: 8} (mismatched types null and struct)
+	// empty disjunction: conflicting values 5 and 2
 }
 
 func ExampleConstrain() {