diff --git a/cue/instance.go b/cue/instance.go
index 6852a71..37ca0dc 100644
--- a/cue/instance.go
+++ b/cue/instance.go
@@ -278,6 +278,7 @@
 // if the path did not exist. The Err method reports if any error occurred
 // during evaluation. The empty path returns the top-level configuration struct,
 // regardless of whether an emit value was specified.
+// Use LookupDef for definitions or LookupField for any kind of field.
 func (inst *Instance) Lookup(path ...string) Value {
 	idx := inst.index
 	ctx := idx.newContext()
@@ -292,6 +293,15 @@
 	return v
 }
 
+// LookupDef reports the definition with the given name within struct v. The
+// Exists method of the returned value will report false if the definition did
+// not exist. The Err method reports if any error occurred during evaluation.
+func (inst *Instance) LookupDef(path string) Value {
+	ctx := inst.index.newContext()
+	v := newValueRoot(ctx, inst.rootValue.evalPartial(ctx))
+	return v.LookupDef(path)
+}
+
 // LookupField reports a Field at a path starting from v, or an error if the
 // path is not. The empty path returns v itself.
 //
@@ -313,6 +323,7 @@
 		if f.IsHidden || (i == 0 || f.IsDefinition) && !goast.IsExported(f.Name) {
 			return f, errNotFound
 		}
+		v = f.Value
 	}
 	return f, err
 }
diff --git a/cue/types.go b/cue/types.go
index 3b60faf..ed269a7 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -1293,14 +1293,16 @@
 	return Iterator{ctx: ctx, val: v, iter: n, len: len(n.arcs)}, nil
 }
 
-// Lookup reports the value at a path starting from v.
-// The empty path returns v itself.
+// Lookup reports the value at a path starting from v. The empty path returns v
+// itself. Use LookupDef for definitions or LookupField for any kind of field.
 //
 // The Exists() method can be used to verify if the returned value existed.
 // Lookup cannot be used to look up hidden or optional fields or definitions.
 func (v Value) Lookup(path ...string) Value {
 	ctx := v.ctx()
 	for _, k := range path {
+		// TODO(eval) TODO(error): always search in full data and change error
+		// message if a field is found but is of the incorrect type.
 		obj, err := v.structValData(ctx)
 		if err != nil {
 			// TODO: return a Value at the same location and a new error?
@@ -1311,25 +1313,69 @@
 	return v
 }
 
+// LookupDef reports the definition with the given name within struct v. The
+// Exists method of the returned value will report false if the definition did
+// not exist. The Err method reports if any error occurred during evaluation.
+func (v Value) LookupDef(name string) Value {
+	ctx := v.ctx()
+	o, err := v.structValFull(ctx)
+	if err != nil {
+		return newErrValue(v, err)
+	}
+
+	f := v.ctx().strLabel(name)
+	for i, a := range o.arcs {
+		if a.feature == f {
+			if !a.definition || a.optional {
+				break
+			}
+			return newChildValue(&o, i)
+		}
+	}
+	return newErrValue(v, ctx.mkErr(v.path.v,
+		"defintion %q not found", name))
+}
+
 var errNotFound = errors.Newf(token.NoPos, "field not found")
 
 // LookupField reports information about a field of v.
-func (v Value) LookupField(path string) (FieldInfo, error) {
+func (v Value) LookupField(name string) (FieldInfo, error) {
 	s, err := v.Struct()
 	if err != nil {
 		// TODO: return a Value at the same location and a new error?
 		return FieldInfo{}, err
 	}
-	f, err := s.FieldByName(path)
+	f, err := s.FieldByName(name)
 	if err != nil {
 		return f, err
 	}
-	if f.IsHidden || f.IsDefinition && !goast.IsExported(path) {
+	if f.IsHidden || f.IsDefinition && !goast.IsExported(name) {
 		return f, errNotFound
 	}
 	return f, err
 }
 
+// Fill creates a new value by unifying v with the value of x at the given path.
+//
+// Any reference in v referring to the value at the given path will resolve
+// to x in the newly created value. The resulting value is not validated.
+func (v Value) Fill(x interface{}, path ...string) Value {
+	if v.path == nil {
+		return v
+	}
+	ctx := v.ctx()
+	root := v.path.val()
+	for i := len(path) - 1; i >= 0; i-- {
+		x = map[string]interface{}{path[i]: x}
+	}
+	value := convert(ctx, root, true, x)
+	a := v.path.arc
+	a.v = mkBin(ctx, v.Pos(), opUnify, root, value)
+	a.cache = a.v.evalPartial(ctx)
+	// TODO: validate recursively?
+	return Value{v.idx, &valueData{v.path.parent, v.path.index, a}}
+}
+
 // Template returns a function that represents the template definition for a
 // struct in a configuration file. It returns nil if v is not a struct kind or
 // if there is no template associated with the struct.
@@ -1337,6 +1383,8 @@
 // The returned function returns the value that would be unified with field
 // given its name.
 func (v Value) Template() func(label string) Value {
+	// TODO: rename to optional.
+
 	ctx := v.ctx()
 	x, ok := v.path.cache.(*structLit)
 	if !ok || x.optionals.isEmpty() {
diff --git a/cue/types_test.go b/cue/types_test.go
index 0f6b2d7..075f468 100644
--- a/cue/types_test.go
+++ b/cue/types_test.go
@@ -752,6 +752,68 @@
 	}
 }
 
+func compile(t *testing.T, r *Runtime, s string) *Instance {
+	t.Helper()
+	inst, err := r.Compile("", s)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return inst
+}
+
+func goValue(v Value) interface{} {
+	var x interface{}
+	err := v.Decode(&x)
+	if err != nil {
+		return err
+	}
+	return x
+}
+
+func TestFill(t *testing.T) {
+	testCases := []struct {
+		in   string
+		x    interface{}
+		path string // comma-separated path
+		out  string
+	}{{
+		in: `
+		foo: int
+		bar: foo
+		`,
+		x:    3,
+		path: "foo",
+		out: `
+		foo: 3
+		bar: 3
+		`,
+	}, {
+		in: `
+		string
+		`,
+		x:    "foo",
+		path: "",
+		out: `
+		"foo"
+		`,
+	}}
+
+	for _, tc := range testCases {
+		var path []string
+		if tc.path != "" {
+			path = strings.Split(tc.path, ",")
+		}
+
+		r := &Runtime{}
+		v := compile(t, r, tc.in).Value().Fill(tc.x, path...)
+		w := compile(t, r, tc.out).Value()
+
+		if !reflect.DeepEqual(goValue(v), goValue(w)) {
+			t.Errorf("\ngot:  %s\nwant: %s", v, w)
+		}
+	}
+}
+
 func TestDefaults(t *testing.T) {
 	testCases := []struct {
 		value string