diff --git a/cue/export.go b/cue/export.go
index 94bcfbc..343edcc 100644
--- a/cue/export.go
+++ b/cue/export.go
@@ -23,6 +23,8 @@
 	"unicode"
 	"unicode/utf8"
 
+	"github.com/cockroachdb/apd"
+
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/token"
 )
@@ -300,14 +302,18 @@
 		return &ast.UnaryExpr{Op: opMap[x.op], X: p.expr(x.value)}
 
 	case *unification:
-		if len(x.values) == 1 {
-			return p.expr(x.values[0])
+		b := boundSimplifier{p: p}
+		vals := make([]evaluated, 0, 3)
+		for _, v := range x.values {
+			if !b.add(v) {
+				vals = append(vals, v)
+			}
 		}
-		bin := p.expr(x.values[0])
-		for _, v := range x.values[1:] {
-			bin = &ast.BinaryExpr{X: bin, Op: token.AND, Y: p.expr(v)}
+		e := b.expr(p.ctx)
+		for _, v := range vals {
+			e = wrapBin(e, p.expr(v), opUnify)
 		}
-		return bin
+		return e
 
 	case *disjunction:
 		if len(x.values) == 1 {
@@ -684,3 +690,198 @@
 	}
 	return buf
 }
+
+type boundSimplifier struct {
+	p *exporter
+
+	isInt  bool
+	min    *bound
+	minNum *numLit
+	max    *bound
+	maxNum *numLit
+}
+
+func (s *boundSimplifier) add(v value) (used bool) {
+	switch x := v.(type) {
+	case *basicType:
+		switch x.k & scalarKinds {
+		case intKind:
+			s.isInt = true
+			return true
+		}
+
+	case *bound:
+		if x.k&concreteKind == intKind {
+			s.isInt = true
+		}
+		switch x.op {
+		case opGtr:
+			if n, ok := x.value.(*numLit); ok {
+				if s.min == nil || s.minNum.v.Cmp(&n.v) != 1 {
+					s.min = x
+					s.minNum = n
+				}
+				return true
+			}
+
+		case opGeq:
+			if n, ok := x.value.(*numLit); ok {
+				if s.min == nil || s.minNum.v.Cmp(&n.v) == -1 {
+					s.min = x
+					s.minNum = n
+				}
+				return true
+			}
+
+		case opLss:
+			if n, ok := x.value.(*numLit); ok {
+				if s.max == nil || s.maxNum.v.Cmp(&n.v) != -1 {
+					s.max = x
+					s.maxNum = n
+				}
+				return true
+			}
+
+		case opLeq:
+			if n, ok := x.value.(*numLit); ok {
+				if s.max == nil || s.maxNum.v.Cmp(&n.v) == 1 {
+					s.max = x
+					s.maxNum = n
+				}
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+type builtinRange struct {
+	typ string
+	lo  *apd.Decimal
+	hi  *apd.Decimal
+}
+
+func makeDec(s string) *apd.Decimal {
+	d, _, err := apd.NewFromString(s)
+	if err != nil {
+		panic(err)
+	}
+	return d
+}
+
+func (s *boundSimplifier) expr(ctx *context) (e ast.Expr) {
+	if s.min == nil || s.max == nil {
+		return nil
+	}
+	switch {
+	case s.isInt:
+		t := s.matchRange(intRanges)
+		if t != "" {
+			e = ast.NewIdent(t)
+			break
+		}
+		if sign := s.minNum.v.Sign(); sign == -1 {
+			e = ast.NewIdent("int")
+
+		} else {
+			e = ast.NewIdent("uint")
+			if sign == 0 && s.min.op == opGeq {
+				s.min = nil
+				break
+			}
+		}
+		fallthrough
+	default:
+		t := s.matchRange(floatRanges)
+		if t != "" {
+			e = wrapBin(e, ast.NewIdent(t), opUnify)
+		}
+	}
+
+	if s.min != nil {
+		e = wrapBin(e, s.p.expr(s.min), opUnify)
+	}
+	if s.max != nil {
+		e = wrapBin(e, s.p.expr(s.max), opUnify)
+	}
+	return e
+}
+
+func (s *boundSimplifier) matchRange(ranges []builtinRange) (t string) {
+	for _, r := range ranges {
+		if !s.minNum.v.IsZero() && s.min.op == opGeq && s.minNum.v.Cmp(r.lo) == 0 {
+			switch s.maxNum.v.Cmp(r.hi) {
+			case 0:
+				if s.max.op == opLeq {
+					s.max = nil
+				}
+				s.min = nil
+				return r.typ
+			case -1:
+				if !s.minNum.v.IsZero() {
+					s.min = nil
+					return r.typ
+				}
+			case 1:
+			}
+		} else if s.max.op == opLeq && s.maxNum.v.Cmp(r.hi) == 0 {
+			switch s.minNum.v.Cmp(r.lo) {
+			case -1:
+			case 0:
+				if s.min.op == opGeq {
+					s.min = nil
+				}
+				fallthrough
+			case 1:
+				s.max = nil
+				t = r.typ
+				return r.typ
+			}
+		}
+	}
+	return ""
+}
+
+var intRanges = []builtinRange{
+	{"int8", makeDec("-128"), makeDec("127")},
+	{"int16", makeDec("-32768"), makeDec("32767")},
+	{"int32", makeDec("-2147483648"), makeDec("2147483647")},
+	{"int64", makeDec("-9223372036854775808"), makeDec("9223372036854775807")},
+	{"int128", makeDec("-170141183460469231731687303715884105728"),
+		makeDec("170141183460469231731687303715884105727")},
+
+	{"uint8", makeDec("0"), makeDec("255")},
+	{"uint16", makeDec("0"), makeDec("65535")},
+	{"uint32", makeDec("0"), makeDec("4294967295")},
+	{"uint64", makeDec("0"), makeDec("18446744073709551615")},
+	{"uint128", makeDec("0"), makeDec("340282366920938463463374607431768211455")},
+
+	// {"rune", makeDec("0"), makeDec(strconv.Itoa(0x10FFFF))},
+}
+
+var floatRanges = []builtinRange{
+	// 2**127 * (2**24 - 1) / 2**23
+	{"float32",
+		makeDec("-3.40282346638528859811704183484516925440e+38"),
+		makeDec("+3.40282346638528859811704183484516925440e+38")},
+
+	// 2**1023 * (2**53 - 1) / 2**52
+	{"float64",
+		makeDec("-1.797693134862315708145274237317043567981e+308"),
+		makeDec("+1.797693134862315708145274237317043567981e+308")},
+}
+
+func wrapBin(a, b ast.Expr, op op) ast.Expr {
+	if a == nil {
+		return b
+	}
+	if b == nil {
+		return a
+	}
+	return &ast.BinaryExpr{
+		X:  a,
+		Op: opMap[op],
+		Y:  b,
+	}
+}
diff --git a/cue/export_test.go b/cue/export_test.go
index 45659a2..464c56f 100644
--- a/cue/export_test.go
+++ b/cue/export_test.go
@@ -165,6 +165,40 @@
 				b: [1 | 2]
 			}`),
 	}, {
+		raw:  true,
+		eval: true,
+		in: `{
+				u16: int & >=0 & <=65535
+				u32: uint32
+				u64: uint64
+				u128: uint128
+				u8: uint8
+				ua: uint16 & >0
+				us: >=0 & <10_000 & int
+				i16: >=-32768 & int & <=32767
+				i32: int32 & > 0
+				i64:  int64
+				i128: int128
+				f64:  float64
+				fi:  float64 & int
+			}`,
+		out: unindent(`
+			{
+				u16:  uint16
+				u32:  uint32
+				u64:  uint64
+				u128: uint128
+				u8:   uint8
+				ua:   uint16 & >0
+				us:   uint & <10000
+				i16:  int16
+				i32:  int32 & >0
+				i64:  int64
+				i128: int128
+				f64:  float64
+				fi:   int & float64
+			}`),
+	}, {
 		raw: true,
 		in:  `{ a: [1, 2], b: { "\(k)": v for k, v in a if v > 1 } }`,
 		out: unindent(`