diff --git a/cue/op.go b/cue/op.go
index 6385903..214e3c8 100644
--- a/cue/op.go
+++ b/cue/op.go
@@ -16,6 +16,74 @@
 
 import "cuelang.org/go/cue/token"
 
+// Op indicates the operation at the top of an expression tree of the expression
+// use to evaluate a value.
+type Op int
+
+// Values of Op.
+const (
+	NoOp Op = iota
+
+	AndOp
+	OrOp
+
+	SelectorOp
+	IndexOp
+	SliceOp
+	CallOp
+
+	BooleanAndOp
+	BooleanOrOp
+
+	EqualOp
+	NotOp
+	NotEqualOp
+	LessThanOp
+	LessThanEqualOp
+	GreaterThanOp
+	GreaterThanEqualOp
+
+	RegexMatchOp
+	NotRegexMatchOp
+
+	AddOp
+	SubtractOp
+	MultiplyOp
+	FloatQuotientOp
+	FloatRemainOp
+	IntQuotientOp
+	IntRemainderOp
+	IntDivideOp
+	IntModuloOp
+
+	InterpolationOp
+)
+
+var opToOp = map[op]Op{
+	opUnify:       AndOp,
+	opDisjunction: OrOp,
+	opLand:        BooleanAndOp,
+	opLor:         BooleanOrOp,
+	opEql:         EqualOp,
+	opNot:         NotOp,
+	opNeq:         NotEqualOp,
+	opLss:         LessThanOp,
+	opLeq:         LessThanEqualOp,
+	opGtr:         GreaterThanOp,
+	opGeq:         GreaterThanEqualOp,
+	opMat:         RegexMatchOp,
+	opNMat:        NotRegexMatchOp,
+	opAdd:         AddOp,
+	opSub:         SubtractOp,
+	opMul:         MultiplyOp,
+	opQuo:         FloatQuotientOp,
+	opRem:         FloatRemainOp,
+	opIQuo:        IntQuotientOp,
+	opIRem:        IntRemainderOp,
+	opIDiv:        IntDivideOp,
+	opIMod:        IntModuloOp,
+}
+
 func opIn(op op, anyOf ...op) bool {
 	for _, o := range anyOf {
 		if o == op {
diff --git a/cue/types.go b/cue/types.go
index 22bd98a..f9aa791 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -460,6 +460,13 @@
 	return Value{obj.ctx.index, &valueData{obj.path, uint32(i), a}}
 }
 
+func remakeValue(base Value, v value) Value {
+	path := *base.path
+	path.v = v
+	path.cache = v.evalPartial(base.ctx())
+	return Value{base.idx, &path}
+}
+
 func (v Value) ctx() *context {
 	return v.idx.newContext()
 }
@@ -476,6 +483,28 @@
 	return ctx.manifest(v.path.cache)
 }
 
+// Eval resolves the references of a value and returns the result.
+// This method is not necessary to obtain concrete values.
+func (v Value) Eval() Value {
+	if v.path == nil {
+		return v
+	}
+	return remakeValue(v, v.path.v.evalPartial(v.ctx()))
+}
+
+// Default reports the default value and whether it existed. It returns the
+// normal value if there is no default.
+func (v Value) Default() (Value, bool) {
+	if v.path == nil {
+		return v, false
+	}
+	x := v.ctx().manifest(v.path.v)
+	if x != v.path.v {
+		return remakeValue(v, x), true
+	}
+	return v, false
+}
+
 // Label reports he label used to obtain this value from the enclosing struct.
 //
 // TODO: get rid of this somehow. Probably by including a FieldInfo struct
@@ -595,7 +624,11 @@
 		return nil
 	}
 	ctx := v.ctx()
-	return export(ctx, v.eval(ctx), getOptions(opts))
+	o := getOptions(opts)
+	if o.raw {
+		return export(ctx, v.path.v, o)
+	}
+	return export(ctx, v.path.cache, o)
 }
 
 // Decode initializes x with Value v. If x is a struct, it will validate the
@@ -634,7 +667,7 @@
 
 func separate(v value) (a []value) {
 	c := v.computed()
-	if c == nil {
+	if c == nil || c.op != opUnify {
 		return []value{v}
 	}
 	if c.x != nil {
@@ -674,9 +707,30 @@
 	return v.idx.fset.Position(pos)
 }
 
-// IsIncomplete indicates that the value cannot be fully evaluated due to
+// IsConcrete reports whether the current value is a concrete scalar value,
+// not relying on default values, a terminal error, a list, or a struct.
+// It does not verify that values of lists or structs are concrete themselves.
+// To check whether there is a concrete default, use v.Default().IsConcrete().
+func (v Value) IsConcrete() bool {
+	if v.path == nil {
+		return false // any is neither concrete, not a list or struct.
+	}
+	x := v.path.v.evalPartial(v.ctx())
+
+	// Errors marked as incomplete are treated as not complete.
+	if isIncomplete(x) {
+		return false
+	}
+	// Other errors are considered ground.
+	return x.kind().isGround()
+}
+
+// IsIncomplete is deprecated.
+//
+// It indicates that the value cannot be fully evaluated due to
 // insufficient information.
 func (v Value) IsIncomplete() bool {
+	// TODO: remove
 	x := v.eval(v.ctx())
 	if x.kind().hasReferences() || !x.kind().isGround() {
 		return true
@@ -724,6 +778,53 @@
 	return nil
 }
 
+func makeInt(v Value, x int64) Value {
+	n := &numLit{numBase: numBase{baseValue: v.path.v.base()}}
+	n.v.SetInt64(x)
+	return remakeValue(v, n)
+}
+
+// Len returns the number of items of the underlying value.
+// For lists it reports the capacity of the list. For structs it indicates the
+// number of fields, for bytes the number of bytes.
+func (v Value) Len() Value {
+	if v.path != nil {
+		switch x := v.path.v.evalPartial(v.ctx()).(type) {
+		case *list:
+			return remakeValue(v, x.len.evalPartial(v.ctx()))
+		case *bytesLit:
+			return makeInt(v, int64(x.len()))
+		case *stringLit:
+			return makeInt(v, int64(x.len()))
+		}
+	}
+	const msg = "len not supported for type %v"
+	return remakeValue(v, v.ctx().mkErr(v.path.v, msg, v.Kind()))
+}
+
+// Elem returns the value of undefined element types of lists and structs.
+func (v Value) Elem() (Value, bool) {
+	ctx := v.ctx()
+	switch x := v.path.cache.(type) {
+	case *structLit:
+		if x.template == nil {
+			break
+		}
+		fn, ok := ctx.manifest(x.template).(*lambdaExpr)
+		if !ok {
+			// TODO: return an error instead.
+			break
+		}
+		// Note, this template does not maintain the relation between the
+		// the attribute value and the instance.
+		y := fn.call(ctx, x, &basicType{x.baseValue, stringKind})
+		return newValueRoot(ctx, y), true
+	case *list:
+		return newValueRoot(ctx, x.typ), true
+	}
+	return Value{}, false
+}
+
 // List creates an iterator over the values of a list or reports an error if
 // v is not a list.
 func (v Value) List() (Iterator, error) {
@@ -942,8 +1043,47 @@
 	io.WriteString(state, debugStr(ctx, v.path.cache))
 }
 
+// Reference returns path from the root of the file referred to by this value
+// or no path if this value is not a reference.
+func (v Value) Reference() []string {
+	// TODO: don't include references to hidden fields.
+	if v.path == nil {
+		return nil
+	}
+	sel, ok := v.path.v.(*selectorExpr)
+	if !ok {
+		return nil
+	}
+	return mkPath(v.ctx(), v.path, sel, 0)
+}
+
+func mkPath(c *context, up *valueData, sel *selectorExpr, d int) (a []string) {
+	switch x := sel.x.(type) {
+	case *selectorExpr:
+		a = mkPath(c, up.parent, x, d+1)
+	case *nodeRef:
+		// the parent must exist.
+		for ; up != nil && up.cache != x.node.(value); up = up.parent {
+		}
+		a = mkFromRoot(c, up, d+1)
+	default:
+		panic("should not happend")
+	}
+	return append(a, c.labelStr(sel.feature))
+}
+
+func mkFromRoot(c *context, up *valueData, d int) []string {
+	if up == nil || up.parent == nil {
+		return make([]string, 0, d)
+	}
+	a := mkFromRoot(c, up.parent, d+1)
+	return append(a, c.labelStr(up.feature))
+}
+
 // References reports all references used to evaluate this value. It does not
 // report references for sub fields if v is a struct.
+//
+// Deprecated: can be implemented in terms of Reference and Expr.
 func (v Value) References() [][]string {
 	ctx := v.ctx()
 	pf := pathFinder{up: v.path}
@@ -1245,3 +1385,103 @@
 	}
 	return "", false, nil
 }
+
+// Expr reports the operation of the underlying expression and the values it
+// operates on. The returned values are appended to the given slice, which may
+// be nil.
+//
+// For unary expressions, it returns the single value of the expression.
+//
+// For binary expressions it returns first the left and right value, in that
+// order. For associative operations however, (for instance '&' and '|'), it may
+// return more than two values, where the operation is to be applied in
+// sequence.
+//
+// For selector and index expressions it returns the subject and then the index.
+// For selectors, the index is the string value of the identifier. For slice
+// expressions, it returns the subject, low value, and high value, in that
+// order.
+//
+// For interpolations it returns a sequence of values to be concatenated, some
+// of which will be literal strings and some unevaluated expressions.
+//
+// A builtin call expression returns the value of the builtin followed by the
+// args of the call.
+//
+// If v is not an expression, Partial append v itself.
+// TODO: return v if this is complete? Yes for now
+// TODO: add values if a == nil?
+func (v Value) Expr() (Op, []Value) {
+	if v.path == nil {
+		return NoOp, nil
+	}
+	// TODO: replace appends with []Value{}. For not leave.
+	a := []Value{}
+	op := NoOp
+	switch x := v.path.v.(type) {
+	case *binaryExpr:
+		a = append(a, remakeValue(v, x.left))
+		a = append(a, remakeValue(v, x.right))
+		op = opToOp[x.op]
+	case *unaryExpr:
+		a = append(a, remakeValue(v, x.x))
+		op = opToOp[x.op]
+	case *bound:
+		a = append(a, remakeValue(v, x.value))
+		op = opToOp[x.op]
+	case *unification:
+		// pre-expanded unification
+		for _, conjunct := range x.values {
+			a = append(a, remakeValue(v, conjunct))
+		}
+		op = AndOp
+	case *disjunction:
+		// Filter defaults that are subsumed by another value.
+		count := 0
+	outer:
+		for _, disjunct := range x.values {
+			if disjunct.marked {
+				for _, n := range x.values {
+					if !n.marked && subsumes(v.ctx(), n.val, disjunct.val, 0) {
+						continue outer
+					}
+				}
+			}
+			count++
+			a = append(a, remakeValue(v, disjunct.val))
+		}
+		if count > 1 {
+			op = OrOp
+		}
+	case *interpolation:
+		for _, p := range x.parts {
+			a = append(a, remakeValue(v, p))
+		}
+		op = InterpolationOp
+	case *selectorExpr:
+		a = append(a, remakeValue(v, x.x))
+		a = append(a, remakeValue(v, &stringLit{
+			x.baseValue,
+			v.ctx().labelStr(x.feature),
+		}))
+		op = SelectorOp
+	case *indexExpr:
+		a = append(a, remakeValue(v, x.x))
+		a = append(a, remakeValue(v, x.index))
+		op = IndexOp
+	case *sliceExpr:
+		a = append(a, remakeValue(v, x.x))
+		a = append(a, remakeValue(v, x.lo))
+		a = append(a, remakeValue(v, x.hi))
+		op = SliceOp
+	case *callExpr:
+		a = append(a, remakeValue(v, x.x))
+		for _, arg := range x.args {
+			a = append(a, remakeValue(v, arg))
+		}
+		op = CallOp
+	default:
+		a = append(a, v)
+	}
+	return op, a
+}
diff --git a/cue/types_test.go b/cue/types_test.go
index 3d199d7..0429e90 100644
--- a/cue/types_test.go
+++ b/cue/types_test.go
@@ -45,6 +45,7 @@
 		incompleteKind Kind
 		json           string
 		valid          bool
+		concrete       bool
 		// pos            token.Pos
 	}{{ // Not a concrete value.
 		value:          `_`,
@@ -54,18 +55,22 @@
 		value:          `_|_`,
 		kind:           BottomKind,
 		incompleteKind: BottomKind,
+		concrete:       true,
 	}, {
 		value:          `1&2`,
 		kind:           BottomKind,
 		incompleteKind: BottomKind,
+		concrete:       true,
 	}, { // TODO: should be error{
 		value:          `b`,
 		kind:           BottomKind,
 		incompleteKind: BottomKind,
+		concrete:       true,
 	}, {
 		value:          `(b[a])`,
 		kind:           BottomKind,
 		incompleteKind: BottomKind,
+		concrete:       true,
 	}, { // TODO: should be error{
 		value: `(b)
 			b: bool`,
@@ -75,18 +80,22 @@
 		value:          `([][b])`,
 		kind:           BottomKind,
 		incompleteKind: BottomKind,
+		concrete:       true,
 	}, {
 		value:          `null`,
 		kind:           NullKind,
 		incompleteKind: NullKind,
+		concrete:       true,
 	}, {
 		value:          `true`,
 		kind:           BoolKind,
 		incompleteKind: BoolKind,
+		concrete:       true,
 	}, {
 		value:          `false`,
 		kind:           BoolKind,
 		incompleteKind: BoolKind,
+		concrete:       true,
 	}, {
 		value:          `bool`,
 		kind:           BottomKind,
@@ -95,18 +104,22 @@
 		value:          `2`,
 		kind:           NumberKind,
 		incompleteKind: NumberKind,
+		concrete:       true,
 	}, {
 		value:          `2.0`,
 		kind:           FloatKind,
 		incompleteKind: FloatKind,
+		concrete:       true,
 	}, {
 		value:          `2.0Mi`,
 		kind:           NumberKind,
 		incompleteKind: NumberKind,
+		concrete:       true,
 	}, {
 		value:          `14_000`,
 		kind:           NumberKind,
 		incompleteKind: NumberKind,
+		concrete:       true,
 	}, {
 		value:          `>=0 & <5`,
 		kind:           BottomKind,
@@ -119,10 +132,12 @@
 		value:          `"str"`,
 		kind:           StringKind,
 		incompleteKind: StringKind,
+		concrete:       true,
 	}, {
 		value:          "'''\n'''",
 		kind:           BytesKind,
 		incompleteKind: BytesKind,
+		concrete:       true,
 	}, {
 		value:          "string",
 		kind:           BottomKind,
@@ -131,10 +146,16 @@
 		value:          `{}`,
 		kind:           StructKind,
 		incompleteKind: StructKind,
+		concrete:       true,
 	}, {
 		value:          `[]`,
 		kind:           ListKind,
 		incompleteKind: ListKind,
+		concrete:       true,
+	}, {
+		value:    `{a: int, b: [1][a]}.b`,
+		kind:     BottomKind,
+		concrete: false,
 	}}
 	for _, tc := range testCases {
 		t.Run(tc.value, func(t *testing.T) {
@@ -151,6 +172,9 @@
 			if got := v.IsIncomplete(); got != incomplete {
 				t.Errorf("IsIncomplete: got %v; want %v", got, incomplete)
 			}
+			if got := v.IsConcrete(); got != tc.concrete {
+				t.Errorf("IsConcrete: got %v; want %v", got, tc.concrete)
+			}
 			invalid := tc.kind == BottomKind
 			if got := v.IsValid(); got != !invalid {
 				t.Errorf("IsValid: got %v; want %v", got, !invalid)
@@ -653,6 +677,83 @@
 	}
 }
 
+func TestDefaults(t *testing.T) {
+	testCases := []struct {
+		value string
+		def   string
+		val   string
+		err   string
+	}{{
+		value: `number | *1`,
+		def:   "1",
+		val:   "number",
+	}, {
+		value: `1 | 2 | *3`,
+		def:   "3",
+		val:   "1|2|3",
+	}, {
+		value: `*{a:1,b:2}|{a:1}|{b:2}`,
+		def:   "<0>{a: 1, b: 2}",
+		val:   "<0>{a: 1}|<0>{b: 2}",
+	}}
+	for _, tc := range testCases {
+		t.Run(tc.value, func(t *testing.T) {
+			v := getInstance(t, "a: "+tc.value).Lookup("a")
+
+			_, val := v.Expr()
+			d, _ := v.Default()
+
+			if got := fmt.Sprint(d); got != tc.def {
+				t.Errorf("default: got %v; want %v", got, tc.def)
+			}
+
+			vars := []string{}
+			for _, v := range val {
+				vars = append(vars, fmt.Sprint(v))
+			}
+			if got := strings.Join(vars, "|"); got != tc.val {
+				t.Errorf("value: got %v; want %v", got, tc.val)
+			}
+		})
+	}
+}
+
+func TestLen(t *testing.T) {
+	testCases := []struct {
+		input  string
+		length string
+	}{{
+		input:  "[1, 3]",
+		length: "2",
+	}, {
+		input:  "[1, 3, ...]",
+		length: ">=2",
+	}, {
+		input:  `"foo"`,
+		length: "3",
+	}, {
+		input:  `'foo'`,
+		length: "3",
+		// TODO: Currently not supported.
+		// }, {
+		// 	input:  "{a:1, b:3, a:1, c?: 3, _hidden: 4}",
+		// 	length: "2",
+	}, {
+		input:  "3",
+		length: "_|_(3:len not supported for type 24)",
+	}}
+	for _, tc := range testCases {
+		t.Run(tc.input, func(t *testing.T) {
+			v := getInstance(t, "a: "+tc.input).Lookup("a")
+
+			length := v.Len()
+			if got := fmt.Sprint(length); got != tc.length {
+				t.Errorf("length: got %v; want %v", got, tc.length)
+			}
+		})
+	}
+}
+
 func TestTemplate(t *testing.T) {
 	testCases := []struct {
 		value string
@@ -1440,6 +1541,33 @@
 	}
 }
 
+func TestReference(t *testing.T) {
+	testCases := []struct {
+		input string
+		want  string
+	}{{
+		input: "v: _|_",
+		want:  "",
+	}, {
+		input: "v: 2",
+		want:  "",
+	}, {
+		input: "v: a, a: 1",
+		want:  "a",
+	}, {
+		input: "v: a.b.c, a b c: 1",
+		want:  "a b c",
+	}}
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			v := getInstance(t, tc.input).Lookup("v")
+			if got := strings.Join(v.Reference(), " "); got != tc.want {
+				t.Errorf("\n got %v;\nwant %v", got, tc.want)
+			}
+		})
+	}
+}
+
 func TestReferences(t *testing.T) {
 	config1 := `
 	a: {
@@ -1522,3 +1650,148 @@
 	}
 	return true
 }
+
+func TestExpr(t *testing.T) {
+	testCases := []struct {
+		input string
+		want  string
+	}{{
+		input: "v: 3",
+		want:  " 3",
+	}, {
+		input: "v: 3 + 4",
+		want:  "+ 3 4",
+	}, {
+		input: "v: !a, a: 3",
+		want:  "! <0>.a",
+	}, {
+		input: "v: 1 | 2 | 3 | *4",
+		want:  "| 1 2 3 4",
+	}, {
+		input: "v: 2 & 5",
+		want:  "& 2 5",
+	}, {
+		input: "v: 2 | 5",
+		want:  "| 2 5",
+	}, {
+		input: "v: 2 && 5",
+		want:  "&& 2 5",
+	}, {
+		input: "v: 2 || 5",
+		want:  "|| 2 5",
+	}, {
+		input: "v: 2 == 5",
+		want:  "== 2 5",
+	}, {
+		input: "v: !b, b: true",
+		want:  "! <0>.b",
+	}, {
+		input: "v: 2 != 5",
+		want:  "!= 2 5",
+	}, {
+		input: "v: <5",
+		want:  "< 5",
+	}, {
+		input: "v: 2 <= 5",
+		want:  "<= 2 5",
+	}, {
+		input: "v: 2 > 5",
+		want:  "> 2 5",
+	}, {
+		input: "v: 2 >= 5",
+		want:  ">= 2 5",
+	}, {
+		input: "v: 2 =~ 5",
+		want:  "=~ 2 5",
+	}, {
+		input: "v: 2 !~ 5",
+		want:  "!~ 2 5",
+	}, {
+		input: "v: 2 + 5",
+		want:  "+ 2 5",
+	}, {
+		input: "v: 2 - 5",
+		want:  "- 2 5",
+	}, {
+		input: "v: 2 * 5",
+		want:  "* 2 5",
+	}, {
+		input: "v: 2 / 5",
+		want:  "/ 2 5",
+	}, {
+		input: "v: 2 % 5",
+		want:  "% 2 5",
+	}, {
+		input: "v: 2 quo 5",
+		want:  "quo 2 5",
+	}, {
+		input: "v: 2 rem 5",
+		want:  "rem 2 5",
+	}, {
+		input: "v: 2 div 5",
+		want:  "div 2 5",
+	}, {
+		input: "v: 2 mod 5",
+		want:  "mod 2 5",
+	}, {
+		input: "v: a.b, a b: 4",
+		want:  `. <0>.a "b"`,
+	}, {
+		input: `v: a["b"], a b: 3 `,
+		want:  `[] <0>.a "b"`,
+	}, {
+		input: "v: a[2:5], a: [1, 2, 3, 4, 5]",
+		want:  "[:] <0>.a 2 5",
+	}, {
+		input: "v: len([])",
+		want:  "() builtin:len []",
+	}, {
+		input: `v: "Hello, \(x)! Welcome to \(place)", place: string, x: string`,
+		want:  `\() "Hello, " <0>.x "! Welcome to " <0>.place ""`,
+	}}
+	for _, tc := range testCases {
+		t.Run(tc.input, func(t *testing.T) {
+			v := getInstance(t, tc.input).Lookup("v")
+			op, operands := v.Expr()
+			got := opToString[op]
+			for _, v := range operands {
+				got += " "
+				got += debugStr(v.ctx(), v.path.v)
+			}
+			if got != tc.want {
+				t.Errorf("\n got %v;\nwant %v", got, tc.want)
+			}
+		})
+	}
+}
+
+var opToString = map[Op]string{
+	AndOp:              "&",
+	OrOp:               "|",
+	BooleanAndOp:       "&&",
+	BooleanOrOp:        "||",
+	EqualOp:            "==",
+	NotOp:              "!",
+	NotEqualOp:         "!=",
+	LessThanOp:         "<",
+	LessThanEqualOp:    "<=",
+	GreaterThanOp:      ">",
+	GreaterThanEqualOp: ">=",
+	RegexMatchOp:       "=~",
+	NotRegexMatchOp:    "!~",
+	AddOp:              "+",
+	SubtractOp:         "-",
+	MultiplyOp:         "*",
+	FloatQuotientOp:    "/",
+	FloatRemainOp:      "%",
+	IntQuotientOp:      "quo",
+	IntRemainderOp:     "rem",
+	IntDivideOp:        "div",
+	IntModuloOp:        "mod",
+
+	SelectorOp:      ".",
+	IndexOp:         "[]",
+	SliceOp:         "[:]",
+	CallOp:          "()",
+	InterpolationOp: `\()`,
+}